Attachment 412328 Details for Bug 199866 – patch

[patch] patch

c-backup.diff (text/plain), 5.68 MB, created by Saam Barati on 2020-10-26 10:21:10 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Saam Barati

Created: 2020-10-26 10:21:10 PDT

Size: 5.68 MB

patch

obsolete

>Index: JSTests/ChangeLog
>===================================================================
>--- JSTests/ChangeLog	(revision 268946)
>+++ JSTests/ChangeLog	(working copy)
>@@ -1,3 +1,14193 @@
>+2020-10-23  Saam Barati  <sbarati@apple.com>
>+
>+        Better cache our serialization of the outer TDZ environment when creating FunctionExecutables during bytecode generation
>+        https://bugs.webkit.org/show_bug.cgi?id=199866
>+        <rdar://problem/53333108>
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * microbenchmarks/let-const-tdz-environment-parsing-and-hash-consing-speed.js: Added.
>+        (console.log):
>+        (foo.dart.privateName):
>+        (foo.async let):
>+        (foo.window.NodeList.prototype):
>+        (foo.window.NamedNodeMap.prototype):
>+        (foo.window.DOMTokenList.prototype):
>+        (foo.window.HTMLCollection.prototype):
>+        (foo.dart.polyfill):
>+        (foo.dart.trackProfile):
>+        (foo.dart.setStartAsyncSynchronously):
>+        (foo.dart.hotRestart):
>+        (foo.dart.defineValue):
>+        (foo.dart.throwTypeError):
>+        (foo.dart.throwInternalError):
>+        (foo.dart.getOwnNamesAndSymbols):
>+        (foo.dart.safeGetOwnProperty):
>+        (foo.desc):
>+        (foo.dart.defineLazyField):
>+        (foo.dart.copyTheseProperties):
>+        (foo.dart.copyProperty):
>+        (foo.dart.export):
>+        (foo.dart.copyProperties):
>+        (foo.dart.applyMixin):
>+        (foo.dart._copyMembers):
>+        (foo.let.obj.desc.set name):
>+        (foo.else.let.obj.desc.get name):
>+        (foo.dart._copyMember):
>+        (foo.dart._mixinSignature):
>+        (foo.dart.getMixin):
>+        (foo.dart.getImplements):
>+        (foo.makeGenericType):
>+        (foo.dart.generic):
>+        (foo.dart.getGenericClass):
>+        (foo.dart.getGenericArgs):
>+        (foo.dart.getGenericTypeFormals):
>+        (foo.dart.instantiateClass):
>+        (foo.dart.getConstructors):
>+        (foo.dart.getMethods):
>+        (foo.dart.getFields):
>+        (foo.dart.getGetters):
>+        (foo.dart.getSetters):
>+        (foo.dart.getStaticMethods):
>+        (foo.dart.getStaticFields):
>+        (foo.dart.getStaticGetters):
>+        (foo.dart.getStaticSetters):
>+        (foo.dart.getGenericTypeCtor):
>+        (foo.dart.getType):
>+        (foo.dart.getLibraryUri):
>+        (foo.dart.setLibraryUri):
>+        (foo.dart.isJsInterop):
>+        (foo.dart.getMethodType):
>+        (foo.dart.getSetterType):
>+        (foo.dart.finalFieldType):
>+        (foo.dart.fieldType):
>+        (foo.dart.classGetConstructorType):
>+        (foo.dart.setMethodSignature):
>+        (foo.dart.setFieldSignature):
>+        (foo.dart.setGetterSignature):
>+        (foo.dart.setSetterSignature):
>+        (foo.dart.setConstructorSignature):
>+        (foo.dart.setStaticMethodSignature):
>+        (foo.dart.setStaticFieldSignature):
>+        (foo.dart.setStaticGetterSignature):
>+        (foo.dart.setStaticSetterSignature):
>+        (foo.dart._getMembers):
>+        (foo.dart._hasMember):
>+        (foo.dart.hasMethod):
>+        (foo.dart.hasGetter):
>+        (foo.dart.hasSetter):
>+        (foo.dart.hasField):
>+        (foo.dart._installProperties):
>+        (foo.dart._installPropertiesForObject):
>+        (foo.jsProto.dartx.toString):
>+        (foo.dart._installPropertiesForGlobalObject):
>+        (foo.dart._applyExtension):
>+        (foo.dart.applyExtension):
>+        (foo.dart.applyAllExtensions):
>+        (foo.dart.registerExtension):
>+        (foo.dart.defineExtensionMethods):
>+        (foo.dart.defineExtensionAccessors):
>+        (foo.dart.definePrimitiveHashCode):
>+        (foo.dart.setBaseClass):
>+        (foo.dart.setExtensionBaseClass):
>+        (foo.ctor.is):
>+        (foo.ctor.as):
>+        (foo.ctor._check):
>+        (foo.dart.addTypeTests):
>+        (foo.dart.fn):
>+        (foo.dart.getFunctionType):
>+        (foo.dart.getReifiedType):
>+        (foo.dart.getModuleName):
>+        (foo.dart.getModuleNames):
>+        (foo.dart.getSourceMap):
>+        (foo.dart.getModuleLibraries):
>+        (foo.dart.getModulePartMap):
>+        (foo.dart.trackLibraries):
>+        (foo.dart._computeLibraryMetadata):
>+        (foo.dart.getLibrary):
>+        (foo.dart.getLibraries):
>+        (foo.dart.getParts):
>+        (foo.dart._isJsObject):
>+        (foo.dart._warn):
>+        (foo.dart.lazyJSType):
>+        (foo.dart.anonymousJSType):
>+        (foo.dart.wrapType):
>+        (foo.dart.unwrapType):
>+        (foo.dart._memoizeArray):
>+        (foo.dart._canonicalizeArray):
>+        (foo.dart._canonicalizeNamed):
>+        (foo.dart._createSmall):
>+        (foo.dart._typeFormalsFromFunction):
>+        (foo.dart.fnType):
>+        (foo.dart.gFnType):
>+        (foo.dart.getFunctionTypeMirror):
>+        (foo.dart.isType):
>+        (foo.dart.checkTypeBound):
>+        (foo.dart.typeName):
>+        (foo.dart._isFunctionSubtype):
>+        (foo.dart.isSubtypeOf):
>+        (foo.dart._isSubtypeOrLegacySubtype):
>+        (foo.dart._isBottom):
>+        (foo.dart._isTop):
>+        (foo.dart._isFutureOr):
>+        (foo.let.t2Future.async Future):
>+        (foo.let.t1Future.async Future):
>+        (foo.async dart._isSubtype):
>+        (foo.definitive):
>+        (foo.dart._isInterfaceSubtype):
>+        (foo.dart.extractTypeArguments):
>+        (foo.dart._getMatchingSupertype):
>+        (foo.dart.trapRuntimeErrors):
>+        (foo.dart.ignoreWhitelistedErrors):
>+        (foo.dart.ignoreAllErrors):
>+        (foo.dart.argumentError):
>+        (foo.dart.throwUnimplementedError):
>+        (foo.dart.assertFailed):
>+        (foo.dart.throwCyclicInitializationError):
>+        (foo.dart.throwNullValueError):
>+        (foo.dart.castError):
>+        (foo.dart._castErrorMessage):
>+        (foo.dart.getThrown):
>+        (foo.dart.stackTrace):
>+        (foo.dart.stackTraceForError):
>+        (foo.dart.rethrow):
>+        (foo.dart.throw):
>+        (foo.dart.createErrorWithStack):
>+        (foo.dart.stackPrint):
>+        (foo.dart.bind):
>+        (foo.dart.bindCall):
>+        (foo.dart.gbind):
>+        (foo.dart.dloadRepl):
>+        (foo.dart.dload):
>+        (foo.dart.dloadMirror):
>+        (foo.dart._stripGenericArguments):
>+        (foo.dart.dputMirror):
>+        (foo.dart.dputRepl):
>+        (foo.dart.dput):
>+        (foo.dart._argumentErrors):
>+        (foo.dart._toSymbolName):
>+        (foo.dart._toDisplayName):
>+        (foo.dart._dartSymbol):
>+        (foo.dart._setterSymbol):
>+        (foo.callNSM):
>+        (foo.dart._checkAndCall):
>+        (foo.dart.dcall):
>+        (foo.dart.dgcall):
>+        (foo.dart.replNameLookup):
>+        (foo.dart._dhelperRepl):
>+        (foo.dart.callMethod):
>+        (foo.dart.dsend):
>+        (foo.dart.dgsend):
>+        (foo.dart.dsendRepl):
>+        (foo.dart.dgsendRepl):
>+        (foo.dart.dindex):
>+        (foo.dart.dsetindex):
>+        (foo.dart._isSubtypeOrIgnorableCastFailure):
>+        (foo.let.typeFuture.async Future):
>+        (foo.dart._ignoreTypeFailure):
>+        (foo.dart.is):
>+        (foo.dart.as):
>+        (foo.dart.test):
>+        (foo.dart.dtest):
>+        (foo.dart._throwBooleanConversionError):
>+        (foo.dart.booleanConversionFailed):
>+        (foo.dart.asInt):
>+        (foo.dart.notNull):
>+        (foo.dart._lookupNonTerminal):
>+        (foo.dart.constMap):
>+        (foo.dart._createImmutableSet):
>+        (foo.dart.constSet):
>+        (foo.dart.dassert):
>+        (foo.dart.multiKeyPutIfAbsent):
>+        (foo.dart.const):
>+        (foo.dart.constList):
>+        (foo.dart.constFn):
>+        (foo.dart.extensionSymbol):
>+        (foo.dart.equals):
>+        (foo.dart.hashCode):
>+        (foo.dart.toString):
>+        (foo.dart.str):
>+        (foo.dart.noSuchMethod):
>+        (foo.dart.defaultNoSuchMethod):
>+        (foo.dart.runtimeType):
>+        (foo.dart._canonicalMember):
>+        (foo.dart.defineLazy):
>+        (foo.dart.global):
>+        (foo.dart.addAsyncCallback):
>+        (foo.dart.removeAsyncCallback):
>+        (foo.core.Object):
>+        (foo.core.Object.prototype._equals):
>+        (foo.core.Object.prototype.get hashCode):
>+        (foo.core.Object.prototype.toString):
>+        (foo.core.Object.prototype.noSuchMethod):
>+        (foo.core.Object.prototype.get runtimeType):
>+        (foo):
>+        (foo.core.Object.is):
>+        (foo.core.Object.as):
>+        (foo.core.Object._check):
>+        (foo.dart.DartType.prototype.get name):
>+        (foo.dart.DartType.prototype.is):
>+        (foo.dart.DartType.prototype.as):
>+        (foo.dart.DartType.prototype._check):
>+        (foo.dart.DartType):
>+        (foo.dart.DynamicType.prototype.toString):
>+        (foo.dart.DynamicType.prototype.is):
>+        (foo.dart.DynamicType.prototype.as):
>+        (foo.dart.DynamicType.prototype._check):
>+        (foo.dart.DynamicType):
>+        (foo.dart.LazyJSType.prototype.toString):
>+        (foo.dart.LazyJSType.prototype._getRawJSType):
>+        (foo.dart.LazyJSType.prototype.rawJSTypeForCheck):
>+        (foo.dart.LazyJSType.prototype.isRawJSType):
>+        (foo.dart.LazyJSType.prototype.is):
>+        (foo.dart.LazyJSType.prototype.as):
>+        (foo.dart.LazyJSType.prototype._check):
>+        (foo.dart.LazyJSType):
>+        (foo.dart.AnonymousJSType.prototype.toString):
>+        (foo.dart.AnonymousJSType.prototype.is):
>+        (foo.dart.AnonymousJSType.prototype.as):
>+        (foo.dart.AnonymousJSType.prototype._check):
>+        (foo.dart.AnonymousJSType):
>+        (foo.dart.VoidType.prototype.toString):
>+        (foo.dart.VoidType):
>+        (foo.dart.BottomType.prototype.toString):
>+        (foo.dart.BottomType):
>+        (foo.return.async Future):
>+        (foo.dart.loadLibrary):
>+        (foo.get dart.JSObjectType.prototype.toString):
>+        (foo.get dart.JSObjectType):
>+        (foo.core.Type):
>+        (foo.dart._Type.prototype.toString):
>+        (foo.dart._Type.prototype.get runtimeType):
>+        (foo.dart._Type):
>+        (foo.get dart):
>+        (foo.dart.AbstractFunctionType):
>+        (foo.dart.FunctionType.create):
>+        (foo.dart.FunctionType.prototype._process):
>+        (foo.dart.FunctionType.prototype.toString):
>+        (foo.dart.FunctionType.prototype.get requiredParameterCount):
>+        (foo.dart.FunctionType.prototype.get positionalParameterCount):
>+        (foo.dart.FunctionType.prototype.getPositionalParameter):
>+        (foo.dart.FunctionType.prototype.getNamedParameters):
>+        (foo.dart.FunctionType.prototype.get name):
>+        (foo.dart.FunctionType.prototype.is):
>+        (foo.dart.FunctionType.prototype.as):
>+        (foo.dart.FunctionType.prototype._check):
>+        (foo.dart.FunctionType):
>+        (foo.async dart):
>+        (foo.dart.TypeVariable.prototype.get name):
>+        (foo.dart.TypeVariable.prototype.set name):
>+        (foo.dart.TypeVariable.prototype.toString):
>+        (foo.dart.TypeVariable):
>+        (foo.dart.GenericFunctionType.prototype.get typeFormals):
>+        (foo.dart.GenericFunctionType.prototype.checkBounds):
>+        (foo.dart.GenericFunctionType.prototype.instantiate):
>+        (foo.dart.GenericFunctionType.prototype.instantiateTypeBounds):
>+        (foo.dart.GenericFunctionType.prototype.toString):
>+        (foo.dart.GenericFunctionType.prototype.instantiateDefaultBounds.hasFreeFormal):
>+        (foo.dart.GenericFunctionType.prototype.instantiateDefaultBounds):
>+        (foo.dart.GenericFunctionType.prototype.is):
>+        (foo.dart.GenericFunctionType.prototype.as):
>+        (foo.dart.GenericFunctionType.prototype._check):
>+        (foo.dart.GenericFunctionType):
>+        (foo.dart._TypeInferrer.prototype.getInferredTypes):
>+        (foo.dart._TypeInferrer.prototype.trySubtypeMatch):
>+        (foo.dart._TypeInferrer.prototype._constrainLower):
>+        (foo.dart._TypeInferrer.prototype._constrainUpper):
>+        (foo.dart._TypeInferrer.prototype._isFunctionSubtypeMatch):
>+        (foo.dart._TypeInferrer.prototype._isInterfaceSubtypeMatch):
>+        (foo.dart._TypeInferrer.prototype._isNull):
>+        (foo.dart._TypeInferrer.prototype._isSubtypeMatch.let.supertypeFuture.async Future):
>+        (foo.dart._TypeInferrer.prototype._isSubtypeMatch.let.subtypeFuture.async Future):
>+        (foo.dart._TypeInferrer.prototype._isSubtypeMatch):
>+        (foo.dart._TypeInferrer.prototype._isTop):
>+        (foo.dart._TypeInferrer):
>+        (foo.dart.TypeConstraint.prototype._constrainLower):
>+        (foo.dart.TypeConstraint.prototype._constrainUpper):
>+        (foo.dart.TypeConstraint.prototype.toString):
>+        (foo.dart.TypeConstraint):
>+        (foo.dart.DartError):
>+        (foo.dart.DartError.prototype.get message):
>+        (foo.dart.RethrownDartError):
>+        (foo.dart.RethrownDartError.prototype.get message):
>+        (foo.dart._StackTrace.prototype.toString):
>+        (foo.dart._StackTrace):
>+        (foo.core.Invocation.method):
>+        (foo.core.Invocation.genericMethod):
>+        (foo.core.Invocation.getter):
>+        (foo.core.Invocation.setter):
>+        (foo.core.Invocation.prototype.get typeArguments):
>+        (foo.core.Invocation.prototype.get isAccessor):
>+        (foo.core.Invocation):
>+        (foo.dart.InvocationImpl.prototype.get typeArguments):
>+        (foo.dart.InvocationImpl.prototype.set typeArguments):
>+        (foo.dart.InvocationImpl._namedArgsToSymbols):
>+        (foo.dart.InvocationImpl):
>+        (foo.dart.JsIterator):
>+        (foo.dart.JsIterator.prototype.next):
>+        (foo._debugger.JsonMLConfig.prototype.toString):
>+        (foo._debugger.JsonMLConfig):
>+        (foo.set get return):
>+        (foo.dart.lazyFn):
>+        (foo.set get _debugger._typeof):
>+        (foo._debugger.getOwnPropertyNames):
>+        (foo._debugger.getOwnPropertySymbols):
>+        (foo._debugger.JSNative.getProperty):
>+        (foo._debugger.JSNative.setProperty):
>+        (foo._debugger.JSNative):
>+        (foo._debugger.addMetadataChildren):
>+        (foo._debugger.addPropertiesFromSignature):
>+        (foo._debugger.sortProperties):
>+        (foo._debugger.getObjectTypeName):
>+        (foo._debugger.getTypeName):
>+        (foo._debugger.safePreview):
>+        (foo._debugger.symbolName):
>+        (foo._debugger.hasMethod):
>+        (foo._debugger.NameValuePair.prototype._equals):
>+        (foo._debugger.NameValuePair.prototype.get hashCode):
>+        (foo._debugger.NameValuePair.prototype.get displayName):
>+        (foo._debugger.NameValuePair):
>+        (foo.set get _debugger):
>+        (foo._debugger.MapEntry):
>+        (foo._debugger.IterableSpan.prototype.get length):
>+        (foo._debugger.IterableSpan.prototype.get maxPowerOfSubsetSize):
>+        (foo._debugger.IterableSpan.prototype.get subsetSize):
>+        (foo._debugger.IterableSpan.prototype.asMap):
>+        (foo._debugger.IterableSpan.prototype.children):
>+        (foo._debugger.IterableSpan):
>+        (foo._debugger.Library):
>+        (foo._debugger.NamedConstructor):
>+        (foo._debugger.HeritageClause):
>+        (foo._debugger.safeGetProperty):
>+        (foo._debugger.safeProperties):
>+        (foo._debugger.JsonMLElement.prototype.appendChild):
>+        (foo._debugger.JsonMLElement.prototype.createChild):
>+        (foo._debugger.JsonMLElement.prototype.createObjectTag):
>+        (foo._debugger.JsonMLElement.prototype.setStyle):
>+        (foo._debugger.JsonMLElement.prototype.addStyle):
>+        (foo._debugger.JsonMLElement.prototype.addAttribute):
>+        (foo._debugger.JsonMLElement.prototype.createTextChild):
>+        (foo._debugger.JsonMLElement.prototype.toJsonML):
>+        (foo._debugger.JsonMLElement):
>+        (foo._debugger.isNativeJavaScriptObject):
>+        (foo._debugger.JsonMLFormatter.prototype.setMaxSpanLengthForTestingOnly):
>+        (foo._debugger.JsonMLFormatter.prototype.header):
>+        (foo._debugger.JsonMLFormatter.prototype.hasBody):
>+        (foo._debugger.JsonMLFormatter.prototype.body):
>+        (foo._debugger.JsonMLFormatter):
>+        (foo._debugger.Formatter):
>+        (foo._debugger.DartFormatter.prototype.preview):
>+        (foo._debugger.DartFormatter.prototype.hasChildren):
>+        (foo._debugger.DartFormatter.prototype.children):
>+        (foo._debugger.DartFormatter):
>+        (foo._debugger.ObjectFormatter.prototype.accept):
>+        (foo._debugger.ObjectFormatter.prototype.preview):
>+        (foo._debugger.ObjectFormatter.prototype.hasChildren):
>+        (foo._debugger.ObjectFormatter.prototype.children):
>+        (foo._debugger.ObjectFormatter):
>+        (foo._debugger.ObjectInternalsFormatter.prototype.accept):
>+        (foo._debugger.ObjectInternalsFormatter.prototype.preview):
>+        (foo._debugger.ObjectInternalsFormatter):
>+        (foo._debugger.LibraryModuleFormatter.prototype.accept):
>+        (foo._debugger.LibraryModuleFormatter.prototype.hasChildren):
>+        (foo._debugger.LibraryModuleFormatter.prototype.preview):
>+        (foo._debugger.LibraryModuleFormatter.prototype.children):
>+        (foo._debugger.LibraryModuleFormatter):
>+        (foo._debugger.LibraryFormatter.prototype.accept):
>+        (foo._debugger.LibraryFormatter.prototype.hasChildren):
>+        (foo._debugger.LibraryFormatter.prototype.preview):
>+        (foo._debugger.LibraryFormatter.prototype.children):
>+        (foo._debugger.LibraryFormatter.prototype.classChild):
>+        (foo._debugger.LibraryFormatter):
>+        (foo._debugger.FunctionFormatter.prototype.accept):
>+        (foo._debugger.FunctionFormatter.prototype.hasChildren):
>+        (foo._debugger.FunctionFormatter.prototype.preview):
>+        (foo._debugger.FunctionFormatter.prototype.children):
>+        (foo._debugger.FunctionFormatter):
>+        (foo._debugger.MapOverviewFormatter.prototype.accept):
>+        (foo._debugger.MapOverviewFormatter.prototype.hasChildren):
>+        (foo._debugger.MapOverviewFormatter.prototype.preview):
>+        (foo._debugger.MapOverviewFormatter.prototype.children):
>+        (foo._debugger.MapOverviewFormatter):
>+        (foo._debugger.MapFormatter.prototype.accept):
>+        (foo._debugger.MapFormatter.prototype.hasChildren):
>+        (foo._debugger.MapFormatter.prototype.preview):
>+        (foo._debugger.MapFormatter.prototype.children):
>+        (foo._debugger.MapFormatter):
>+        (foo._debugger.IterableFormatter.prototype.accept):
>+        (foo._debugger.IterableFormatter.prototype.preview):
>+        (foo._debugger.IterableFormatter.prototype.hasChildren):
>+        (foo._debugger.IterableFormatter.prototype.children):
>+        (foo._debugger.IterableFormatter):
>+        (foo._debugger.NamedConstructorFormatter.prototype.accept):
>+        (foo._debugger.NamedConstructorFormatter.prototype.preview):
>+        (foo._debugger.NamedConstructorFormatter.prototype.hasChildren):
>+        (foo._debugger.NamedConstructorFormatter.prototype.children):
>+        (foo._debugger.NamedConstructorFormatter):
>+        (foo._debugger.MapEntryFormatter.prototype.accept):
>+        (foo._debugger.MapEntryFormatter.prototype.preview):
>+        (foo._debugger.MapEntryFormatter.prototype.hasChildren):
>+        (foo._debugger.MapEntryFormatter.prototype.children):
>+        (foo._debugger.MapEntryFormatter):
>+        (foo._debugger.HeritageClauseFormatter.prototype.accept):
>+        (foo._debugger.HeritageClauseFormatter.prototype.preview):
>+        (foo._debugger.HeritageClauseFormatter.prototype.hasChildren):
>+        (foo._debugger.HeritageClauseFormatter.prototype.children):
>+        (foo._debugger.HeritageClauseFormatter):
>+        (foo._debugger.IterableSpanFormatter.prototype.accept):
>+        (foo._debugger.IterableSpanFormatter.prototype.preview):
>+        (foo._debugger.IterableSpanFormatter.prototype.hasChildren):
>+        (foo._debugger.IterableSpanFormatter.prototype.children):
>+        (foo._debugger.IterableSpanFormatter):
>+        (foo._debugger.ErrorAndExceptionFormatter.prototype.accept):
>+        (foo._debugger.ErrorAndExceptionFormatter.prototype.hasChildren):
>+        (foo._debugger.ErrorAndExceptionFormatter.prototype.preview):
>+        (foo._debugger.ErrorAndExceptionFormatter.prototype.children):
>+        (foo._debugger.ErrorAndExceptionFormatter.prototype.addInstanceMembers):
>+        (foo._debugger.ErrorAndExceptionFormatter):
>+        (foo.get _debugger.StackTraceFormatter.prototype.accept):
>+        (foo.get _debugger.StackTraceFormatter.prototype.preview):
>+        (foo.get _debugger.StackTraceFormatter.prototype.hasChildren):
>+        (foo.get _debugger.StackTraceFormatter.prototype.children):
>+        (foo.get _debugger.StackTraceFormatter):
>+        (foo.get _debugger):
>+        (foo._debugger.ClassFormatter.prototype.accept):
>+        (foo._debugger.ClassFormatter.prototype.preview):
>+        (foo._debugger.ClassFormatter.prototype.hasChildren):
>+        (foo._debugger.ClassFormatter.prototype.children):
>+        (foo._debugger.ClassFormatter):
>+        (foo._debugger.TypeFormatter.prototype.accept):
>+        (foo._debugger.TypeFormatter.prototype.preview):
>+        (foo._debugger.TypeFormatter.prototype.hasChildren):
>+        (foo._debugger.TypeFormatter.prototype.children):
>+        (foo._debugger.TypeFormatter):
>+        (foo.get _debugger.registerDevtoolsFormatter):
>+        (foo._debugger.getModuleNames):
>+        (foo._debugger.getModuleLibraries):
>+        (foo._debugger._MethodStats):
>+        (foo._debugger._CallMethodRecord):
>+        (foo.set get _debugger.getDynamicStats):
>+        (foo._debugger.clearDynamicStats):
>+        (foo.get _debugger.trackCall):
>+        (foo._foreign_helper.JS):
>+        (foo._foreign_helper.JSExportName):
>+        (foo._foreign_helper.JS_DART_OBJECT_CONSTRUCTOR):
>+        (foo._foreign_helper.JS_INTERCEPTOR_CONSTANT):
>+        (foo._foreign_helper.JS_OPERATOR_IS_PREFIX):
>+        (foo._foreign_helper.JS_OPERATOR_AS_PREFIX):
>+        (foo._foreign_helper.JS_OBJECT_CLASS_NAME):
>+        (foo._foreign_helper.JS_NULL_CLASS_NAME):
>+        (foo._foreign_helper.JS_FUNCTION_CLASS_NAME):
>+        (foo._foreign_helper.JS_IS_INDEXABLE_FIELD_NAME):
>+        (foo._foreign_helper.JS_SIGNATURE_NAME):
>+        (foo._foreign_helper.JS_TYPEDEF_TAG):
>+        (foo._foreign_helper.JS_FUNCTION_TYPE_TAG):
>+        (foo._foreign_helper.JS_FUNCTION_TYPE_VOID_RETURN_TAG):
>+        (foo._foreign_helper.JS_FUNCTION_TYPE_RETURN_TYPE_TAG):
>+        (foo._foreign_helper.JS_FUNCTION_TYPE_REQUIRED_PARAMETERS_TAG):
>+        (foo._foreign_helper.JS_FUNCTION_TYPE_OPTIONAL_PARAMETERS_TAG):
>+        (foo._foreign_helper.JS_FUNCTION_TYPE_NAMED_PARAMETERS_TAG):
>+        (foo._foreign_helper.JS_GET_NAME):
>+        (foo._foreign_helper.JS_GET_FLAG):
>+        (foo._foreign_helper.JS_EFFECT):
>+        (foo._foreign_helper.JS_CONST):
>+        (foo._foreign_helper.JS_STRING_CONCAT):
>+        (foo._foreign_helper._Rest):
>+        (foo.get _foreign_helper.spread):
>+        (foo._interceptors.Interceptor.prototype.toString):
>+        (foo._interceptors.Interceptor):
>+        (foo._interceptors.getInterceptor):
>+        (foo._interceptors.JSBool.prototype.toString):
>+        (foo._interceptors.JSBool.prototype.get hashCode):
>+        (foo._interceptors.JSBool.prototype.bitAnd):
>+        (foo._interceptors.JSBool.prototype.bitOr):
>+        (foo._interceptors.JSBool.prototype.bitXor):
>+        (foo._interceptors.JSBool.prototype.get runtimeType):
>+        (foo._interceptors.JSBool):
>+        (foo.get _foreign_helper):
>+        (foo._interceptors.JSIndexable.dart.generic):
>+        (foo._interceptors.JSObject):
>+        (foo._interceptors.JavaScriptObject.prototype.get hashCode):
>+        (foo._interceptors.JavaScriptObject.prototype.get runtimeType):
>+        (foo._interceptors.JavaScriptObject):
>+        (foo._interceptors.PlainJavaScriptObject):
>+        (foo._interceptors.UnknownJavaScriptObject.prototype.toString):
>+        (foo._interceptors.UnknownJavaScriptObject):
>+        (foo._interceptors.NativeError.prototype.dartStack):
>+        (foo._interceptors.NativeError):
>+        (foo._interceptors.JSNoSuchMethodError.prototype._fieldName):
>+        (foo._interceptors.JSNoSuchMethodError.prototype._functionCallTarget):
>+        (foo._interceptors.JSNoSuchMethodError.prototype.dartStack):
>+        (foo._interceptors.JSNoSuchMethodError.prototype.get stackTrace):
>+        (foo._interceptors.JSNoSuchMethodError.prototype.toString):
>+        (foo._interceptors.JSNoSuchMethodError):
>+        (foo._interceptors.JSFunction.prototype.toString):
>+        (foo._interceptors.JSFunction.prototype._equals):
>+        (foo._interceptors.JSFunction.prototype.get hashCode):
>+        (foo._interceptors.JSFunction.prototype.get runtimeType):
>+        (foo._interceptors.JSFunction):
>+        (foo._interceptors.JSNull.prototype.toString):
>+        (foo._interceptors.JSNull.prototype.noSuchMethod):
>+        (foo._interceptors.JSNull):
>+        (foo.get _interceptors.JSRangeError.prototype.get stackTrace):
>+        (foo.get _interceptors.JSRangeError.prototype.get invalidValue):
>+        (foo.get _interceptors.JSRangeError.prototype.get name):
>+        (foo.get _interceptors.JSRangeError.prototype.get message):
>+        (foo.get _interceptors.JSRangeError.prototype.toString):
>+        (foo.get _interceptors.JSRangeError):
>+        (foo.get _interceptors):
>+        (foo._interceptors.findInterceptorConstructorForType):
>+        (foo._interceptors.findConstructorForNativeSubclassType):
>+        (foo._interceptors.getNativeInterceptor):
>+        (foo._interceptors.setDispatchProperty):
>+        (foo._interceptors.JSArray.dart.generic):
>+        (foo._interceptors.JSMutableArray.dart.generic):
>+        (foo._interceptors.JSFixedArray.dart.generic):
>+        (foo._interceptors.JSExtendableArray.dart.generic):
>+        (foo._interceptors.JSUnmodifiableArray.dart.generic):
>+        (foo._interceptors.ArrayIterator.dart.generic):
>+        (foo._interceptors.JSNumber.prototype.compareTo):
>+        (foo._interceptors.JSNumber.prototype.get isNegative):
>+        (foo._interceptors.JSNumber.prototype.get isNaN):
>+        (foo._interceptors.JSNumber.prototype.get isInfinite):
>+        (foo._interceptors.JSNumber.prototype.get isFinite):
>+        (foo._interceptors.JSNumber.prototype.remainder):
>+        (foo._interceptors.JSNumber.prototype.abs):
>+        (foo._interceptors.JSNumber.prototype.get sign):
>+        (foo._interceptors.JSNumber.prototype.toInt):
>+        (foo._interceptors.JSNumber.prototype.truncate):
>+        (foo._interceptors.JSNumber.prototype.ceil):
>+        (foo._interceptors.JSNumber.prototype.floor):
>+        (foo._interceptors.JSNumber.prototype.round):
>+        (foo._interceptors.JSNumber.prototype.ceilToDouble):
>+        (foo._interceptors.JSNumber.prototype.floorToDouble):
>+        (foo._interceptors.JSNumber.prototype.roundToDouble):
>+        (foo._interceptors.JSNumber.prototype.truncateToDouble):
>+        (foo._interceptors.JSNumber.prototype.clamp):
>+        (foo._interceptors.JSNumber.prototype.toDouble):
>+        (foo._interceptors.JSNumber.prototype.toStringAsFixed):
>+        (foo._interceptors.JSNumber.prototype.toStringAsExponential):
>+        (foo._interceptors.JSNumber.prototype.toStringAsPrecision):
>+        (foo._interceptors.JSNumber.prototype.toRadixString):
>+        (foo._interceptors.JSNumber._handleIEtoString):
>+        (foo._interceptors.JSNumber.prototype.toString):
>+        (foo._interceptors.JSNumber.prototype.get hashCode):
>+        (foo._interceptors.JSNumber.prototype._negate):
>+        (foo._interceptors.JSNumber.prototype.plus):
>+        (foo._interceptors.JSNumber.prototype.minus):
>+        (foo._interceptors.JSNumber.prototype.divide):
>+        (foo._interceptors.JSNumber.prototype.times):
>+        (foo._interceptors.JSNumber.prototype.modulo):
>+        (foo._interceptors.JSNumber.prototype._isInt32):
>+        (foo._interceptors.JSNumber.prototype.floorDivide):
>+        (foo._interceptors.JSNumber.prototype._tdivSlow):
>+        (foo._interceptors.JSNumber.prototype.leftShift):
>+        (foo._interceptors.JSNumber.prototype._shlPositive):
>+        (foo._interceptors.JSNumber.prototype.rightShift):
>+        (foo._interceptors.JSNumber.prototype._shrOtherPositive):
>+        (foo._interceptors.JSNumber.prototype._shrBothPositive):
>+        (foo._interceptors.JSNumber.prototype.bitAnd):
>+        (foo._interceptors.JSNumber.prototype.bitOr):
>+        (foo._interceptors.JSNumber.prototype.bitXor):
>+        (foo._interceptors.JSNumber.prototype.lessThan):
>+        (foo._interceptors.JSNumber.prototype.greaterThan):
>+        (foo._interceptors.JSNumber.prototype.lessOrEquals):
>+        (foo._interceptors.JSNumber.prototype.greaterOrEquals):
>+        (foo._interceptors.JSNumber.prototype.get isEven):
>+        (foo._interceptors.JSNumber.prototype.get isOdd):
>+        (foo._interceptors.JSNumber.prototype.toUnsigned):
>+        (foo._interceptors.JSNumber.prototype.toSigned):
>+        (foo._interceptors.JSNumber.prototype.get bitLength):
>+        (foo._interceptors.JSNumber._clz32):
>+        (foo._interceptors.JSNumber.prototype.modPow):
>+        (foo._interceptors.JSNumber._binaryGcd):
>+        (foo._interceptors.JSNumber.prototype.modInverse):
>+        (foo._interceptors.JSNumber.prototype.gcd):
>+        (foo._interceptors.JSNumber._bitCount):
>+        (foo._interceptors.JSNumber._shru):
>+        (foo._interceptors.JSNumber._shrs):
>+        (foo._interceptors.JSNumber._ors):
>+        (foo._interceptors.JSNumber._spread):
>+        (foo._interceptors.JSNumber.prototype.bitNot):
>+        (foo._interceptors.JSNumber):
>+        (foo._interceptors.JSString.prototype.codeUnitAt):
>+        (foo._interceptors.JSString.prototype.allMatches):
>+        (foo._interceptors.JSString.prototype.matchAsPrefix):
>+        (foo._interceptors.JSString.prototype.plus):
>+        (foo._interceptors.JSString.prototype.endsWith):
>+        (foo._interceptors.JSString.prototype.replaceAll):
>+        (foo._interceptors.JSString.prototype.replaceAllMapped):
>+        (foo._interceptors.JSString.prototype.splitMapJoin):
>+        (foo._interceptors.JSString.prototype.replaceFirst):
>+        (foo._interceptors.JSString.prototype.replaceFirstMapped):
>+        (foo._interceptors.JSString.prototype.split):
>+        (foo._interceptors.JSString.prototype.replaceRange):
>+        (foo._interceptors.JSString.prototype._defaultSplit):
>+        (foo._interceptors.JSString.prototype.startsWith):
>+        (foo._interceptors.JSString.prototype.substring):
>+        (foo._interceptors.JSString.prototype.toLowerCase):
>+        (foo._interceptors.JSString.prototype.toUpperCase):
>+        (foo._interceptors.JSString._isWhitespace):
>+        (foo._interceptors.JSString._skipLeadingWhitespace):
>+        (foo._interceptors.JSString._skipTrailingWhitespace):
>+        (foo._interceptors.JSString.prototype.trim):
>+        (foo._interceptors.JSString.prototype.trimLeft):
>+        (foo._interceptors.JSString.prototype.trimRight):
>+        (foo._interceptors.JSString.prototype.times):
>+        (foo._interceptors.JSString.prototype.padLeft):
>+        (foo._interceptors.JSString.prototype.padRight):
>+        (foo._interceptors.JSString.prototype.get codeUnits):
>+        (foo._interceptors.JSString.prototype.get runes):
>+        (foo._interceptors.JSString.prototype.indexOf):
>+        (foo._interceptors.JSString.prototype.lastIndexOf):
>+        (foo._interceptors.JSString.prototype.contains):
>+        (foo._interceptors.JSString.prototype.get isEmpty):
>+        (foo._interceptors.JSString.prototype.get isNotEmpty):
>+        (foo._interceptors.JSString.prototype.compareTo):
>+        (foo._interceptors.JSString.prototype.toString):
>+        (foo._interceptors.JSString.prototype.get hashCode):
>+        (foo._interceptors.JSString.prototype.get runtimeType):
>+        (foo._interceptors.JSString.prototype.get length):
>+        (foo._interceptors.JSString.prototype._get):
>+        (foo._interceptors.JSString):
>+        (foo.collection.ListMixin.dart.generic):
>+        (foo.get const):
>+        (foo.collection.ListBase.dart.generic):
>+        (foo._internal.UnmodifiableListMixin.dart.generic):
>+        (foo._internal.UnmodifiableListBase.dart.generic):
>+        (foo.core.num.parse):
>+        (foo.core.num.tryParse):
>+        (foo.core.num._returnIntNull):
>+        (foo.core.num._returnDoubleNull):
>+        (foo.core.num):
>+        (foo.core.num.is):
>+        (foo.core.num.as):
>+        (foo.core.num._check):
>+        (foo.core.int.fromEnvironment):
>+        (foo.core.int.parse):
>+        (foo.core.int.tryParse):
>+        (foo.core.int):
>+        (foo.core.int.is):
>+        (foo.core.int.as):
>+        (foo.core.int._check):
>+        (foo._internal.CodeUnits.prototype.get length):
>+        (foo._internal.CodeUnits.prototype.set length):
>+        (foo._internal.CodeUnits.prototype._get):
>+        (foo._internal.CodeUnits.stringOf):
>+        (foo._internal.CodeUnits):
>+        (foo._internal.ExternalName):
>+        (foo._internal.hexDigitValue):
>+        (foo._internal.parseHexByte):
>+        (foo._internal.extractTypeArguments):
>+        (foo._internal.Since):
>+        (foo._internal.HttpStatus):
>+        (foo.async Stream.dart.generic.):
>+        (foo.async Stream.dart.generic):
>+        (foo.async Stream):
>+        (foo.):
>+        (foo.async const):
>+        (foo.prototype._internal.CastStreamSubscription.dart.generic):
>+        (foo.prototype.async StreamTransformerBase):
>+        (foo.prototype.convert.Converter.dart.generic):
>+        (foo.prototype._internal.CastConverter.dart.generic):
>+        (foo.core.Iterable.dart.generic):
>+        (foo.prototype._internal._CastIterableBase.dart.generic):
>+        (foo.prototype._internal.CastIterator.dart.generic):
>+        (foo.prototype._internal.CastIterable.dart.generic):
>+        (foo.prototype._internal._EfficientLengthCastIterable.dart.generic):
>+        (foo.prototype._internal._CastListBase.dart.generic):
>+        (foo.prototype._internal.CastList.dart.generic):
>+        (foo.prototype._internal.CastSet.dart.generic):
>+        (foo.prototype.collection.MapMixin.dart.generic):
>+        (foo.prototype.collection.MapBase.dart.generic):
>+        (foo.prototype._internal.CastMap.dart.generic):
>+        (foo.prototype._internal.CastQueue.dart.generic):
>+        (foo._internal.EfficientLengthIterable.dart.generic):
>+        (foo._internal.ListIterable.dart.generic):
>+        (foo._internal.SubListIterable.dart.generic):
>+        (foo._internal.ListIterator.dart.generic):
>+        (foo.prototype._internal.MappedIterable.dart.generic):
>+        (foo.prototype._internal.EfficientLengthMappedIterable.dart.generic):
>+        (foo.core.Iterator.dart.generic):
>+        (foo.prototype._internal.MappedIterator.dart.generic):
>+        (foo.prototype._internal.MappedListIterable.dart.generic):
>+        (foo._internal.WhereIterable.dart.generic):
>+        (foo._internal.WhereIterator.dart.generic):
>+        (foo.prototype._internal.ExpandIterable.dart.generic):
>+        (foo.prototype._internal.ExpandIterator.dart.generic):
>+        (foo._internal.TakeIterable.dart.generic):
>+        (foo._internal.EfficientLengthTakeIterable.dart.generic):
>+        (foo._internal.TakeIterator.dart.generic):
>+        (foo._internal.TakeWhileIterable.dart.generic):
>+        (foo._internal.TakeWhileIterator.dart.generic):
>+        (foo._internal.SkipIterable.dart.generic):
>+        (foo._internal.EfficientLengthSkipIterable.dart.generic):
>+        (foo._internal._checkCount):
>+        (foo._internal.SkipIterator.dart.generic):
>+        (foo._internal.SkipWhileIterable.dart.generic):
>+        (foo._internal.SkipWhileIterator.dart.generic):
>+        (foo._internal.EmptyIterable.dart.generic):
>+        (foo._internal.EmptyIterator.dart.generic):
>+        (foo._internal.FollowedByIterable.dart.generic):
>+        (foo._internal.EfficientLengthFollowedByIterable.dart.generic):
>+        (foo._internal.FollowedByIterator.dart.generic):
>+        (foo._internal.WhereTypeIterable.dart.generic):
>+        (foo._internal.WhereTypeIterator.dart.generic):
>+        (foo._internal.IterableElementError.noElement):
>+        (foo._internal.IterableElementError.tooMany):
>+        (foo._internal.IterableElementError.tooFew):
>+        (foo._internal.IterableElementError):
>+        (foo._internal.FixedLengthListMixin.dart.generic):
>+        (foo._internal.FixedLengthListBase.dart.generic):
>+        (foo._internal._ListIndicesIterable.prototype.get length):
>+        (foo._internal._ListIndicesIterable.prototype.elementAt):
>+        (foo._internal._ListIndicesIterable):
>+        (foo.prototype.collection._UnmodifiableMapMixin.dart.generic):
>+        (foo.prototype.collection.UnmodifiableMapBase.dart.generic):
>+        (foo._internal.ListMapView.dart.generic):
>+        (foo._internal.ReversedListIterable.dart.generic):
>+        (foo._internal.UnmodifiableListError.add):
>+        (foo._internal.UnmodifiableListError.change):
>+        (foo._internal.UnmodifiableListError.length):
>+        (foo._internal.UnmodifiableListError.remove):
>+        (foo._internal.UnmodifiableListError):
>+        (foo._internal.NonGrowableListError.add):
>+        (foo._internal.NonGrowableListError.length):
>+        (foo._internal.NonGrowableListError.remove):
>+        (foo._internal.NonGrowableListError):
>+        (foo._internal.makeListFixedLength):
>+        (foo._internal.makeFixedListUnmodifiable):
>+        (foo.set get _internal.printToConsole):
>+        (foo._internal.Sort.sort):
>+        (foo._internal.Sort.sortRange):
>+        (foo._internal.Sort._doSort):
>+        (foo._internal.Sort._insertionSort):
>+        (foo._internal.Sort._dualPivotQuicksort):
>+        (foo._internal.Sort):
>+        (foo.prototype.set get _internal):
>+        (foo._internal.Symbol.prototype._equals):
>+        (foo._internal.Symbol.prototype.get hashCode):
>+        (foo._internal.Symbol.prototype.toString):
>+        (foo._internal.Symbol.getName):
>+        (foo._internal.Symbol.validatePublicSymbol):
>+        (foo._internal.Symbol.isValidSymbol):
>+        (foo._internal.Symbol.computeUnmangledName):
>+        (foo._internal.Symbol):
>+        (foo.prototype.get const):
>+        (foo.collection.IterableBase.dart.generic):
>+        (foo._internal.LinkedList.dart.generic):
>+        (foo._internal.LinkedListEntry.dart.generic):
>+        (foo._internal._LinkedListIterator.dart.generic):
>+        (foo._isolate_helper.startRootIsolate):
>+        (foo._isolate_helper.TimerImpl.prototype.get tick):
>+        (foo._isolate_helper.TimerImpl.prototype.cancel):
>+        (foo._isolate_helper.TimerImpl.prototype.get isActive):
>+        (foo._isolate_helper.TimerImpl):
>+        (foo._isolate_helper.TimerImpl.dart.implements.async Timer):
>+        (foo._isolate_helper.hasTimer):
>+        (foo._js_helper._Patch):
>+        (foo._js_helper.DartIterator.dart.generic):
>+        (foo._js_helper.SyncIterable.dart.generic):
>+        (foo._js_helper.Primitives._parseIntError):
>+        (foo._js_helper.Primitives.parseInt):
>+        (foo._js_helper.Primitives._parseDoubleError):
>+        (foo._js_helper.Primitives.parseDouble):
>+        (foo._js_helper.Primitives.dateNow):
>+        (foo._js_helper.Primitives.initTicker):
>+        (foo._js_helper.Primitives.get isD8):
>+        (foo._js_helper.Primitives.get isJsshell):
>+        (foo._js_helper.Primitives.currentUri):
>+        (foo._js_helper.Primitives._fromCharCodeApply):
>+        (foo._js_helper.Primitives.stringFromCodePoints):
>+        (foo._js_helper.Primitives.stringFromCharCodes):
>+        (foo._js_helper.Primitives.stringFromNativeUint8List):
>+        (foo._js_helper.Primitives.stringFromCharCode):
>+        (foo._js_helper.Primitives.stringConcatUnchecked):
>+        (foo._js_helper.Primitives.flattenString):
>+        (foo._js_helper.Primitives.getTimeZoneName):
>+        (foo._js_helper.Primitives.getTimeZoneOffsetInMinutes):
>+        (foo._js_helper.Primitives.valueFromDecomposedDate):
>+        (foo._js_helper.Primitives.patchUpY2K):
>+        (foo._js_helper.Primitives.lazyAsJsDate):
>+        (foo._js_helper.Primitives.getYear):
>+        (foo._js_helper.Primitives.getMonth):
>+        (foo._js_helper.Primitives.getDay):
>+        (foo._js_helper.Primitives.getHours):
>+        (foo._js_helper.Primitives.getMinutes):
>+        (foo._js_helper.Primitives.getSeconds):
>+        (foo._js_helper.Primitives.getMilliseconds):
>+        (foo._js_helper.Primitives.getWeekday):
>+        (foo._js_helper.Primitives.valueFromDateString):
>+        (foo._js_helper.Primitives.getProperty):
>+        (foo._js_helper.Primitives.setProperty):
>+        (foo._js_helper.Primitives):
>+        (foo.set get _js_helper.diagnoseIndexError):
>+        (foo._js_helper.diagnoseRangeError):
>+        (foo._js_helper.stringLastIndexOfUnchecked):
>+        (foo._js_helper.argumentErrorValue):
>+        (foo._js_helper.throwArgumentErrorValue):
>+        (foo._js_helper.checkInt):
>+        (foo._js_helper.throwRuntimeError):
>+        (foo._js_helper.throwAbstractClassInstantiationError):
>+        (foo._js_helper.throwConcurrentModificationError):
>+        (foo.core.Error.safeToString):
>+        (foo.core.Error._stringToSafeString):
>+        (foo.core.Error._objectToString):
>+        (foo.core.Error.prototype.get stackTrace):
>+        (foo.core.Error):
>+        (foo.prototype.set get _js_helper):
>+        (foo._js_helper.JsNoSuchMethodError.prototype.toString):
>+        (foo._js_helper.JsNoSuchMethodError):
>+        (foo._js_helper.UnknownJsTypeError.prototype.toString):
>+        (foo._js_helper.UnknownJsTypeError):
>+        (foo._js_helper.fillLiteralMap):
>+        (foo._js_helper.jsHasOwnProperty):
>+        (foo._js_helper.jsPropertyAccess):
>+        (foo._js_helper.getFallThroughError):
>+        (foo._js_helper.Creates):
>+        (foo._js_helper.Returns):
>+        (foo._js_helper.JSName):
>+        (foo._js_helper.JavaScriptIndexingBehavior.dart.generic):
>+        (foo._js_helper.TypeErrorImpl.prototype.toString):
>+        (foo._js_helper.TypeErrorImpl):
>+        (foo._js_helper.CastErrorImpl.prototype.toString):
>+        (foo._js_helper.CastErrorImpl):
>+        (foo.core.FallThroughError.prototype.toString):
>+        (foo.core.FallThroughError):
>+        (foo._js_helper.FallThroughErrorImplementation.prototype.toString):
>+        (foo._js_helper.FallThroughErrorImplementation):
>+        (foo._js_helper.RuntimeError.prototype.toString):
>+        (foo._js_helper.RuntimeError):
>+        (foo.core.AssertionError.prototype.get message):
>+        (foo.core.AssertionError.prototype.set message):
>+        (foo.core.AssertionError.prototype.toString):
>+        (foo.core.AssertionError):
>+        (foo._js_helper.AssertionErrorImpl.prototype.toString):
>+        (foo._js_helper.AssertionErrorImpl):
>+        (foo._js_helper.random64):
>+        (foo._js_helper.BooleanConversionAssertionError.prototype.toString):
>+        (foo._js_helper.BooleanConversionAssertionError):
>+        (foo._js_helper.registerGlobalObject):
>+        (foo._js_helper.applyExtension):
>+        (foo._js_helper.PrivateSymbol.getName):
>+        (foo._js_helper.PrivateSymbol.getNativeSymbol):
>+        (foo._js_helper.PrivateSymbol.prototype._equals):
>+        (foo._js_helper.PrivateSymbol.prototype.get hashCode):
>+        (foo._js_helper.PrivateSymbol.prototype.toString):
>+        (foo._js_helper.PrivateSymbol):
>+        (foo._js_helper.ForceInline):
>+        (foo._js_helper._NotNull):
>+        (foo.get _js_helper.NoReifyGeneric):
>+        (foo._js_helper.ReifyFunctionTypes):
>+        (foo.prototype.get _js_helper):
>+        (foo._js_helper._NullCheck):
>+        (foo.get _js_helper._Undefined):
>+        (foo.get _js_helper.NoThrows):
>+        (foo._js_helper.NoInline):
>+        (foo._js_helper.Native):
>+        (foo._js_helper.JsPeerInterface):
>+        (foo._js_helper.SupportJsExtensionMethods):
>+        (foo.prototype._js_helper.InternalMap.dart.generic):
>+        (foo.prototype._js_helper.LinkedMap.dart.generic):
>+        (foo._js_helper.putLinkedMapKey):
>+        (foo.prototype._js_helper.ImmutableMap.dart.generic):
>+        (foo.prototype._js_helper.IdentityMap.dart.generic):
>+        (foo._js_helper._JSMapIterable.dart.generic):
>+        (foo.prototype._js_helper.CustomHashMap.dart.generic):
>+        (foo.prototype._js_helper.CustomKeyHashMap.dart.generic):
>+        (foo._js_helper.convertDartClosureToJS):
>+        (foo._js_helper.setNativeSubclassDispatchRecord):
>+        (foo._js_helper.findDispatchTagForInterceptorClass):
>+        (foo._js_helper.makeLeafDispatchRecord):
>+        (foo._js_helper.regExpGetNative):
>+        (foo._js_helper.regExpGetGlobalNative):
>+        (foo._js_helper.regExpCaptureCount):
>+        (foo._js_helper.JSSyntaxRegExp.prototype.toString):
>+        (foo._js_helper.JSSyntaxRegExp.prototype.get _nativeGlobalVersion):
>+        (foo._js_helper.JSSyntaxRegExp.prototype.get _nativeAnchoredVersion):
>+        (foo._js_helper.JSSyntaxRegExp.prototype.get _isMultiLine):
>+        (foo._js_helper.JSSyntaxRegExp.prototype.get _isCaseSensitive):
>+        (foo._js_helper.JSSyntaxRegExp.prototype.get _isUnicode):
>+        (foo._js_helper.JSSyntaxRegExp.prototype.get _isDotAll):
>+        (foo._js_helper.JSSyntaxRegExp.makeNative.let.regexp):
>+        (foo._js_helper.JSSyntaxRegExp.makeNative):
>+        (foo._js_helper.JSSyntaxRegExp.prototype.firstMatch):
>+        (foo._js_helper.JSSyntaxRegExp.prototype.hasMatch):
>+        (foo._js_helper.JSSyntaxRegExp.prototype.stringMatch):
>+        (foo._js_helper.JSSyntaxRegExp.prototype.allMatches):
>+        (foo._js_helper.JSSyntaxRegExp.prototype._execGlobal):
>+        (foo._js_helper.JSSyntaxRegExp.prototype._execAnchored):
>+        (foo._js_helper.JSSyntaxRegExp.prototype.matchAsPrefix):
>+        (foo._js_helper.JSSyntaxRegExp.prototype.get isMultiLine):
>+        (foo._js_helper.JSSyntaxRegExp.prototype.get isCaseSensitive):
>+        (foo._js_helper.JSSyntaxRegExp.prototype.get isUnicode):
>+        (foo._js_helper.JSSyntaxRegExp.prototype.get isDotAll):
>+        (foo._js_helper.JSSyntaxRegExp):
>+        (foo._js_helper._MatchImplementation.prototype.get input):
>+        (foo._js_helper._MatchImplementation.prototype.get start):
>+        (foo._js_helper._MatchImplementation.prototype.get end):
>+        (foo._js_helper._MatchImplementation.prototype.group):
>+        (foo._js_helper._MatchImplementation.prototype._get):
>+        (foo._js_helper._MatchImplementation.prototype.get groupCount):
>+        (foo._js_helper._MatchImplementation.prototype.groups):
>+        (foo._js_helper._MatchImplementation.prototype.namedGroup):
>+        (foo._js_helper._MatchImplementation.prototype.get groupNames):
>+        (foo._js_helper._MatchImplementation):
>+        (foo.core.RegExpMatch):
>+        (foo._js_helper._AllMatchesIterable.prototype.get iterator):
>+        (foo._js_helper._AllMatchesIterable):
>+        (foo._js_helper._AllMatchesIterator.prototype.get current):
>+        (foo._js_helper._AllMatchesIterator._isLeadSurrogate):
>+        (foo._js_helper._AllMatchesIterator._isTrailSurrogate):
>+        (foo._js_helper._AllMatchesIterator.prototype.moveNext):
>+        (foo._js_helper._AllMatchesIterator):
>+        (foo._js_helper.firstMatchAfter):
>+        (foo._js_helper.stringIndexOfStringUnchecked):
>+        (foo._js_helper.substring1Unchecked):
>+        (foo._js_helper.substring2Unchecked):
>+        (foo._js_helper.stringContainsStringUnchecked):
>+        (foo._js_helper.StringMatch.prototype.get end):
>+        (foo._js_helper.StringMatch.prototype._get):
>+        (foo._js_helper.StringMatch.prototype.get groupCount):
>+        (foo._js_helper.StringMatch.prototype.group):
>+        (foo._js_helper.StringMatch.prototype.groups):
>+        (foo._js_helper.StringMatch):
>+        (foo.prototype.async Stream):
>+        (foo._js_helper.allMatchesInStringUnchecked):
>+        (foo.core.Match):
>+        (foo._js_helper._StringAllMatchesIterable.prototype.get iterator):
>+        (foo._js_helper._StringAllMatchesIterable.prototype.get first):
>+        (foo._js_helper._StringAllMatchesIterable):
>+        (foo._js_helper._StringAllMatchesIterator.prototype.moveNext):
>+        (foo._js_helper._StringAllMatchesIterator.prototype.get current):
>+        (foo._js_helper._StringAllMatchesIterator):
>+        (foo._js_helper.stringContainsUnchecked):
>+        (foo._js_helper.stringReplaceJS):
>+        (foo._js_helper.stringReplaceFirstRE):
>+        (foo._js_helper.quoteStringForRegExp):
>+        (foo._js_helper.stringReplaceAllUnchecked):
>+        (foo._js_helper._matchString):
>+        (foo._js_helper._stringIdentity):
>+        (foo._js_helper.stringReplaceAllFuncUnchecked):
>+        (foo._js_helper.stringReplaceAllEmptyFuncUnchecked):
>+        (foo._js_helper.stringReplaceAllStringFuncUnchecked):
>+        (foo._js_helper.stringReplaceFirstUnchecked):
>+        (foo._js_helper.stringReplaceFirstMappedUnchecked):
>+        (foo._js_helper.stringJoinUnchecked):
>+        (foo._js_helper.stringReplaceRangeUnchecked):
>+        (foo._js_helper.getRuntimeType):
>+        (foo._js_helper.getIndex):
>+        (foo._js_helper.getLength):
>+        (foo._js_helper.isJsArray):
>+        (foo._js_mirrors.getName):
>+        (foo._js_mirrors.getSymbol):
>+        (foo.get _js_mirrors.reflect):
>+        (foo._js_mirrors.reflectType):
>+        (foo._js_mirrors._getESSymbol):
>+        (foo._js_mirrors._getMember):
>+        (foo._js_mirrors._getNameForESSymbol):
>+        (foo._js_mirrors._getSymbolForESSymbol):
>+        (foo._js_mirrors._getSymbolForMember):
>+        (foo._js_mirrors._toDartMap):
>+        (foo._js_mirrors._runtimeType):
>+        (foo._js_mirrors._unimplemented):
>+        (foo._js_mirrors._toJsMap):
>+        (foo._js_mirrors.JsMirrorSystem.prototype.get libraries):
>+        (foo._js_mirrors.JsMirrorSystem.prototype.noSuchMethod):
>+        (foo._js_mirrors.JsMirrorSystem.prototype.findLibrary):
>+        (foo._js_mirrors.JsMirrorSystem.prototype.get isolate):
>+        (foo._js_mirrors.JsMirrorSystem.prototype.get dynamicType):
>+        (foo._js_mirrors.JsMirrorSystem.prototype.get voidType):
>+        (foo._js_mirrors.JsMirrorSystem):
>+        (foo.get _js_mirrors):
>+        (foo._js_mirrors.JsMirror.prototype.noSuchMethod):
>+        (foo._js_mirrors.JsMirror):
>+        (foo._js_mirrors.JsCombinatorMirror.prototype.get identifiers):
>+        (foo._js_mirrors.JsCombinatorMirror.prototype.get isShow):
>+        (foo._js_mirrors.JsCombinatorMirror.prototype.get isHide):
>+        (foo._js_mirrors.JsCombinatorMirror):
>+        (foo._js_mirrors.JsDeclarationMirror.prototype.get simpleName):
>+        (foo._js_mirrors.JsDeclarationMirror.prototype.get qualifiedName):
>+        (foo._js_mirrors.JsDeclarationMirror.prototype.get owner):
>+        (foo._js_mirrors.JsDeclarationMirror.prototype.get isPrivate):
>+        (foo._js_mirrors.JsDeclarationMirror.prototype.get isTopLevel):
>+        (foo._js_mirrors.JsDeclarationMirror.prototype.get location):
>+        (foo._js_mirrors.JsDeclarationMirror.prototype.get metadata):
>+        (foo._js_mirrors.JsDeclarationMirror):
>+        (foo._js_mirrors.JsIsolateMirror.prototype.loadUri):
>+        (foo._js_mirrors.JsIsolateMirror.prototype.get debugName):
>+        (foo._js_mirrors.JsIsolateMirror.prototype.get isCurrent):
>+        (foo._js_mirrors.JsIsolateMirror.prototype.get rootLibrary):
>+        (foo._js_mirrors.JsIsolateMirror):
>+        (foo._js_mirrors.JsLibraryDependencyMirror.prototype.loadLibrary):
>+        (foo._js_mirrors.JsLibraryDependencyMirror.prototype.get isImport):
>+        (foo._js_mirrors.JsLibraryDependencyMirror.prototype.get isExport):
>+        (foo._js_mirrors.JsLibraryDependencyMirror.prototype.get isDeferred):
>+        (foo._js_mirrors.JsLibraryDependencyMirror.prototype.get sourceLibrary):
>+        (foo._js_mirrors.JsLibraryDependencyMirror.prototype.get targetLibrary):
>+        (foo._js_mirrors.JsLibraryDependencyMirror.prototype.get prefix):
>+        (foo._js_mirrors.JsLibraryDependencyMirror.prototype.get combinators):
>+        (foo._js_mirrors.JsLibraryDependencyMirror.prototype.get location):
>+        (foo._js_mirrors.JsLibraryDependencyMirror.prototype.get metadata):
>+        (foo._js_mirrors.JsLibraryDependencyMirror):
>+        (foo._js_mirrors.JsObjectMirror.prototype.invoke):
>+        (foo._js_mirrors.JsObjectMirror.prototype.getField):
>+        (foo._js_mirrors.JsObjectMirror.prototype.setField):
>+        (foo._js_mirrors.JsObjectMirror.prototype.delegate):
>+        (foo._js_mirrors.JsObjectMirror):
>+        (foo._js_mirrors.JsInstanceMirror.prototype.get hasReflectee):
>+        (foo._js_mirrors.JsInstanceMirror.prototype.get type):
>+        (foo._js_mirrors.JsInstanceMirror.prototype._equals):
>+        (foo._js_mirrors.JsInstanceMirror.prototype.get hashCode):
>+        (foo._js_mirrors.JsInstanceMirror.prototype.getField):
>+        (foo._js_mirrors.JsInstanceMirror.prototype.setField):
>+        (foo._js_mirrors.JsInstanceMirror.prototype.invoke):
>+        (foo._js_mirrors.JsInstanceMirror.prototype.toString):
>+        (foo._js_mirrors.JsInstanceMirror.prototype.delegate):
>+        (foo._js_mirrors.JsInstanceMirror):
>+        (foo._js_mirrors.JsClosureMirror.prototype.apply):
>+        (foo._js_mirrors.JsClosureMirror.prototype.delegate):
>+        (foo._js_mirrors.JsClosureMirror.get return):
>+        (foo._js_mirrors.JsClosureMirror):
>+        (foo._js_mirrors.JsClassMirror.prototype.get metadata):
>+        (foo._js_mirrors.JsClassMirror.get declarations.):
>+        (foo._js_mirrors.JsClassMirror.prototype.get declarations):
>+        (foo._js_mirrors.JsClassMirror.prototype.newInstance):
>+        (foo._js_mirrors.JsClassMirror.prototype.getField):
>+        (foo._js_mirrors.JsClassMirror.prototype.setField):
>+        (foo._js_mirrors.JsClassMirror.prototype.invoke):
>+        (foo._js_mirrors.JsClassMirror.prototype.get superinterfaces):
>+        (foo._js_mirrors.JsClassMirror.prototype.get hasReflectedType):
>+        (foo._js_mirrors.JsClassMirror.prototype.get reflectedType):
>+        (foo._js_mirrors.JsClassMirror.prototype.get isOriginalDeclaration):
>+        (foo._js_mirrors.JsClassMirror.prototype.get typeArguments):
>+        (foo._js_mirrors.JsClassMirror.prototype.get originalDeclaration):
>+        (foo._js_mirrors.JsClassMirror.prototype.get superclass):
>+        (foo._js_mirrors.JsClassMirror.prototype.get mixin):
>+        (foo._js_mirrors.JsClassMirror.prototype.toString):
>+        (foo._js_mirrors.JsClassMirror.prototype.get qualifiedName):
>+        (foo._js_mirrors.JsClassMirror.prototype.get owner):
>+        (foo._js_mirrors.JsClassMirror.prototype.get isPrivate):
>+        (foo._js_mirrors.JsClassMirror.prototype.get isTopLevel):
>+        (foo._js_mirrors.JsClassMirror.prototype.get location):
>+        (foo._js_mirrors.JsClassMirror.prototype.isSubtypeOf):
>+        (foo._js_mirrors.JsClassMirror.prototype.isAssignableTo):
>+        (foo._js_mirrors.JsClassMirror.prototype.get typeVariables):
>+        (foo._js_mirrors.JsClassMirror.prototype.delegate):
>+        (foo._js_mirrors.JsClassMirror.prototype.isSubclassOf):
>+        (foo._js_mirrors.JsClassMirror.prototype.get isAbstract):
>+        (foo._js_mirrors.JsClassMirror.prototype.get isEnum):
>+        (foo._js_mirrors.JsClassMirror.prototype.get instanceMembers):
>+        (foo._js_mirrors.JsClassMirror.prototype.get staticMembers):
>+        (foo._js_mirrors.JsClassMirror):
>+        (foo._js_mirrors.JsVariableMirror.prototype.get simpleName):
>+        (foo._js_mirrors.JsVariableMirror.prototype.toString):
>+        (foo._js_mirrors.JsVariableMirror.prototype.get qualifiedName):
>+        (foo._js_mirrors.JsVariableMirror.prototype.get owner):
>+        (foo._js_mirrors.JsVariableMirror.prototype.get isPrivate):
>+        (foo._js_mirrors.JsVariableMirror.prototype.get isTopLevel):
>+        (foo._js_mirrors.JsVariableMirror.prototype.get location):
>+        (foo._js_mirrors.JsVariableMirror.prototype.get isConst):
>+        (foo._js_mirrors.JsVariableMirror):
>+        (foo._js_mirrors.JsParameterMirror.prototype.toString):
>+        (foo._js_mirrors.JsParameterMirror.prototype.get qualifiedName):
>+        (foo._js_mirrors.JsParameterMirror.prototype.get owner):
>+        (foo._js_mirrors.JsParameterMirror.prototype.get isPrivate):
>+        (foo._js_mirrors.JsParameterMirror.prototype.get isTopLevel):
>+        (foo._js_mirrors.JsParameterMirror.prototype.get location):
>+        (foo._js_mirrors.JsParameterMirror.prototype.get isConst):
>+        (foo._js_mirrors.JsParameterMirror.prototype.get isOptional):
>+        (foo._js_mirrors.JsParameterMirror.prototype.get isNamed):
>+        (foo._js_mirrors.JsParameterMirror.prototype.get hasDefaultValue):
>+        (foo._js_mirrors.JsParameterMirror.prototype.get defaultValue):
>+        (foo._js_mirrors.JsParameterMirror):
>+        (foo._js_mirrors.JsMethodMirror.prototype.get isSetter):
>+        (foo._js_mirrors.JsMethodMirror.prototype.get isPrivate):
>+        (foo._js_mirrors.JsMethodMirror.prototype.get simpleName):
>+        (foo._js_mirrors.JsMethodMirror.prototype.get constructorName):
>+        (foo._js_mirrors.JsMethodMirror.prototype.get parameters):
>+        (foo._js_mirrors.JsMethodMirror.prototype.get metadata):
>+        (foo._js_mirrors.JsMethodMirror.prototype._createParameterMirrorList):
>+        (foo._js_mirrors.JsMethodMirror.prototype.toString):
>+        (foo._js_mirrors.JsMethodMirror.prototype.get qualifiedName):
>+        (foo._js_mirrors.JsMethodMirror.prototype.get owner):
>+        (foo._js_mirrors.JsMethodMirror.prototype.get isTopLevel):
>+        (foo._js_mirrors.JsMethodMirror.prototype.get location):
>+        (foo._js_mirrors.JsMethodMirror.prototype.get returnType):
>+        (foo._js_mirrors.JsMethodMirror.prototype.get source):
>+        (foo._js_mirrors.JsMethodMirror.prototype.get isAbstract):
>+        (foo._js_mirrors.JsMethodMirror.prototype.get isSynthetic):
>+        (foo._js_mirrors.JsMethodMirror.prototype.get isRegularMethod):
>+        (foo._js_mirrors.JsMethodMirror.prototype.get isOperator):
>+        (foo._js_mirrors.JsMethodMirror.prototype.get isGetter):
>+        (foo._js_mirrors.JsMethodMirror.prototype.get isConstConstructor):
>+        (foo._js_mirrors.JsMethodMirror.prototype.get isGenerativeConstructor):
>+        (foo._js_mirrors.JsMethodMirror.prototype.get isRedirectingConstructor):
>+        (foo._js_mirrors.JsMethodMirror.prototype.get isFactoryConstructor):
>+        (foo._js_mirrors.JsMethodMirror):
>+        (foo._js_primitives.printString):
>+        (foo._metadata.SupportedBrowser):
>+        (foo.get _metadata.Experimental):
>+        (foo._metadata.DomName):
>+        (foo.get _metadata):
>+        (foo._metadata.DocsEditable):
>+        (foo._metadata.Unstable):
>+        (foo._native_typed_data.NativeByteBuffer.prototype.get lengthInBytes):
>+        (foo._native_typed_data.NativeByteBuffer.prototype.get runtimeType):
>+        (foo._native_typed_data.NativeByteBuffer.prototype.asUint8List):
>+        (foo._native_typed_data.NativeByteBuffer.prototype.asInt8List):
>+        (foo._native_typed_data.NativeByteBuffer.prototype.asUint8ClampedList):
>+        (foo._native_typed_data.NativeByteBuffer.prototype.asUint16List):
>+        (foo._native_typed_data.NativeByteBuffer.prototype.asInt16List):
>+        (foo._native_typed_data.NativeByteBuffer.prototype.asUint32List):
>+        (foo._native_typed_data.NativeByteBuffer.prototype.asInt32List):
>+        (foo._native_typed_data.NativeByteBuffer.prototype.asUint64List):
>+        (foo._native_typed_data.NativeByteBuffer.prototype.asInt64List):
>+        (foo._native_typed_data.NativeByteBuffer.prototype.asInt32x4List):
>+        (foo._native_typed_data.NativeByteBuffer.prototype.asFloat32List):
>+        (foo._native_typed_data.NativeByteBuffer.prototype.asFloat64List):
>+        (foo._native_typed_data.NativeByteBuffer.prototype.asFloat32x4List):
>+        (foo._native_typed_data.NativeByteBuffer.prototype.asFloat64x2List):
>+        (foo._native_typed_data.NativeByteBuffer.prototype.asByteData):
>+        (foo._native_typed_data.NativeByteBuffer):
>+        (foo.typed_data.Float32x4.new):
>+        (foo.typed_data.Float32x4.splat):
>+        (foo.typed_data.Float32x4.zero):
>+        (foo.typed_data.Float32x4.fromInt32x4Bits):
>+        (foo.typed_data.Float32x4.fromFloat64x2):
>+        (foo.typed_data.Float32x4):
>+        (foo.get const.Object_ListMixin):
>+        (foo.const.Object_FixedLengthListMixin):
>+        (foo._native_typed_data.NativeFloat32x4List.prototype.get runtimeType):
>+        (foo._native_typed_data.NativeFloat32x4List.fromList):
>+        (foo._native_typed_data.NativeFloat32x4List.prototype.get buffer):
>+        (foo._native_typed_data.NativeFloat32x4List.prototype.get lengthInBytes):
>+        (foo._native_typed_data.NativeFloat32x4List.prototype.get offsetInBytes):
>+        (foo._native_typed_data.NativeFloat32x4List.prototype.get elementSizeInBytes):
>+        (foo._native_typed_data.NativeFloat32x4List.prototype.get length):
>+        (foo._native_typed_data.NativeFloat32x4List.prototype.set length):
>+        (foo._native_typed_data.NativeFloat32x4List.prototype._get):
>+        (foo._native_typed_data.NativeFloat32x4List.prototype._set):
>+        (foo._native_typed_data.NativeFloat32x4List.prototype.sublist):
>+        (foo._native_typed_data.NativeFloat32x4List):
>+        (foo.typed_data.Int32x4.new):
>+        (foo.typed_data.Int32x4.bool):
>+        (foo.typed_data.Int32x4.fromFloat32x4Bits):
>+        (foo.typed_data.Int32x4):
>+        (foo._native_typed_data.NativeInt32x4List.prototype.get runtimeType):
>+        (foo._native_typed_data.NativeInt32x4List.fromList):
>+        (foo._native_typed_data.NativeInt32x4List.prototype.get buffer):
>+        (foo._native_typed_data.NativeInt32x4List.prototype.get lengthInBytes):
>+        (foo._native_typed_data.NativeInt32x4List.prototype.get offsetInBytes):
>+        (foo._native_typed_data.NativeInt32x4List.prototype.get elementSizeInBytes):
>+        (foo._native_typed_data.NativeInt32x4List.prototype.get length):
>+        (foo._native_typed_data.NativeInt32x4List.prototype.set length):
>+        (foo._native_typed_data.NativeInt32x4List.prototype._get):
>+        (foo._native_typed_data.NativeInt32x4List.prototype._set):
>+        (foo._native_typed_data.NativeInt32x4List.prototype.sublist):
>+        (foo._native_typed_data.NativeInt32x4List):
>+        (foo.typed_data.Float64x2.new):
>+        (foo.typed_data.Float64x2.splat):
>+        (foo.typed_data.Float64x2.zero):
>+        (foo.typed_data.Float64x2.fromFloat32x4):
>+        (foo.typed_data.Float64x2):
>+        (foo.const.Object_ListMixin.0):
>+        (foo.const.Object_FixedLengthListMixin.0):
>+        (foo._native_typed_data.NativeFloat64x2List.fromList):
>+        (foo._native_typed_data.NativeFloat64x2List.prototype.get runtimeType):
>+        (foo._native_typed_data.NativeFloat64x2List.prototype.get buffer):
>+        (foo._native_typed_data.NativeFloat64x2List.prototype.get lengthInBytes):
>+        (foo._native_typed_data.NativeFloat64x2List.prototype.get offsetInBytes):
>+        (foo._native_typed_data.NativeFloat64x2List.prototype.get elementSizeInBytes):
>+        (foo._native_typed_data.NativeFloat64x2List.prototype.get length):
>+        (foo._native_typed_data.NativeFloat64x2List.prototype.set length):
>+        (foo._native_typed_data.NativeFloat64x2List.prototype._get):
>+        (foo._native_typed_data.NativeFloat64x2List.prototype._set):
>+        (foo._native_typed_data.NativeFloat64x2List.prototype.sublist):
>+        (foo._native_typed_data.NativeFloat64x2List):
>+        (foo._native_typed_data.NativeTypedData.prototype.get buffer):
>+        (foo._native_typed_data.NativeTypedData.prototype.get lengthInBytes):
>+        (foo._native_typed_data.NativeTypedData.prototype.get offsetInBytes):
>+        (foo._native_typed_data.NativeTypedData.prototype.get elementSizeInBytes):
>+        (foo._native_typed_data.NativeTypedData.prototype._invalidPosition):
>+        (foo._native_typed_data.NativeTypedData.prototype._checkPosition):
>+        (foo._native_typed_data.NativeTypedData):
>+        (foo._native_typed_data._checkLength):
>+        (foo._native_typed_data._checkViewArguments):
>+        (foo._native_typed_data._ensureNativeList):
>+        (foo._native_typed_data.NativeByteData.new):
>+        (foo._native_typed_data.NativeByteData.view):
>+        (foo._native_typed_data.NativeByteData.prototype.get runtimeType):
>+        (foo._native_typed_data.NativeByteData.prototype.get elementSizeInBytes):
>+        (foo._native_typed_data.NativeByteData.prototype.getFloat32):
>+        (foo._native_typed_data.NativeByteData.prototype._getFloat32):
>+        (foo._native_typed_data.NativeByteData.prototype.getFloat64):
>+        (foo._native_typed_data.NativeByteData.prototype._getFloat64):
>+        (foo._native_typed_data.NativeByteData.prototype.getInt16):
>+        (foo._native_typed_data.NativeByteData.prototype._getInt16):
>+        (foo._native_typed_data.NativeByteData.prototype.getInt32):
>+        (foo._native_typed_data.NativeByteData.prototype._getInt32):
>+        (foo._native_typed_data.NativeByteData.prototype.getInt64):
>+        (foo._native_typed_data.NativeByteData.prototype.getInt8):
>+        (foo._native_typed_data.NativeByteData.prototype.getUint16):
>+        (foo._native_typed_data.NativeByteData.prototype._getUint16):
>+        (foo._native_typed_data.NativeByteData.prototype.getUint32):
>+        (foo._native_typed_data.NativeByteData.prototype._getUint32):
>+        (foo._native_typed_data.NativeByteData.prototype.getUint64):
>+        (foo._native_typed_data.NativeByteData.prototype.getUint8):
>+        (foo._native_typed_data.NativeByteData.prototype.setFloat32):
>+        (foo._native_typed_data.NativeByteData.prototype._setFloat32):
>+        (foo._native_typed_data.NativeByteData.prototype.setFloat64):
>+        (foo._native_typed_data.NativeByteData.prototype._setFloat64):
>+        (foo._native_typed_data.NativeByteData.prototype.setInt16):
>+        (foo._native_typed_data.NativeByteData.prototype._setInt16):
>+        (foo._native_typed_data.NativeByteData.prototype.setInt32):
>+        (foo._native_typed_data.NativeByteData.prototype._setInt32):
>+        (foo._native_typed_data.NativeByteData.prototype.setInt64):
>+        (foo._native_typed_data.NativeByteData.prototype.setInt8):
>+        (foo._native_typed_data.NativeByteData.prototype.setUint16):
>+        (foo._native_typed_data.NativeByteData.prototype._setUint16):
>+        (foo._native_typed_data.NativeByteData.prototype.setUint32):
>+        (foo._native_typed_data.NativeByteData.prototype._setUint32):
>+        (foo._native_typed_data.NativeByteData.prototype.setUint64):
>+        (foo._native_typed_data.NativeByteData.prototype.setUint8):
>+        (foo._native_typed_data.NativeByteData._create1):
>+        (foo._native_typed_data.NativeByteData._create2):
>+        (foo._native_typed_data.NativeByteData._create3):
>+        (foo._native_typed_data.NativeByteData):
>+        (foo._native_typed_data.NativeTypedArray.prototype._setRangeFast):
>+        (foo._native_typed_data.NativeTypedArray):
>+        (foo.core.double.parse):
>+        (foo.core.double.tryParse):
>+        (foo.core.double):
>+        (foo.core.double.is):
>+        (foo.core.double.as):
>+        (foo.core.double._check):
>+        (foo.get const.NativeTypedArray_ListMixin):
>+        (foo.const.NativeTypedArray_FixedLengthListMixin):
>+        (foo._native_typed_data.NativeTypedArrayOfDouble.prototype.get length):
>+        (foo._native_typed_data.NativeTypedArrayOfDouble.prototype.set length):
>+        (foo._native_typed_data.NativeTypedArrayOfDouble.prototype._get):
>+        (foo._native_typed_data.NativeTypedArrayOfDouble.prototype._set):
>+        (foo._native_typed_data.NativeTypedArrayOfDouble.prototype.setRange):
>+        (foo._native_typed_data.NativeTypedArrayOfDouble):
>+        (foo.const.NativeTypedArray_ListMixin):
>+        (foo._native_typed_data.NativeTypedArrayOfInt.prototype.get length):
>+        (foo._native_typed_data.NativeTypedArrayOfInt.prototype.set length):
>+        (foo._native_typed_data.NativeTypedArrayOfInt.prototype._set):
>+        (foo._native_typed_data.NativeTypedArrayOfInt.prototype.setRange):
>+        (foo._native_typed_data.NativeTypedArrayOfInt):
>+        (foo._native_typed_data.NativeFloat32List.new):
>+        (foo._native_typed_data.NativeFloat32List.fromList):
>+        (foo._native_typed_data.NativeFloat32List.view):
>+        (foo._native_typed_data.NativeFloat32List.prototype.get runtimeType):
>+        (foo._native_typed_data.NativeFloat32List.prototype.sublist):
>+        (foo._native_typed_data.NativeFloat32List._create1):
>+        (foo._native_typed_data.NativeFloat32List._create2):
>+        (foo._native_typed_data.NativeFloat32List._create3):
>+        (foo._native_typed_data.NativeFloat32List):
>+        (foo._native_typed_data.NativeFloat64List.new):
>+        (foo._native_typed_data.NativeFloat64List.fromList):
>+        (foo._native_typed_data.NativeFloat64List.view):
>+        (foo._native_typed_data.NativeFloat64List.prototype.get runtimeType):
>+        (foo._native_typed_data.NativeFloat64List.prototype.sublist):
>+        (foo._native_typed_data.NativeFloat64List._create1):
>+        (foo._native_typed_data.NativeFloat64List._create2):
>+        (foo._native_typed_data.NativeFloat64List._create3):
>+        (foo._native_typed_data.NativeFloat64List):
>+        (foo._native_typed_data.NativeInt16List.new):
>+        (foo._native_typed_data.NativeInt16List.fromList):
>+        (foo._native_typed_data.NativeInt16List.view):
>+        (foo._native_typed_data.NativeInt16List.prototype.get runtimeType):
>+        (foo._native_typed_data.NativeInt16List.prototype._get):
>+        (foo._native_typed_data.NativeInt16List.prototype.sublist):
>+        (foo._native_typed_data.NativeInt16List._create1):
>+        (foo._native_typed_data.NativeInt16List._create2):
>+        (foo._native_typed_data.NativeInt16List._create3):
>+        (foo._native_typed_data.NativeInt16List):
>+        (foo._native_typed_data.NativeInt32List.new):
>+        (foo._native_typed_data.NativeInt32List.fromList):
>+        (foo._native_typed_data.NativeInt32List.view):
>+        (foo._native_typed_data.NativeInt32List.prototype.get runtimeType):
>+        (foo._native_typed_data.NativeInt32List.prototype._get):
>+        (foo._native_typed_data.NativeInt32List.prototype.sublist):
>+        (foo._native_typed_data.NativeInt32List._create1):
>+        (foo._native_typed_data.NativeInt32List._create2):
>+        (foo._native_typed_data.NativeInt32List._create3):
>+        (foo._native_typed_data.NativeInt32List):
>+        (foo._native_typed_data.NativeInt8List.new):
>+        (foo._native_typed_data.NativeInt8List.fromList):
>+        (foo._native_typed_data.NativeInt8List.view):
>+        (foo._native_typed_data.NativeInt8List.prototype.get runtimeType):
>+        (foo._native_typed_data.NativeInt8List.prototype._get):
>+        (foo._native_typed_data.NativeInt8List.prototype.sublist):
>+        (foo._native_typed_data.NativeInt8List._create1):
>+        (foo._native_typed_data.NativeInt8List._create2):
>+        (foo._native_typed_data.NativeInt8List._create3):
>+        (foo._native_typed_data.NativeInt8List):
>+        (foo._native_typed_data.NativeUint16List.new):
>+        (foo._native_typed_data.NativeUint16List.fromList):
>+        (foo._native_typed_data.NativeUint16List.view):
>+        (foo._native_typed_data.NativeUint16List.prototype.get runtimeType):
>+        (foo._native_typed_data.NativeUint16List.prototype._get):
>+        (foo._native_typed_data.NativeUint16List.prototype.sublist):
>+        (foo._native_typed_data.NativeUint16List._create1):
>+        (foo._native_typed_data.NativeUint16List._create2):
>+        (foo._native_typed_data.NativeUint16List._create3):
>+        (foo._native_typed_data.NativeUint16List):
>+        (foo._native_typed_data.NativeUint32List.new):
>+        (foo._native_typed_data.NativeUint32List.fromList):
>+        (foo._native_typed_data.NativeUint32List.view):
>+        (foo._native_typed_data.NativeUint32List.prototype.get runtimeType):
>+        (foo._native_typed_data.NativeUint32List.prototype._get):
>+        (foo._native_typed_data.NativeUint32List.prototype.sublist):
>+        (foo._native_typed_data.NativeUint32List._create1):
>+        (foo._native_typed_data.NativeUint32List._create2):
>+        (foo._native_typed_data.NativeUint32List._create3):
>+        (foo._native_typed_data.NativeUint32List):
>+        (foo._native_typed_data.NativeUint8ClampedList.new):
>+        (foo._native_typed_data.NativeUint8ClampedList.fromList):
>+        (foo._native_typed_data.NativeUint8ClampedList.view):
>+        (foo._native_typed_data.NativeUint8ClampedList.prototype.get runtimeType):
>+        (foo._native_typed_data.NativeUint8ClampedList.prototype.get length):
>+        (foo._native_typed_data.NativeUint8ClampedList.prototype.set length):
>+        (foo._native_typed_data.NativeUint8ClampedList.prototype._get):
>+        (foo._native_typed_data.NativeUint8ClampedList.prototype.sublist):
>+        (foo._native_typed_data.NativeUint8ClampedList._create1):
>+        (foo._native_typed_data.NativeUint8ClampedList._create2):
>+        (foo._native_typed_data.NativeUint8ClampedList._create3):
>+        (foo._native_typed_data.NativeUint8ClampedList):
>+        (foo._native_typed_data.NativeUint8List.new):
>+        (foo._native_typed_data.NativeUint8List.fromList):
>+        (foo._native_typed_data.NativeUint8List.view):
>+        (foo._native_typed_data.NativeUint8List.prototype.get runtimeType):
>+        (foo._native_typed_data.NativeUint8List.prototype.get length):
>+        (foo._native_typed_data.NativeUint8List.prototype.set length):
>+        (foo._native_typed_data.NativeUint8List.prototype._get):
>+        (foo._native_typed_data.NativeUint8List.prototype.sublist):
>+        (foo._native_typed_data.NativeUint8List._create1):
>+        (foo._native_typed_data.NativeUint8List._create2):
>+        (foo._native_typed_data.NativeUint8List._create3):
>+        (foo._native_typed_data.NativeUint8List):
>+        (foo._native_typed_data.NativeFloat32x4._truncate):
>+        (foo._native_typed_data.NativeFloat32x4.fromInt32x4Bits):
>+        (foo._native_typed_data.NativeFloat32x4.prototype.toString):
>+        (foo._native_typed_data.NativeFloat32x4.prototype.string_appeared_here):
>+        (foo._native_typed_data.NativeFloat32x4.prototype._negate):
>+        (foo._native_typed_data.NativeFloat32x4.prototype.lessThan):
>+        (foo._native_typed_data.NativeFloat32x4.prototype.lessThanOrEqual):
>+        (foo._native_typed_data.NativeFloat32x4.prototype.greaterThan):
>+        (foo._native_typed_data.NativeFloat32x4.prototype.greaterThanOrEqual):
>+        (foo._native_typed_data.NativeFloat32x4.prototype.equal):
>+        (foo._native_typed_data.NativeFloat32x4.prototype.notEqual):
>+        (foo._native_typed_data.NativeFloat32x4.prototype.scale):
>+        (foo._native_typed_data.NativeFloat32x4.prototype.abs):
>+        (foo._native_typed_data.NativeFloat32x4.prototype.clamp):
>+        (foo._native_typed_data.NativeFloat32x4.prototype.get signMask):
>+        (foo._native_typed_data.NativeFloat32x4.prototype.shuffle):
>+        (foo._native_typed_data.NativeFloat32x4.prototype.shuffleMix):
>+        (foo._native_typed_data.NativeFloat32x4.prototype.withX):
>+        (foo._native_typed_data.NativeFloat32x4.prototype.withY):
>+        (foo._native_typed_data.NativeFloat32x4.prototype.withZ):
>+        (foo._native_typed_data.NativeFloat32x4.prototype.withW):
>+        (foo._native_typed_data.NativeFloat32x4.prototype.min):
>+        (foo._native_typed_data.NativeFloat32x4.prototype.max):
>+        (foo._native_typed_data.NativeFloat32x4.prototype.sqrt):
>+        (foo._native_typed_data.NativeFloat32x4.prototype.reciprocal):
>+        (foo._native_typed_data.NativeFloat32x4.prototype.reciprocalSqrt):
>+        (foo._native_typed_data.NativeFloat32x4):
>+        (foo.get _native_typed_data.NativeInt32x4._truncate):
>+        (foo.get _native_typed_data.NativeInt32x4.fromFloat32x4Bits):
>+        (foo.get _native_typed_data.NativeInt32x4.prototype.toString):
>+        (foo.get _native_typed_data.NativeInt32x4.prototype.string_appeared_here):
>+        (foo.get _native_typed_data.NativeInt32x4.prototype._negate):
>+        (foo.get _native_typed_data.NativeInt32x4.prototype.get signMask):
>+        (foo.get _native_typed_data.NativeInt32x4.prototype.shuffle):
>+        (foo.get _native_typed_data.NativeInt32x4.prototype.shuffleMix):
>+        (foo.get _native_typed_data.NativeInt32x4.prototype.withX):
>+        (foo.get _native_typed_data.NativeInt32x4.prototype.withY):
>+        (foo.get _native_typed_data.NativeInt32x4.prototype.withZ):
>+        (foo.get _native_typed_data.NativeInt32x4.prototype.withW):
>+        (foo.get _native_typed_data.NativeInt32x4.prototype.get flagX):
>+        (foo.get _native_typed_data.NativeInt32x4.prototype.get flagY):
>+        (foo.get _native_typed_data.NativeInt32x4.prototype.get flagZ):
>+        (foo.get _native_typed_data.NativeInt32x4.prototype.get flagW):
>+        (foo.get _native_typed_data.NativeInt32x4.prototype.withFlagX):
>+        (foo.get _native_typed_data.NativeInt32x4.prototype.withFlagY):
>+        (foo.get _native_typed_data.NativeInt32x4.prototype.withFlagZ):
>+        (foo.get _native_typed_data.NativeInt32x4.prototype.withFlagW):
>+        (foo.get _native_typed_data.NativeInt32x4.prototype.select):
>+        (foo.get _native_typed_data.NativeInt32x4):
>+        (foo.get _native_typed_data):
>+        (foo.get _native_typed_data.NativeFloat64x2.prototype.toString):
>+        (foo.get _native_typed_data.NativeFloat64x2.prototype.string_appeared_here):
>+        (foo.get _native_typed_data.NativeFloat64x2.prototype._negate):
>+        (foo.get _native_typed_data.NativeFloat64x2.prototype.scale):
>+        (foo.get _native_typed_data.NativeFloat64x2.prototype.abs):
>+        (foo.get _native_typed_data.NativeFloat64x2.prototype.clamp):
>+        (foo.get _native_typed_data.NativeFloat64x2.prototype.get signMask):
>+        (foo.get _native_typed_data.NativeFloat64x2.prototype.withX):
>+        (foo.get _native_typed_data.NativeFloat64x2.prototype.withY):
>+        (foo.get _native_typed_data.NativeFloat64x2.prototype.min):
>+        (foo.get _native_typed_data.NativeFloat64x2.prototype.max):
>+        (foo.get _native_typed_data.NativeFloat64x2.prototype.sqrt):
>+        (foo.get _native_typed_data.NativeFloat64x2):
>+        (foo.set get _native_typed_data._isInvalidArrayIndex):
>+        (foo._native_typed_data._checkValidIndex):
>+        (foo._native_typed_data._checkValidRange):
>+        (foo.async _AsyncStarImpl.dart.generic):
>+        (foo.async _AsyncStarImpl):
>+        (foo.async _invokeErrorHandler):
>+        (foo.async _StreamImpl.dart.generic):
>+        (foo.async _StreamImpl):
>+        (foo.async _ControllerStream.dart.generic):
>+        (foo.async _ControllerStream):
>+        (foo.async _BroadcastStream.dart.generic):
>+        (foo.async _BroadcastStream):
>+        (foo.async _BufferingStreamSubscription.dart.generic):
>+        (foo.async _BufferingStreamSubscription):
>+        (foo.prototype.async _BufferingStreamSubscription):
>+        (foo.async _ControllerSubscription.dart.generic):
>+        (foo.async _ControllerSubscription):
>+        (foo.async _BroadcastSubscription.dart.generic):
>+        (foo.async _BroadcastSubscription):
>+        (foo.prototype.async _BroadcastSubscription):
>+        (foo.async _BroadcastStreamController.dart.generic):
>+        (foo.async _BroadcastStreamController):
>+        (foo.prototype.async _BroadcastStreamController):
>+        (foo.async _SyncBroadcastStreamController.dart.generic):
>+        (foo.async _SyncBroadcastStreamController):
>+        (foo.async _AsyncBroadcastStreamController.dart.generic):
>+        (foo.async _AsyncBroadcastStreamController):
>+        (foo.async _AsBroadcastStreamController.dart.generic):
>+        (foo.async _AsBroadcastStreamController):
>+        (foo.async DeferredLibrary.prototype.get libraryName):
>+        (foo.async DeferredLibrary.prototype.set libraryName):
>+        (foo.async DeferredLibrary.prototype.get uri):
>+        (foo.async DeferredLibrary.prototype.set uri):
>+        (foo.async DeferredLibrary.prototype.load):
>+        (foo.async DeferredLibrary):
>+        (foo.async DeferredLoadException.prototype.toString):
>+        (foo.async DeferredLoadException):
>+        (foo.async FutureOr.dart.generic):
>+        (foo.async FutureOr):
>+        (foo.async Future.dart.generic.):
>+        (foo.async Future.dart.generic):
>+        (foo.async Future):
>+        (foo.prototype.async Future):
>+        (foo.async TimeoutException.prototype.get message):
>+        (foo.async TimeoutException.prototype.set message):
>+        (foo.async TimeoutException.prototype.get duration):
>+        (foo.async TimeoutException.prototype.set duration):
>+        (foo.async TimeoutException.prototype.toString):
>+        (foo.async TimeoutException):
>+        (foo.async Completer.dart.generic):
>+        (foo.async Completer):
>+        (foo.async _nonNullError):
>+        (foo.async _Completer.dart.generic):
>+        (foo.async _Completer):
>+        (foo.async _AsyncCompleter.dart.generic):
>+        (foo.async _AsyncCompleter):
>+        (foo.async _SyncCompleter.dart.generic):
>+        (foo.async _SyncCompleter):
>+        (foo.async _FutureListener):
>+        (foo.prototype.async _FutureListener):
>+        (foo.async _Future.dart.generic.):
>+        (foo.async _Future.dart.generic):
>+        (foo.async _Future):
>+        (foo.prototype.async _Future):
>+        (foo.async _registerErrorHandler):
>+        (foo.async _AsyncCallbackEntry):
>+        (foo.async _AsyncRun._initializeScheduleImmediate.return.async _AsyncRun):
>+        (foo.async get StreamSubscription.dart.generic):
>+        (foo.async get StreamSubscription):
>+        (foo.async EventSink.dart.generic):
>+        (foo.async EventSink):
>+        (foo.async StreamView.dart.generic):
>+        (foo.async StreamView):
>+        (foo.async StreamConsumer.dart.generic):
>+        (foo.async StreamConsumer):
>+        (foo.async StreamSink.dart.generic):
>+        (foo.async StreamSink):
>+        (foo.async StreamTransformer):
>+        (foo.async StreamIterator.dart.generic):
>+        (foo.async StreamIterator):
>+        (foo.async _ControllerEventSinkWrapper.dart.generic):
>+        (foo.async _ControllerEventSinkWrapper):
>+        (foo.async StreamController.dart.generic):
>+        (foo.async StreamController):
>+        (foo.async SynchronousStreamController.dart.generic):
>+        (foo.async SynchronousStreamController):
>+        (foo.async _StreamControllerLifecycle.dart.generic):
>+        (foo.async _StreamControllerLifecycle):
>+        (foo.async _StreamControllerBase.dart.generic):
>+        (foo.async _StreamControllerBase):
>+        (foo.async _StreamController.dart.generic):
>+        (foo.async _StreamController):
>+        (foo.prototype.async _StreamController):
>+        (foo.async _SyncStreamControllerDispatch.dart.generic):
>+        (foo.async _SyncStreamControllerDispatch):
>+        (foo.async _AsyncStreamControllerDispatch.dart.generic):
>+        (foo.async _AsyncStreamControllerDispatch):
>+        (foo.async _AsyncStreamController.dart.generic):
>+        (foo.async _AsyncStreamController):
>+        (foo.async _SyncStreamController.dart.generic):
>+        (foo.async _SyncStreamController):
>+        (foo.async _StreamSinkWrapper.dart.generic):
>+        (foo.async _StreamSinkWrapper):
>+        (foo.async _AddStreamState.dart.generic):
>+        (foo.async _AddStreamState):
>+        (foo.async _StreamControllerAddStreamState.dart.generic):
>+        (foo.async _StreamControllerAddStreamState):
>+        (foo.async _EventSink.dart.generic):
>+        (foo.async _EventSink):
>+        (foo.async _EventDispatch.dart.generic):
>+        (foo.async _EventDispatch):
>+        (foo.async _GeneratedStreamImpl.dart.generic):
>+        (foo.async _GeneratedStreamImpl):
>+        (foo.async _PendingEvents.dart.generic):
>+        (foo.async _PendingEvents):
>+        (foo.prototype.async _PendingEvents):
>+        (foo.async _IterablePendingEvents.dart.generic):
>+        (foo.async _IterablePendingEvents):
>+        (foo.async _nullDataHandler):
>+        (foo.async _nullDoneHandler):
>+        (foo.async _DelayedEvent.dart.generic):
>+        (foo.async _DelayedEvent):
>+        (foo.async _DelayedData.dart.generic):
>+        (foo.async _DelayedData):
>+        (foo.async _DelayedError.prototype.perform):
>+        (foo.async _DelayedError):
>+        (foo.async _DelayedDone.prototype.perform):
>+        (foo.async _DelayedDone.prototype.get next):
>+        (foo.async _DelayedDone.prototype.set next):
>+        (foo.async _DelayedDone):
>+        (foo.async _DelayedDone.dart.implements.async _DelayedEvent):
>+        (foo.async _StreamImplEvents.dart.generic):
>+        (foo.async _StreamImplEvents):
>+        (foo.async _DoneStreamSubscription.dart.generic):
>+        (foo.async _DoneStreamSubscription):
>+        (foo.prototype.async _DoneStreamSubscription):
>+        (foo.async _AsBroadcastStream.dart.generic):
>+        (foo.async _AsBroadcastStream):
>+        (foo.async _BroadcastSubscriptionWrapper.dart.generic):
>+        (foo.async _BroadcastSubscriptionWrapper):
>+        (foo.async _StreamIterator.dart.generic):
>+        (foo.async _StreamIterator):
>+        (foo.async _EmptyStream.dart.generic):
>+        (foo.async _EmptyStream):
>+        (foo.catch.let.replacement.async Zone):
>+        (foo.async _cancelAndErrorClosure):
>+        (foo.async _ForwardingStream):
>+        (foo.async _ForwardingStreamSubscription):
>+        (foo.async _WhereStream.dart.generic):
>+        (foo.async _WhereStream):
>+        (foo.async _MapStream):
>+        (foo.async _ExpandStream):
>+        (foo.async _HandleErrorStream.dart.generic):
>+        (foo.async _HandleErrorStream):
>+        (foo.async _TakeStream.dart.generic):
>+        (foo.async _TakeStream):
>+        (foo.async _StateStreamSubscription.dart.generic):
>+        (foo.async _StateStreamSubscription):
>+        (foo.async _TakeWhileStream.dart.generic):
>+        (foo.async _TakeWhileStream):
>+        (foo.async _SkipStream.dart.generic):
>+        (foo.async _SkipStream):
>+        (foo.async _SkipWhileStream.dart.generic):
>+        (foo.async _SkipWhileStream):
>+        (foo.async _DistinctStream.dart.generic):
>+        (foo.async _DistinctStream):
>+        (foo.prototype.async _DistinctStream):
>+        (foo.async _EventSinkWrapper.dart.generic):
>+        (foo.async _EventSinkWrapper):
>+        (foo.async _SinkTransformerStreamSubscription):
>+        (foo.async _StreamSinkTransformer):
>+        (foo.async _BoundSinkStream):
>+        (foo.async _HandlerEventSink):
>+        (foo.async _StreamHandlerTransformer):
>+        (foo.async _StreamBindTransformer):
>+        (foo.async _StreamSubscriptionTransformer):
>+        (foo.async _BoundSubscriptionStream):
>+        (foo.async AsyncError.prototype.get error):
>+        (foo.async AsyncError.prototype.set error):
>+        (foo.async AsyncError.prototype.get stackTrace):
>+        (foo.async AsyncError.prototype.set stackTrace):
>+        (foo.async AsyncError.prototype.toString):
>+        (foo.async AsyncError):
>+        (foo.async ZoneSpecification.return.async ZoneSpecification):
>+        (foo.async _ZoneSpecification):
>+        (foo.async ZoneDelegate):
>+        (foo.async _parentDelegate):
>+        (foo.async _ZoneDelegate.dart.implements.async ZoneDelegate):
>+        (foo.async _Zone.prototype.inSameErrorZone):
>+        (foo.async _Zone):
>+        (foo.async _Zone.dart.implements.async Zone):
>+        (foo.async _CustomZone.get errorZone):
>+        (foo.async _CustomZone.get _delegate.this._delegateCache.new.async _ZoneDelegate):
>+        (foo.async _CustomZone.prototype.get _delegate):
>+        (foo.async _CustomZone.prototype.runUnaryGuarded):
>+        (foo.async _CustomZone.prototype.runBinaryGuarded):
>+        (foo.async _CustomZone.prototype.bindCallback):
>+        (foo.async _CustomZone.prototype.bindUnaryCallback):
>+        (foo.async _CustomZone.prototype.bindBinaryCallback):
>+        (foo.async _CustomZone.prototype.bindCallbackGuarded):
>+        (foo.async _CustomZone.prototype.bindUnaryCallbackGuarded):
>+        (foo.async _CustomZone.prototype.bindBinaryCallbackGuarded):
>+        (foo.async _schedulePriorityAsyncCallback):
>+        (foo.async _rootHandleUncaughtError):
>+        (foo.async _rethrow):
>+        (foo.let.old.async Zone):
>+        (foo.async _rootRegisterCallback):
>+        (foo.async _rootRegisterUnaryCallback):
>+        (foo.async _rootRegisterBinaryCallback):
>+        (foo.async _rootErrorCallback):
>+        (foo.async if):
>+        (foo.async _rootPrint):
>+        (foo.async _RootZone.prototype.get _run):
>+        (foo.async _RootZone.prototype.async get _runUnary):
>+        (foo.async _RootZone.prototype.async get _runBinary):
>+        (foo.async _RootZone.prototype.async get _registerCallback):
>+        (foo.async _RootZone.prototype.async get _registerUnaryCallback):
>+        (foo.async _RootZone.prototype.async get _registerBinaryCallback):
>+        (foo.async _RootZone.prototype.async get _errorCallback):
>+        (foo.async _RootZone.prototype.async get _scheduleMicrotask):
>+        (foo.async _RootZone.prototype.async get _createTimer):
>+        (foo.async _RootZone.prototype.async get _createPeriodicTimer):
>+        (foo.async _RootZone.prototype.async get _print):
>+        (foo.async _RootZone.prototype.async get _fork):
>+        (foo.async _RootZone.prototype.async get _handleUncaughtError):
>+        (foo.async _RootZone.prototype.async get parent):
>+        (foo.async _RootZone.get errorZone):
>+        (foo.async set get dart):
>+        (foo.return.async _runZoned):
>+        (foo.zoneSpecification.async ZoneSpecification):
>+        (foo.else.zoneSpecification.async ZoneSpecification):
>+        (foo.try.return.async _runZoned):
>+        (foo.async get runZoned):
>+        (foo.return.async Zone):
>+        (foo.async _runZoned):
>+        (foo.collection._SetBase.dart.generic):
>+        (foo.collection._InternalSet.dart.generic):
>+        (foo.collection._HashSet.dart.generic):
>+        (foo.collection._ImmutableSet.dart.generic):
>+        (foo.collection._IdentityHashSet.dart.generic):
>+        (foo.collection._CustomHashSet.dart.generic):
>+        (foo.collection._CustomKeyHashSet.dart.generic):
>+        (foo.collection.UnmodifiableListView.dart.generic):
>+        (foo.collection._defaultEquals):
>+        (foo.collection._defaultHashCode):
>+        (foo.prototype.collection.HashMap.dart.generic):
>+        (foo.collection.HashSet.dart.generic):
>+        (foo.collection.IterableMixin.dart.generic):
>+        (foo.get collection._isToStringVisiting):
>+        (foo.collection._iterablePartsToStrings):
>+        (foo.collection.HasNextIterator.dart.generic):
>+        (foo.prototype.get collection):
>+        (foo.prototype.get dart):
>+        (foo.collection.LinkedHashSet.dart.generic):
>+        (foo.collection.LinkedList.dart.generic):
>+        (foo.collection._LinkedListIterator.dart.generic):
>+        (foo.collection.LinkedListEntry.dart.generic):
>+        (foo.prototype.collection._MapBaseValueIterable.dart.generic):
>+        (foo.prototype.collection._MapBaseValueIterator.dart.generic):
>+        (foo.prototype.collection.MapView.dart.generic):
>+        (foo.prototype.collection.UnmodifiableMapView.dart.generic):
>+        (foo.collection.Queue.dart.generic):
>+        (foo.collection._DoubleLink.dart.generic):
>+        (foo.collection.DoubleLinkedQueueEntry.dart.generic):
>+        (foo.collection._DoubleLinkedQueueEntry.dart.generic):
>+        (foo.collection._DoubleLinkedQueueElement.dart.generic):
>+        (foo.collection._DoubleLinkedQueueSentinel.dart.generic):
>+        (foo.collection.DoubleLinkedQueue.dart.generic):
>+        (foo.collection._DoubleLinkedQueueIterator.dart.generic):
>+        (foo.collection.ListQueue.dart.generic):
>+        (foo.collection._ListQueueIterator.dart.generic):
>+        (foo.collection.SetMixin.dart.generic):
>+        (foo.collection.SetBase.dart.generic):
>+        (foo.collection._UnmodifiableSet.dart.generic):
>+        (foo.collection._SplayTreeNode.dart.generic):
>+        (foo.prototype.collection._SplayTreeMapNode.dart.generic):
>+        (foo.prototype.collection._SplayTree.dart.generic):
>+        (foo.collection._TypeTest.dart.generic):
>+        (foo.collection._dynamicCompare):
>+        (foo.collection._defaultCompare):
>+        (foo.prototype.collection.SplayTreeMap.dart.generic):
>+        (foo.prototype.collection._SplayTreeIterator.dart.generic):
>+        (foo.collection._SplayTreeKeyIterable.dart.generic):
>+        (foo.prototype.collection._SplayTreeValueIterable.dart.generic):
>+        (foo.collection._SplayTreeKeyIterator.dart.generic):
>+        (foo.prototype.collection._SplayTreeValueIterator.dart.generic):
>+        (foo.collection._SplayTreeNodeIterator.dart.generic):
>+        (foo.collection.SplayTreeSet.dart.generic):
>+        (foo.walk):
>+        (foo.convert._convertJsonToDart):
>+        (foo.convert._convertJsonToDartLazy):
>+        (foo.core.String.fromCharCodes):
>+        (foo.core.String.fromCharCode):
>+        (foo.core.String.fromEnvironment):
>+        (foo.core.String._stringFromJSArray):
>+        (foo.core.String._stringFromUint8List):
>+        (foo.core.String._stringFromIterable):
>+        (foo.core.String):
>+        (foo.core.String.is):
>+        (foo.core.String.as):
>+        (foo.core.String._check):
>+        (foo.convert._JsonMap.prototype._get):
>+        (foo.convert._JsonMap.prototype.get length):
>+        (foo.convert._JsonMap.prototype.get isEmpty):
>+        (foo.convert._JsonMap.prototype.get isNotEmpty):
>+        (foo.convert._JsonMap.prototype.get keys):
>+        (foo.convert._JsonMap.prototype.get values):
>+        (foo.convert._JsonMap.prototype._set):
>+        (foo.convert._JsonMap.prototype.addAll):
>+        (foo.convert._JsonMap.prototype.containsValue):
>+        (foo.convert._JsonMap.prototype.containsKey):
>+        (foo.convert._JsonMap.prototype.putIfAbsent):
>+        (foo.convert._JsonMap.prototype.remove):
>+        (foo.convert._JsonMap.prototype.clear):
>+        (foo.convert._JsonMap.prototype.forEach):
>+        (foo.convert._JsonMap.prototype.get _isUpgraded):
>+        (foo.convert._JsonMap.prototype.get _upgradedMap):
>+        (foo.convert._JsonMap.prototype._computeKeys):
>+        (foo.convert._JsonMap.prototype._upgrade):
>+        (foo.convert._JsonMap.prototype._process):
>+        (foo.convert._JsonMap._hasProperty):
>+        (foo.convert._JsonMap._getProperty):
>+        (foo.convert._JsonMap._setProperty):
>+        (foo.convert._JsonMap._getPropertyNames):
>+        (foo.convert._JsonMap._isUnprocessed):
>+        (foo.convert._JsonMap._newJavaScriptObject):
>+        (foo.convert._JsonMap):
>+        (foo.convert._JsonMapKeyIterable.prototype.get length):
>+        (foo.convert._JsonMapKeyIterable.prototype.elementAt):
>+        (foo.convert._JsonMapKeyIterable.prototype.get iterator):
>+        (foo.convert._JsonMapKeyIterable.prototype.contains):
>+        (foo.convert._JsonMapKeyIterable):
>+        (foo.convert.StringConversionSinkMixin.prototype.add):
>+        (foo.convert.StringConversionSinkMixin.prototype.asUtf8Sink):
>+        (foo.convert.StringConversionSinkMixin.prototype.asStringSink):
>+        (foo.convert.StringConversionSinkMixin):
>+        (foo.convert.StringConversionSinkBase):
>+        (foo.convert._StringSinkConversionSink.dart.generic):
>+        (foo.core.StringSink):
>+        (foo.convert._JsonDecoderSink.prototype.close):
>+        (foo.convert._JsonDecoderSink):
>+        (foo.core.List.dart.generic):
>+        (foo.convert.Encoding.prototype.decodeStream):
>+        (foo.convert.Encoding.getByName):
>+        (foo.convert.Encoding):
>+        (foo.prototype.async dart):
>+        (foo.get convert.AsciiCodec.prototype.get name):
>+        (foo.get convert.AsciiCodec.prototype.encode):
>+        (foo.get convert.AsciiCodec.prototype.decode):
>+        (foo.get convert.AsciiCodec.prototype.get encoder):
>+        (foo.get convert.AsciiCodec.prototype.get decoder):
>+        (foo.get convert.AsciiCodec):
>+        (foo.prototype.get convert):
>+        (foo.convert._UnicodeSubsetEncoder.prototype.convert):
>+        (foo.convert._UnicodeSubsetEncoder.prototype.startChunkedConversion):
>+        (foo.convert._UnicodeSubsetEncoder.prototype.bind):
>+        (foo.convert._UnicodeSubsetEncoder):
>+        (foo.convert.AsciiEncoder):
>+        (foo.convert._UnicodeSubsetEncoderSink.prototype.close):
>+        (foo.convert._UnicodeSubsetEncoderSink.prototype.addSlice):
>+        (foo.convert._UnicodeSubsetEncoderSink):
>+        (foo.async prototype.async _RootZone):
>+        (foo.async prototype):
>+        (foo.convert._UnicodeSubsetDecoder.prototype.convert):
>+        (foo.convert._UnicodeSubsetDecoder.prototype._convertInvalid):
>+        (foo.convert._UnicodeSubsetDecoder.prototype.bind):
>+        (foo.convert._UnicodeSubsetDecoder):
>+        (foo.convert.AsciiDecoder.prototype.startChunkedConversion):
>+        (foo.convert.AsciiDecoder):
>+        (foo.async _RootZone.return.async Timer):
>+        (foo.convert.ChunkedConversionSink.dart.generic):
>+        (foo.convert.ByteConversionSink.withCallback):
>+        (foo.convert.ByteConversionSink.from):
>+        (foo.convert.ByteConversionSink):
>+        (foo.convert.ByteConversionSinkBase.prototype.addSlice):
>+        (foo.convert.ByteConversionSinkBase):
>+        (foo.convert._ErrorHandlingAsciiDecoderSink.prototype.close):
>+        (foo.convert._ErrorHandlingAsciiDecoderSink.prototype.add):
>+        (foo.convert._ErrorHandlingAsciiDecoderSink.prototype.addSlice):
>+        (foo.convert._ErrorHandlingAsciiDecoderSink):
>+        (foo.convert._SimpleAsciiDecoderSink.prototype.close):
>+        (foo.convert._SimpleAsciiDecoderSink.prototype.add):
>+        (foo.convert._SimpleAsciiDecoderSink.prototype.addSlice):
>+        (foo.convert._SimpleAsciiDecoderSink):
>+        (foo.get convert.base64Encode):
>+        (foo.convert.base64UrlEncode):
>+        (foo.convert.base64Decode):
>+        (foo.get convert):
>+        (foo.convert.Base64Codec.prototype.get encoder):
>+        (foo.convert.Base64Codec.prototype.get decoder):
>+        (foo.convert.Base64Codec.prototype.decode):
>+        (foo.convert.Base64Codec.prototype.normalize):
>+        (foo.convert.Base64Codec._checkPadding):
>+        (foo.convert.Base64Codec):
>+        (foo.convert.Base64Encoder.prototype.convert):
>+        (foo.convert.Base64Encoder.prototype.startChunkedConversion):
>+        (foo.convert.Base64Encoder):
>+        (foo.convert._Base64Encoder._encodeState):
>+        (foo.convert._Base64Encoder._stateBits):
>+        (foo.convert._Base64Encoder._stateCount):
>+        (foo.convert._Base64Encoder.prototype.createBuffer):
>+        (foo.convert._Base64Encoder.prototype.encode):
>+        (foo.convert._Base64Encoder.encodeChunk):
>+        (foo.convert._Base64Encoder.writeFinalChunk):
>+        (foo.convert._Base64Encoder):
>+        (foo.get convert._BufferCachingBase64Encoder.prototype.createBuffer):
>+        (foo.get convert._BufferCachingBase64Encoder):
>+        (foo.convert._Base64EncoderSink.prototype.add):
>+        (foo.convert._Base64EncoderSink.prototype.close):
>+        (foo.convert._Base64EncoderSink.prototype.addSlice):
>+        (foo.convert._Base64EncoderSink):
>+        (foo.convert._AsciiBase64EncoderSink.prototype._add.0):
>+        (foo.convert._AsciiBase64EncoderSink):
>+        (foo.convert._Utf8Base64EncoderSink.prototype._add.0):
>+        (foo.convert._Utf8Base64EncoderSink):
>+        (foo.convert.Base64Decoder.prototype.convert):
>+        (foo.convert.Base64Decoder.prototype.startChunkedConversion):
>+        (foo.convert.Base64Decoder):
>+        (foo.convert._Base64Decoder._encodeCharacterState):
>+        (foo.convert._Base64Decoder._stateCount):
>+        (foo.convert._Base64Decoder._stateBits):
>+        (foo.convert._Base64Decoder._encodePaddingState):
>+        (foo.convert._Base64Decoder._statePadding):
>+        (foo.convert._Base64Decoder._hasSeenPadding):
>+        (foo.convert._Base64Decoder.prototype.decode):
>+        (foo.convert._Base64Decoder.prototype.close):
>+        (foo.convert._Base64Decoder.decodeChunk):
>+        (foo.convert._Base64Decoder._allocateBuffer):
>+        (foo.convert._Base64Decoder._trimPaddingChars):
>+        (foo.convert._Base64Decoder._checkPadding):
>+        (foo.convert._Base64Decoder):
>+        (foo.convert._Base64DecoderSink.prototype.add):
>+        (foo.convert._Base64DecoderSink.prototype.close):
>+        (foo.convert._Base64DecoderSink.prototype.addSlice):
>+        (foo.convert._Base64DecoderSink):
>+        (foo.convert._ByteAdapterSink.prototype.add):
>+        (foo.convert._ByteAdapterSink.prototype.close):
>+        (foo.convert._ByteAdapterSink):
>+        (foo.convert._ByteCallbackSink.prototype.add):
>+        (foo.convert._ByteCallbackSink._roundToPowerOf2):
>+        (foo.convert._ByteCallbackSink.prototype.close):
>+        (foo.convert._ByteCallbackSink):
>+        (foo.convert._SimpleCallbackSink.dart.generic):
>+        (foo.prototype.convert._ConverterStreamEventSink.dart.generic):
>+        (foo.prototype.convert._FusedCodec.dart.generic):
>+        (foo.prototype.convert._InvertedCodec.dart.generic):
>+        (foo.prototype.convert._FusedConverter.dart.generic):
>+        (foo.convert.HtmlEscapeMode.prototype.get escapeLtGt):
>+        (foo.convert.HtmlEscapeMode.prototype.set escapeLtGt):
>+        (foo.convert.HtmlEscapeMode.prototype.get escapeQuot):
>+        (foo.convert.HtmlEscapeMode.prototype.set escapeQuot):
>+        (foo.convert.HtmlEscapeMode.prototype.get escapeApos):
>+        (foo.convert.HtmlEscapeMode.prototype.set escapeApos):
>+        (foo.convert.HtmlEscapeMode.prototype.get escapeSlash):
>+        (foo.convert.HtmlEscapeMode.prototype.set escapeSlash):
>+        (foo.convert.HtmlEscapeMode.prototype.toString):
>+        (foo.convert.HtmlEscapeMode):
>+        (foo.convert.HtmlEscape.prototype.get mode):
>+        (foo.convert.HtmlEscape.prototype.set mode):
>+        (foo.convert.HtmlEscape.prototype.convert):
>+        (foo.convert.HtmlEscape.prototype._convert):
>+        (foo.convert.HtmlEscape.prototype.startChunkedConversion):
>+        (foo.convert.HtmlEscape):
>+        (foo.convert._HtmlEscapeSink.prototype.addSlice):
>+        (foo.convert._HtmlEscapeSink.prototype.close):
>+        (foo.convert._HtmlEscapeSink):
>+        (foo.convert.JsonUnsupportedObjectError.prototype.get unsupportedObject):
>+        (foo.convert.JsonUnsupportedObjectError.prototype.set unsupportedObject):
>+        (foo.convert.JsonUnsupportedObjectError.prototype.get cause):
>+        (foo.convert.JsonUnsupportedObjectError.prototype.set cause):
>+        (foo.convert.JsonUnsupportedObjectError.prototype.get partialResult):
>+        (foo.convert.JsonUnsupportedObjectError.prototype.set partialResult):
>+        (foo.convert.JsonUnsupportedObjectError.prototype.toString):
>+        (foo.convert.JsonUnsupportedObjectError):
>+        (foo.convert.JsonCyclicError.prototype.toString):
>+        (foo.convert.JsonCyclicError):
>+        (foo.get convert.jsonEncode):
>+        (foo.convert.jsonDecode):
>+        (foo.convert.JsonCodec.prototype.decode):
>+        (foo.convert.JsonCodec.prototype.encode):
>+        (foo.convert.JsonCodec.prototype.get encoder):
>+        (foo.convert.JsonCodec.prototype.get decoder):
>+        (foo.convert.JsonCodec):
>+        (foo.convert.JsonEncoder.prototype.get indent):
>+        (foo.convert.JsonEncoder.prototype.set indent):
>+        (foo.convert.JsonEncoder.prototype.convert):
>+        (foo.convert.JsonEncoder.prototype.startChunkedConversion):
>+        (foo.convert.JsonEncoder.prototype.bind):
>+        (foo.convert.JsonEncoder.prototype.fuse):
>+        (foo.convert.JsonEncoder):
>+        (foo.convert.JsonUtf8Encoder._utf8Encode):
>+        (foo.convert.JsonUtf8Encoder.prototype.convert.addChunk):
>+        (foo.convert.JsonUtf8Encoder.prototype.convert):
>+        (foo.convert.JsonUtf8Encoder.prototype.startChunkedConversion):
>+        (foo.convert.JsonUtf8Encoder.prototype.bind):
>+        (foo.convert.JsonUtf8Encoder):
>+        (foo.convert._JsonEncoderSink.prototype.add):
>+        (foo.convert._JsonEncoderSink.prototype.close):
>+        (foo.convert._JsonEncoderSink):
>+        (foo.convert._JsonUtf8EncoderSink.prototype._addChunk):
>+        (foo.convert._JsonUtf8EncoderSink.prototype.add):
>+        (foo.convert._JsonUtf8EncoderSink.prototype.close):
>+        (foo.convert._JsonUtf8EncoderSink):
>+        (foo.convert.JsonDecoder.prototype.convert):
>+        (foo.convert.JsonDecoder.prototype.startChunkedConversion):
>+        (foo.convert.JsonDecoder.prototype.bind):
>+        (foo.convert.JsonDecoder):
>+        (foo.convert._parseJson):
>+        (foo.convert._defaultToEncodable):
>+        (foo.convert._JsonStringifier.hexDigit):
>+        (foo.convert._JsonStringifier.prototype.writeStringContent):
>+        (foo.convert._JsonStringifier.prototype._checkCycle):
>+        (foo.convert._JsonStringifier.prototype._removeSeen):
>+        (foo.convert._JsonStringifier.prototype.writeObject):
>+        (foo.convert._JsonStringifier.prototype.writeJsonValue):
>+        (foo.convert._JsonStringifier.prototype.writeList):
>+        (foo.convert._JsonStringifier.prototype.writeMap):
>+        (foo.convert._JsonStringifier):
>+        (foo.convert._JsonPrettyPrintMixin.prototype.writeList):
>+        (foo.convert._JsonPrettyPrintMixin.prototype.writeMap):
>+        (foo.convert._JsonPrettyPrintMixin):
>+        (foo.convert._JsonStringStringifier.stringify):
>+        (foo.convert._JsonStringStringifier.printOn):
>+        (foo.convert._JsonStringStringifier.prototype.get _partialResult):
>+        (foo.convert._JsonStringStringifier.prototype.writeNumber):
>+        (foo.convert._JsonStringStringifier.prototype.writeString):
>+        (foo.convert._JsonStringStringifier.prototype.writeStringSlice):
>+        (foo.convert._JsonStringStringifier.prototype.writeCharCode):
>+        (foo.convert._JsonStringStringifier):
>+        (foo.const._JsonStringStringifier__JsonPrettyPrintMixin):
>+        (foo.convert._JsonStringStringifierPretty.prototype.writeIndentation):
>+        (foo.convert._JsonStringStringifierPretty):
>+        (foo.convert._JsonUtf8Stringifier.stringify):
>+        (foo.convert._JsonUtf8Stringifier.prototype.flush):
>+        (foo.convert._JsonUtf8Stringifier.prototype.get _partialResult):
>+        (foo.convert._JsonUtf8Stringifier.prototype.writeNumber):
>+        (foo.convert._JsonUtf8Stringifier.prototype.writeAsciiString):
>+        (foo.convert._JsonUtf8Stringifier.prototype.writeString):
>+        (foo.convert._JsonUtf8Stringifier.prototype.writeStringSlice):
>+        (foo.convert._JsonUtf8Stringifier.prototype.writeCharCode):
>+        (foo.convert._JsonUtf8Stringifier.prototype.writeMultiByteCharCode):
>+        (foo.convert._JsonUtf8Stringifier.prototype.writeFourByteCharCode):
>+        (foo.convert._JsonUtf8Stringifier.prototype.writeByte):
>+        (foo.convert._JsonUtf8Stringifier):
>+        (foo.const._JsonUtf8Stringifier__JsonPrettyPrintMixin):
>+        (foo.convert._JsonUtf8StringifierPretty.prototype.writeIndentation):
>+        (foo.convert._JsonUtf8StringifierPretty):
>+        (foo.convert.Latin1Codec.prototype.get name):
>+        (foo.convert.Latin1Codec.prototype.encode):
>+        (foo.convert.Latin1Codec.prototype.decode):
>+        (foo.convert.Latin1Codec.prototype.get encoder):
>+        (foo.convert.Latin1Codec.prototype.get decoder):
>+        (foo.convert.Latin1Codec):
>+        (foo.get let):
>+        (foo.convert.Latin1Encoder):
>+        (foo.convert.Latin1Decoder.prototype.startChunkedConversion):
>+        (foo.convert.Latin1Decoder):
>+        (foo.convert._Latin1DecoderSink.prototype.close):
>+        (foo.convert._Latin1DecoderSink.prototype.add):
>+        (foo.convert._Latin1DecoderSink.prototype._addSliceToSink):
>+        (foo.convert._Latin1DecoderSink.prototype.addSlice):
>+        (foo.convert._Latin1DecoderSink._checkValidLatin1):
>+        (foo.convert._Latin1DecoderSink._reportInvalidLatin1):
>+        (foo.convert._Latin1DecoderSink):
>+        (foo.convert._Latin1AllowInvalidDecoderSink.prototype.addSlice):
>+        (foo.convert._Latin1AllowInvalidDecoderSink):
>+        (foo.get convert.LineSplitter.split.return.new.new):
>+        (foo.get convert.LineSplitter.split):
>+        (foo.get convert.LineSplitter.prototype.convert):
>+        (foo.get convert.LineSplitter.prototype.startChunkedConversion):
>+        (foo.get convert.LineSplitter.prototype.bind):
>+        (foo.get convert.LineSplitter):
>+        (foo.convert._LineSplitterSink.prototype.addSlice):
>+        (foo.convert._LineSplitterSink.prototype.close):
>+        (foo.convert._LineSplitterSink.prototype._addLines):
>+        (foo.convert._LineSplitterSink):
>+        (foo.convert._LineSplitterEventSink.prototype.addError):
>+        (foo.convert._LineSplitterEventSink):
>+        (foo.convert.StringConversionSink.withCallback):
>+        (foo.convert.StringConversionSink.from):
>+        (foo.convert.StringConversionSink.fromStringSink):
>+        (foo.convert.StringConversionSink):
>+        (foo.convert.ClosableStringSink.fromStringSink):
>+        (foo.convert.ClosableStringSink):
>+        (foo.convert._ClosableStringSink.prototype.close):
>+        (foo.convert._ClosableStringSink.prototype.writeCharCode):
>+        (foo.convert._ClosableStringSink.prototype.write):
>+        (foo.convert._ClosableStringSink.prototype.writeln):
>+        (foo.convert._ClosableStringSink.prototype.writeAll):
>+        (foo.convert._ClosableStringSink):
>+        (foo.convert._StringConversionSinkAsStringSinkAdapter.prototype.close):
>+        (foo.convert._StringConversionSinkAsStringSinkAdapter.prototype.writeCharCode):
>+        (foo.convert._StringConversionSinkAsStringSinkAdapter.prototype.write):
>+        (foo.convert._StringConversionSinkAsStringSinkAdapter.prototype.writeln):
>+        (foo.convert._StringConversionSinkAsStringSinkAdapter.prototype.writeAll):
>+        (foo.convert._StringConversionSinkAsStringSinkAdapter.prototype._flush):
>+        (foo.convert._StringConversionSinkAsStringSinkAdapter):
>+        (foo.core.StringBuffer.prototype.get length):
>+        (foo.core.StringBuffer.prototype.get isEmpty):
>+        (foo.core.StringBuffer.prototype.get isNotEmpty):
>+        (foo.core.StringBuffer.prototype.write):
>+        (foo.core.StringBuffer.prototype.writeCharCode):
>+        (foo.core.StringBuffer.prototype.writeAll):
>+        (foo.core.StringBuffer.prototype.writeln):
>+        (foo.core.StringBuffer.prototype.clear):
>+        (foo.core.StringBuffer.prototype.toString):
>+        (foo.core.StringBuffer.prototype._writeString):
>+        (foo.core.StringBuffer._writeAll):
>+        (foo.core.StringBuffer._writeOne):
>+        (foo.core.StringBuffer):
>+        (foo.convert._StringCallbackSink.prototype.close):
>+        (foo.convert._StringCallbackSink.prototype.asUtf8Sink):
>+        (foo.convert._StringCallbackSink):
>+        (foo.convert._StringAdapterSink.prototype.add):
>+        (foo.convert._StringAdapterSink.prototype.addSlice):
>+        (foo.convert._StringAdapterSink.prototype.close):
>+        (foo.convert._StringAdapterSink):
>+        (foo.convert._Utf8StringSinkAdapter.prototype.close):
>+        (foo.convert._Utf8StringSinkAdapter.prototype.add):
>+        (foo.convert._Utf8StringSinkAdapter.prototype.addSlice):
>+        (foo.convert._Utf8StringSinkAdapter):
>+        (foo.convert._Utf8ConversionSink.prototype.close):
>+        (foo.convert._Utf8ConversionSink.prototype.add):
>+        (foo.convert._Utf8ConversionSink.prototype.addSlice):
>+        (foo.convert._Utf8ConversionSink):
>+        (foo.convert.Utf8Codec.prototype.get name):
>+        (foo.convert.Utf8Codec.prototype.decode):
>+        (foo.convert.Utf8Codec.prototype.get encoder):
>+        (foo.convert.Utf8Codec.prototype.get decoder):
>+        (foo.convert.Utf8Codec):
>+        (foo.convert.Utf8Encoder.prototype.convert):
>+        (foo.convert.Utf8Encoder.prototype.startChunkedConversion):
>+        (foo.convert.Utf8Encoder.prototype.bind):
>+        (foo.convert.Utf8Encoder):
>+        (foo.convert._Utf8Encoder._createBuffer):
>+        (foo.convert._Utf8Encoder.prototype._writeSurrogate):
>+        (foo.convert._Utf8Encoder.prototype._fillBuffer):
>+        (foo.convert._Utf8Encoder):
>+        (foo.get const._Utf8Encoder_StringConversionSinkMixin):
>+        (foo.convert._Utf8EncoderSink.prototype.close):
>+        (foo.convert._Utf8EncoderSink.prototype.addSlice):
>+        (foo.convert._Utf8EncoderSink):
>+        (foo.convert.Utf8Decoder.prototype.convert):
>+        (foo.convert.Utf8Decoder.prototype.startChunkedConversion):
>+        (foo.convert.Utf8Decoder.prototype.bind):
>+        (foo.convert.Utf8Decoder.prototype.fuse):
>+        (foo.convert.Utf8Decoder._convertIntercepted):
>+        (foo.convert.Utf8Decoder._convertInterceptedUint8List):
>+        (foo.convert.Utf8Decoder._useTextDecoderChecked):
>+        (foo.convert.Utf8Decoder._useTextDecoderUnchecked):
>+        (foo.convert.Utf8Decoder._unsafe):
>+        (foo.convert.Utf8Decoder):
>+        (foo.get convert._isLeadSurrogate):
>+        (foo.convert._isTailSurrogate):
>+        (foo.convert._combineSurrogatePair):
>+        (foo.convert._Utf8Decoder.prototype.get hasPartialInput):
>+        (foo.convert._Utf8Decoder.prototype.close):
>+        (foo.convert._Utf8Decoder.prototype.flush):
>+        (foo.convert._Utf8Decoder.prototype.convert):
>+        (foo.convert._Utf8Decoder):
>+        (foo.get convert._scanOneByteCharacters):
>+        (foo.core._symbolToString):
>+        (foo.core._kNull):
>+        (foo.core._CompileTimeError.prototype.toString):
>+        (foo.core._CompileTimeError):
>+        (foo.core._DuplicatedFieldInitializerError.prototype.toString):
>+        (foo.core._DuplicatedFieldInitializerError):
>+        (foo.core._max):
>+        (foo.core._min):
>+        (foo.core._BigIntImpl.parse):
>+        (foo.core._BigIntImpl._parseDecimal):
>+        (foo.core._BigIntImpl._codeUnitToRadixValue):
>+        (foo.core._BigIntImpl._parseHex):
>+        (foo.core._BigIntImpl._parseRadix):
>+        (foo.core._BigIntImpl._tryParse):
>+        (foo.core._BigIntImpl._normalize):
>+        (foo.core._BigIntImpl.prototype.get _isZero):
>+        (foo.core._BigIntImpl._cloneDigits):
>+        (foo.core._BigIntImpl.from):
>+        (foo.core._BigIntImpl._fromInt):
>+        (foo.core._BigIntImpl._fromDouble):
>+        (foo.core._BigIntImpl.prototype._negate):
>+        (foo.core._BigIntImpl.prototype.abs):
>+        (foo.core._BigIntImpl.prototype._dlShift):
>+        (foo.core._BigIntImpl._dlShiftDigits):
>+        (foo.core._BigIntImpl.prototype._drShift):
>+        (foo.core._BigIntImpl._lsh):
>+        (foo.core._BigIntImpl.prototype.string_appeared_here):
>+        (foo.core._BigIntImpl._lShiftDigits):
>+        (foo.core._BigIntImpl._rsh):
>+        (foo.core._BigIntImpl.prototype._absCompare):
>+        (foo.core._BigIntImpl.prototype.compareTo):
>+        (foo.core._BigIntImpl._compareDigits):
>+        (foo.core._BigIntImpl._absAdd):
>+        (foo.core._BigIntImpl._absSub):
>+        (foo.core._BigIntImpl.prototype._absAddSetSign):
>+        (foo.core._BigIntImpl.prototype._absSubSetSign):
>+        (foo.core._BigIntImpl.prototype._absAndSetSign):
>+        (foo.core._BigIntImpl.prototype._absAndNotSetSign):
>+        (foo.core._BigIntImpl.prototype._absOrSetSign):
>+        (foo.core._BigIntImpl.prototype._absXorSetSign):
>+        (foo.core._BigIntImpl._mulAdd):
>+        (foo.core._BigIntImpl._mulDigits):
>+        (foo.core._BigIntImpl._estimateQuotientDigit):
>+        (foo.core._BigIntImpl.prototype._div):
>+        (foo.core._BigIntImpl.prototype._rem):
>+        (foo.core._BigIntImpl.prototype._divRem):
>+        (foo.core._BigIntImpl.get hashCode.combine):
>+        (foo.core._BigIntImpl.get hashCode.finish):
>+        (foo.core._BigIntImpl.prototype.get hashCode):
>+        (foo.core._BigIntImpl.prototype._equals):
>+        (foo.core._BigIntImpl.prototype.get bitLength):
>+        (foo.core._BigIntImpl.prototype.remainder):
>+        (foo.core._BigIntImpl.prototype.get sign):
>+        (foo.core._BigIntImpl.prototype.get isEven):
>+        (foo.core._BigIntImpl.prototype.get isOdd):
>+        (foo.core._BigIntImpl.prototype.get isNegative):
>+        (foo.core._BigIntImpl.prototype.pow):
>+        (foo.core._BigIntImpl.prototype.modPow):
>+        (foo.core._BigIntImpl._binaryGcd):
>+        (foo.core._BigIntImpl.prototype.modInverse):
>+        (foo.core._BigIntImpl.prototype.gcd):
>+        (foo.core._BigIntImpl.prototype.toUnsigned):
>+        (foo.core._BigIntImpl.prototype.toSigned):
>+        (foo.core._BigIntImpl.prototype.get isValidInt):
>+        (foo.core._BigIntImpl.prototype.toInt):
>+        (foo.core._BigIntImpl.prototype.toDouble.roundUp):
>+        (foo.core._BigIntImpl.prototype.toDouble):
>+        (foo.core._BigIntImpl.prototype.toString):
>+        (foo.core._BigIntImpl.prototype._toRadixCodeUnit):
>+        (foo.core._BigIntImpl.prototype.toRadixString):
>+        (foo.core._BigIntImpl.prototype._toHexString):
>+        (foo.core._BigIntImpl):
>+        (foo.set get core._BigIntReduction):
>+        (foo.core._BigIntClassic.prototype.convert):
>+        (foo.core._BigIntClassic.prototype.revert):
>+        (foo.core._BigIntClassic.prototype._reduce):
>+        (foo.core._BigIntClassic.prototype.sqr):
>+        (foo.core._BigIntClassic.prototype.mul):
>+        (foo.core._BigIntClassic):
>+        (foo.set get core):
>+        (foo.core.Deprecated.prototype.get message):
>+        (foo.core.Deprecated.prototype.set message):
>+        (foo.core.Deprecated.prototype.get expires):
>+        (foo.core.Deprecated.prototype.toString):
>+        (foo.core.Deprecated):
>+        (foo.get core._Override):
>+        (foo.get core):
>+        (foo.get core.Provisional.prototype.get message):
>+        (foo.get core.Provisional):
>+        (foo.get core._Proxy):
>+        (foo.get core.pragma.prototype.get name):
>+        (foo.get core.pragma.prototype.set name):
>+        (foo.get core.pragma.prototype.get options):
>+        (foo.get core.pragma.prototype.set options):
>+        (foo.get core.pragma.new):
>+        (foo.get core.pragma):
>+        (foo.core.BigInt.get zero):
>+        (foo.core.BigInt.get one):
>+        (foo.core.BigInt.get two):
>+        (foo.core.BigInt.parse):
>+        (foo.core.BigInt.tryParse):
>+        (foo.core.BigInt.from):
>+        (foo.core.BigInt):
>+        (foo.core.bool.fromEnvironment):
>+        (foo.core.bool.prototype.get hashCode):
>+        (foo.core.bool.prototype.bitAnd):
>+        (foo.core.bool.prototype.bitOr):
>+        (foo.core.bool.prototype.bitXor):
>+        (foo.core.bool.prototype.toString):
>+        (foo.core.bool):
>+        (foo.core.bool.is):
>+        (foo.core.bool.as):
>+        (foo.core.bool._check):
>+        (foo.async _RootZone.scheduleMicrotask.async _rootScheduleMicrotask):
>+        (foo.core.Comparable.dart.generic):
>+        (foo.core.DateTime.prototype.get isUtc):
>+        (foo.core.DateTime.prototype.set isUtc):
>+        (foo.core.DateTime.parse.):
>+        (foo.core.DateTime.parse.parseMilliAndMicroseconds):
>+        (foo.core.DateTime.parse):
>+        (foo.core.DateTime.tryParse):
>+        (foo.core.DateTime.prototype._equals):
>+        (foo.core.DateTime.prototype.isBefore):
>+        (foo.core.DateTime.prototype.isAfter):
>+        (foo.core.DateTime.prototype.isAtSameMomentAs):
>+        (foo.core.DateTime.prototype.compareTo):
>+        (foo.core.DateTime.prototype.get hashCode):
>+        (foo.core.DateTime.prototype.toLocal):
>+        (foo.core.DateTime.prototype.toUtc):
>+        (foo.core.DateTime._fourDigits):
>+        (foo.core.DateTime._sixDigits):
>+        (foo.core.DateTime._threeDigits):
>+        (foo.core.DateTime._twoDigits):
>+        (foo.core.DateTime.prototype.toString):
>+        (foo.core.DateTime.prototype.toIso8601String):
>+        (foo.core.DateTime.prototype.add):
>+        (foo.core.DateTime.prototype.subtract):
>+        (foo.core.DateTime.prototype.difference):
>+        (foo.core.DateTime._brokenDownDateToValue):
>+        (foo.core.DateTime.prototype.get millisecondsSinceEpoch):
>+        (foo.core.DateTime.prototype.get microsecondsSinceEpoch):
>+        (foo.core.DateTime.prototype.get timeZoneName):
>+        (foo.core.DateTime.prototype.get timeZoneOffset):
>+        (foo.core.DateTime.prototype.get year):
>+        (foo.core.DateTime.prototype.get month):
>+        (foo.core.DateTime.prototype.get day):
>+        (foo.core.DateTime.prototype.get hour):
>+        (foo.core.DateTime.prototype.get minute):
>+        (foo.core.DateTime.prototype.get second):
>+        (foo.core.DateTime.prototype.get millisecond):
>+        (foo.core.DateTime.prototype.get microsecond):
>+        (foo.core.DateTime.prototype.get weekday):
>+        (foo.core.DateTime._microsecondInRoundedMilliseconds):
>+        (foo.core.DateTime):
>+        (foo.core.Duration.prototype.string_appeared_here):
>+        (foo.core.Duration.prototype.get inDays):
>+        (foo.core.Duration.prototype.get inHours):
>+        (foo.core.Duration.prototype.get inMinutes):
>+        (foo.core.Duration.prototype.get inSeconds):
>+        (foo.core.Duration.prototype.get inMilliseconds):
>+        (foo.core.Duration.prototype.get inMicroseconds):
>+        (foo.core.Duration.prototype._equals):
>+        (foo.core.Duration.prototype.get hashCode):
>+        (foo.core.Duration.prototype.compareTo):
>+        (foo.core.Duration.prototype.toString.sixDigits):
>+        (foo.core.Duration.prototype.toString.twoDigits):
>+        (foo.core.Duration.prototype.toString):
>+        (foo.core.Duration.prototype.get isNegative):
>+        (foo.core.Duration.prototype.abs):
>+        (foo.core.Duration.prototype._negate):
>+        (foo.core.Duration):
>+        (foo.async _RootZone.return.async _rootRunBinary):
>+        (foo.get core.TypeError):
>+        (foo.core.CastError):
>+        (foo.core.NullThrownError.prototype.toString):
>+        (foo.core.NullThrownError):
>+        (foo.core.ArgumentError.prototype.get invalidValue):
>+        (foo.core.ArgumentError.prototype.set invalidValue):
>+        (foo.core.ArgumentError.prototype.get name):
>+        (foo.core.ArgumentError.prototype.set name):
>+        (foo.core.ArgumentError.prototype.get message):
>+        (foo.core.ArgumentError.prototype.set message):
>+        (foo.core.ArgumentError.checkNotNull):
>+        (foo.core.ArgumentError.prototype.get _errorName):
>+        (foo.core.ArgumentError.prototype.get _errorExplanation):
>+        (foo.core.ArgumentError.prototype.toString):
>+        (foo.core.ArgumentError):
>+        (foo.core.RangeError.prototype.get start):
>+        (foo.core.RangeError.prototype.set start):
>+        (foo.core.RangeError.prototype.get end):
>+        (foo.core.RangeError.prototype.set end):
>+        (foo.core.RangeError.index):
>+        (foo.core.RangeError.checkValueInInterval):
>+        (foo.core.RangeError.checkValidIndex):
>+        (foo.core.RangeError.checkValidRange):
>+        (foo.core.RangeError.checkNotNegative):
>+        (foo.core.RangeError.prototype.get _errorName):
>+        (foo.core.RangeError.prototype.get _errorExplanation):
>+        (foo.core.RangeError):
>+        (foo.core.IndexError.prototype.get indexable):
>+        (foo.core.IndexError.prototype.set indexable):
>+        (foo.core.IndexError.prototype.get length):
>+        (foo.core.IndexError.prototype.set length):
>+        (foo.core.IndexError.prototype.get start):
>+        (foo.core.IndexError.prototype.get end):
>+        (foo.core.IndexError.prototype.get _errorName):
>+        (foo.core.IndexError.prototype.get _errorExplanation):
>+        (foo.core.IndexError):
>+        (foo.core.AbstractClassInstantiationError.prototype.toString):
>+        (foo.core.AbstractClassInstantiationError):
>+        (foo.core.NoSuchMethodError.prototype.toString):
>+        (foo.core.NoSuchMethodError):
>+        (foo.core.UnsupportedError.prototype.get message):
>+        (foo.core.UnsupportedError.prototype.set message):
>+        (foo.core.UnsupportedError.prototype.toString):
>+        (foo.core.UnsupportedError):
>+        (foo.core.UnimplementedError.prototype.get message):
>+        (foo.core.UnimplementedError.prototype.set message):
>+        (foo.core.UnimplementedError.prototype.toString):
>+        (foo.core.UnimplementedError):
>+        (foo.core.StateError.prototype.get message):
>+        (foo.core.StateError.prototype.set message):
>+        (foo.core.StateError.prototype.toString):
>+        (foo.core.StateError):
>+        (foo.core.ConcurrentModificationError.prototype.get modifiedObject):
>+        (foo.core.ConcurrentModificationError.prototype.set modifiedObject):
>+        (foo.core.ConcurrentModificationError.prototype.toString):
>+        (foo.core.ConcurrentModificationError):
>+        (foo.core.OutOfMemoryError.prototype.toString):
>+        (foo.core.OutOfMemoryError.prototype.get stackTrace):
>+        (foo.core.OutOfMemoryError):
>+        (foo.core.StackOverflowError.prototype.toString):
>+        (foo.core.StackOverflowError.prototype.get stackTrace):
>+        (foo.core.StackOverflowError):
>+        (foo.core.CyclicInitializationError.prototype.get variableName):
>+        (foo.core.CyclicInitializationError.prototype.set variableName):
>+        (foo.core.CyclicInitializationError.prototype.toString):
>+        (foo.core.CyclicInitializationError):
>+        (foo.core.Exception.new):
>+        (foo.core.Exception):
>+        (foo.core._Exception.prototype.toString):
>+        (foo.core._Exception):
>+        (foo.core.FormatException.prototype.get message):
>+        (foo.core.FormatException.prototype.set message):
>+        (foo.core.FormatException.prototype.get source):
>+        (foo.core.FormatException.prototype.set source):
>+        (foo.core.FormatException.prototype.get offset):
>+        (foo.core.FormatException.prototype.set offset):
>+        (foo.core.FormatException.prototype.toString):
>+        (foo.core.FormatException):
>+        (foo.core.IntegerDivisionByZeroException.prototype.toString):
>+        (foo.core.IntegerDivisionByZeroException):
>+        (foo.async _RootZone.async return):
>+        (foo.async _RootZone.return.async _rootRunUnary):
>+        (foo.async _RootZone.return.async _rootRun):
>+        (foo.async _RootZone.fork.return.async _rootFork):
>+        (foo.core.Expando.dart.generic):
>+        (foo.core.Function.apply):
>+        (foo.core.Function._toMangledNames):
>+        (foo.core.Function):
>+        (foo.core.Function.is):
>+        (foo.core.Function.as):
>+        (foo.core.Function._check):
>+        (foo.core.identical):
>+        (foo.core.identityHashCode):
>+        (foo.core._Invocation.prototype.get positionalArguments):
>+        (foo.core._Invocation.prototype.get namedArguments):
>+        (foo.core._Invocation.prototype.get isMethod):
>+        (foo.core._Invocation.prototype.get isGetter):
>+        (foo.core._Invocation.prototype.get isSetter):
>+        (foo.core._Invocation.prototype.get isAccessor):
>+        (foo.core._Invocation._ensureNonNullTypes):
>+        (foo.core._Invocation._makeUnmodifiable):
>+        (foo.core._Invocation):
>+        (foo.set get dart):
>+        (foo.async _RootZone.async _rootHandleUncaughtError):
>+        (foo.core._GeneratorIterable.dart.generic):
>+        (foo.core.BidirectionalIterator.dart.generic):
>+        (foo.prototype.core.Map.dart.generic):
>+        (foo.prototype.core.MapEntry.dart.generic):
>+        (foo.core.Null.prototype.get hashCode):
>+        (foo.core.Null.prototype.toString):
>+        (foo.core.Null):
>+        (foo.core.Null.is):
>+        (foo.core.Null.as):
>+        (foo.core.Null._check):
>+        (foo.core.Pattern):
>+        (foo.core.print):
>+        (foo.core.RegExp.new):
>+        (foo.core.RegExp.escape):
>+        (foo.core.RegExp):
>+        (foo.core.Set.dart.generic):
>+        (foo.core.Sink.dart.generic):
>+        (foo.core.StackTrace.fromString):
>+        (foo.core.StackTrace.get current):
>+        (foo.core.StackTrace):
>+        (foo.core._StringStackTrace.prototype.toString):
>+        (foo.core._StringStackTrace):
>+        (foo.core.Stopwatch.prototype.get frequency):
>+        (foo.core.Stopwatch.prototype.start):
>+        (foo.core.Stopwatch.prototype.stop):
>+        (foo.core.Stopwatch.prototype.reset):
>+        (foo.core.Stopwatch.prototype.get elapsedTicks):
>+        (foo.core.Stopwatch.prototype.get elapsed):
>+        (foo.core.Stopwatch.prototype.get elapsedMicroseconds):
>+        (foo.core.Stopwatch.prototype.get elapsedMilliseconds):
>+        (foo.core.Stopwatch.prototype.get isRunning):
>+        (foo.core.Stopwatch._initTicker):
>+        (foo.core.Stopwatch._now):
>+        (foo.core.Stopwatch):
>+        (foo.set get core.Runes.prototype.get string):
>+        (foo.set get core.Runes.prototype.set string):
>+        (foo.set get core.Runes.prototype.get iterator):
>+        (foo.set get core.Runes.prototype.get last):
>+        (foo.set get core.Runes):
>+        (foo.core._isLeadSurrogate):
>+        (foo.core._isTrailSurrogate):
>+        (foo.core._combineSurrogatePair):
>+        (foo.core.RuneIterator.prototype.get string):
>+        (foo.core.RuneIterator.prototype.set string):
>+        (foo.core.RuneIterator.prototype._checkSplitSurrogate):
>+        (foo.core.RuneIterator.prototype.get rawIndex):
>+        (foo.core.RuneIterator.prototype.set rawIndex):
>+        (foo.core.RuneIterator.prototype.reset):
>+        (foo.core.RuneIterator.prototype.get current):
>+        (foo.core.RuneIterator.prototype.get currentSize):
>+        (foo.core.RuneIterator.prototype.get currentAsString):
>+        (foo.core.RuneIterator.prototype.moveNext):
>+        (foo.core.RuneIterator.prototype.movePrevious):
>+        (foo.core.RuneIterator):
>+        (foo.core.Symbol.new):
>+        (foo.core.Symbol):
>+        (foo.get core.Uri.get base):
>+        (foo.get core.Uri.new):
>+        (foo.get core.Uri.http):
>+        (foo.get core.Uri.https):
>+        (foo.get core.Uri.file):
>+        (foo.get core.Uri.directory):
>+        (foo.get core.Uri.dataFromString):
>+        (foo.get core.Uri.dataFromBytes):
>+        (foo.get core.Uri.prototype.get hasScheme):
>+        (foo.get core.Uri.parse):
>+        (foo.get core.Uri.tryParse):
>+        (foo.get core.Uri.encodeComponent):
>+        (foo.get core.Uri.encodeQueryComponent):
>+        (foo.get core.Uri.decodeComponent):
>+        (foo.get core.Uri.decodeQueryComponent):
>+        (foo.get core.Uri.encodeFull):
>+        (foo.get core.Uri.decodeFull):
>+        (foo.get core.Uri.splitQueryString):
>+        (foo.get core.Uri.parseIPv4Address):
>+        (foo.get core.Uri._parseIPv4Address.error):
>+        (foo.get core.Uri._parseIPv4Address):
>+        (foo.get core.Uri.parseIPv6Address.error):
>+        (foo.get core.Uri.parseIPv6Address.parseHex):
>+        (foo.get core.Uri.parseIPv6Address):
>+        (foo.get core.Uri):
>+        (foo.core._Uri.notSimple):
>+        (foo.core._Uri.new):
>+        (foo.core._Uri.http):
>+        (foo.core._Uri.https):
>+        (foo.core._Uri.prototype.get authority):
>+        (foo.core._Uri.prototype.get userInfo):
>+        (foo.core._Uri.prototype.get host):
>+        (foo.core._Uri.prototype.get port):
>+        (foo.core._Uri._defaultPort):
>+        (foo.core._Uri.prototype.get query):
>+        (foo.core._Uri.prototype.get fragment):
>+        (foo.core._Uri.prototype.isScheme):
>+        (foo.core._Uri._compareScheme):
>+        (foo.core._Uri._fail):
>+        (foo.core._Uri._makeHttpUri):
>+        (foo.core._Uri.file):
>+        (foo.core._Uri.directory):
>+        (foo.core._Uri.get _isWindows):
>+        (foo.core._Uri._checkNonWindowsPathReservedCharacters):
>+        (foo.core._Uri._checkWindowsPathReservedCharacters):
>+        (foo.core._Uri._checkWindowsDriveLetter):
>+        (foo.core._Uri._makeFileUri):
>+        (foo.core._Uri._makeWindowsFileUrl):
>+        (foo.core._Uri.prototype.replace):
>+        (foo.core._Uri.prototype.removeFragment):
>+        (foo.core._Uri.prototype.get pathSegments):
>+        (foo.core._Uri.prototype.get queryParameters):
>+        (foo.core._Uri.prototype.get queryParametersAll):
>+        (foo.core._Uri.prototype.normalizePath):
>+        (foo.core._Uri._makePort):
>+        (foo.core._Uri._makeHost):
>+        (foo.core._Uri._isRegNameChar):
>+        (foo.core._Uri._normalizeRegName):
>+        (foo.core._Uri._makeScheme):
>+        (foo.core._Uri._canonicalizeScheme):
>+        (foo.core._Uri._makeUserInfo):
>+        (foo.core._Uri._makePath):
>+        (foo.core._Uri._normalizePath):
>+        (foo.core._Uri._makeQuery.writeParameter):
>+        (foo.core._Uri._makeQuery):
>+        (foo.core._Uri._makeFragment):
>+        (foo.core._Uri._normalizeEscape):
>+        (foo.core._Uri._escapeChar):
>+        (foo.core._Uri._normalizeOrSubstring):
>+        (foo.core._Uri._normalize):
>+        (foo.core._Uri._isSchemeCharacter):
>+        (foo.core._Uri._isGeneralDelimiter):
>+        (foo.core._Uri.prototype.get isAbsolute):
>+        (foo.core._Uri.prototype._mergePaths):
>+        (foo.core._Uri._mayContainDotSegments):
>+        (foo.core._Uri._removeDotSegments):
>+        (foo.core._Uri._normalizeRelativePath):
>+        (foo.core._Uri._escapeScheme):
>+        (foo.core._Uri.prototype.resolve):
>+        (foo.core._Uri.prototype.resolveUri):
>+        (foo.core._Uri.prototype.get hasScheme):
>+        (foo.core._Uri.prototype.get hasAuthority):
>+        (foo.core._Uri.prototype.get hasPort):
>+        (foo.core._Uri.prototype.get hasQuery):
>+        (foo.core._Uri.prototype.get hasFragment):
>+        (foo.core._Uri.prototype.get hasEmptyPath):
>+        (foo.core._Uri.prototype.get hasAbsolutePath):
>+        (foo.core._Uri.prototype.get origin):
>+        (foo.core._Uri.prototype.toFilePath):
>+        (foo.core._Uri.prototype._toFilePath):
>+        (foo.core._Uri._toWindowsFilePath):
>+        (foo.core._Uri.prototype.get _isPathAbsolute):
>+        (foo.core._Uri.prototype._writeAuthority):
>+        (foo.core._Uri.prototype.get data):
>+        (foo.core._Uri.prototype.toString):
>+        (foo.core._Uri.prototype._initializeText):
>+        (foo.core._Uri.prototype._equals):
>+        (foo.core._Uri.prototype.get hashCode):
>+        (foo.core._Uri._createList):
>+        (foo.core._Uri._splitQueryStringAll.parsePair):
>+        (foo.core._Uri._splitQueryStringAll):
>+        (foo.core._Uri._uriEncode):
>+        (foo.core._Uri._hexCharPairToByte):
>+        (foo.core._Uri._uriDecode):
>+        (foo.core._Uri._isAlphabeticCharacter):
>+        (foo.core._Uri._isUnreservedChar):
>+        (foo.core._Uri):
>+        (foo.core.UriData.fromString):
>+        (foo.core.UriData.fromBytes):
>+        (foo.core.UriData.fromUri):
>+        (foo.core.UriData._writeUri):
>+        (foo.core.UriData._validateMimeType):
>+        (foo.core.UriData.parse):
>+        (foo.core.UriData.prototype.get uri):
>+        (foo.core.UriData.prototype.get mimeType):
>+        (foo.core.UriData.prototype.get charset):
>+        (foo.core.UriData.prototype.get isBase64):
>+        (foo.core.UriData.prototype.get contentText):
>+        (foo.core.UriData.prototype.contentAsBytes):
>+        (foo.core.UriData.prototype.contentAsString):
>+        (foo.core.UriData.prototype.get parameters):
>+        (foo.core.UriData._parse):
>+        (foo.core.UriData._uriEncodeBytes):
>+        (foo.core.UriData.prototype.toString):
>+        (foo.core.UriData):
>+        (foo.setChars):
>+        (foo.setRange):
>+        (foo.get core._createTables):
>+        (foo.core._scan):
>+        (foo.core._SimpleUri.prototype.get hasScheme):
>+        (foo.core._SimpleUri.prototype.get hasAuthority):
>+        (foo.core._SimpleUri.prototype.get hasUserInfo):
>+        (foo.core._SimpleUri.prototype.get hasPort):
>+        (foo.core._SimpleUri.prototype.get hasQuery):
>+        (foo.core._SimpleUri.prototype.get hasFragment):
>+        (foo.core._SimpleUri.prototype.get _isFile):
>+        (foo.core._SimpleUri.prototype.get _isHttp):
>+        (foo.core._SimpleUri.prototype.get _isHttps):
>+        (foo.core._SimpleUri.prototype.get _isPackage):
>+        (foo.core._SimpleUri.prototype._isScheme):
>+        (foo.core._SimpleUri.prototype.get hasAbsolutePath):
>+        (foo.core._SimpleUri.prototype.get hasEmptyPath):
>+        (foo.core._SimpleUri.prototype.get isAbsolute):
>+        (foo.core._SimpleUri.prototype.isScheme):
>+        (foo.core._SimpleUri.prototype.get scheme):
>+        (foo.core._SimpleUri.prototype.get authority):
>+        (foo.core._SimpleUri.prototype.get userInfo):
>+        (foo.core._SimpleUri.prototype.get host):
>+        (foo.core._SimpleUri.prototype.get port):
>+        (foo.core._SimpleUri.prototype.get path):
>+        (foo.core._SimpleUri.prototype.get query):
>+        (foo.core._SimpleUri.prototype.get fragment):
>+        (foo.core._SimpleUri.prototype.get origin):
>+        (foo.core._SimpleUri.prototype.get pathSegments):
>+        (foo.core._SimpleUri.prototype.get queryParameters):
>+        (foo.core._SimpleUri.prototype.get queryParametersAll):
>+        (foo.core._SimpleUri.prototype._isPort):
>+        (foo.core._SimpleUri.prototype.normalizePath):
>+        (foo.core._SimpleUri.prototype.removeFragment):
>+        (foo.core._SimpleUri.prototype.replace):
>+        (foo.core._SimpleUri.prototype.resolve):
>+        (foo.core._SimpleUri.prototype.resolveUri):
>+        (foo.core._SimpleUri.prototype._simpleMerge):
>+        (foo.core._SimpleUri.prototype.toFilePath):
>+        (foo.core._SimpleUri.prototype._toFilePath):
>+        (foo.core._SimpleUri.prototype.get data):
>+        (foo.core._SimpleUri.prototype.get hashCode):
>+        (foo.core._SimpleUri.prototype._equals):
>+        (foo.core._SimpleUri.prototype._toNonSimple):
>+        (foo.core._SimpleUri.prototype.toString):
>+        (foo.core._SimpleUri):
>+        (foo.core._DataUri.prototype.get data):
>+        (foo.core._DataUri):
>+        (foo.core._startsWithData):
>+        (foo.core._stringOrNullLength):
>+        (foo.developer.debugger):
>+        (foo.developer.inspect):
>+        (foo.developer.log):
>+        (foo.developer.invokeExtension):
>+        (foo.set get developer._FakeUserTag.new):
>+        (foo.set get developer._FakeUserTag.prototype.makeCurrent):
>+        (foo.set get developer._FakeUserTag):
>+        (foo.set get developer):
>+        (foo.set get developer.ServiceExtensionResponse.prototype.get result):
>+        (foo.set get developer.ServiceExtensionResponse.prototype.set result):
>+        (foo.set get developer.ServiceExtensionResponse.prototype.get errorCode):
>+        (foo.set get developer.ServiceExtensionResponse.prototype.set errorCode):
>+        (foo.set get developer.ServiceExtensionResponse.prototype.get errorDetail):
>+        (foo.set get developer.ServiceExtensionResponse.prototype.set errorDetail):
>+        (foo.set get developer.ServiceExtensionResponse._errorCodeMessage):
>+        (foo.set get developer.ServiceExtensionResponse._validateErrorCode):
>+        (foo.set get developer.ServiceExtensionResponse.prototype.isError):
>+        (foo.set get developer.ServiceExtensionResponse.prototype._toString):
>+        (foo.set get developer.ServiceExtensionResponse):
>+        (foo.get developer.registerExtension):
>+        (foo.developer.postEvent):
>+        (foo.developer._postEvent):
>+        (foo.developer._lookupExtension):
>+        (foo.developer._registerExtension):
>+        (foo.developer.UserTag.new):
>+        (foo.developer.UserTag.get defaultTag):
>+        (foo.developer.UserTag):
>+        (foo.get developer):
>+        (foo.get developer.getCurrentTag):
>+        (foo.developer.Metric.prototype.get name):
>+        (foo.developer.Metric.prototype.set name):
>+        (foo.developer.Metric.prototype.get description):
>+        (foo.developer.Metric.prototype.set description):
>+        (foo.developer.Metric):
>+        (foo.developer.Gauge.prototype.get min):
>+        (foo.developer.Gauge.prototype.set min):
>+        (foo.developer.Gauge.prototype.get max):
>+        (foo.developer.Gauge.prototype.set max):
>+        (foo.developer.Gauge.prototype.get value):
>+        (foo.developer.Gauge.prototype.set value):
>+        (foo.developer.Gauge.prototype._toJSON):
>+        (foo.developer.Gauge):
>+        (foo.developer.Counter.prototype.get value):
>+        (foo.developer.Counter.prototype.set value):
>+        (foo.developer.Counter.prototype._toJSON):
>+        (foo.developer.Counter):
>+        (foo.developer.Metrics.register):
>+        (foo.developer.Metrics.deregister):
>+        (foo.developer.Metrics._printMetric):
>+        (foo.developer.Metrics._printMetrics):
>+        (foo.developer.Metrics):
>+        (foo.get developer.ServiceProtocolInfo.prototype.get majorVersion):
>+        (foo.get developer.ServiceProtocolInfo.prototype.set majorVersion):
>+        (foo.get developer.ServiceProtocolInfo.prototype.get minorVersion):
>+        (foo.get developer.ServiceProtocolInfo.prototype.set minorVersion):
>+        (foo.get developer.ServiceProtocolInfo.prototype.get serverUri):
>+        (foo.get developer.ServiceProtocolInfo.prototype.set serverUri):
>+        (foo.get developer.ServiceProtocolInfo.prototype.toString):
>+        (foo.get developer.ServiceProtocolInfo):
>+        (foo.developer.Service.getInfo):
>+        (foo.developer.Service.async controlWebServer):
>+        (foo.developer.Service.async getIsolateID):
>+        (foo.developer.Service):
>+        (foo.developer._getServerInfo):
>+        (foo.developer._webServerControl):
>+        (foo.developer._getServiceMajorVersion):
>+        (foo.developer._getServiceMinorVersion):
>+        (foo.developer._getIsolateIDFromSendPort):
>+        (foo.developer.Flow.prototype.get id):
>+        (foo.developer.Flow.prototype.set id):
>+        (foo.developer.Flow.begin):
>+        (foo.developer.Flow.step):
>+        (foo.developer.Flow.end):
>+        (foo.developer.Flow):
>+        (foo.developer.Timeline.startSync):
>+        (foo.developer.Timeline.finishSync):
>+        (foo.developer.Timeline.instantSync):
>+        (foo.developer.Timeline.timeSync):
>+        (foo.developer.Timeline.get now):
>+        (foo.developer.Timeline):
>+        (foo.developer.TimelineTask.prototype.start):
>+        (foo.developer.TimelineTask.prototype.instant):
>+        (foo.developer.TimelineTask.prototype.finish):
>+        (foo.developer.TimelineTask.prototype.pass):
>+        (foo.developer.TimelineTask):
>+        (foo.developer._AsyncBlock.prototype._start.1):
>+        (foo.developer._AsyncBlock.prototype._finish):
>+        (foo.developer._AsyncBlock):
>+        (foo.developer._SyncBlock.prototype.finish):
>+        (foo.developer._SyncBlock.prototype.set flow):
>+        (foo.developer._SyncBlock):
>+        (foo.developer._argumentsAsJson):
>+        (foo.developer._isDartStreamEnabled):
>+        (foo.developer._getNextAsyncId):
>+        (foo.developer._getTraceClock):
>+        (foo.developer._getThreadCpuClock):
>+        (foo.developer._reportTaskEvent):
>+        (foo.developer._reportCompleteEvent):
>+        (foo.developer._reportFlowEvent):
>+        (foo.developer._reportInstantEvent):
>+        (foo.io.BytesBuilder.new):
>+        (foo.io.BytesBuilder):
>+        (foo.io._CopyingBytesBuilder.prototype.add):
>+        (foo.io._CopyingBytesBuilder.prototype.addByte):
>+        (foo.io._CopyingBytesBuilder.prototype._grow):
>+        (foo.io._CopyingBytesBuilder.prototype.takeBytes):
>+        (foo.io._CopyingBytesBuilder.prototype.toBytes):
>+        (foo.io._CopyingBytesBuilder.prototype.get length):
>+        (foo.io._CopyingBytesBuilder.prototype.get isEmpty):
>+        (foo.io._CopyingBytesBuilder.prototype.get isNotEmpty):
>+        (foo.io._CopyingBytesBuilder.prototype.clear):
>+        (foo.io._CopyingBytesBuilder._pow2roundup):
>+        (foo.io._CopyingBytesBuilder):
>+        (foo.io._BytesBuilder.prototype.add):
>+        (foo.io._BytesBuilder.prototype.addByte):
>+        (foo.io._BytesBuilder.prototype.takeBytes):
>+        (foo.io._BytesBuilder.prototype.toBytes):
>+        (foo.io._BytesBuilder.prototype.get length):
>+        (foo.io._BytesBuilder.prototype.get isEmpty):
>+        (foo.io._BytesBuilder.prototype.get isNotEmpty):
>+        (foo.io._BytesBuilder.prototype.clear):
>+        (foo.io._BytesBuilder):
>+        (foo.get io._isErrorResponse):
>+        (foo.io._exceptionFromResponse):
>+        (foo.io.IOException.prototype.toString):
>+        (foo.io.IOException):
>+        (foo.io.OSError.prototype.get message):
>+        (foo.io.OSError.prototype.set message):
>+        (foo.io.OSError.prototype.get errorCode):
>+        (foo.io.OSError.prototype.set errorCode):
>+        (foo.io.OSError.prototype.toString):
>+        (foo.io.OSError):
>+        (foo.get io):
>+        (foo.get io._BufferAndStart):
>+        (foo.io._ensureFastAndSerializableByteData):
>+        (foo.io._IOCrypto.getRandomBytes):
>+        (foo.io._IOCrypto):
>+        (foo.io.ZLibOption):
>+        (foo.get io.ZLibCodec.prototype.get gzip):
>+        (foo.get io.ZLibCodec.prototype.set gzip):
>+        (foo.get io.ZLibCodec.prototype.get level):
>+        (foo.get io.ZLibCodec.prototype.set level):
>+        (foo.get io.ZLibCodec.prototype.get memLevel):
>+        (foo.get io.ZLibCodec.prototype.set memLevel):
>+        (foo.get io.ZLibCodec.prototype.get strategy):
>+        (foo.get io.ZLibCodec.prototype.set strategy):
>+        (foo.get io.ZLibCodec.prototype.get windowBits):
>+        (foo.get io.ZLibCodec.prototype.set windowBits):
>+        (foo.get io.ZLibCodec.prototype.get raw):
>+        (foo.get io.ZLibCodec.prototype.set raw):
>+        (foo.get io.ZLibCodec.prototype.get dictionary):
>+        (foo.get io.ZLibCodec.prototype.set dictionary):
>+        (foo.get io.ZLibCodec.prototype.get encoder):
>+        (foo.get io.ZLibCodec.prototype.get decoder):
>+        (foo.get io.ZLibCodec):
>+        (foo.get io.GZipCodec.prototype.get gzip):
>+        (foo.get io.GZipCodec.prototype.set gzip):
>+        (foo.get io.GZipCodec.prototype.get level):
>+        (foo.get io.GZipCodec.prototype.set level):
>+        (foo.get io.GZipCodec.prototype.get memLevel):
>+        (foo.get io.GZipCodec.prototype.set memLevel):
>+        (foo.get io.GZipCodec.prototype.get strategy):
>+        (foo.get io.GZipCodec.prototype.set strategy):
>+        (foo.get io.GZipCodec.prototype.get windowBits):
>+        (foo.get io.GZipCodec.prototype.set windowBits):
>+        (foo.get io.GZipCodec.prototype.get dictionary):
>+        (foo.get io.GZipCodec.prototype.set dictionary):
>+        (foo.get io.GZipCodec.prototype.get raw):
>+        (foo.get io.GZipCodec.prototype.set raw):
>+        (foo.get io.GZipCodec.prototype.get encoder):
>+        (foo.get io.GZipCodec.prototype.get decoder):
>+        (foo.get io.GZipCodec):
>+        (foo.io.ZLibEncoder.prototype.get gzip):
>+        (foo.io.ZLibEncoder.prototype.set gzip):
>+        (foo.io.ZLibEncoder.prototype.get level):
>+        (foo.io.ZLibEncoder.prototype.set level):
>+        (foo.io.ZLibEncoder.prototype.get memLevel):
>+        (foo.io.ZLibEncoder.prototype.set memLevel):
>+        (foo.io.ZLibEncoder.prototype.get strategy):
>+        (foo.io.ZLibEncoder.prototype.set strategy):
>+        (foo.io.ZLibEncoder.prototype.get windowBits):
>+        (foo.io.ZLibEncoder.prototype.set windowBits):
>+        (foo.io.ZLibEncoder.prototype.get dictionary):
>+        (foo.io.ZLibEncoder.prototype.set dictionary):
>+        (foo.io.ZLibEncoder.prototype.get raw):
>+        (foo.io.ZLibEncoder.prototype.set raw):
>+        (foo.io.ZLibEncoder.prototype.convert):
>+        (foo.io.ZLibEncoder.prototype.startChunkedConversion):
>+        (foo.io.ZLibEncoder):
>+        (foo.io.ZLibDecoder.prototype.get windowBits):
>+        (foo.io.ZLibDecoder.prototype.set windowBits):
>+        (foo.io.ZLibDecoder.prototype.get dictionary):
>+        (foo.io.ZLibDecoder.prototype.set dictionary):
>+        (foo.io.ZLibDecoder.prototype.get raw):
>+        (foo.io.ZLibDecoder.prototype.set raw):
>+        (foo.io.ZLibDecoder.prototype.convert):
>+        (foo.io.ZLibDecoder.prototype.startChunkedConversion):
>+        (foo.io.ZLibDecoder):
>+        (foo.io.RawZLibFilter.deflateFilter):
>+        (foo.io.RawZLibFilter.inflateFilter):
>+        (foo.io.RawZLibFilter._makeZLibDeflateFilter):
>+        (foo.io.RawZLibFilter._makeZLibInflateFilter):
>+        (foo.io.RawZLibFilter):
>+        (foo.io._BufferSink.prototype.add):
>+        (foo.io._BufferSink.prototype.addSlice):
>+        (foo.io._BufferSink.prototype.close):
>+        (foo.io._BufferSink):
>+        (foo.io._FilterSink.prototype.add):
>+        (foo.io._FilterSink.prototype.addSlice):
>+        (foo.io._FilterSink.prototype.close):
>+        (foo.io._FilterSink):
>+        (foo.io._ZLibEncoderSink):
>+        (foo.io._ZLibDecoderSink):
>+        (foo.io._validateZLibWindowBits):
>+        (foo.io._validateZLibeLevel):
>+        (foo.io._validateZLibMemLevel):
>+        (foo.io._validateZLibStrategy):
>+        (foo.io.Directory.new):
>+        (foo.io.Directory.fromRawPath):
>+        (foo.io.Directory.fromUri):
>+        (foo.io.Directory.get current):
>+        (foo.io.Directory.set current):
>+        (foo.io.Directory.get systemTemp):
>+        (foo.io.Directory):
>+        (foo.io.FileSystemEntity.prototype.get _path):
>+        (foo.io.FileSystemEntity.prototype.set _path):
>+        (foo.io.FileSystemEntity.prototype.get _rawPath):
>+        (foo.io.FileSystemEntity.prototype.set _rawPath):
>+        (foo.io.FileSystemEntity.prototype.get uri):
>+        (foo.io.FileSystemEntity.prototype.resolveSymbolicLinks):
>+        (foo.io.FileSystemEntity.prototype.resolveSymbolicLinksSync):
>+        (foo.io.FileSystemEntity.prototype.stat):
>+        (foo.io.FileSystemEntity.prototype.statSync):
>+        (foo.io.FileSystemEntity.prototype.delete):
>+        (foo.io.FileSystemEntity.prototype.deleteSync):
>+        (foo.io.FileSystemEntity.prototype.watch):
>+        (foo.io.FileSystemEntity._identical):
>+        (foo.io.FileSystemEntity.identical):
>+        (foo.io.FileSystemEntity.prototype.get isAbsolute):
>+        (foo.io.FileSystemEntity.prototype.get _absolutePath):
>+        (foo.io.FileSystemEntity.prototype.get _rawAbsolutePath):
>+        (foo.io.FileSystemEntity._identicalSync):
>+        (foo.io.FileSystemEntity.identicalSync):
>+        (foo.io.FileSystemEntity.get isWatchSupported):
>+        (foo.io.FileSystemEntity._toUtf8Array):
>+        (foo.io.FileSystemEntity._toNullTerminatedUtf8Array):
>+        (foo.io.FileSystemEntity._toStringFromUtf8Array):
>+        (foo.io.FileSystemEntity.type):
>+        (foo.io.FileSystemEntity.typeSync):
>+        (foo.io.FileSystemEntity.isLink):
>+        (foo.io.FileSystemEntity._isLinkRaw):
>+        (foo.io.FileSystemEntity.isFile):
>+        (foo.io.FileSystemEntity.isDirectory):
>+        (foo.io.FileSystemEntity.isLinkSync):
>+        (foo.io.FileSystemEntity._isLinkRawSync):
>+        (foo.io.FileSystemEntity.isFileSync):
>+        (foo.io.FileSystemEntity.isDirectorySync):
>+        (foo.io.FileSystemEntity._getTypeNative):
>+        (foo.io.FileSystemEntity._identicalNative):
>+        (foo.io.FileSystemEntity._resolveSymbolicLinks):
>+        (foo.io.FileSystemEntity.parentOf):
>+        (foo.io.FileSystemEntity.prototype.get parent):
>+        (foo.io.FileSystemEntity._getTypeSyncHelper):
>+        (foo.io.FileSystemEntity._getTypeSync):
>+        (foo.io.FileSystemEntity._getTypeRequest):
>+        (foo.io.FileSystemEntity._getType):
>+        (foo.io.FileSystemEntity._throwIfError):
>+        (foo.io.FileSystemEntity._trimTrailingPathSeparators):
>+        (foo.io.FileSystemEntity._ensureTrailingPathSeparators):
>+        (foo.io.FileSystemEntity):
>+        (foo.get io._Directory.prototype.get _path):
>+        (foo.get io._Directory.prototype.set _path):
>+        (foo.get io._Directory.prototype.get _rawPath):
>+        (foo.get io._Directory.prototype.set _rawPath):
>+        (foo.get io._Directory.prototype.get path):
>+        (foo.get io._Directory._current):
>+        (foo.get io._Directory._setCurrent):
>+        (foo.get io._Directory._createTemp):
>+        (foo.get io._Directory._systemTemp):
>+        (foo.get io._Directory._exists):
>+        (foo.get io._Directory._create):
>+        (foo.get io._Directory._deleteNative):
>+        (foo.get io._Directory._rename):
>+        (foo.get io._Directory._fillWithDirectoryListing):
>+        (foo.get io._Directory.get current):
>+        (foo.get io._Directory.set current):
>+        (foo.get io._Directory.prototype.get uri):
>+        (foo.get io._Directory.prototype.exists):
>+        (foo.get io._Directory.prototype.existsSync):
>+        (foo.get io._Directory.prototype.get absolute):
>+        (foo.get io._Directory.prototype.create):
>+        (foo.get io._Directory.prototype.createSync):
>+        (foo.get io._Directory.get systemTemp):
>+        (foo.get io._Directory.prototype.createTemp):
>+        (foo.get io._Directory.prototype.createTempSync):
>+        (foo.get io._Directory.prototype._delete):
>+        (foo.get io._Directory.prototype._deleteSync):
>+        (foo.get io._Directory.prototype.rename):
>+        (foo.get io._Directory.prototype.renameSync):
>+        (foo.get io._Directory.prototype.list):
>+        (foo.get io._Directory.prototype.listSync):
>+        (foo.get io._Directory.prototype.toString):
>+        (foo.get io._Directory.prototype._isErrorResponse):
>+        (foo.get io._Directory.prototype._exceptionOrErrorFromResponse):
>+        (foo.get io._Directory):
>+        (foo.io._AsyncDirectoryListerOps.new):
>+        (foo.io._AsyncDirectoryListerOps):
>+        (foo.io._AsyncDirectoryLister.prototype._pointer):
>+        (foo.io._AsyncDirectoryLister.prototype.get stream):
>+        (foo.io._AsyncDirectoryLister.prototype.onListen):
>+        (foo.io._AsyncDirectoryLister.prototype.onResume):
>+        (foo.io._AsyncDirectoryLister.prototype.onCancel):
>+        (foo.io._AsyncDirectoryLister.prototype.next):
>+        (foo.io._AsyncDirectoryLister.prototype._cleanup):
>+        (foo.io._AsyncDirectoryLister.prototype.close):
>+        (foo.io._AsyncDirectoryLister.prototype.error):
>+        (foo.io._AsyncDirectoryLister):
>+        (foo.get io._EmbedderConfig):
>+        (foo.set get io._EventHandler._sendData):
>+        (foo.set get io._EventHandler):
>+        (foo.io.FileMode):
>+        (foo.set get io):
>+        (foo.io.FileLock):
>+        (foo.get io.File.new):
>+        (foo.get io.File.fromUri):
>+        (foo.get io.File.fromRawPath):
>+        (foo.get io.File):
>+        (foo.io.RandomAccessFile):
>+        (foo.io.FileSystemException.prototype.get message):
>+        (foo.io.FileSystemException.prototype.set message):
>+        (foo.io.FileSystemException.prototype.get path):
>+        (foo.io.FileSystemException.prototype.set path):
>+        (foo.io.FileSystemException.prototype.get osError):
>+        (foo.io.FileSystemException.prototype.set osError):
>+        (foo.io.FileSystemException.prototype.toString):
>+        (foo.io.FileSystemException):
>+        (foo.io._FileStream.prototype.listen):
>+        (foo.io._FileStream.prototype._setupController):
>+        (foo.io._FileStream.prototype._closeFile):
>+        (foo.io._FileStream.prototype._readBlock):
>+        (foo.io._FileStream.prototype._start.2):
>+        (foo.io._FileStream):
>+        (foo.io._FileStreamConsumer.prototype.addStream.):
>+        (foo.io._FileStreamConsumer.prototype.addStream):
>+        (foo.io._FileStreamConsumer.prototype.close):
>+        (foo.io._FileStreamConsumer):
>+        (foo.io._File.prototype.get _path):
>+        (foo.io._File.prototype.set _path):
>+        (foo.io._File.prototype.get _rawPath):
>+        (foo.io._File.prototype.set _rawPath):
>+        (foo.io._File.prototype.get path):
>+        (foo.io._File._namespacePointer):
>+        (foo.io._File._dispatchWithNamespace):
>+        (foo.io._File.prototype.exists):
>+        (foo.io._File._exists):
>+        (foo.io._File.prototype.existsSync):
>+        (foo.io._File.prototype.get absolute):
>+        (foo.io._File.prototype.create):
>+        (foo.io._File._create):
>+        (foo.io._File._createLink):
>+        (foo.io._File._linkTarget):
>+        (foo.io._File.prototype.createSync):
>+        (foo.io._File.prototype._delete):
>+        (foo.io._File._deleteNative):
>+        (foo.io._File._deleteLinkNative):
>+        (foo.io._File.prototype._deleteSync):
>+        (foo.io._File.prototype.rename):
>+        (foo.io._File._rename):
>+        (foo.io._File._renameLink):
>+        (foo.io._File.prototype.renameSync):
>+        (foo.io._File.prototype.copy):
>+        (foo.io._File._copy):
>+        (foo.io._File.prototype.copySync):
>+        (foo.io._File.prototype.open):
>+        (foo.io._File.prototype.length):
>+        (foo.io._File._lengthFromPath):
>+        (foo.io._File.prototype.lengthSync):
>+        (foo.io._File.prototype.lastAccessed):
>+        (foo.io._File._lastAccessed):
>+        (foo.io._File.prototype.lastAccessedSync):
>+        (foo.io._File.prototype.setLastAccessed):
>+        (foo.io._File._setLastAccessed):
>+        (foo.io._File.prototype.setLastAccessedSync):
>+        (foo.io._File.prototype.lastModified):
>+        (foo.io._File._lastModified):
>+        (foo.io._File.prototype.lastModifiedSync):
>+        (foo.io._File.prototype.setLastModified):
>+        (foo.io._File._setLastModified):
>+        (foo.io._File.prototype.setLastModifiedSync):
>+        (foo.io._File._open):
>+        (foo.io._File.prototype.openSync):
>+        (foo.io._File._openStdio):
>+        (foo.io._File._openStdioSync):
>+        (foo.io._File.prototype.openRead):
>+        (foo.io._File.prototype.openWrite):
>+        (foo.io._File.prototype.readAsBytes.readDataChunked.read):
>+        (foo.io._File.prototype.readAsBytes.readDataChunked):
>+        (foo.io._File.prototype.readAsBytes):
>+        (foo.io._File.prototype.readAsBytesSync):
>+        (foo.io._File.prototype._tryDecode):
>+        (foo.io._File.prototype.readAsString):
>+        (foo.io._File.prototype.readAsStringSync):
>+        (foo.io._File.prototype.readAsLines):
>+        (foo.io._File.prototype.readAsLinesSync):
>+        (foo.io._File.prototype.writeAsBytes):
>+        (foo.io._File.prototype.writeAsBytesSync):
>+        (foo.io._File.prototype.writeAsString):
>+        (foo.io._File.prototype.writeAsStringSync):
>+        (foo.io._File.prototype.toString):
>+        (foo.io._File.throwIfError):
>+        (foo.io._File):
>+        (foo.io._RandomAccessFileOps.new):
>+        (foo.io._RandomAccessFileOps):
>+        (foo.io._RandomAccessFile.prototype._maybePerformCleanup):
>+        (foo.io._RandomAccessFile.prototype._maybeConnectHandler):
>+        (foo.io._RandomAccessFile.prototype.close):
>+        (foo.io._RandomAccessFile.prototype.closeSync):
>+        (foo.io._RandomAccessFile.prototype.readByte):
>+        (foo.io._RandomAccessFile.prototype.readByteSync):
>+        (foo.io._RandomAccessFile.prototype.read):
>+        (foo.io._RandomAccessFile.prototype.readSync):
>+        (foo.io._RandomAccessFile.prototype.readInto):
>+        (foo.io._RandomAccessFile.prototype.readIntoSync):
>+        (foo.io._RandomAccessFile.prototype.writeByte):
>+        (foo.io._RandomAccessFile.prototype.writeByteSync):
>+        (foo.io._RandomAccessFile.prototype.writeFrom):
>+        (foo.io._RandomAccessFile.prototype.writeFromSync):
>+        (foo.io._RandomAccessFile.prototype.writeString):
>+        (foo.io._RandomAccessFile.prototype.writeStringSync):
>+        (foo.io._RandomAccessFile.prototype.position):
>+        (foo.io._RandomAccessFile.prototype.positionSync):
>+        (foo.io._RandomAccessFile.prototype.setPosition):
>+        (foo.io._RandomAccessFile.prototype.setPositionSync):
>+        (foo.io._RandomAccessFile.prototype.truncate):
>+        (foo.io._RandomAccessFile.prototype.truncateSync):
>+        (foo.io._RandomAccessFile.prototype.length):
>+        (foo.io._RandomAccessFile.prototype.lengthSync):
>+        (foo.io._RandomAccessFile.prototype.flush):
>+        (foo.io._RandomAccessFile.prototype.flushSync):
>+        (foo.io._RandomAccessFile.prototype._fileLockValue):
>+        (foo.io._RandomAccessFile.prototype.lock):
>+        (foo.io._RandomAccessFile.prototype.unlock):
>+        (foo.io._RandomAccessFile.prototype.lockSync):
>+        (foo.io._RandomAccessFile.prototype.unlockSync):
>+        (foo.io._RandomAccessFile.prototype._pointer):
>+        (foo.io.FileSystemEntityType._lookup):
>+        (foo.io.FileSystemEntityType.prototype.toString):
>+        (foo.io.FileSystemEntityType):
>+        (foo.set get let):
>+        (foo.io.FileStat.prototype.get changed):
>+        (foo.io.FileStat.prototype.set changed):
>+        (foo.io.FileStat.prototype.get modified):
>+        (foo.io.FileStat.prototype.set modified):
>+        (foo.io.FileStat.prototype.get accessed):
>+        (foo.io.FileStat.prototype.set accessed):
>+        (foo.io.FileStat.prototype.get type):
>+        (foo.io.FileStat.prototype.set type):
>+        (foo.io.FileStat.prototype.get mode):
>+        (foo.io.FileStat.prototype.set mode):
>+        (foo.io.FileStat.prototype.get size):
>+        (foo.io.FileStat.prototype.set size):
>+        (foo.io.FileStat._statSync):
>+        (foo.io.FileStat.statSync):
>+        (foo.io.FileStat._statSyncInternal):
>+        (foo.io.FileStat.stat):
>+        (foo.io.FileStat._stat):
>+        (foo.io.FileStat.prototype.toString):
>+        (foo.io.FileStat.prototype.modeString):
>+        (foo.io.FileStat):
>+        (foo.get io.FileSystemEvent.prototype.get type):
>+        (foo.get io.FileSystemEvent.prototype.set type):
>+        (foo.get io.FileSystemEvent.prototype.get path):
>+        (foo.get io.FileSystemEvent.prototype.set path):
>+        (foo.get io.FileSystemEvent.prototype.get isDirectory):
>+        (foo.get io.FileSystemEvent.prototype.set isDirectory):
>+        (foo.get io.FileSystemEvent):
>+        (foo.get io.FileSystemCreateEvent.prototype.toString):
>+        (foo.get io.FileSystemCreateEvent):
>+        (foo.io.FileSystemModifyEvent.prototype.get contentChanged):
>+        (foo.io.FileSystemModifyEvent.prototype.set contentChanged):
>+        (foo.io.FileSystemModifyEvent.prototype.toString):
>+        (foo.io.FileSystemModifyEvent):
>+        (foo.io.FileSystemDeleteEvent.prototype.toString):
>+        (foo.io.FileSystemDeleteEvent):
>+        (foo.io.FileSystemMoveEvent.prototype.get destination):
>+        (foo.io.FileSystemMoveEvent.prototype.set destination):
>+        (foo.io.FileSystemMoveEvent.prototype.toString):
>+        (foo.io.FileSystemMoveEvent):
>+        (foo.io._FileSystemWatcher._watch):
>+        (foo.io._FileSystemWatcher.get isSupported):
>+        (foo.io._FileSystemWatcher):
>+        (foo.io._IOResourceInfo.get timestamp):
>+        (foo.io._IOResourceInfo.prototype.get referenceValueMap):
>+        (foo.io._IOResourceInfo.getNextID):
>+        (foo.io._IOResourceInfo):
>+        (foo.set get io._ReadWriteResourceInfo.prototype.addRead):
>+        (foo.set get io._ReadWriteResourceInfo.prototype.didRead):
>+        (foo.set get io._ReadWriteResourceInfo.prototype.addWrite):
>+        (foo.set get io._ReadWriteResourceInfo.prototype.get fullValueMap):
>+        (foo.set get io._ReadWriteResourceInfo):
>+        (foo.io._FileResourceInfo.FileOpened):
>+        (foo.io._FileResourceInfo.FileClosed):
>+        (foo.io._FileResourceInfo.getOpenFilesList):
>+        (foo.io._FileResourceInfo.getOpenFiles):
>+        (foo.io._FileResourceInfo.prototype.getFileInfoMap):
>+        (foo.io._FileResourceInfo.getFileInfoMapByID):
>+        (foo.io._FileResourceInfo.prototype.get name):
>+        (foo.io._FileResourceInfo):
>+        (foo.io._ProcessResourceInfo.prototype.get name):
>+        (foo.io._ProcessResourceInfo.prototype.stopped):
>+        (foo.io._ProcessResourceInfo.prototype.get fullValueMap):
>+        (foo.io._ProcessResourceInfo.ProcessStarted):
>+        (foo.io._ProcessResourceInfo.ProcessStopped):
>+        (foo.io._ProcessResourceInfo.getStartedProcessesList):
>+        (foo.io._ProcessResourceInfo.getStartedProcesses):
>+        (foo.io._ProcessResourceInfo.getProcessInfoMapById):
>+        (foo.io._ProcessResourceInfo):
>+        (foo.set get const):
>+        (foo.set get io._SocketResourceInfo.prototype.get name):
>+        (foo.set get io._SocketResourceInfo.getOpenSocketsList):
>+        (foo.set get io._SocketResourceInfo.prototype.getSocketInfoMap):
>+        (foo.set get io._SocketResourceInfo.getSocketInfoMapByID):
>+        (foo.set get io._SocketResourceInfo.getOpenSockets):
>+        (foo.set get io._SocketResourceInfo.SocketOpened):
>+        (foo.set get io._SocketResourceInfo.SocketClosed):
>+        (foo.set get io._SocketResourceInfo):
>+        (foo.set get io.IOSink.new):
>+        (foo.set get io.IOSink.prototype.get encoding):
>+        (foo.set get io.IOSink.prototype.set encoding):
>+        (foo.set get io.IOSink):
>+        (foo.io._RandomAccessFile.prototype._dispatch.return.async Future):
>+        (foo.io._RandomAccessFile.prototype._dispatch):
>+        (foo.io._StreamSinkImpl.dart.generic):
>+        (foo.io._RandomAccessFile):
>+        (foo.io._IOSinkImpl.prototype.get encoding):
>+        (foo.io._IOSinkImpl.prototype.set encoding):
>+        (foo.io._IOSinkImpl.prototype.write):
>+        (foo.io._IOSinkImpl.prototype.writeAll):
>+        (foo.io._IOSinkImpl.prototype.writeln):
>+        (foo.io._IOSinkImpl.prototype.writeCharCode):
>+        (foo.io._IOSinkImpl):
>+        (foo.io._IOService._dispatch):
>+        (foo.io._IOService):
>+        (foo.get io.Link.new):
>+        (foo.get io.Link.fromRawPath):
>+        (foo.get io.Link.fromUri):
>+        (foo.get io.Link):
>+        (foo.io._Link.prototype.get _path):
>+        (foo.io._Link.prototype.set _path):
>+        (foo.io._Link.prototype.get _rawPath):
>+        (foo.io._Link.prototype.set _rawPath):
>+        (foo.io._Link.prototype.get path):
>+        (foo.io._Link.prototype.toString):
>+        (foo.io._Link.prototype.exists):
>+        (foo.io._Link.prototype.existsSync):
>+        (foo.io._Link.prototype.get absolute):
>+        (foo.io._Link.prototype.create):
>+        (foo.io._Link.prototype.createSync):
>+        (foo.io._Link.prototype.updateSync):
>+        (foo.io._Link.prototype.update):
>+        (foo.io._Link.prototype._delete):
>+        (foo.io._Link.prototype._deleteSync):
>+        (foo.io._Link.prototype.rename):
>+        (foo.io._Link.prototype.renameSync):
>+        (foo.io._Link.prototype.target):
>+        (foo.io._Link.prototype.targetSync):
>+        (foo.io._Link.throwIfError):
>+        (foo.io._Link.prototype._isErrorResponse):
>+        (foo.io._Link.prototype._exceptionFromResponse):
>+        (foo.io._Link):
>+        (foo.io._Namespace.get _namespace):
>+        (foo.io._Namespace.get _namespacePointer):
>+        (foo.io._Namespace._setupNamespace):
>+        (foo.io._Namespace):
>+        (foo.async get io.IOOverrides.get current):
>+        (foo.async get io.IOOverrides.async set global):
>+        (foo.async get io.IOOverrides.runZoned):
>+        (foo.async get io.IOOverrides.runWithIOOverrides):
>+        (foo.async get io.IOOverrides.prototype.createDirectory):
>+        (foo.async get io.IOOverrides.prototype.getCurrentDirectory):
>+        (foo.async get io.IOOverrides.prototype.setCurrentDirectory):
>+        (foo.async get io.IOOverrides.prototype.getSystemTempDirectory):
>+        (foo.async get io.IOOverrides.prototype.createFile):
>+        (foo.async get io.IOOverrides.prototype.stat):
>+        (foo.async get io.IOOverrides.prototype.statSync):
>+        (foo.async get io.IOOverrides.prototype.fseIdentical):
>+        (foo.async get io.IOOverrides.prototype.fseIdenticalSync):
>+        (foo.async get io.IOOverrides.prototype.fseGetType):
>+        (foo.async get io.IOOverrides.prototype.fseGetTypeSync):
>+        (foo.async get io.IOOverrides.prototype.fsWatch):
>+        (foo.async get io.IOOverrides.prototype.fsWatchIsSupported):
>+        (foo.async get io.IOOverrides.prototype.createLink):
>+        (foo.async get io.IOOverrides.prototype.socketConnect):
>+        (foo.async get io.IOOverrides.prototype.socketStartConnect):
>+        (foo.async get io.IOOverrides):
>+        (foo.async get io):
>+        (foo.io._IOOverridesScope.prototype.createDirectory):
>+        (foo.io._IOOverridesScope.prototype.getCurrentDirectory):
>+        (foo.io._IOOverridesScope.prototype.setCurrentDirectory):
>+        (foo.io._IOOverridesScope.prototype.getSystemTempDirectory):
>+        (foo.io._IOOverridesScope.prototype.createFile):
>+        (foo.io._IOOverridesScope.prototype.stat):
>+        (foo.io._IOOverridesScope.prototype.statSync):
>+        (foo.io._IOOverridesScope.prototype.fseIdentical):
>+        (foo.io._IOOverridesScope.prototype.fseIdenticalSync):
>+        (foo.io._IOOverridesScope.prototype.fseGetType):
>+        (foo.io._IOOverridesScope.prototype.fseGetTypeSync):
>+        (foo.io._IOOverridesScope.prototype.fsWatch):
>+        (foo.io._IOOverridesScope.prototype.fsWatchIsSupported):
>+        (foo.io._IOOverridesScope.prototype.createLink):
>+        (foo.io._IOOverridesScope.prototype.socketConnect):
>+        (foo.io._IOOverridesScope.prototype.socketStartConnect):
>+        (foo.io._IOOverridesScope):
>+        (foo.io.Platform.get numberOfProcessors):
>+        (foo.io.Platform.get pathSeparator):
>+        (foo.io.Platform.get localeName):
>+        (foo.io.Platform.get operatingSystem):
>+        (foo.io.Platform.get operatingSystemVersion):
>+        (foo.io.Platform.get localHostname):
>+        (foo.io.Platform.get environment):
>+        (foo.io.Platform.get executable):
>+        (foo.io.Platform.get resolvedExecutable):
>+        (foo.io.Platform.get script):
>+        (foo.io.Platform.get executableArguments):
>+        (foo.io.Platform.get packageRoot):
>+        (foo.io.Platform.get packageConfig):
>+        (foo.io.Platform.get version):
>+        (foo.io.Platform):
>+        (foo.get io._Platform._numberOfProcessors):
>+        (foo.get io._Platform._pathSeparator):
>+        (foo.get io._Platform._operatingSystem):
>+        (foo.get io._Platform._operatingSystemVersion):
>+        (foo.get io._Platform._localHostname):
>+        (foo.get io._Platform._executable):
>+        (foo.get io._Platform._resolvedExecutable):
>+        (foo.get io._Platform._environment):
>+        (foo.get io._Platform._executableArguments):
>+        (foo.get io._Platform._packageRoot):
>+        (foo.get io._Platform._packageConfig):
>+        (foo.get io._Platform._version):
>+        (foo.get io._Platform._localeName):
>+        (foo.get io._Platform._script):
>+        (foo.get io._Platform.localeName):
>+        (foo.get io._Platform.get numberOfProcessors):
>+        (foo.get io._Platform.get pathSeparator):
>+        (foo.get io._Platform.get operatingSystem):
>+        (foo.get io._Platform.get script):
>+        (foo.get io._Platform.get operatingSystemVersion):
>+        (foo.get io._Platform.get localHostname):
>+        (foo.get io._Platform.get executableArguments):
>+        (foo.get io._Platform.get environment):
>+        (foo.get io._Platform.get version):
>+        (foo.get io._Platform):
>+        (foo.io._CaseInsensitiveStringMap.dart.generic):
>+        (foo.io._ProcessUtils._exit):
>+        (foo.io._ProcessUtils._setExitCode):
>+        (foo.io._ProcessUtils._getExitCode):
>+        (foo.io._ProcessUtils._sleep):
>+        (foo.io._ProcessUtils._pid):
>+        (foo.io._ProcessUtils._watchSignal):
>+        (foo.io._ProcessUtils):
>+        (foo.io.exit):
>+        (foo.set get io.sleep):
>+        (foo.get io.ProcessInfo.get currentRss):
>+        (foo.get io.ProcessInfo.get maxRss):
>+        (foo.get io.ProcessInfo):
>+        (foo.io.ProcessStartMode.get values):
>+        (foo.io.ProcessStartMode.prototype.toString):
>+        (foo.io.ProcessStartMode):
>+        (foo.get io.Process.start):
>+        (foo.get io.Process.run):
>+        (foo.get io.Process.runSync):
>+        (foo.get io.Process.killPid):
>+        (foo.get io.Process):
>+        (foo.io.ProcessResult.prototype.get exitCode):
>+        (foo.io.ProcessResult.prototype.set exitCode):
>+        (foo.io.ProcessResult.prototype.get stdout):
>+        (foo.io.ProcessResult.prototype.set stdout):
>+        (foo.io.ProcessResult.prototype.get stderr):
>+        (foo.io.ProcessResult.prototype.set stderr):
>+        (foo.io.ProcessResult.prototype.get pid):
>+        (foo.io.ProcessResult.prototype.set pid):
>+        (foo.io.ProcessResult):
>+        (foo.io.ProcessSignal.prototype.toString):
>+        (foo.io.ProcessSignal.prototype.watch):
>+        (foo.io.ProcessSignal):
>+        (foo.get io.SignalException.prototype.get message):
>+        (foo.get io.SignalException.prototype.set message):
>+        (foo.get io.SignalException.prototype.get osError):
>+        (foo.get io.SignalException.prototype.set osError):
>+        (foo.get io.SignalException.prototype.toString):
>+        (foo.get io.SignalException):
>+        (foo.io.ProcessException.prototype.get executable):
>+        (foo.io.ProcessException.prototype.set executable):
>+        (foo.io.ProcessException.prototype.get arguments):
>+        (foo.io.ProcessException.prototype.set arguments):
>+        (foo.io.ProcessException.prototype.get message):
>+        (foo.io.ProcessException.prototype.set message):
>+        (foo.io.ProcessException.prototype.get errorCode):
>+        (foo.io.ProcessException.prototype.set errorCode):
>+        (foo.io.ProcessException.prototype.toString):
>+        (foo.io.ProcessException):
>+        (foo.io.SecureSocket.connect):
>+        (foo.io.SecureSocket.startConnect):
>+        (foo.io.SecureSocket.secure):
>+        (foo.io.SecureSocket.async secureServer):
>+        (foo.io.SecureSocket):
>+        (foo.io.SecureServerSocket.bind):
>+        (foo.io.SecureServerSocket.prototype.listen):
>+        (foo.io.SecureServerSocket.prototype.get port):
>+        (foo.io.SecureServerSocket.prototype.get address):
>+        (foo.io.SecureServerSocket.prototype.close):
>+        (foo.io.SecureServerSocket.prototype.set _owner):
>+        (foo.io.SecureServerSocket):
>+        (foo.io.RawSecureSocket.connect):
>+        (foo.io.RawSecureSocket.startConnect):
>+        (foo.io.RawSecureSocket.secure):
>+        (foo.io.RawSecureSocket.secureServer):
>+        (foo.io.RawSecureSocket):
>+        (foo.io.RawSecureServerSocket.prototype.get requestClientCertificate):
>+        (foo.io.RawSecureServerSocket.prototype.set requestClientCertificate):
>+        (foo.io.RawSecureServerSocket.prototype.get requireClientCertificate):
>+        (foo.io.RawSecureServerSocket.prototype.set requireClientCertificate):
>+        (foo.io.RawSecureServerSocket.prototype.get supportedProtocols):
>+        (foo.io.RawSecureServerSocket.prototype.set supportedProtocols):
>+        (foo.io.RawSecureServerSocket.bind):
>+        (foo.io.RawSecureServerSocket.prototype.listen):
>+        (foo.io.RawSecureServerSocket.prototype.get port):
>+        (foo.io.RawSecureServerSocket.prototype.get address):
>+        (foo.io.RawSecureServerSocket.prototype.close):
>+        (foo.io.RawSecureServerSocket.prototype._onData.0):
>+        (foo.io.RawSecureServerSocket.prototype._onPauseStateChange):
>+        (foo.io.RawSecureServerSocket.prototype._onSubscriptionStateChange):
>+        (foo.io.RawSecureServerSocket.prototype.set _owner):
>+        (foo.io.RawSecureServerSocket):
>+        (foo.io.X509Certificate):
>+        (foo.io._FilterStatus):
>+        (foo.io.RawSocketEvent.prototype.toString):
>+        (foo.io.RawSocketEvent):
>+        (foo.get io._RawSecureSocket._isBufferEncrypted):
>+        (foo.get io._RawSecureSocket.connect):
>+        (foo.get io._RawSecureSocket.prototype.listen):
>+        (foo.get io._RawSecureSocket._verifyFields):
>+        (foo.get io._RawSecureSocket.prototype.get port):
>+        (foo.get io._RawSecureSocket.prototype.get remoteAddress):
>+        (foo.get io._RawSecureSocket.prototype.get remotePort):
>+        (foo.get io._RawSecureSocket.prototype.set _owner):
>+        (foo.get io._RawSecureSocket.prototype.available):
>+        (foo.get io._RawSecureSocket.prototype.close):
>+        (foo.get io._RawSecureSocket.prototype._completeCloseCompleter):
>+        (foo.get io._RawSecureSocket.prototype._close):
>+        (foo.get io._RawSecureSocket.prototype.shutdown):
>+        (foo.get io._RawSecureSocket.prototype.get writeEventsEnabled):
>+        (foo.get io._RawSecureSocket.get readEventsEnabled):
>+        (foo.get io._RawSecureSocket.set readEventsEnabled):
>+        (foo.get io._RawSecureSocket.get peerCertificate):
>+        (foo.get io._RawSecureSocket.get selectedProtocol):
>+        (foo.get io._RawSecureSocket.set writeEventsEnabled.async Timer):
>+        (foo.get io._RawSecureSocket.prototype.set writeEventsEnabled):
>+        (foo.get io._RawSecureSocket.prototype._readHandler):
>+        (foo.get io._RawSecureSocket.prototype._writeHandler):
>+        (foo.get io._RawSecureSocket.prototype._doneHandler):
>+        (foo.get io._RawSecureSocket.prototype._reportError):
>+        (foo.get io._RawSecureSocket.prototype._closeHandler):
>+        (foo.get io._RawSecureSocket.prototype._secureHandshake):
>+        (foo.get io._RawSecureSocket.prototype.renegotiate):
>+        (foo.get io._RawSecureSocket.prototype._secureHandshakeCompleteHandler.try.async Timer):
>+        (foo.get io._RawSecureSocket.prototype._secureHandshakeCompleteHandler):
>+        (foo.get io._RawSecureSocket.prototype._readSocketOrBufferedData):
>+        (foo.get io._RawSecureSocket.prototype._readSocket):
>+        (foo.get io._RawSecureSocket.prototype._writeSocket):
>+        (foo.get io._RawSecureSocket.prototype._scheduleReadEvent.async Timer):
>+        (foo.get io._RawSecureSocket._pushAllFilterStages.):
>+        (foo.get io._RawSecureSocket.prototype._scheduleReadEvent):
>+        (foo.get io._RawSecureSocket):
>+        (foo.get io._ExternalBuffer.prototype.advanceStart):
>+        (foo.get io._ExternalBuffer.prototype.advanceEnd):
>+        (foo.get io._ExternalBuffer.prototype.get isEmpty):
>+        (foo.get io._ExternalBuffer.prototype.get length):
>+        (foo.get io._ExternalBuffer.prototype.get linearLength):
>+        (foo.get io._ExternalBuffer.prototype.get free):
>+        (foo.get io._ExternalBuffer.prototype.get linearFree):
>+        (foo.get io._ExternalBuffer.prototype.read):
>+        (foo.get io._ExternalBuffer.prototype.write):
>+        (foo.get io._ExternalBuffer.prototype.writeFromSource):
>+        (foo.get io._ExternalBuffer.prototype.readToSocket):
>+        (foo.get io._ExternalBuffer):
>+        (foo.io._SecureFilter.new):
>+        (foo.io._SecureFilter):
>+        (foo.io.TlsException.prototype.get type):
>+        (foo.io.TlsException.prototype.set type):
>+        (foo.io.TlsException.prototype.get message):
>+        (foo.io.TlsException.prototype.set message):
>+        (foo.io.TlsException.prototype.get osError):
>+        (foo.io.TlsException.prototype.set osError):
>+        (foo.io.TlsException.prototype.toString):
>+        (foo.io.TlsException):
>+        (foo.io.HandshakeException):
>+        (foo.io.CertificateException):
>+        (foo.io.SecurityContext.new):
>+        (foo.io.SecurityContext.get defaultContext):
>+        (foo.io.SecurityContext.get alpnSupported):
>+        (foo.io.SecurityContext._protocolsToLengthEncoding):
>+        (foo.io.SecurityContext._protocolsToLengthEncodingNonAsciiBailout.addProtocol):
>+        (foo.io.SecurityContext._protocolsToLengthEncodingNonAsciiBailout):
>+        (foo.io.SecurityContext):
>+        (foo.io._ServiceObject.prototype.get _serviceId):
>+        (foo.io._ServiceObject.prototype.get _servicePath):
>+        (foo.io._ServiceObject.prototype._serviceType):
>+        (foo.io._ServiceObject):
>+        (foo.io.InternetAddressType._from):
>+        (foo.io.InternetAddressType.prototype.get name):
>+        (foo.io.InternetAddressType.prototype.toString):
>+        (foo.io.InternetAddressType):
>+        (foo.get io.InternetAddress.get loopbackIPv4):
>+        (foo.get io.InternetAddress.get LOOPBACK_IP_V4):
>+        (foo.get io.InternetAddress.get loopbackIPv6):
>+        (foo.get io.InternetAddress.get LOOPBACK_IP_V6):
>+        (foo.get io.InternetAddress.get anyIPv4):
>+        (foo.get io.InternetAddress.get ANY_IP_V4):
>+        (foo.get io.InternetAddress.get anyIPv6):
>+        (foo.get io.InternetAddress.get ANY_IP_V6):
>+        (foo.get io.InternetAddress.new):
>+        (foo.get io.InternetAddress.lookup):
>+        (foo.get io.InternetAddress._cloneWithNewHost):
>+        (foo.get io.InternetAddress):
>+        (foo.io.NetworkInterface.get listSupported):
>+        (foo.io.NetworkInterface.list):
>+        (foo.io.NetworkInterface):
>+        (foo.io.RawServerSocket.bind):
>+        (foo.io.RawServerSocket):
>+        (foo.io.ServerSocket.bind):
>+        (foo.io.ServerSocket):
>+        (foo.io.SocketDirection):
>+        (foo.get io.SocketOption):
>+        (foo.get io._RawSocketOptions.prototype.toString):
>+        (foo.get io._RawSocketOptions):
>+        (foo.io.RawSocketOption.fromInt):
>+        (foo.io.RawSocketOption.fromBool):
>+        (foo.io.RawSocketOption.prototype.get level):
>+        (foo.io.RawSocketOption.prototype.set level):
>+        (foo.io.RawSocketOption.prototype.get option):
>+        (foo.io.RawSocketOption.prototype.set option):
>+        (foo.io.RawSocketOption.prototype.get value):
>+        (foo.io.RawSocketOption.prototype.set value):
>+        (foo.io.RawSocketOption.get levelSocket):
>+        (foo.io.RawSocketOption.get levelIPv4):
>+        (foo.io.RawSocketOption.get IPv4MulticastInterface):
>+        (foo.io.RawSocketOption.get levelIPv6):
>+        (foo.io.RawSocketOption.get IPv6MulticastInterface):
>+        (foo.io.RawSocketOption.get levelTcp):
>+        (foo.io.RawSocketOption.get levelUdp):
>+        (foo.io.RawSocketOption._getOptionValue):
>+        (foo.io.RawSocketOption):
>+        (foo.io.ConnectionTask.dart.generic):
>+        (foo.io.RawSocket.prototype.get readEventsEnabled):
>+        (foo.io.RawSocket.prototype.set readEventsEnabled):
>+        (foo.io.RawSocket.prototype.get writeEventsEnabled):
>+        (foo.io.RawSocket.prototype.set writeEventsEnabled):
>+        (foo.io.RawSocket.connect):
>+        (foo.io.RawSocket.startConnect):
>+        (foo.io.RawSocket):
>+        (foo.io.Socket.connect):
>+        (foo.io.Socket.startConnect):
>+        (foo.io.Socket._connect):
>+        (foo.io.Socket._startConnect):
>+        (foo.io.Socket):
>+        (foo.io.Datagram.prototype.get data):
>+        (foo.io.Datagram.prototype.set data):
>+        (foo.io.Datagram.prototype.get address):
>+        (foo.io.Datagram.prototype.set address):
>+        (foo.io.Datagram.prototype.get port):
>+        (foo.io.Datagram.prototype.set port):
>+        (foo.io.Datagram):
>+        (foo.io.RawDatagramSocket.prototype.get readEventsEnabled):
>+        (foo.io.RawDatagramSocket.prototype.set readEventsEnabled):
>+        (foo.io.RawDatagramSocket.prototype.get writeEventsEnabled):
>+        (foo.io.RawDatagramSocket.prototype.set writeEventsEnabled):
>+        (foo.io.RawDatagramSocket.prototype.get multicastLoopback):
>+        (foo.io.RawDatagramSocket.prototype.set multicastLoopback):
>+        (foo.io.RawDatagramSocket.prototype.get multicastHops):
>+        (foo.io.RawDatagramSocket.prototype.set multicastHops):
>+        (foo.io.RawDatagramSocket.prototype.get multicastInterface):
>+        (foo.io.RawDatagramSocket.prototype.set multicastInterface):
>+        (foo.io.RawDatagramSocket.prototype.get broadcastEnabled):
>+        (foo.io.RawDatagramSocket.prototype.set broadcastEnabled):
>+        (foo.io.RawDatagramSocket.bind):
>+        (foo.io.RawDatagramSocket):
>+        (foo.io.SocketException.prototype.get message):
>+        (foo.io.SocketException.prototype.set message):
>+        (foo.io.SocketException.prototype.get osError):
>+        (foo.io.SocketException.prototype.set osError):
>+        (foo.io.SocketException.prototype.get address):
>+        (foo.io.SocketException.prototype.set address):
>+        (foo.io.SocketException.prototype.get port):
>+        (foo.io.SocketException.prototype.set port):
>+        (foo.io.SocketException.prototype.toString):
>+        (foo.io.SocketException):
>+        (foo.get io._StdStream.prototype.listen):
>+        (foo.get io._StdStream):
>+        (foo.io.Stdin.prototype.readLineSync):
>+        (foo.io.Stdin.prototype.get echoMode):
>+        (foo.io.Stdin.prototype.set echoMode):
>+        (foo.io.Stdin.prototype.get lineMode):
>+        (foo.io.Stdin.prototype.set lineMode):
>+        (foo.io.Stdin.prototype.get supportsAnsiEscapes):
>+        (foo.io.Stdin.prototype.readByteSync):
>+        (foo.io.Stdin.prototype.get hasTerminal):
>+        (foo.io.Stdin):
>+        (foo.io._StdSink.prototype.get encoding):
>+        (foo.io._StdSink.prototype.set encoding):
>+        (foo.io._StdSink.prototype.write):
>+        (foo.io._StdSink.prototype.writeln):
>+        (foo.io._StdSink.prototype.writeAll):
>+        (foo.io._StdSink.prototype.add):
>+        (foo.io._StdSink.prototype.addError):
>+        (foo.io._StdSink.prototype.writeCharCode):
>+        (foo.io._StdSink.prototype.addStream):
>+        (foo.io._StdSink.prototype.flush):
>+        (foo.io._StdSink.prototype.close):
>+        (foo.io._StdSink.prototype.get done):
>+        (foo.io._StdSink):
>+        (foo.io.Stdout.prototype.get hasTerminal):
>+        (foo.io.Stdout.prototype.get terminalColumns):
>+        (foo.io.Stdout.prototype.get terminalLines):
>+        (foo.io.Stdout.prototype.get supportsAnsiEscapes):
>+        (foo.io.Stdout.prototype._hasTerminal):
>+        (foo.io.Stdout.prototype._terminalColumns):
>+        (foo.io.Stdout.prototype._terminalLines):
>+        (foo.io.Stdout._supportsAnsiEscapes):
>+        (foo.io.Stdout.prototype.get nonBlocking):
>+        (foo.io.Stdout):
>+        (foo.io.StdoutException.prototype.get message):
>+        (foo.io.StdoutException.prototype.set message):
>+        (foo.io.StdoutException.prototype.get osError):
>+        (foo.io.StdoutException.prototype.set osError):
>+        (foo.io.StdoutException.prototype.toString):
>+        (foo.io.StdoutException):
>+        (foo.io.StdinException.prototype.get message):
>+        (foo.io.StdinException.prototype.set message):
>+        (foo.io.StdinException.prototype.get osError):
>+        (foo.io.StdinException.prototype.set osError):
>+        (foo.io.StdinException.prototype.toString):
>+        (foo.io.StdinException):
>+        (foo.io._StdConsumer.prototype.addStream.let.completer.async Completer):
>+        (foo.io._StdConsumer.prototype.addStream):
>+        (foo.io.StdioType.prototype.get name):
>+        (foo.io.StdioType.prototype.set name):
>+        (foo.io.StdioType.prototype.toString):
>+        (foo.io.StdioType):
>+        (foo.set get io._setStdioFDs):
>+        (foo.get io.stdioType):
>+        (foo.io._StdIOUtils._getStdioOutputStream):
>+        (foo.io._StdIOUtils._getStdioInputStream):
>+        (foo.io._StdIOUtils._socketType):
>+        (foo.io._StdIOUtils._getStdioHandleType):
>+        (foo.io._StdIOUtils):
>+        (foo.io.SystemEncoding.prototype.get name):
>+        (foo.io.SystemEncoding.prototype.encode):
>+        (foo.io.SystemEncoding.prototype.decode):
>+        (foo.io.SystemEncoding.prototype.get encoder):
>+        (foo.io.SystemEncoding.prototype.get decoder):
>+        (foo.io.SystemEncoding):
>+        (foo.io._WindowsCodePageEncoder.prototype.convert):
>+        (foo.io._WindowsCodePageEncoder.prototype.startChunkedConversion):
>+        (foo.io._WindowsCodePageEncoder._encodeString):
>+        (foo.io._WindowsCodePageEncoder):
>+        (foo.io._WindowsCodePageEncoderSink.prototype.close):
>+        (foo.io._WindowsCodePageEncoderSink.prototype.add):
>+        (foo.io._WindowsCodePageEncoderSink.prototype.addSlice):
>+        (foo.io._WindowsCodePageEncoderSink):
>+        (foo.io._WindowsCodePageDecoder.prototype.convert):
>+        (foo.io._WindowsCodePageDecoder.prototype.startChunkedConversion):
>+        (foo.io._WindowsCodePageDecoder._decodeBytes):
>+        (foo.io._WindowsCodePageDecoder):
>+        (foo.io._WindowsCodePageDecoderSink.prototype.close):
>+        (foo.io._WindowsCodePageDecoderSink.prototype.add):
>+        (foo.io._WindowsCodePageDecoderSink):
>+        (foo.io.RawSynchronousSocket.connectSync):
>+        (foo.io.RawSynchronousSocket):
>+        (foo.isolate.IsolateSpawnException.prototype.get message):
>+        (foo.isolate.IsolateSpawnException.prototype.set message):
>+        (foo.isolate.IsolateSpawnException.prototype.toString):
>+        (foo.isolate.IsolateSpawnException):
>+        (foo.isolate.Isolate.prototype.get controlPort):
>+        (foo.isolate.Isolate.prototype.set controlPort):
>+        (foo.isolate.Isolate.prototype.get pauseCapability):
>+        (foo.isolate.Isolate.prototype.set pauseCapability):
>+        (foo.isolate.Isolate.prototype.get terminateCapability):
>+        (foo.isolate.Isolate.prototype.set terminateCapability):
>+        (foo.isolate.Isolate.prototype.get debugName):
>+        (foo.isolate.Isolate.get current):
>+        (foo.isolate.Isolate.get packageRoot):
>+        (foo.isolate.Isolate.get packageConfig):
>+        (foo.isolate.Isolate.resolvePackageUri):
>+        (foo.isolate.Isolate.spawn):
>+        (foo.isolate.Isolate.spawnUri):
>+        (foo.isolate.Isolate.prototype.pause):
>+        (foo.isolate.Isolate.prototype._pause):
>+        (foo.isolate.Isolate.prototype.resume):
>+        (foo.isolate.Isolate.prototype.addOnExitListener):
>+        (foo.isolate.Isolate.prototype.removeOnExitListener):
>+        (foo.isolate.Isolate.prototype.setErrorsFatal):
>+        (foo.isolate.Isolate.prototype.kill):
>+        (foo.isolate.Isolate.prototype.ping):
>+        (foo.isolate.Isolate.prototype.addErrorListener):
>+        (foo.isolate.Isolate.prototype.removeErrorListener):
>+        (foo.isolate.Isolate.get errors.handleError):
>+        (foo.isolate.Isolate.get errors.controller.async StreamController):
>+        (foo.isolate.Isolate.prototype.get errors):
>+        (foo.isolate.Isolate):
>+        (foo.get isolate.SendPort):
>+        (foo.isolate.ReceivePort.new):
>+        (foo.isolate.ReceivePort.fromRawReceivePort):
>+        (foo.isolate.ReceivePort):
>+        (foo.isolate.RawReceivePort.new):
>+        (foo.isolate.RawReceivePort):
>+        (foo.isolate.RemoteError.prototype.get stackTrace):
>+        (foo.isolate.RemoteError.prototype.set stackTrace):
>+        (foo.isolate.RemoteError.prototype.toString):
>+        (foo.isolate.RemoteError):
>+        (foo.isolate.ReceivePort.dart.implements.async Stream):
>+        (foo.isolate.TransferableTypedData.fromList):
>+        (foo.isolate.TransferableTypedData):
>+        (foo.isolate._ReceivePort.prototype.close):
>+        (foo.isolate._ReceivePort.prototype.get sendPort):
>+        (foo.isolate._ReceivePort.prototype.listen):
>+        (foo.isolate._ReceivePort):
>+        (foo.get isolate):
>+        (foo.isolate._unsupported):
>+        (foo.isolate.Capability.new):
>+        (foo.isolate.Capability):
>+        (foo.js.JsObject.new):
>+        (foo.js.JsObject.fromBrowserObject):
>+        (foo.js.JsObject.jsify):
>+        (foo.js.JsObject._convertDataTree._convert):
>+        (foo.js.JsObject._convertDataTree):
>+        (foo.js.JsObject.prototype._get):
>+        (foo.js.JsObject.prototype._set):
>+        (foo.js.JsObject.prototype.get hashCode):
>+        (foo.js.JsObject.prototype._equals):
>+        (foo.js.JsObject.prototype.hasProperty):
>+        (foo.js.JsObject.prototype.deleteProperty):
>+        (foo.js.JsObject.prototype.instanceof):
>+        (foo.js.JsObject.prototype.toString):
>+        (foo.js.JsObject.prototype.callMethod):
>+        (foo.js.JsObject):
>+        (foo.js.JsFunction.withThis):
>+        (foo.js.JsFunction.prototype.apply):
>+        (foo.js.JsFunction):
>+        (foo.js.JsArray.dart.generic):
>+        (foo.io._StdConsumer.prototype.close.return.async Future):
>+        (foo.io._StdConsumer.prototype.close):
>+        (foo.io._StdConsumer):
>+        (foo.js._isBrowserType):
>+        (foo.js._DartObject):
>+        (foo.js._convertToJS):
>+        (foo.let.wrapper):
>+        (foo.js._wrapDartFunction):
>+        (foo.js._convertToDart):
>+        (foo.js._wrapToDart):
>+        (foo.js._wrapToDartHelper):
>+        (foo.get js._putIfAbsent):
>+        (foo.js.allowInterop):
>+        (foo.get js):
>+        (foo.ret):
>+        (foo.set get js.allowInteropCaptureThis):
>+        (foo.js_util.jsify):
>+        (foo._convert):
>+        (foo.js_util._convertDataTree):
>+        (foo.js_util.newObject):
>+        (foo.js_util.hasProperty):
>+        (foo.js_util.getProperty):
>+        (foo.js_util.setProperty):
>+        (foo.js_util.callMethod):
>+        (foo.js_util.instanceof):
>+        (foo.js_util.callConstructor):
>+        (foo.set get js):
>+        (foo.get math.min):
>+        (foo.math.max):
>+        (foo.math.atan2):
>+        (foo.math.pow):
>+        (foo.math.sin):
>+        (foo.math.cos):
>+        (foo.math.tan):
>+        (foo.math.acos):
>+        (foo.math.asin):
>+        (foo.math.atan):
>+        (foo.math.sqrt):
>+        (foo.math.exp):
>+        (foo.math.log):
>+        (foo.get math):
>+        (foo.get math._JSRandom.prototype.nextInt):
>+        (foo.get math._JSRandom.prototype.nextDouble):
>+        (foo.get math._JSRandom.prototype.nextBool):
>+        (foo.get math._JSRandom):
>+        (foo.math._Random.prototype._nextState):
>+        (foo.math._Random.prototype.nextInt):
>+        (foo.math._Random.prototype.nextDouble):
>+        (foo.math._Random.prototype.nextBool):
>+        (foo.math._Random):
>+        (foo.math._JSSecureRandom.prototype._getRandomBytes):
>+        (foo.math._JSSecureRandom.prototype.nextBool):
>+        (foo.math._JSSecureRandom.prototype.nextDouble):
>+        (foo.math._JSSecureRandom.prototype.nextInt):
>+        (foo.math._JSSecureRandom):
>+        (foo.math._JenkinsSmiHash.combine):
>+        (foo.math._JenkinsSmiHash.finish):
>+        (foo.math._JenkinsSmiHash.hash2):
>+        (foo.math._JenkinsSmiHash.hash4):
>+        (foo.math._JenkinsSmiHash):
>+        (foo.math.Point.dart.generic):
>+        (foo.math.Random.new):
>+        (foo.math.Random.secure):
>+        (foo.math.Random):
>+        (foo.math._RectangleBase.dart.generic):
>+        (foo.math.Rectangle.dart.generic):
>+        (foo.math.MutableRectangle.dart.generic):
>+        (foo.math._clampToZero):
>+        (foo.mirrors.MirrorSystem.prototype.findLibrary):
>+        (foo.mirrors.MirrorSystem.getName):
>+        (foo.mirrors.MirrorSystem.getSymbol):
>+        (foo.mirrors.MirrorSystem):
>+        (foo.mirrors.currentMirrorSystem):
>+        (foo.mirrors.reflect):
>+        (foo.mirrors.reflectClass):
>+        (foo.mirrors.reflectType):
>+        (foo.mirrors.Mirror):
>+        (foo.mirrors.IsolateMirror):
>+        (foo.mirrors.DeclarationMirror):
>+        (foo.mirrors.ObjectMirror):
>+        (foo.mirrors.InstanceMirror):
>+        (foo.mirrors.ClosureMirror):
>+        (foo.mirrors.LibraryMirror):
>+        (foo.mirrors.LibraryDependencyMirror):
>+        (foo.mirrors.CombinatorMirror):
>+        (foo.mirrors.TypeMirror):
>+        (foo.mirrors.ClassMirror):
>+        (foo.mirrors.FunctionTypeMirror):
>+        (foo.mirrors.TypeVariableMirror):
>+        (foo.mirrors.TypedefMirror):
>+        (foo.mirrors.MethodMirror):
>+        (foo.mirrors.VariableMirror):
>+        (foo.mirrors.ParameterMirror):
>+        (foo.mirrors.SourceLocation):
>+        (foo.mirrors.Comment.prototype.get text):
>+        (foo.mirrors.Comment.prototype.set text):
>+        (foo.mirrors.Comment.prototype.get trimmedText):
>+        (foo.mirrors.Comment.prototype.set trimmedText):
>+        (foo.mirrors.Comment.prototype.get isDocComment):
>+        (foo.mirrors.Comment.prototype.set isDocComment):
>+        (foo.mirrors.Comment):
>+        (foo.mirrors.MirrorsUsed.prototype.get symbols):
>+        (foo.mirrors.MirrorsUsed.prototype.set symbols):
>+        (foo.mirrors.MirrorsUsed.prototype.get targets):
>+        (foo.mirrors.MirrorsUsed.prototype.set targets):
>+        (foo.mirrors.MirrorsUsed.prototype.get metaTargets):
>+        (foo.mirrors.MirrorsUsed.prototype.set metaTargets):
>+        (foo.mirrors.MirrorsUsed.prototype.get override):
>+        (foo.mirrors.MirrorsUsed.prototype.set override):
>+        (foo.mirrors.MirrorsUsed):
>+        (foo.mirrors._instantiateClass):
>+        (foo.typed_data.ByteBuffer):
>+        (foo.typed_data.TypedData):
>+        (foo.typed_data._TypedIntList):
>+        (foo.typed_data._TypedFloatList):
>+        (foo.typed_data.Endian):
>+        (foo.get typed_data.ByteData.new):
>+        (foo.get typed_data.ByteData.view):
>+        (foo.get typed_data.ByteData):
>+        (foo.typed_data.Int8List.new):
>+        (foo.typed_data.Int8List.fromList):
>+        (foo.typed_data.Int8List.view):
>+        (foo.typed_data.Int8List):
>+        (foo.get typed_data):
>+        (foo.get typed_data.Uint8List.new):
>+        (foo.get typed_data.Uint8List.fromList):
>+        (foo.get typed_data.Uint8List.view):
>+        (foo.get typed_data.Uint8List):
>+        (foo.get typed_data.Uint8ClampedList.new):
>+        (foo.get typed_data.Uint8ClampedList.fromList):
>+        (foo.get typed_data.Uint8ClampedList.view):
>+        (foo.get typed_data.Uint8ClampedList):
>+        (foo.get typed_data.Int16List.new):
>+        (foo.get typed_data.Int16List.fromList):
>+        (foo.get typed_data.Int16List.view):
>+        (foo.get typed_data.Int16List):
>+        (foo.get typed_data.Uint16List.new):
>+        (foo.get typed_data.Uint16List.fromList):
>+        (foo.get typed_data.Uint16List.view):
>+        (foo.get typed_data.Uint16List):
>+        (foo.get typed_data.Int32List.new):
>+        (foo.get typed_data.Int32List.fromList):
>+        (foo.get typed_data.Int32List.view):
>+        (foo.get typed_data.Int32List):
>+        (foo.get typed_data.Uint32List.new):
>+        (foo.get typed_data.Uint32List.fromList):
>+        (foo.get typed_data.Uint32List.view):
>+        (foo.get typed_data.Uint32List):
>+        (foo.get typed_data.Int64List.new):
>+        (foo.get typed_data.Int64List.fromList):
>+        (foo.get typed_data.Int64List.view):
>+        (foo.get typed_data.Int64List):
>+        (foo.get typed_data.Uint64List.new):
>+        (foo.get typed_data.Uint64List.fromList):
>+        (foo.get typed_data.Uint64List.view):
>+        (foo.get typed_data.Uint64List):
>+        (foo.get typed_data.Float32List.new):
>+        (foo.get typed_data.Float32List.fromList):
>+        (foo.get typed_data.Float32List.view):
>+        (foo.get typed_data.Float32List):
>+        (foo.get typed_data.Float64List.new):
>+        (foo.get typed_data.Float64List.fromList):
>+        (foo.get typed_data.Float64List.view):
>+        (foo.get typed_data.Float64List):
>+        (foo.get typed_data.Float32x4List.new):
>+        (foo.get typed_data.Float32x4List.fromList):
>+        (foo.get typed_data.Float32x4List.view):
>+        (foo.get typed_data.Float32x4List):
>+        (foo.get typed_data.Int32x4List.new):
>+        (foo.get typed_data.Int32x4List.fromList):
>+        (foo.get typed_data.Int32x4List.view):
>+        (foo.get typed_data.Int32x4List):
>+        (foo.get typed_data.Float64x2List.new):
>+        (foo.get typed_data.Float64x2List.fromList):
>+        (foo.get typed_data.Float64x2List.view):
>+        (foo.get typed_data.Float64x2List):
>+        (foo.typed_data.UnmodifiableByteBufferView.prototype.get lengthInBytes):
>+        (foo.typed_data.UnmodifiableByteBufferView.prototype.asUint8List):
>+        (foo.typed_data.UnmodifiableByteBufferView.prototype.asInt8List):
>+        (foo.typed_data.UnmodifiableByteBufferView.prototype.asUint8ClampedList):
>+        (foo.typed_data.UnmodifiableByteBufferView.prototype.asUint16List):
>+        (foo.typed_data.UnmodifiableByteBufferView.prototype.asInt16List):
>+        (foo.typed_data.UnmodifiableByteBufferView.prototype.asUint32List):
>+        (foo.typed_data.UnmodifiableByteBufferView.prototype.asInt32List):
>+        (foo.typed_data.UnmodifiableByteBufferView.prototype.asUint64List):
>+        (foo.typed_data.UnmodifiableByteBufferView.prototype.asInt64List):
>+        (foo.typed_data.UnmodifiableByteBufferView.prototype.asInt32x4List):
>+        (foo.typed_data.UnmodifiableByteBufferView.prototype.asFloat32List):
>+        (foo.typed_data.UnmodifiableByteBufferView.prototype.asFloat64List):
>+        (foo.typed_data.UnmodifiableByteBufferView.prototype.asFloat32x4List):
>+        (foo.typed_data.UnmodifiableByteBufferView.prototype.asFloat64x2List):
>+        (foo.typed_data.UnmodifiableByteBufferView.prototype.asByteData):
>+        (foo.typed_data.UnmodifiableByteBufferView):
>+        (foo.typed_data.UnmodifiableByteDataView.prototype.getInt8):
>+        (foo.typed_data.UnmodifiableByteDataView.prototype.setInt8):
>+        (foo.typed_data.UnmodifiableByteDataView.prototype.getUint8):
>+        (foo.typed_data.UnmodifiableByteDataView.prototype.setUint8):
>+        (foo.typed_data.UnmodifiableByteDataView.prototype.getInt16):
>+        (foo.typed_data.UnmodifiableByteDataView.prototype.setInt16):
>+        (foo.typed_data.UnmodifiableByteDataView.prototype.getUint16):
>+        (foo.typed_data.UnmodifiableByteDataView.prototype.setUint16):
>+        (foo.typed_data.UnmodifiableByteDataView.prototype.getInt32):
>+        (foo.typed_data.UnmodifiableByteDataView.prototype.setInt32):
>+        (foo.typed_data.UnmodifiableByteDataView.prototype.getUint32):
>+        (foo.typed_data.UnmodifiableByteDataView.prototype.setUint32):
>+        (foo.typed_data.UnmodifiableByteDataView.prototype.getInt64):
>+        (foo.typed_data.UnmodifiableByteDataView.prototype.setInt64):
>+        (foo.typed_data.UnmodifiableByteDataView.prototype.getUint64):
>+        (foo.typed_data.UnmodifiableByteDataView.prototype.setUint64):
>+        (foo.typed_data.UnmodifiableByteDataView.prototype.getFloat32):
>+        (foo.typed_data.UnmodifiableByteDataView.prototype.setFloat32):
>+        (foo.typed_data.UnmodifiableByteDataView.prototype.getFloat64):
>+        (foo.typed_data.UnmodifiableByteDataView.prototype.setFloat64):
>+        (foo.typed_data.UnmodifiableByteDataView.prototype.get elementSizeInBytes):
>+        (foo.typed_data.UnmodifiableByteDataView.prototype.get offsetInBytes):
>+        (foo.typed_data.UnmodifiableByteDataView.prototype.get lengthInBytes):
>+        (foo.typed_data.UnmodifiableByteDataView.prototype.get buffer):
>+        (foo.typed_data.UnmodifiableByteDataView.prototype._unsupported):
>+        (foo.typed_data.UnmodifiableByteDataView):
>+        (foo.const.UnmodifiableListBase__UnmodifiableListMixin):
>+        (foo.typed_data.UnmodifiableUint8ListView):
>+        (foo.typed_data.UnmodifiableInt8ListView):
>+        (foo.const.UnmodifiableListBase__UnmodifiableListMixin.0):
>+        (foo.typed_data.UnmodifiableUint8ClampedListView):
>+        (foo.const.UnmodifiableListBase__UnmodifiableListMixin.1):
>+        (foo.typed_data.UnmodifiableUint16ListView):
>+        (foo.const.UnmodifiableListBase__UnmodifiableListMixin.2):
>+        (foo.typed_data.UnmodifiableInt16ListView):
>+        (foo.const.UnmodifiableListBase__UnmodifiableListMixin.3):
>+        (foo.typed_data.UnmodifiableUint32ListView):
>+        (foo.const.UnmodifiableListBase__UnmodifiableListMixin.4):
>+        (foo.typed_data.UnmodifiableInt32ListView):
>+        (foo.const.UnmodifiableListBase__UnmodifiableListMixin.5):
>+        (foo.typed_data.UnmodifiableUint64ListView):
>+        (foo.const.UnmodifiableListBase__UnmodifiableListMixin.6):
>+        (foo.typed_data.UnmodifiableInt64ListView):
>+        (foo.const.UnmodifiableListBase__UnmodifiableListMixin.7):
>+        (foo.typed_data.UnmodifiableInt32x4ListView):
>+        (foo.const.UnmodifiableListBase__UnmodifiableListMixin.8):
>+        (foo.typed_data.UnmodifiableFloat32x4ListView):
>+        (foo.const.UnmodifiableListBase__UnmodifiableListMixin.9):
>+        (foo.typed_data.UnmodifiableFloat64x2ListView):
>+        (foo.const.UnmodifiableListBase__UnmodifiableListMixin.10):
>+        (foo.typed_data.UnmodifiableFloat32ListView):
>+        (foo.const.UnmodifiableListBase__UnmodifiableListMixin.11):
>+        (foo.typed_data.UnmodifiableFloat64ListView):
>+        (foo.indexed_db._KeyRangeFactoryProvider.createKeyRange_only):
>+        (foo.indexed_db._KeyRangeFactoryProvider.createKeyRange_lowerBound):
>+        (foo.indexed_db._KeyRangeFactoryProvider.createKeyRange_upperBound):
>+        (foo.indexed_db._KeyRangeFactoryProvider.createKeyRange_bound):
>+        (foo.indexed_db._KeyRangeFactoryProvider._class):
>+        (foo.indexed_db._KeyRangeFactoryProvider._uncachedClass):
>+        (foo.indexed_db._KeyRangeFactoryProvider._translateKey):
>+        (foo.indexed_db._KeyRangeFactoryProvider._only):
>+        (foo.indexed_db._KeyRangeFactoryProvider._lowerBound):
>+        (foo.indexed_db._KeyRangeFactoryProvider._upperBound):
>+        (foo.indexed_db._KeyRangeFactoryProvider._bound):
>+        (foo.indexed_db._KeyRangeFactoryProvider):
>+        (foo.set get indexed_db._convertNativeToDart_IDBKey):
>+        (foo.indexed_db._convertDartToNative_IDBKey):
>+        (foo.indexed_db._convertNativeToDart_IDBAny):
>+        (foo.set get indexed_db):
>+        (foo.indexed_db.Cursor.get direction):
>+        (foo.indexed_db.Cursor.get key):
>+        (foo.indexed_db.Cursor.get primaryKey):
>+        (foo.indexed_db.Cursor.get source):
>+        (foo.indexed_db.CursorWithValue.prototype.get value):
>+        (foo.indexed_db.CursorWithValue.prototype.get _get_value):
>+        (foo.indexed_db.CursorWithValue):
>+        (foo.html.EventTarget.prototype.get on):
>+        (foo.html.EventTarget.prototype.addEventListener):
>+        (foo.html.EventTarget.prototype.removeEventListener):
>+        (foo.html.EventTarget.prototype._addEventListener):
>+        (foo.html.EventTarget.prototype.dispatchEvent):
>+        (foo.html.EventTarget.prototype._removeEventListener):
>+        (foo.html.EventTarget):
>+        (foo.indexed_db.Database.prototype.createObjectStore):
>+        (foo.indexed_db.Database.prototype.transaction):
>+        (foo.indexed_db.Database.prototype.transactionStore):
>+        (foo.indexed_db.Database.prototype.transactionList):
>+        (foo.indexed_db.Database.prototype.transactionStores):
>+        (foo.indexed_db.Database.prototype._transaction):
>+        (foo.indexed_db.Database.prototype.get name):
>+        (foo.indexed_db.Database.prototype.get objectStoreNames):
>+        (foo.indexed_db.Database.prototype.get version):
>+        (foo.indexed_db.Database.prototype.close):
>+        (foo.indexed_db.Database.prototype._createObjectStore):
>+        (foo.indexed_db.Database.prototype._createObjectStore_1):
>+        (foo.indexed_db.Database.prototype._createObjectStore_2):
>+        (foo.indexed_db.Database.prototype.deleteObjectStore):
>+        (foo.indexed_db.Database.prototype.get onAbort):
>+        (foo.indexed_db.Database.prototype.get onClose):
>+        (foo.indexed_db.Database.prototype.get onError):
>+        (foo.indexed_db.Database.prototype.get onVersionChange):
>+        (foo.indexed_db.Database):
>+        (foo.indexed_db.IdbFactory.get supported):
>+        (foo.indexed_db.IdbFactory.prototype.open):
>+        (foo.indexed_db.IdbFactory.prototype.deleteDatabase):
>+        (foo.indexed_db.IdbFactory.prototype.get supportsDatabaseNames):
>+        (foo.indexed_db.IdbFactory.prototype.cmp):
>+        (foo.indexed_db.IdbFactory.prototype._deleteDatabase):
>+        (foo.indexed_db.IdbFactory.prototype._open):
>+        (foo.indexed_db.IdbFactory):
>+        (foo.let.completer.async Completer):
>+        (foo.indexed_db._completeRequest):
>+        (foo.indexed_db.Index.prototype.count):
>+        (foo.indexed_db.Index.prototype.get try):
>+        (foo.indexed_db.Index.getKey.catch.return.async Future):
>+        (foo.indexed_db.Index.prototype.catch.return.async Future):
>+        (foo.indexed_db.Index.prototype.catch):
>+        (foo.indexed_db.Index.prototype.get keyPath):
>+        (foo.indexed_db.Index.prototype.get multiEntry):
>+        (foo.indexed_db.Index.prototype.get name):
>+        (foo.indexed_db.Index.prototype.set name):
>+        (foo.indexed_db.Index.prototype.get objectStore):
>+        (foo.indexed_db.Index.prototype.get unique):
>+        (foo.indexed_db.Index.prototype._count.0):
>+        (foo.indexed_db.Index.prototype._get):
>+        (foo.indexed_db.Index.prototype.getAll):
>+        (foo.indexed_db.Index.prototype.getAllKeys):
>+        (foo.indexed_db.Index.prototype._getKey):
>+        (foo.indexed_db.Index.prototype._openCursor):
>+        (foo.indexed_db.Index.prototype._openKeyCursor):
>+        (foo.indexed_db.Index):
>+        (foo.async get dart):
>+        (foo.indexed_db.KeyRange.only):
>+        (foo.indexed_db.KeyRange.lowerBound):
>+        (foo.indexed_db.KeyRange.upperBound):
>+        (foo.indexed_db.KeyRange.bound):
>+        (foo.indexed_db.KeyRange.prototype.get lower):
>+        (foo.indexed_db.KeyRange.prototype.get lowerOpen):
>+        (foo.indexed_db.KeyRange.prototype.get upper):
>+        (foo.indexed_db.KeyRange.prototype.get upperOpen):
>+        (foo.indexed_db.KeyRange.prototype.includes):
>+        (foo.indexed_db.KeyRange):
>+        (foo.indexed_db.ObjectStore.delete.catch.return.async Future):
>+        (foo.indexed_db.ObjectStore.clear.catch.return.async Future):
>+        (foo.indexed_db.ObjectStore.getObject.catch.return.async Future):
>+        (foo.indexed_db.ObjectStore.get autoIncrement):
>+        (foo.indexed_db.ObjectStore.get indexNames):
>+        (foo.indexed_db.ObjectStore.get keyPath):
>+        (foo.indexed_db.ObjectStore.get name):
>+        (foo.indexed_db.ObjectStore.set name):
>+        (foo.indexed_db.ObjectStore.get transaction):
>+        (foo.indexed_db.ObjectStore.let.controller.async StreamController):
>+        (foo.indexed_db.ObjectStore.catch.return.async Future):
>+        (foo.indexed_db.ObjectStore.prototype.add.catch.return.async Future):
>+        (foo.indexed_db.ObjectStore.prototype.add):
>+        (foo.indexed_db.ObjectStore):
>+        (foo.indexed_db.Observation.prototype.get key):
>+        (foo.indexed_db.Observation.prototype.get type):
>+        (foo.indexed_db.Observation.prototype.get value):
>+        (foo.indexed_db.Observation):
>+        (foo.indexed_db.Observer.new):
>+        (foo.indexed_db.Observer._create_1):
>+        (foo.indexed_db.Observer.prototype.observe):
>+        (foo.indexed_db.Observer.prototype._observe_1):
>+        (foo.indexed_db.Observer.prototype.unobserve):
>+        (foo.indexed_db.Observer):
>+        (foo.indexed_db.ObserverChanges.prototype.get database):
>+        (foo.indexed_db.ObserverChanges.prototype.get records):
>+        (foo.indexed_db.ObserverChanges.prototype.get transaction):
>+        (foo.indexed_db.ObserverChanges):
>+        (foo.indexed_db.Request.prototype.get error):
>+        (foo.indexed_db.Request.prototype.get readyState):
>+        (foo.indexed_db.Request.prototype.get result):
>+        (foo.indexed_db.Request.prototype.get _get_result):
>+        (foo.indexed_db.Request.prototype.get source):
>+        (foo.indexed_db.Request.prototype.get transaction):
>+        (foo.indexed_db.Request.prototype.get onError):
>+        (foo.indexed_db.Request.prototype.get onSuccess):
>+        (foo.indexed_db.Request):
>+        (foo.indexed_db.OpenDBRequest.prototype.get onBlocked):
>+        (foo.indexed_db.OpenDBRequest.prototype.get onUpgradeNeeded):
>+        (foo.indexed_db.OpenDBRequest):
>+        (foo.indexed_db.Transaction.prototype.get completed):
>+        (foo.indexed_db.Transaction.prototype.get db):
>+        (foo.indexed_db.Transaction.prototype.get error):
>+        (foo.indexed_db.Transaction.prototype.get mode):
>+        (foo.indexed_db.Transaction.prototype.get objectStoreNames):
>+        (foo.indexed_db.Transaction.prototype.abort):
>+        (foo.indexed_db.Transaction.prototype.objectStore):
>+        (foo.indexed_db.Transaction.prototype.get onAbort):
>+        (foo.indexed_db.Transaction.prototype.get onComplete):
>+        (foo.indexed_db.Transaction.prototype.get onError):
>+        (foo.indexed_db.Transaction):
>+        (foo.html.Event.new):
>+        (foo.html.Event.eventType):
>+        (foo.html.Event.prototype.get _selector):
>+        (foo.html.Event.prototype.set _selector):
>+        (foo.html.Event.prototype.get matchingTarget):
>+        (foo.html.Event.prototype.get path):
>+        (foo.html.Event.__):
>+        (foo.html.Event._create_1):
>+        (foo.html.Event._create_2):
>+        (foo.html.Event.prototype.get bubbles):
>+        (foo.html.Event.prototype.get cancelable):
>+        (foo.html.Event.prototype.get composed):
>+        (foo.html.Event.prototype.get currentTarget):
>+        (foo.html.Event.prototype.get _get_currentTarget):
>+        (foo.html.Event.prototype.get defaultPrevented):
>+        (foo.html.Event.prototype.get eventPhase):
>+        (foo.html.Event.prototype.get isTrusted):
>+        (foo.html.Event.prototype.get target):
>+        (foo.html.Event.prototype.get _get_target):
>+        (foo.html.Event.prototype.get timeStamp):
>+        (foo.html.Event.prototype.get type):
>+        (foo.html.Event.prototype.composedPath):
>+        (foo.html.Event.prototype._initEvent):
>+        (foo.html.Event.prototype.preventDefault):
>+        (foo.html.Event.prototype.stopImmediatePropagation):
>+        (foo.html.Event.prototype.stopPropagation):
>+        (foo.html.Event):
>+        (foo.indexed_db.VersionChangeEvent.new):
>+        (foo.indexed_db.VersionChangeEvent._create_1):
>+        (foo.indexed_db.VersionChangeEvent._create_2):
>+        (foo.indexed_db.VersionChangeEvent.prototype.get dataLoss):
>+        (foo.indexed_db.VersionChangeEvent.prototype.get dataLossMessage):
>+        (foo.indexed_db.VersionChangeEvent.prototype.get newVersion):
>+        (foo.indexed_db.VersionChangeEvent.prototype.get oldVersion):
>+        (foo.indexed_db.VersionChangeEvent.prototype.get target):
>+        (foo.indexed_db.VersionChangeEvent):
>+        (foo.html.promiseToFutureAsMap):
>+        (foo.html.Node.prototype.get nodes):
>+        (foo.html.Node.prototype.set nodes):
>+        (foo.html.Node.prototype.remove):
>+        (foo.html.Node.prototype.replaceWith):
>+        (foo.html.Node.prototype.insertAllBefore):
>+        (foo.html.Node.prototype._clearChildren):
>+        (foo.html.Node.prototype.toString):
>+        (foo.html.Node.prototype.get childNodes):
>+        (foo.html.Node.prototype.get baseUri):
>+        (foo.html.Node.prototype.get firstChild):
>+        (foo.html.Node.prototype.get isConnected):
>+        (foo.html.Node.prototype.get lastChild):
>+        (foo.html.Node.prototype.get nextNode):
>+        (foo.html.Node.prototype.get nodeName):
>+        (foo.html.Node.prototype.get nodeType):
>+        (foo.html.Node.prototype.get nodeValue):
>+        (foo.html.Node.prototype.get ownerDocument):
>+        (foo.html.Node.prototype.get parent):
>+        (foo.html.Node.prototype.get parentNode):
>+        (foo.html.Node.prototype.get previousNode):
>+        (foo.html.Node.prototype.get text):
>+        (foo.html.Node.prototype.set text):
>+        (foo.html.Node.prototype.append):
>+        (foo.html.Node.prototype.clone):
>+        (foo.html.Node.prototype.contains):
>+        (foo.html.Node.prototype.getRootNode):
>+        (foo.html.Node.prototype._getRootNode_1):
>+        (foo.html.Node.prototype._getRootNode_2):
>+        (foo.html.Node.prototype.hasChildNodes):
>+        (foo.html.Node.prototype.insertBefore):
>+        (foo.html.Node.prototype._removeChild):
>+        (foo.html.Node.prototype._replaceChild):
>+        (foo.html.Node):
>+        (foo.get html.promiseToFuture):
>+        (foo.html.Element.html):
>+        (foo.html.Element.tag):
>+        (foo.html.Element.a):
>+        (foo.html.Element.article):
>+        (foo.html.Element.aside):
>+        (foo.html.Element.audio):
>+        (foo.html.Element.br):
>+        (foo.html.Element.canvas):
>+        (foo.html.Element.div):
>+        (foo.html.Element.footer):
>+        (foo.html.Element.header):
>+        (foo.html.Element.hr):
>+        (foo.html.Element.iframe):
>+        (foo.html.Element.img):
>+        (foo.html.Element.li):
>+        (foo.html.Element.nav):
>+        (foo.html.Element.ol):
>+        (foo.html.Element.option):
>+        (foo.html.Element.p):
>+        (foo.html.Element.pre):
>+        (foo.html.Element.section):
>+        (foo.html.Element.select):
>+        (foo.html.Element.span):
>+        (foo.html.Element.svg):
>+        (foo.html.Element.table):
>+        (foo.html.Element.td):
>+        (foo.html.Element.textarea):
>+        (foo.html.Element.th):
>+        (foo.html.Element.tr):
>+        (foo.html.Element.ul):
>+        (foo.html.Element.video):
>+        (foo.html.Element.prototype.get attributes):
>+        (foo.html.Element.prototype.set attributes):
>+        (foo.html.Element.prototype.getAttribute):
>+        (foo.html.Element.prototype.getAttributeNS):
>+        (foo.html.Element.prototype.hasAttribute):
>+        (foo.html.Element.prototype.hasAttributeNS):
>+        (foo.html.Element.prototype.removeAttribute):
>+        (foo.html.Element.prototype.removeAttributeNS):
>+        (foo.html.Element.prototype.setAttribute):
>+        (foo.html.Element.prototype.setAttributeNS):
>+        (foo.html.Element.prototype.get children):
>+        (foo.html.Element.prototype.set children):
>+        (foo.html.Element.prototype.querySelectorAll):
>+        (foo.html.Element.prototype._setApplyScroll):
>+        (foo.html.Element.prototype.setApplyScroll):
>+        (foo.html.Element.prototype._setDistributeScroll):
>+        (foo.html.Element.prototype.setDistributeScroll):
>+        (foo.html.Element.prototype.get classes):
>+        (foo.html.Element.prototype.set classes):
>+        (foo.html.Element.prototype.get dataset):
>+        (foo.html.Element.prototype.set dataset):
>+        (foo.html.Element.prototype.getNamespacedAttributes):
>+        (foo.html.Element.prototype.getComputedStyle):
>+        (foo.html.Element.prototype.get client):
>+        (foo.html.Element.prototype.get offset):
>+        (foo.html.Element.prototype.appendText):
>+        (foo.html.Element.prototype.appendHtml):
>+        (foo.html.Element.isTagSupported):
>+        (foo.html.Element.prototype.attached):
>+        (foo.html.Element.prototype.detached):
>+        (foo.html.Element.prototype.enteredView):
>+        (foo.html.Element.prototype.getClientRects):
>+        (foo.html.Element.prototype.leftView):
>+        (foo.html.Element.prototype.animate):
>+        (foo.html.Element.prototype._animate):
>+        (foo.html.Element.prototype.attributeChanged):
>+        (foo.html.Element.prototype.get localName):
>+        (foo.html.Element.prototype.get namespaceUri):
>+        (foo.html.Element.prototype.toString):
>+        (foo.html.Element.prototype.scrollIntoView):
>+        (foo.html.Element._determineMouseWheelEventType):
>+        (foo.html.Element._determineTransitionEventType):
>+        (foo.html.Element.prototype.insertAdjacentText):
>+        (foo.html.Element.prototype._insertAdjacentText):
>+        (foo.html.Element.prototype.insertAdjacentHtml):
>+        (foo.html.Element.prototype._insertAdjacentHtml):
>+        (foo.html.Element.prototype.insertAdjacentElement):
>+        (foo.html.Element.prototype._insertAdjacentElement):
>+        (foo.html.Element.prototype._insertAdjacentNode):
>+        (foo.html.Element.prototype.matches):
>+        (foo.html.Element.prototype.matchesWithAncestors):
>+        (foo.html.Element.prototype.createShadowRoot):
>+        (foo.html.Element.prototype.get shadowRoot):
>+        (foo.html.Element.prototype.get contentEdge):
>+        (foo.html.Element.prototype.get paddingEdge):
>+        (foo.html.Element.prototype.get borderEdge):
>+        (foo.html.Element.prototype.get marginEdge):
>+        (foo.html.Element.prototype.get documentOffset):
>+        (foo.html.Element.prototype.offsetTo):
>+        (foo.html.Element._offsetToHelper):
>+        (foo.html.Element.prototype.createFragment):
>+        (foo.html.Element.prototype.get _canBeUsedToCreateContextualFragment):
>+        (foo.html.Element.prototype.get _cannotBeUsedToCreateContextualFragment):
>+        (foo.html.Element.prototype.set innerHtml):
>+        (foo.html.Element.prototype.setInnerHtml):
>+        (foo.html.Element.prototype.get innerHtml):
>+        (foo.html.Element.prototype.get on):
>+        (foo.html.Element._hasCorruptedAttributes):
>+        (foo.html.Element._hasCorruptedAttributesAdditionalCheck):
>+        (foo.html.Element._safeTagName):
>+        (foo.html.Element.prototype.get offsetParent):
>+        (foo.html.Element.prototype.get offsetHeight):
>+        (foo.html.Element.prototype.get offsetLeft):
>+        (foo.html.Element.prototype.get offsetTop):
>+        (foo.html.Element.prototype.get offsetWidth):
>+        (foo.html.Element.prototype.get scrollHeight):
>+        (foo.html.Element.prototype.get scrollLeft):
>+        (foo.html.Element.prototype.set scrollLeft):
>+        (foo.html.Element.prototype.get scrollTop):
>+        (foo.html.Element.prototype.set scrollTop):
>+        (foo.html.Element.prototype.get scrollWidth):
>+        (foo.html.Element.prototype.get contentEditable):
>+        (foo.html.Element.prototype.set contentEditable):
>+        (foo.html.Element.prototype.get dir):
>+        (foo.html.Element.prototype.set dir):
>+        (foo.html.Element.prototype.get draggable):
>+        (foo.html.Element.prototype.set draggable):
>+        (foo.html.Element.prototype.get hidden):
>+        (foo.html.Element.prototype.set hidden):
>+        (foo.html.Element.prototype.get inert):
>+        (foo.html.Element.prototype.set inert):
>+        (foo.html.Element.prototype.get inputMode):
>+        (foo.html.Element.prototype.set inputMode):
>+        (foo.html.Element.prototype.get isContentEditable):
>+        (foo.html.Element.prototype.get lang):
>+        (foo.html.Element.prototype.set lang):
>+        (foo.html.Element.prototype.get spellcheck):
>+        (foo.html.Element.prototype.set spellcheck):
>+        (foo.html.Element.prototype.get style):
>+        (foo.html.Element.prototype.get tabIndex):
>+        (foo.html.Element.prototype.set tabIndex):
>+        (foo.html.Element.prototype.get title):
>+        (foo.html.Element.prototype.set title):
>+        (foo.html.Element.prototype.get translate):
>+        (foo.html.Element.prototype.set translate):
>+        (foo.html.Element.prototype.blur):
>+        (foo.html.Element.prototype.click):
>+        (foo.html.Element.prototype.focus):
>+        (foo.html.Element.prototype.get accessibleNode):
>+        (foo.html.Element.prototype.get assignedSlot):
>+        (foo.html.Element.prototype.get _attributes):
>+        (foo.html.Element.prototype.get className):
>+        (foo.html.Element.prototype.set className):
>+        (foo.html.Element.prototype.get clientHeight):
>+        (foo.html.Element.prototype.get clientLeft):
>+        (foo.html.Element.prototype.get clientTop):
>+        (foo.html.Element.prototype.get clientWidth):
>+        (foo.html.Element.prototype.get computedName):
>+        (foo.html.Element.prototype.get computedRole):
>+        (foo.html.Element.prototype.get id):
>+        (foo.html.Element.prototype.set id):
>+        (foo.html.Element.prototype.get _innerHtml):
>+        (foo.html.Element.prototype.set _innerHtml):
>+        (foo.html.Element.prototype.get innerText):
>+        (foo.html.Element.prototype.set innerText):
>+        (foo.html.Element.prototype.get _localName):
>+        (foo.html.Element.prototype.get _namespaceUri):
>+        (foo.html.Element.prototype.get outerHtml):
>+        (foo.html.Element.prototype.get _scrollHeight):
>+        (foo.html.Element.prototype.get _scrollLeft):
>+        (foo.html.Element.prototype.set _scrollLeft):
>+        (foo.html.Element.prototype.get _scrollTop):
>+        (foo.html.Element.prototype.set _scrollTop):
>+        (foo.html.Element.prototype.get _scrollWidth):
>+        (foo.html.Element.prototype.get slot):
>+        (foo.html.Element.prototype.set slot):
>+        (foo.html.Element.prototype.get styleMap):
>+        (foo.html.Element.prototype.get tagName):
>+        (foo.html.Element.prototype.attachShadow):
>+        (foo.html.Element.prototype._attachShadow_1):
>+        (foo.html.Element.prototype.closest):
>+        (foo.html.Element.prototype.getAnimations):
>+        (foo.html.Element.prototype._getAttribute):
>+        (foo.html.Element.prototype._getAttributeNS):
>+        (foo.html.Element.prototype.getAttributeNames):
>+        (foo.html.Element.prototype.getBoundingClientRect):
>+        (foo.html.Element.prototype._getClientRects):
>+        (foo.html.Element.prototype.getDestinationInsertionPoints):
>+        (foo.html.Element.prototype.getElementsByClassName):
>+        (foo.html.Element.prototype._getElementsByTagName):
>+        (foo.html.Element.prototype._hasAttribute):
>+        (foo.html.Element.prototype._hasAttributeNS):
>+        (foo.html.Element.prototype.hasPointerCapture):
>+        (foo.html.Element.prototype.releasePointerCapture):
>+        (foo.html.Element.prototype._removeAttribute):
>+        (foo.html.Element.prototype._removeAttributeNS):
>+        (foo.html.Element.prototype.requestPointerLock):
>+        (foo.html.Element.prototype.scroll):
>+        (foo.html.Element.prototype._scroll_1):
>+        (foo.html.Element.prototype._scroll_2):
>+        (foo.html.Element.prototype._scroll_3):
>+        (foo.html.Element.prototype.scrollBy):
>+        (foo.html.Element.prototype._scrollBy_1):
>+        (foo.html.Element.prototype._scrollBy_2):
>+        (foo.html.Element.prototype._scrollBy_3):
>+        (foo.html.Element.prototype._scrollIntoView):
>+        (foo.html.Element.prototype._scrollIntoViewIfNeeded):
>+        (foo.html.Element.prototype.scrollTo):
>+        (foo.html.Element.prototype._scrollTo_1):
>+        (foo.html.Element.prototype._scrollTo_2):
>+        (foo.html.Element.prototype._scrollTo_3):
>+        (foo.html.Element.prototype._setAttribute):
>+        (foo.html.Element.prototype._setAttributeNS):
>+        (foo.html.Element.prototype.setPointerCapture):
>+        (foo.html.Element.prototype.requestFullscreen):
>+        (foo.html.Element.prototype.after):
>+        (foo.html.Element.prototype.before):
>+        (foo.html.Element.prototype.get nextElementSibling):
>+        (foo.html.Element.prototype.get previousElementSibling):
>+        (foo.html.Element.prototype.get _childElementCount):
>+        (foo.html.Element.prototype.get _children):
>+        (foo.html.Element.prototype.get _firstElementChild):
>+        (foo.html.Element.prototype.get _lastElementChild):
>+        (foo.html.Element.prototype.querySelector):
>+        (foo.html.Element.prototype._querySelectorAll):
>+        (foo.html.Element.prototype.get onAbort):
>+        (foo.html.Element.prototype.get onBeforeCopy):
>+        (foo.html.Element.prototype.get onBeforeCut):
>+        (foo.html.Element.prototype.get onBeforePaste):
>+        (foo.html.Element.prototype.get onBlur):
>+        (foo.html.Element.prototype.get onCanPlay):
>+        (foo.html.Element.prototype.get onCanPlayThrough):
>+        (foo.html.Element.prototype.get onChange):
>+        (foo.html.Element.prototype.get onClick):
>+        (foo.html.Element.prototype.get onContextMenu):
>+        (foo.html.Element.prototype.get onCopy):
>+        (foo.html.Element.prototype.get onCut):
>+        (foo.html.Element.prototype.get onDoubleClick):
>+        (foo.html.Element.prototype.get onDrag):
>+        (foo.html.Element.prototype.get onDragEnd):
>+        (foo.html.Element.prototype.get onDragEnter):
>+        (foo.html.Element.prototype.get onDragLeave):
>+        (foo.html.Element.prototype.get onDragOver):
>+        (foo.html.Element.prototype.get onDragStart):
>+        (foo.html.Element.prototype.get onDrop):
>+        (foo.html.Element.prototype.get onDurationChange):
>+        (foo.html.Element.prototype.get onEmptied):
>+        (foo.html.Element.prototype.get onEnded):
>+        (foo.html.Element.prototype.get onError):
>+        (foo.html.Element.prototype.get onFocus):
>+        (foo.html.Element.prototype.get onInput):
>+        (foo.html.Element.prototype.get onInvalid):
>+        (foo.html.Element.prototype.get onKeyDown):
>+        (foo.html.Element.prototype.get onKeyPress):
>+        (foo.html.Element.prototype.get onKeyUp):
>+        (foo.html.Element.prototype.get onLoad):
>+        (foo.html.Element.prototype.get onLoadedData):
>+        (foo.html.Element.prototype.get onLoadedMetadata):
>+        (foo.html.Element.prototype.get onMouseDown):
>+        (foo.html.Element.prototype.get onMouseEnter):
>+        (foo.html.Element.prototype.get onMouseLeave):
>+        (foo.html.Element.prototype.get onMouseMove):
>+        (foo.html.Element.prototype.get onMouseOut):
>+        (foo.html.Element.prototype.get onMouseOver):
>+        (foo.html.Element.prototype.get onMouseUp):
>+        (foo.html.Element.prototype.get onMouseWheel):
>+        (foo.html.Element.prototype.get onPaste):
>+        (foo.html.Element.prototype.get onPause):
>+        (foo.html.Element.prototype.get onPlay):
>+        (foo.html.Element.prototype.get onPlaying):
>+        (foo.html.Element.prototype.get onRateChange):
>+        (foo.html.Element.prototype.get onReset):
>+        (foo.html.Element.prototype.get onResize):
>+        (foo.html.Element.prototype.get onScroll):
>+        (foo.html.Element.prototype.get onSearch):
>+        (foo.html.Element.prototype.get onSeeked):
>+        (foo.html.Element.prototype.get onSeeking):
>+        (foo.html.Element.prototype.get onSelect):
>+        (foo.html.Element.prototype.get onSelectStart):
>+        (foo.html.Element.prototype.get onStalled):
>+        (foo.html.Element.prototype.get onSubmit):
>+        (foo.html.Element.prototype.get onSuspend):
>+        (foo.html.Element.prototype.get onTimeUpdate):
>+        (foo.html.Element.prototype.get onTouchCancel):
>+        (foo.html.Element.prototype.get onTouchEnd):
>+        (foo.html.Element.prototype.get onTouchEnter):
>+        (foo.html.Element.prototype.get onTouchLeave):
>+        (foo.html.Element.prototype.get onTouchMove):
>+        (foo.html.Element.prototype.get onTouchStart):
>+        (foo.html.Element.prototype.get onTransitionEnd):
>+        (foo.html.Element.prototype.get onVolumeChange):
>+        (foo.html.Element.prototype.get onWaiting):
>+        (foo.html.Element.prototype.get onFullscreenChange):
>+        (foo.html.Element.prototype.get onFullscreenError):
>+        (foo.html.Element.prototype.get onWheel):
>+        (foo.html.Element):
>+        (foo.get html):
>+        (foo.html.HtmlElement.new):
>+        (foo.html.HtmlElement.prototype.get nonce):
>+        (foo.html.HtmlElement.prototype.set nonce):
>+        (foo.html.HtmlElement):
>+        (foo.get html.ExtendableEvent.new):
>+        (foo.get html.ExtendableEvent._create_1):
>+        (foo.get html.ExtendableEvent._create_2):
>+        (foo.get html.ExtendableEvent.prototype.waitUntil):
>+        (foo.get html.ExtendableEvent):
>+        (foo.html.AbortPaymentEvent.new):
>+        (foo.html.AbortPaymentEvent._create_1):
>+        (foo.html.AbortPaymentEvent.prototype.respondWith):
>+        (foo.html.AbortPaymentEvent):
>+        (foo.html.Sensor.prototype.get activated):
>+        (foo.html.Sensor.prototype.get hasReading):
>+        (foo.html.Sensor.prototype.get timestamp):
>+        (foo.html.Sensor.prototype.start):
>+        (foo.html.Sensor.prototype.stop):
>+        (foo.html.Sensor.prototype.get onError):
>+        (foo.html.Sensor):
>+        (foo.html.OrientationSensor.prototype.get quaternion):
>+        (foo.html.OrientationSensor.prototype.populateMatrix):
>+        (foo.html.OrientationSensor):
>+        (foo.html.AbsoluteOrientationSensor.new):
>+        (foo.html.AbsoluteOrientationSensor._create_1):
>+        (foo.html.AbsoluteOrientationSensor._create_2):
>+        (foo.html.AbsoluteOrientationSensor):
>+        (foo.html.AbstractWorker.prototype.get onError):
>+        (foo.html.AbstractWorker):
>+        (foo.get html.Accelerometer.new):
>+        (foo.get html.Accelerometer._create_1):
>+        (foo.get html.Accelerometer._create_2):
>+        (foo.get html.Accelerometer.prototype.get x):
>+        (foo.get html.Accelerometer.prototype.get y):
>+        (foo.get html.Accelerometer.prototype.get z):
>+        (foo.get html.Accelerometer):
>+        (foo.html.AccessibleNode.new):
>+        (foo.html.AccessibleNode._create_1):
>+        (foo.html.AccessibleNode.prototype.get activeDescendant):
>+        (foo.html.AccessibleNode.prototype.set activeDescendant):
>+        (foo.html.AccessibleNode.prototype.get atomic):
>+        (foo.html.AccessibleNode.prototype.set atomic):
>+        (foo.html.AccessibleNode.prototype.get autocomplete):
>+        (foo.html.AccessibleNode.prototype.set autocomplete):
>+        (foo.html.AccessibleNode.prototype.get busy):
>+        (foo.html.AccessibleNode.prototype.set busy):
>+        (foo.html.AccessibleNode.prototype.get checked):
>+        (foo.html.AccessibleNode.prototype.set checked):
>+        (foo.html.AccessibleNode.prototype.get colCount):
>+        (foo.html.AccessibleNode.prototype.set colCount):
>+        (foo.html.AccessibleNode.prototype.get colIndex):
>+        (foo.html.AccessibleNode.prototype.set colIndex):
>+        (foo.html.AccessibleNode.prototype.get colSpan):
>+        (foo.html.AccessibleNode.prototype.set colSpan):
>+        (foo.html.AccessibleNode.prototype.get controls):
>+        (foo.html.AccessibleNode.prototype.set controls):
>+        (foo.html.AccessibleNode.prototype.get current):
>+        (foo.html.AccessibleNode.prototype.set current):
>+        (foo.html.AccessibleNode.prototype.get describedBy):
>+        (foo.html.AccessibleNode.prototype.set describedBy):
>+        (foo.html.AccessibleNode.prototype.get details):
>+        (foo.html.AccessibleNode.prototype.set details):
>+        (foo.html.AccessibleNode.prototype.get disabled):
>+        (foo.html.AccessibleNode.prototype.set disabled):
>+        (foo.html.AccessibleNode.prototype.get errorMessage):
>+        (foo.html.AccessibleNode.prototype.set errorMessage):
>+        (foo.html.AccessibleNode.prototype.get expanded):
>+        (foo.html.AccessibleNode.prototype.set expanded):
>+        (foo.html.AccessibleNode.prototype.get flowTo):
>+        (foo.html.AccessibleNode.prototype.set flowTo):
>+        (foo.html.AccessibleNode.prototype.get hasPopUp):
>+        (foo.html.AccessibleNode.prototype.set hasPopUp):
>+        (foo.html.AccessibleNode.prototype.get hidden):
>+        (foo.html.AccessibleNode.prototype.set hidden):
>+        (foo.html.AccessibleNode.prototype.get invalid):
>+        (foo.html.AccessibleNode.prototype.set invalid):
>+        (foo.html.AccessibleNode.prototype.get keyShortcuts):
>+        (foo.html.AccessibleNode.prototype.set keyShortcuts):
>+        (foo.html.AccessibleNode.prototype.get label):
>+        (foo.html.AccessibleNode.prototype.set label):
>+        (foo.html.AccessibleNode.prototype.get labeledBy):
>+        (foo.html.AccessibleNode.prototype.set labeledBy):
>+        (foo.html.AccessibleNode.prototype.get level):
>+        (foo.html.AccessibleNode.prototype.set level):
>+        (foo.html.AccessibleNode.prototype.get live):
>+        (foo.html.AccessibleNode.prototype.set live):
>+        (foo.html.AccessibleNode.prototype.get modal):
>+        (foo.html.AccessibleNode.prototype.set modal):
>+        (foo.html.AccessibleNode.prototype.get multiline):
>+        (foo.html.AccessibleNode.prototype.set multiline):
>+        (foo.html.AccessibleNode.prototype.get multiselectable):
>+        (foo.html.AccessibleNode.prototype.set multiselectable):
>+        (foo.html.AccessibleNode.prototype.get orientation):
>+        (foo.html.AccessibleNode.prototype.set orientation):
>+        (foo.html.AccessibleNode.prototype.get owns):
>+        (foo.html.AccessibleNode.prototype.set owns):
>+        (foo.html.AccessibleNode.prototype.get placeholder):
>+        (foo.html.AccessibleNode.prototype.set placeholder):
>+        (foo.html.AccessibleNode.prototype.get posInSet):
>+        (foo.html.AccessibleNode.prototype.set posInSet):
>+        (foo.html.AccessibleNode.prototype.get pressed):
>+        (foo.html.AccessibleNode.prototype.set pressed):
>+        (foo.html.AccessibleNode.prototype.get readOnly):
>+        (foo.html.AccessibleNode.prototype.set readOnly):
>+        (foo.html.AccessibleNode.prototype.get relevant):
>+        (foo.html.AccessibleNode.prototype.set relevant):
>+        (foo.html.AccessibleNode.prototype.get required):
>+        (foo.html.AccessibleNode.prototype.set required):
>+        (foo.html.AccessibleNode.prototype.get role):
>+        (foo.html.AccessibleNode.prototype.set role):
>+        (foo.html.AccessibleNode.prototype.get roleDescription):
>+        (foo.html.AccessibleNode.prototype.set roleDescription):
>+        (foo.html.AccessibleNode.prototype.get rowCount):
>+        (foo.html.AccessibleNode.prototype.set rowCount):
>+        (foo.html.AccessibleNode.prototype.get rowIndex):
>+        (foo.html.AccessibleNode.prototype.set rowIndex):
>+        (foo.html.AccessibleNode.prototype.get rowSpan):
>+        (foo.html.AccessibleNode.prototype.set rowSpan):
>+        (foo.html.AccessibleNode.prototype.get selected):
>+        (foo.html.AccessibleNode.prototype.set selected):
>+        (foo.html.AccessibleNode.prototype.get setSize):
>+        (foo.html.AccessibleNode.prototype.set setSize):
>+        (foo.html.AccessibleNode.prototype.get sort):
>+        (foo.html.AccessibleNode.prototype.set sort):
>+        (foo.html.AccessibleNode.prototype.get valueMax):
>+        (foo.html.AccessibleNode.prototype.set valueMax):
>+        (foo.html.AccessibleNode.prototype.get valueMin):
>+        (foo.html.AccessibleNode.prototype.set valueMin):
>+        (foo.html.AccessibleNode.prototype.get valueNow):
>+        (foo.html.AccessibleNode.prototype.set valueNow):
>+        (foo.html.AccessibleNode.prototype.get valueText):
>+        (foo.html.AccessibleNode.prototype.set valueText):
>+        (foo.html.AccessibleNode.prototype.appendChild):
>+        (foo.html.AccessibleNode.prototype.get onAccessibleClick):
>+        (foo.html.AccessibleNode.prototype.get onAccessibleContextMenu):
>+        (foo.html.AccessibleNode.prototype.get onAccessibleDecrement):
>+        (foo.html.AccessibleNode.prototype.get onAccessibleFocus):
>+        (foo.html.AccessibleNode.prototype.get onAccessibleIncrement):
>+        (foo.html.AccessibleNode.prototype.get onAccessibleScrollIntoView):
>+        (foo.html.AccessibleNode):
>+        (foo.html.AccessibleNodeList.new):
>+        (foo.html.AccessibleNodeList._create_1):
>+        (foo.html.AccessibleNodeList._create_2):
>+        (foo.html.AccessibleNodeList.prototype.get length):
>+        (foo.html.AccessibleNodeList.prototype.set length):
>+        (foo.html.AccessibleNodeList.prototype.__setter__):
>+        (foo.html.AccessibleNodeList.prototype.add):
>+        (foo.html.AccessibleNodeList.prototype.item):
>+        (foo.html.AccessibleNodeList.prototype.remove):
>+        (foo.html.AccessibleNodeList):
>+        (foo.html.AmbientLightSensor.new):
>+        (foo.html.AmbientLightSensor._create_1):
>+        (foo.html.AmbientLightSensor._create_2):
>+        (foo.html.AmbientLightSensor.prototype.get illuminance):
>+        (foo.html.AmbientLightSensor):
>+        (foo.html.AnchorElement.new):
>+        (foo.html.AnchorElement.prototype.get download):
>+        (foo.html.AnchorElement.prototype.set download):
>+        (foo.html.AnchorElement.prototype.get hreflang):
>+        (foo.html.AnchorElement.prototype.set hreflang):
>+        (foo.html.AnchorElement.prototype.get referrerPolicy):
>+        (foo.html.AnchorElement.prototype.set referrerPolicy):
>+        (foo.html.AnchorElement.prototype.get rel):
>+        (foo.html.AnchorElement.prototype.set rel):
>+        (foo.html.AnchorElement.prototype.get target):
>+        (foo.html.AnchorElement.prototype.set target):
>+        (foo.html.AnchorElement.prototype.get type):
>+        (foo.html.AnchorElement.prototype.set type):
>+        (foo.html.AnchorElement.prototype.get hash):
>+        (foo.html.AnchorElement.prototype.set hash):
>+        (foo.html.AnchorElement.prototype.get host):
>+        (foo.html.AnchorElement.prototype.set host):
>+        (foo.html.AnchorElement.prototype.get hostname):
>+        (foo.html.AnchorElement.prototype.set hostname):
>+        (foo.html.AnchorElement.prototype.get href):
>+        (foo.html.AnchorElement.prototype.set href):
>+        (foo.html.AnchorElement.prototype.get origin):
>+        (foo.html.AnchorElement.prototype.get password):
>+        (foo.html.AnchorElement.prototype.set password):
>+        (foo.html.AnchorElement.prototype.get pathname):
>+        (foo.html.AnchorElement.prototype.set pathname):
>+        (foo.html.AnchorElement.prototype.get port):
>+        (foo.html.AnchorElement.prototype.set port):
>+        (foo.html.AnchorElement.prototype.get protocol):
>+        (foo.html.AnchorElement.prototype.set protocol):
>+        (foo.html.AnchorElement.prototype.get search):
>+        (foo.html.AnchorElement.prototype.set search):
>+        (foo.html.AnchorElement.prototype.get username):
>+        (foo.html.AnchorElement.prototype.set username):
>+        (foo.html.AnchorElement.prototype.toString):
>+        (foo.html.AnchorElement):
>+        (foo.html.Animation.new):
>+        (foo.html.Animation._create_1):
>+        (foo.html.Animation._create_2):
>+        (foo.html.Animation._create_3):
>+        (foo.html.Animation.get supported):
>+        (foo.html.Animation.prototype.get currentTime):
>+        (foo.html.Animation.prototype.set currentTime):
>+        (foo.html.Animation.prototype.get effect):
>+        (foo.html.Animation.prototype.set effect):
>+        (foo.html.Animation.prototype.get finished):
>+        (foo.html.Animation.prototype.get id):
>+        (foo.html.Animation.prototype.set id):
>+        (foo.html.Animation.prototype.get playState):
>+        (foo.html.Animation.prototype.get playbackRate):
>+        (foo.html.Animation.prototype.set playbackRate):
>+        (foo.html.Animation.prototype.get ready):
>+        (foo.html.Animation.prototype.get startTime):
>+        (foo.html.Animation.prototype.set startTime):
>+        (foo.html.Animation.prototype.get timeline):
>+        (foo.html.Animation.prototype.cancel):
>+        (foo.html.Animation.prototype.finish):
>+        (foo.html.Animation.prototype.pause):
>+        (foo.html.Animation.prototype.play):
>+        (foo.html.Animation.prototype.reverse):
>+        (foo.html.Animation.prototype.get onCancel):
>+        (foo.html.Animation.prototype.get onFinish):
>+        (foo.html.Animation):
>+        (foo.html.AnimationEffectReadOnly.prototype.get timing):
>+        (foo.html.AnimationEffectReadOnly.prototype.getComputedTiming):
>+        (foo.html.AnimationEffectReadOnly.prototype._getComputedTiming_1):
>+        (foo.html.AnimationEffectReadOnly):
>+        (foo.html.AnimationEffectTimingReadOnly.prototype.get delay):
>+        (foo.html.AnimationEffectTimingReadOnly.prototype.get direction):
>+        (foo.html.AnimationEffectTimingReadOnly.prototype.get duration):
>+        (foo.html.AnimationEffectTimingReadOnly.prototype.get easing):
>+        (foo.html.AnimationEffectTimingReadOnly.prototype.get endDelay):
>+        (foo.html.AnimationEffectTimingReadOnly.prototype.get fill):
>+        (foo.html.AnimationEffectTimingReadOnly.prototype.get iterationStart):
>+        (foo.html.AnimationEffectTimingReadOnly.prototype.get iterations):
>+        (foo.html.AnimationEffectTimingReadOnly):
>+        (foo.html.AnimationEffectTiming.prototype.get delay):
>+        (foo.html.AnimationEffectTiming.prototype.set delay):
>+        (foo.html.AnimationEffectTiming.prototype.get direction):
>+        (foo.html.AnimationEffectTiming.prototype.set direction):
>+        (foo.html.AnimationEffectTiming.prototype.get duration):
>+        (foo.html.AnimationEffectTiming.prototype.set duration):
>+        (foo.html.AnimationEffectTiming.prototype.get easing):
>+        (foo.html.AnimationEffectTiming.prototype.set easing):
>+        (foo.html.AnimationEffectTiming.prototype.get endDelay):
>+        (foo.html.AnimationEffectTiming.prototype.set endDelay):
>+        (foo.html.AnimationEffectTiming.prototype.get fill):
>+        (foo.html.AnimationEffectTiming.prototype.set fill):
>+        (foo.html.AnimationEffectTiming.prototype.get iterationStart):
>+        (foo.html.AnimationEffectTiming.prototype.set iterationStart):
>+        (foo.html.AnimationEffectTiming.prototype.get iterations):
>+        (foo.html.AnimationEffectTiming.prototype.set iterations):
>+        (foo.html.AnimationEffectTiming):
>+        (foo.html.AnimationEvent.new):
>+        (foo.html.AnimationEvent._create_1):
>+        (foo.html.AnimationEvent._create_2):
>+        (foo.html.AnimationEvent.prototype.get animationName):
>+        (foo.html.AnimationEvent.prototype.get elapsedTime):
>+        (foo.html.AnimationEvent):
>+        (foo.html.AnimationPlaybackEvent.new):
>+        (foo.html.AnimationPlaybackEvent._create_1):
>+        (foo.html.AnimationPlaybackEvent._create_2):
>+        (foo.html.AnimationPlaybackEvent.prototype.get currentTime):
>+        (foo.html.AnimationPlaybackEvent.prototype.get timelineTime):
>+        (foo.html.AnimationPlaybackEvent):
>+        (foo.html.AnimationTimeline.prototype.get currentTime):
>+        (foo.html.AnimationTimeline):
>+        (foo.html.WorkletGlobalScope):
>+        (foo.html.AnimationWorkletGlobalScope.prototype.registerAnimator):
>+        (foo.html.AnimationWorkletGlobalScope):
>+        (foo.html.ApplicationCache.get supported):
>+        (foo.html.ApplicationCache.prototype.get status):
>+        (foo.html.ApplicationCache.prototype.abort):
>+        (foo.html.ApplicationCache.prototype.swapCache):
>+        (foo.html.ApplicationCache.prototype.update):
>+        (foo.html.ApplicationCache.prototype.get onCached):
>+        (foo.html.ApplicationCache.prototype.get onChecking):
>+        (foo.html.ApplicationCache.prototype.get onDownloading):
>+        (foo.html.ApplicationCache.prototype.get onError):
>+        (foo.html.ApplicationCache.prototype.get onNoUpdate):
>+        (foo.html.ApplicationCache.prototype.get onObsolete):
>+        (foo.html.ApplicationCache.prototype.get onProgress):
>+        (foo.html.ApplicationCache.prototype.get onUpdateReady):
>+        (foo.html.ApplicationCache):
>+        (foo.html.ApplicationCacheErrorEvent.new):
>+        (foo.html.ApplicationCacheErrorEvent._create_1):
>+        (foo.html.ApplicationCacheErrorEvent._create_2):
>+        (foo.html.ApplicationCacheErrorEvent.prototype.get message):
>+        (foo.html.ApplicationCacheErrorEvent.prototype.get reason):
>+        (foo.html.ApplicationCacheErrorEvent.prototype.get status):
>+        (foo.html.ApplicationCacheErrorEvent.prototype.get url):
>+        (foo.html.ApplicationCacheErrorEvent):
>+        (foo.html.AreaElement.new):
>+        (foo.html.AreaElement.prototype.get alt):
>+        (foo.html.AreaElement.prototype.set alt):
>+        (foo.html.AreaElement.prototype.get coords):
>+        (foo.html.AreaElement.prototype.set coords):
>+        (foo.html.AreaElement.prototype.get download):
>+        (foo.html.AreaElement.prototype.set download):
>+        (foo.html.AreaElement.prototype.get referrerPolicy):
>+        (foo.html.AreaElement.prototype.set referrerPolicy):
>+        (foo.html.AreaElement.prototype.get rel):
>+        (foo.html.AreaElement.prototype.set rel):
>+        (foo.html.AreaElement.prototype.get shape):
>+        (foo.html.AreaElement.prototype.set shape):
>+        (foo.html.AreaElement.prototype.get target):
>+        (foo.html.AreaElement.prototype.set target):
>+        (foo.html.AreaElement.prototype.get hash):
>+        (foo.html.AreaElement.prototype.set hash):
>+        (foo.html.AreaElement.prototype.get host):
>+        (foo.html.AreaElement.prototype.set host):
>+        (foo.html.AreaElement.prototype.get hostname):
>+        (foo.html.AreaElement.prototype.set hostname):
>+        (foo.html.AreaElement.prototype.get href):
>+        (foo.html.AreaElement.prototype.set href):
>+        (foo.html.AreaElement.prototype.get origin):
>+        (foo.html.AreaElement.prototype.get password):
>+        (foo.html.AreaElement.prototype.set password):
>+        (foo.html.AreaElement.prototype.get pathname):
>+        (foo.html.AreaElement.prototype.set pathname):
>+        (foo.html.AreaElement.prototype.get port):
>+        (foo.html.AreaElement.prototype.set port):
>+        (foo.html.AreaElement.prototype.get protocol):
>+        (foo.html.AreaElement.prototype.set protocol):
>+        (foo.html.AreaElement.prototype.get search):
>+        (foo.html.AreaElement.prototype.set search):
>+        (foo.html.AreaElement.prototype.get username):
>+        (foo.html.AreaElement.prototype.set username):
>+        (foo.html.AreaElement.prototype.toString):
>+        (foo.html.AreaElement):
>+        (foo.html.MediaElement.prototype.get audioTracks):
>+        (foo.html.MediaElement.prototype.get autoplay):
>+        (foo.html.MediaElement.prototype.set autoplay):
>+        (foo.html.MediaElement.prototype.get buffered):
>+        (foo.html.MediaElement.prototype.get controls):
>+        (foo.html.MediaElement.prototype.set controls):
>+        (foo.html.MediaElement.prototype.get controlsList):
>+        (foo.html.MediaElement.prototype.get crossOrigin):
>+        (foo.html.MediaElement.prototype.set crossOrigin):
>+        (foo.html.MediaElement.prototype.get currentSrc):
>+        (foo.html.MediaElement.prototype.get currentTime):
>+        (foo.html.MediaElement.prototype.set currentTime):
>+        (foo.html.MediaElement.prototype.get defaultMuted):
>+        (foo.html.MediaElement.prototype.set defaultMuted):
>+        (foo.html.MediaElement.prototype.get defaultPlaybackRate):
>+        (foo.html.MediaElement.prototype.set defaultPlaybackRate):
>+        (foo.html.MediaElement.prototype.get disableRemotePlayback):
>+        (foo.html.MediaElement.prototype.set disableRemotePlayback):
>+        (foo.html.MediaElement.prototype.get duration):
>+        (foo.html.MediaElement.prototype.get ended):
>+        (foo.html.MediaElement.prototype.get error):
>+        (foo.html.MediaElement.prototype.get loop):
>+        (foo.html.MediaElement.prototype.set loop):
>+        (foo.html.MediaElement.prototype.get mediaKeys):
>+        (foo.html.MediaElement.prototype.get muted):
>+        (foo.html.MediaElement.prototype.set muted):
>+        (foo.html.MediaElement.prototype.get networkState):
>+        (foo.html.MediaElement.prototype.get paused):
>+        (foo.html.MediaElement.prototype.get playbackRate):
>+        (foo.html.MediaElement.prototype.set playbackRate):
>+        (foo.html.MediaElement.prototype.get played):
>+        (foo.html.MediaElement.prototype.get preload):
>+        (foo.html.MediaElement.prototype.set preload):
>+        (foo.html.MediaElement.prototype.get readyState):
>+        (foo.html.MediaElement.prototype.get remote):
>+        (foo.html.MediaElement.prototype.get seekable):
>+        (foo.html.MediaElement.prototype.get seeking):
>+        (foo.html.MediaElement.prototype.get sinkId):
>+        (foo.html.MediaElement.prototype.get src):
>+        (foo.html.MediaElement.prototype.set src):
>+        (foo.html.MediaElement.prototype.get srcObject):
>+        (foo.html.MediaElement.prototype.set srcObject):
>+        (foo.html.MediaElement.prototype.get textTracks):
>+        (foo.html.MediaElement.prototype.get videoTracks):
>+        (foo.html.MediaElement.prototype.get volume):
>+        (foo.html.MediaElement.prototype.set volume):
>+        (foo.html.MediaElement.prototype.get audioDecodedByteCount):
>+        (foo.html.MediaElement.prototype.get videoDecodedByteCount):
>+        (foo.html.MediaElement.prototype.addTextTrack):
>+        (foo.html.MediaElement.prototype.canPlayType):
>+        (foo.html.MediaElement.prototype.captureStream):
>+        (foo.html.MediaElement.prototype.load):
>+        (foo.html.MediaElement.prototype.pause):
>+        (foo.html.MediaElement.prototype.play):
>+        (foo.html.MediaElement.prototype.setMediaKeys):
>+        (foo.html.MediaElement.prototype.setSinkId):
>+        (foo.html.MediaElement):
>+        (foo.html.AudioElement.__):
>+        (foo.html.AudioElement._create_1):
>+        (foo.html.AudioElement._create_2):
>+        (foo.html.AudioElement.new):
>+        (foo.html.AudioElement):
>+        (foo.html.AuthenticatorResponse.prototype.get clientDataJson):
>+        (foo.html.AuthenticatorResponse):
>+        (foo.html.AuthenticatorAssertionResponse.prototype.get authenticatorData):
>+        (foo.html.AuthenticatorAssertionResponse.prototype.get signature):
>+        (foo.html.AuthenticatorAssertionResponse):
>+        (foo.html.AuthenticatorAttestationResponse.prototype.get attestationObject):
>+        (foo.html.AuthenticatorAttestationResponse):
>+        (foo.html.BRElement.new):
>+        (foo.html.BRElement):
>+        (foo.html.BackgroundFetchEvent.new):
>+        (foo.html.BackgroundFetchEvent._create_1):
>+        (foo.html.BackgroundFetchEvent.prototype.get id):
>+        (foo.html.BackgroundFetchEvent):
>+        (foo.html.BackgroundFetchClickEvent.new):
>+        (foo.html.BackgroundFetchClickEvent._create_1):
>+        (foo.html.BackgroundFetchClickEvent.prototype.get state):
>+        (foo.html.BackgroundFetchClickEvent):
>+        (foo.html.BackgroundFetchFailEvent.new):
>+        (foo.html.BackgroundFetchFailEvent._create_1):
>+        (foo.html.BackgroundFetchFailEvent.prototype.get fetches):
>+        (foo.html.BackgroundFetchFailEvent):
>+        (foo.html.BackgroundFetchFetch.prototype.get request):
>+        (foo.html.BackgroundFetchFetch):
>+        (foo.html.BackgroundFetchManager.prototype.fetch):
>+        (foo.html.BackgroundFetchRegistration.prototype.get downloadTotal):
>+        (foo.html.BackgroundFetchRegistration.prototype.get downloaded):
>+        (foo.html.BackgroundFetchRegistration.prototype.get id):
>+        (foo.html.BackgroundFetchRegistration.prototype.get title):
>+        (foo.html.BackgroundFetchRegistration.prototype.get totalDownloadSize):
>+        (foo.html.BackgroundFetchRegistration.prototype.get uploadTotal):
>+        (foo.html.BackgroundFetchRegistration.prototype.get uploaded):
>+        (foo.html.BackgroundFetchRegistration.prototype.abort):
>+        (foo.html.BackgroundFetchRegistration):
>+        (foo.html.BackgroundFetchSettledFetch.new):
>+        (foo.html.BackgroundFetchSettledFetch._create_1):
>+        (foo.html.BackgroundFetchSettledFetch.prototype.get response):
>+        (foo.html.BackgroundFetchSettledFetch):
>+        (foo.html.BackgroundFetchedEvent.new):
>+        (foo.html.BackgroundFetchedEvent._create_1):
>+        (foo.html.BackgroundFetchedEvent.prototype.get fetches):
>+        (foo.html.BackgroundFetchedEvent.prototype.updateUI):
>+        (foo.html.BackgroundFetchedEvent):
>+        (foo.html.BarProp.prototype.get visible):
>+        (foo.html.BarProp):
>+        (foo.html.BarcodeDetector.new):
>+        (foo.html.BarcodeDetector._create_1):
>+        (foo.html.BarcodeDetector.prototype.detect):
>+        (foo.html.BarcodeDetector):
>+        (foo.html.BaseElement.new):
>+        (foo.html.BaseElement.prototype.get href):
>+        (foo.html.BaseElement.prototype.set href):
>+        (foo.html.BaseElement.prototype.get target):
>+        (foo.html.BaseElement.prototype.set target):
>+        (foo.html.BaseElement):
>+        (foo.html.BatteryManager.prototype.get charging):
>+        (foo.html.BatteryManager.prototype.get chargingTime):
>+        (foo.html.BatteryManager.prototype.get dischargingTime):
>+        (foo.html.BatteryManager.prototype.get level):
>+        (foo.html.BatteryManager):
>+        (foo.html.BeforeInstallPromptEvent.new):
>+        (foo.html.BeforeInstallPromptEvent._create_1):
>+        (foo.html.BeforeInstallPromptEvent._create_2):
>+        (foo.html.BeforeInstallPromptEvent.prototype.get platforms):
>+        (foo.html.BeforeInstallPromptEvent.prototype.get userChoice):
>+        (foo.html.BeforeInstallPromptEvent.prototype.prompt):
>+        (foo.html.BeforeInstallPromptEvent):
>+        (foo.html.BeforeUnloadEvent.prototype.get returnValue):
>+        (foo.html.BeforeUnloadEvent.prototype.set returnValue):
>+        (foo.html.BeforeUnloadEvent):
>+        (foo.html.Blob.prototype.get size):
>+        (foo.html.Blob.prototype.get type):
>+        (foo.html.Blob.prototype.slice):
>+        (foo.html.Blob.new):
>+        (foo.html.Blob._create_1):
>+        (foo.html.Blob._create_2):
>+        (foo.html.Blob._create_bag):
>+        (foo.html.Blob._bag_set):
>+        (foo.html.Blob):
>+        (foo.html.BlobEvent.new):
>+        (foo.html.BlobEvent._create_1):
>+        (foo.html.BlobEvent.prototype.get data):
>+        (foo.html.BlobEvent.prototype.get timecode):
>+        (foo.html.BlobEvent):
>+        (foo.html.BluetoothRemoteGattDescriptor.prototype.get characteristic):
>+        (foo.html.BluetoothRemoteGattDescriptor.prototype.get uuid):
>+        (foo.html.BluetoothRemoteGattDescriptor.prototype.get value):
>+        (foo.html.BluetoothRemoteGattDescriptor.prototype.readValue):
>+        (foo.html.BluetoothRemoteGattDescriptor.prototype.writeValue):
>+        (foo.html.BluetoothRemoteGattDescriptor):
>+        (foo.html.Body.prototype.get bodyUsed):
>+        (foo.html.Body.prototype.arrayBuffer):
>+        (foo.html.Body.prototype.blob):
>+        (foo.html.Body.prototype.formData):
>+        (foo.html.Body.prototype.json):
>+        (foo.html.Body.prototype.text):
>+        (foo.html.Body):
>+        (foo.html.BodyElement.new):
>+        (foo.html.BodyElement.prototype.get onBlur):
>+        (foo.html.BodyElement.prototype.get onError):
>+        (foo.html.BodyElement.prototype.get onFocus):
>+        (foo.html.BodyElement.prototype.get onHashChange):
>+        (foo.html.BodyElement.prototype.get onLoad):
>+        (foo.html.BodyElement.prototype.get onMessage):
>+        (foo.html.BodyElement.prototype.get onOffline):
>+        (foo.html.BodyElement.prototype.get onOnline):
>+        (foo.html.BodyElement.prototype.get onPopState):
>+        (foo.html.BodyElement.prototype.get onResize):
>+        (foo.html.BodyElement.prototype.get onScroll):
>+        (foo.html.BodyElement.prototype.get onStorage):
>+        (foo.html.BodyElement.prototype.get onUnload):
>+        (foo.html.BodyElement):
>+        (foo.html.BroadcastChannel.new):
>+        (foo.html.BroadcastChannel._create_1):
>+        (foo.html.BroadcastChannel.prototype.get name):
>+        (foo.html.BroadcastChannel.prototype.close):
>+        (foo.html.BroadcastChannel.prototype.postMessage):
>+        (foo.html.BroadcastChannel.prototype.get onMessage):
>+        (foo.html.BroadcastChannel):
>+        (foo.html.BudgetState.prototype.get budgetAt):
>+        (foo.html.BudgetState.prototype.get time):
>+        (foo.html.BudgetState):
>+        (foo.html.ButtonElement.new):
>+        (foo.html.ButtonElement.prototype.get autofocus):
>+        (foo.html.ButtonElement.prototype.set autofocus):
>+        (foo.html.ButtonElement.prototype.get disabled):
>+        (foo.html.ButtonElement.prototype.set disabled):
>+        (foo.html.ButtonElement.prototype.get form):
>+        (foo.html.ButtonElement.prototype.get formAction):
>+        (foo.html.ButtonElement.prototype.set formAction):
>+        (foo.html.ButtonElement.prototype.get formEnctype):
>+        (foo.html.ButtonElement.prototype.set formEnctype):
>+        (foo.html.ButtonElement.prototype.get formMethod):
>+        (foo.html.ButtonElement.prototype.set formMethod):
>+        (foo.html.ButtonElement.prototype.get formNoValidate):
>+        (foo.html.ButtonElement.prototype.set formNoValidate):
>+        (foo.html.ButtonElement.prototype.get formTarget):
>+        (foo.html.ButtonElement.prototype.set formTarget):
>+        (foo.html.ButtonElement.prototype.get labels):
>+        (foo.html.ButtonElement.prototype.get name):
>+        (foo.html.ButtonElement.prototype.set name):
>+        (foo.html.ButtonElement.prototype.get type):
>+        (foo.html.ButtonElement.prototype.set type):
>+        (foo.html.ButtonElement.prototype.get validationMessage):
>+        (foo.html.ButtonElement.prototype.get validity):
>+        (foo.html.ButtonElement.prototype.get value):
>+        (foo.html.ButtonElement.prototype.set value):
>+        (foo.html.ButtonElement.prototype.get willValidate):
>+        (foo.html.ButtonElement.prototype.checkValidity):
>+        (foo.html.ButtonElement.prototype.reportValidity):
>+        (foo.html.ButtonElement.prototype.setCustomValidity):
>+        (foo.html.ButtonElement):
>+        (foo.html.CharacterData.prototype.get data):
>+        (foo.html.CharacterData.prototype.set data):
>+        (foo.html.CharacterData.prototype.get length):
>+        (foo.html.CharacterData.prototype.appendData):
>+        (foo.html.CharacterData.prototype.deleteData):
>+        (foo.html.CharacterData.prototype.insertData):
>+        (foo.html.CharacterData.prototype.replaceData):
>+        (foo.html.CharacterData.prototype.substringData):
>+        (foo.html.CharacterData.prototype.after):
>+        (foo.html.CharacterData.prototype.before):
>+        (foo.html.CharacterData.prototype.get nextElementSibling):
>+        (foo.html.CharacterData.prototype.get previousElementSibling):
>+        (foo.html.CharacterData):
>+        (foo.html.Text.new):
>+        (foo.html.Text.prototype.get assignedSlot):
>+        (foo.html.Text.prototype.get wholeText):
>+        (foo.html.Text.prototype.getDestinationInsertionPoints):
>+        (foo.html.Text.prototype.splitText):
>+        (foo.html.Text):
>+        (foo.html.CDataSection):
>+        (foo.html.CacheStorage.prototype.delete):
>+        (foo.html.CacheStorage.prototype.has):
>+        (foo.html.CacheStorage.prototype.keys):
>+        (foo.html.CacheStorage.prototype.match):
>+        (foo.html.CacheStorage.prototype.open):
>+        (foo.html.CacheStorage):
>+        (foo.html.CanMakePaymentEvent.new):
>+        (foo.html.CanMakePaymentEvent._create_1):
>+        (foo.html.CanMakePaymentEvent.prototype.get methodData):
>+        (foo.html.CanMakePaymentEvent.prototype.get modifiers):
>+        (foo.html.CanMakePaymentEvent.prototype.get paymentRequestOrigin):
>+        (foo.html.CanMakePaymentEvent.prototype.get topLevelOrigin):
>+        (foo.html.CanMakePaymentEvent.prototype.respondWith):
>+        (foo.html.CanMakePaymentEvent):
>+        (foo.html.MediaStreamTrack.prototype.get contentHint):
>+        (foo.html.MediaStreamTrack.prototype.set contentHint):
>+        (foo.html.MediaStreamTrack.prototype.get enabled):
>+        (foo.html.MediaStreamTrack.prototype.set enabled):
>+        (foo.html.MediaStreamTrack.prototype.get id):
>+        (foo.html.MediaStreamTrack.prototype.get kind):
>+        (foo.html.MediaStreamTrack.prototype.get label):
>+        (foo.html.MediaStreamTrack.prototype.get muted):
>+        (foo.html.MediaStreamTrack.prototype.get readyState):
>+        (foo.html.MediaStreamTrack.prototype.applyConstraints):
>+        (foo.html.MediaStreamTrack.prototype.clone):
>+        (foo.html.MediaStreamTrack.prototype.getCapabilities):
>+        (foo.html.MediaStreamTrack.prototype._getCapabilities_1):
>+        (foo.html.MediaStreamTrack.prototype.getConstraints):
>+        (foo.html.MediaStreamTrack.prototype._getConstraints_1):
>+        (foo.html.MediaStreamTrack.prototype.getSettings):
>+        (foo.html.MediaStreamTrack.prototype._getSettings_1):
>+        (foo.html.MediaStreamTrack.prototype.stop):
>+        (foo.html.MediaStreamTrack.prototype.get onEnded):
>+        (foo.html.MediaStreamTrack.prototype.get onMute):
>+        (foo.html.MediaStreamTrack.prototype.get onUnmute):
>+        (foo.html.MediaStreamTrack):
>+        (foo.html.CanvasCaptureMediaStreamTrack.prototype.get canvas):
>+        (foo.html.CanvasCaptureMediaStreamTrack.prototype.requestFrame):
>+        (foo.html.CanvasCaptureMediaStreamTrack):
>+        (foo.html.CanvasElement.new):
>+        (foo.html.CanvasElement.prototype.get height):
>+        (foo.html.CanvasElement.prototype.set height):
>+        (foo.html.CanvasElement.prototype.get width):
>+        (foo.html.CanvasElement.prototype.set width):
>+        (foo.html.CanvasElement.prototype.captureStream):
>+        (foo.html.CanvasElement.prototype.getContext):
>+        (foo.html.CanvasElement.prototype._getContext_1):
>+        (foo.html.CanvasElement.prototype._getContext_2):
>+        (foo.html.CanvasElement.prototype._toDataUrl):
>+        (foo.html.CanvasElement.prototype.transferControlToOffscreen):
>+        (foo.html.CanvasElement.prototype.get onWebGlContextLost):
>+        (foo.html.CanvasElement.prototype.get onWebGlContextRestored):
>+        (foo.html.CanvasElement.prototype.get context2D):
>+        (foo.html.CanvasElement.prototype.getContext3d):
>+        (foo.html.CanvasElement.prototype.toDataUrl):
>+        (foo.html.CanvasElement.prototype._toBlob):
>+        (foo.html.CanvasElement.prototype.toBlob):
>+        (foo.html.CanvasElement):
>+        (foo.html.CanvasGradient.prototype.addColorStop):
>+        (foo.html.CanvasGradient):
>+        (foo.html.CanvasPattern.prototype.setTransform):
>+        (foo.html.CanvasPattern):
>+        (foo.html.CanvasRenderingContext):
>+        (foo.html.CanvasRenderingContext2D.prototype.get canvas):
>+        (foo.html.CanvasRenderingContext2D.prototype.get currentTransform):
>+        (foo.html.CanvasRenderingContext2D.prototype.set currentTransform):
>+        (foo.html.CanvasRenderingContext2D.prototype.get direction):
>+        (foo.html.CanvasRenderingContext2D.prototype.set direction):
>+        (foo.html.CanvasRenderingContext2D.prototype.get fillStyle):
>+        (foo.html.CanvasRenderingContext2D.prototype.set fillStyle):
>+        (foo.html.CanvasRenderingContext2D.prototype.get filter):
>+        (foo.html.CanvasRenderingContext2D.prototype.set filter):
>+        (foo.html.CanvasRenderingContext2D.prototype.get font):
>+        (foo.html.CanvasRenderingContext2D.prototype.set font):
>+        (foo.html.CanvasRenderingContext2D.prototype.get globalAlpha):
>+        (foo.html.CanvasRenderingContext2D.prototype.set globalAlpha):
>+        (foo.html.CanvasRenderingContext2D.prototype.get globalCompositeOperation):
>+        (foo.html.CanvasRenderingContext2D.prototype.set globalCompositeOperation):
>+        (foo.html.CanvasRenderingContext2D.prototype.get imageSmoothingEnabled):
>+        (foo.html.CanvasRenderingContext2D.prototype.set imageSmoothingEnabled):
>+        (foo.html.CanvasRenderingContext2D.prototype.get imageSmoothingQuality):
>+        (foo.html.CanvasRenderingContext2D.prototype.set imageSmoothingQuality):
>+        (foo.html.CanvasRenderingContext2D.prototype.get lineCap):
>+        (foo.html.CanvasRenderingContext2D.prototype.set lineCap):
>+        (foo.html.CanvasRenderingContext2D.prototype.get lineJoin):
>+        (foo.html.CanvasRenderingContext2D.prototype.set lineJoin):
>+        (foo.html.CanvasRenderingContext2D.prototype.get lineWidth):
>+        (foo.html.CanvasRenderingContext2D.prototype.set lineWidth):
>+        (foo.html.CanvasRenderingContext2D.prototype.get miterLimit):
>+        (foo.html.CanvasRenderingContext2D.prototype.set miterLimit):
>+        (foo.html.CanvasRenderingContext2D.prototype.get shadowBlur):
>+        (foo.html.CanvasRenderingContext2D.prototype.set shadowBlur):
>+        (foo.html.CanvasRenderingContext2D.prototype.get shadowColor):
>+        (foo.html.CanvasRenderingContext2D.prototype.set shadowColor):
>+        (foo.html.CanvasRenderingContext2D.prototype.get shadowOffsetX):
>+        (foo.html.CanvasRenderingContext2D.prototype.set shadowOffsetX):
>+        (foo.html.CanvasRenderingContext2D.prototype.get shadowOffsetY):
>+        (foo.html.CanvasRenderingContext2D.prototype.set shadowOffsetY):
>+        (foo.html.CanvasRenderingContext2D.prototype.get strokeStyle):
>+        (foo.html.CanvasRenderingContext2D.prototype.set strokeStyle):
>+        (foo.html.CanvasRenderingContext2D.prototype.get textAlign):
>+        (foo.html.CanvasRenderingContext2D.prototype.set textAlign):
>+        (foo.html.CanvasRenderingContext2D.prototype.get textBaseline):
>+        (foo.html.CanvasRenderingContext2D.prototype.set textBaseline):
>+        (foo.html.CanvasRenderingContext2D.prototype.addHitRegion):
>+        (foo.html.CanvasRenderingContext2D.prototype._addHitRegion_1):
>+        (foo.html.CanvasRenderingContext2D.prototype._addHitRegion_2):
>+        (foo.html.CanvasRenderingContext2D.prototype.beginPath):
>+        (foo.html.CanvasRenderingContext2D.prototype.clearHitRegions):
>+        (foo.html.CanvasRenderingContext2D.prototype.clearRect):
>+        (foo.html.CanvasRenderingContext2D.prototype.clip):
>+        (foo.html.CanvasRenderingContext2D.prototype.createImageData):
>+        (foo.html.CanvasRenderingContext2D.prototype._createImageData_1):
>+        (foo.html.CanvasRenderingContext2D.prototype._createImageData_2):
>+        (foo.html.CanvasRenderingContext2D.prototype._createImageData_3):
>+        (foo.html.CanvasRenderingContext2D.prototype._createImageData_4):
>+        (foo.html.CanvasRenderingContext2D.prototype._createImageData_5):
>+        (foo.html.CanvasRenderingContext2D.prototype.createLinearGradient):
>+        (foo.html.CanvasRenderingContext2D.prototype.createPattern):
>+        (foo.html.CanvasRenderingContext2D.prototype.createRadialGradient):
>+        (foo.html.CanvasRenderingContext2D.prototype.drawFocusIfNeeded):
>+        (foo.html.CanvasRenderingContext2D.prototype.fill):
>+        (foo.html.CanvasRenderingContext2D.prototype.fillRect):
>+        (foo.html.CanvasRenderingContext2D.prototype.getContextAttributes):
>+        (foo.html.CanvasRenderingContext2D.prototype._getContextAttributes_1):
>+        (foo.html.CanvasRenderingContext2D.prototype.getImageData):
>+        (foo.html.CanvasRenderingContext2D.prototype._getImageData_1):
>+        (foo.html.CanvasRenderingContext2D.prototype._getLineDash):
>+        (foo.html.CanvasRenderingContext2D.prototype.isContextLost):
>+        (foo.html.CanvasRenderingContext2D.prototype.isPointInPath):
>+        (foo.html.CanvasRenderingContext2D.prototype.isPointInStroke):
>+        (foo.html.CanvasRenderingContext2D.prototype.measureText):
>+        (foo.html.CanvasRenderingContext2D.prototype.putImageData):
>+        (foo.html.CanvasRenderingContext2D.prototype._putImageData_1):
>+        (foo.html.CanvasRenderingContext2D.prototype._putImageData_2):
>+        (foo.html.CanvasRenderingContext2D.prototype.removeHitRegion):
>+        (foo.html.CanvasRenderingContext2D.prototype.resetTransform):
>+        (foo.html.CanvasRenderingContext2D.prototype.restore):
>+        (foo.html.CanvasRenderingContext2D.prototype.rotate):
>+        (foo.html.CanvasRenderingContext2D.prototype.save):
>+        (foo.html.CanvasRenderingContext2D.prototype.scale):
>+        (foo.html.CanvasRenderingContext2D.prototype.scrollPathIntoView):
>+        (foo.html.CanvasRenderingContext2D.prototype.setTransform):
>+        (foo.html.CanvasRenderingContext2D.prototype.stroke):
>+        (foo.html.CanvasRenderingContext2D.prototype.strokeRect):
>+        (foo.html.CanvasRenderingContext2D.prototype.strokeText):
>+        (foo.html.CanvasRenderingContext2D.prototype.transform):
>+        (foo.html.CanvasRenderingContext2D.prototype.translate):
>+        (foo.html.CanvasRenderingContext2D.prototype._arc):
>+        (foo.html.CanvasRenderingContext2D.prototype.arcTo):
>+        (foo.html.CanvasRenderingContext2D.prototype.bezierCurveTo):
>+        (foo.html.CanvasRenderingContext2D.prototype.closePath):
>+        (foo.html.CanvasRenderingContext2D.prototype.ellipse):
>+        (foo.html.CanvasRenderingContext2D.prototype.lineTo):
>+        (foo.html.CanvasRenderingContext2D.prototype.moveTo):
>+        (foo.html.CanvasRenderingContext2D.prototype.quadraticCurveTo):
>+        (foo.html.CanvasRenderingContext2D.prototype.rect):
>+        (foo.html.CanvasRenderingContext2D.prototype.createImageDataFromImageData):
>+        (foo.html.CanvasRenderingContext2D.prototype.setFillColorRgb):
>+        (foo.html.CanvasRenderingContext2D.prototype.setFillColorHsl):
>+        (foo.html.CanvasRenderingContext2D.prototype.setStrokeColorRgb):
>+        (foo.html.CanvasRenderingContext2D.prototype.setStrokeColorHsl):
>+        (foo.html.CanvasRenderingContext2D.prototype.arc):
>+        (foo.html.CanvasRenderingContext2D.prototype.createPatternFromImage):
>+        (foo.html.CanvasRenderingContext2D.prototype.drawImageToRect):
>+        (foo.html.CanvasRenderingContext2D.prototype.drawImage):
>+        (foo.html.CanvasRenderingContext2D.prototype.drawImageScaled):
>+        (foo.html.CanvasRenderingContext2D.prototype.drawImageScaledFromSource):
>+        (foo.html.CanvasRenderingContext2D.prototype.get lineDashOffset):
>+        (foo.html.CanvasRenderingContext2D.prototype.set lineDashOffset):
>+        (foo.html.CanvasRenderingContext2D.prototype.getLineDash):
>+        (foo.html.CanvasRenderingContext2D.prototype.setLineDash):
>+        (foo.html.CanvasRenderingContext2D.prototype.fillText):
>+        (foo.html.CanvasRenderingContext2D.prototype.get backingStorePixelRatio):
>+        (foo.html.CanvasRenderingContext2D):
>+        (foo.html.ChildNode):
>+        (foo.html.Client.prototype.get frameType):
>+        (foo.html.Client.prototype.get id):
>+        (foo.html.Client.prototype.get type):
>+        (foo.html.Client.prototype.get url):
>+        (foo.html.Client.prototype.postMessage):
>+        (foo.html.Client):
>+        (foo.html.Clients.prototype.claim):
>+        (foo.html.Clients.prototype.get return):
>+        (foo.html.Clients.prototype.openWindow):
>+        (foo.html.Clients):
>+        (foo.html.ClipboardEvent.new):
>+        (foo.html.ClipboardEvent._create_1):
>+        (foo.html.ClipboardEvent._create_2):
>+        (foo.html.ClipboardEvent.prototype.get clipboardData):
>+        (foo.html.ClipboardEvent):
>+        (foo.html.CloseEvent.new):
>+        (foo.html.CloseEvent._create_1):
>+        (foo.html.CloseEvent._create_2):
>+        (foo.html.CloseEvent.prototype.get code):
>+        (foo.html.CloseEvent.prototype.get reason):
>+        (foo.html.CloseEvent.prototype.get wasClean):
>+        (foo.html.CloseEvent):
>+        (foo.html.Comment.new):
>+        (foo.html.Comment):
>+        (foo.html.UIEvent.new):
>+        (foo.html.UIEvent.__):
>+        (foo.html.UIEvent._create_1):
>+        (foo.html.UIEvent._create_2):
>+        (foo.html.UIEvent.prototype.get detail):
>+        (foo.html.UIEvent.prototype.get sourceCapabilities):
>+        (foo.html.UIEvent.prototype.get view):
>+        (foo.html.UIEvent.prototype.get _get_view):
>+        (foo.html.UIEvent.prototype.get _which):
>+        (foo.html.UIEvent.prototype._initUIEvent):
>+        (foo.html.UIEvent):
>+        (foo.html.CompositionEvent.new):
>+        (foo.html.CompositionEvent.__):
>+        (foo.html.CompositionEvent._create_1):
>+        (foo.html.CompositionEvent._create_2):
>+        (foo.html.CompositionEvent.prototype.get data):
>+        (foo.html.CompositionEvent.prototype._initCompositionEvent):
>+        (foo.html.CompositionEvent):
>+        (foo.html.ContentElement.new):
>+        (foo.html.ContentElement.get supported):
>+        (foo.html.ContentElement.prototype.get select):
>+        (foo.html.ContentElement.prototype.set select):
>+        (foo.html.ContentElement.prototype.getDistributedNodes):
>+        (foo.html.ContentElement):
>+        (foo.html.CookieStore.prototype.getAll):
>+        (foo.html.CookieStore.prototype.set if):
>+        (foo.html.CookieStore):
>+        (foo.html.Coordinates.prototype.get accuracy):
>+        (foo.html.Coordinates.prototype.get altitude):
>+        (foo.html.Coordinates.prototype.get altitudeAccuracy):
>+        (foo.html.Coordinates.prototype.get heading):
>+        (foo.html.Coordinates.prototype.get latitude):
>+        (foo.html.Coordinates.prototype.get longitude):
>+        (foo.html.Coordinates.prototype.get speed):
>+        (foo.html.Coordinates):
>+        (foo.async set dart):
>+        (foo.html.Credential.prototype.get id):
>+        (foo.html.Credential.prototype.get type):
>+        (foo.html.Credential):
>+        (foo.html.CredentialUserData.prototype.get iconUrl):
>+        (foo.html.CredentialUserData.prototype.get name):
>+        (foo.html.CredentialUserData):
>+        (foo.html.CredentialsContainer.prototype.create):
>+        (foo.html.CredentialsContainer.prototype.get if):
>+        (foo.html.CredentialsContainer.prototype.preventSilentAccess):
>+        (foo.html.CredentialsContainer.prototype.requireUserMediation):
>+        (foo.html.CredentialsContainer.prototype.store):
>+        (foo.html.CredentialsContainer):
>+        (foo.html.Crypto.prototype.getRandomValues):
>+        (foo.html.Crypto.get supported):
>+        (foo.html.Crypto.prototype.get subtle):
>+        (foo.html.Crypto.prototype._getRandomValues):
>+        (foo.html.Crypto):
>+        (foo.html.CryptoKey.prototype.get algorithm):
>+        (foo.html.CryptoKey.prototype.get extractable):
>+        (foo.html.CryptoKey.prototype.get type):
>+        (foo.html.CryptoKey.prototype.get usages):
>+        (foo.html.CryptoKey):
>+        (foo.html.Css.registerProperty):
>+        (foo.html.Css):
>+        (foo.html.CssRule.prototype.get cssText):
>+        (foo.html.CssRule.prototype.set cssText):
>+        (foo.html.CssRule.prototype.get parentRule):
>+        (foo.html.CssRule.prototype.get parentStyleSheet):
>+        (foo.html.CssRule.prototype.get type):
>+        (foo.html.CssRule):
>+        (foo.html.CssCharsetRule.prototype.get encoding):
>+        (foo.html.CssCharsetRule.prototype.set encoding):
>+        (foo.html.CssCharsetRule):
>+        (foo.html.CssGroupingRule.prototype.get cssRules):
>+        (foo.html.CssGroupingRule.prototype.deleteRule):
>+        (foo.html.CssGroupingRule.prototype.insertRule):
>+        (foo.html.CssGroupingRule):
>+        (foo.html.CssConditionRule.prototype.get conditionText):
>+        (foo.html.CssConditionRule):
>+        (foo.html.CssFontFaceRule.prototype.get style):
>+        (foo.html.CssFontFaceRule):
>+        (foo.html.CssStyleValue):
>+        (foo.html.CssResourceValue.prototype.get state):
>+        (foo.html.CssResourceValue):
>+        (foo.html.CssImageValue.prototype.get intrinsicHeight):
>+        (foo.html.CssImageValue.prototype.get intrinsicRatio):
>+        (foo.html.CssImageValue.prototype.get intrinsicWidth):
>+        (foo.html.CssImageValue):
>+        (foo.html.CssImportRule.prototype.get href):
>+        (foo.html.CssImportRule.prototype.get media):
>+        (foo.html.CssImportRule.prototype.get styleSheet):
>+        (foo.html.CssImportRule):
>+        (foo.html.CssKeyframeRule.prototype.get keyText):
>+        (foo.html.CssKeyframeRule.prototype.set keyText):
>+        (foo.html.CssKeyframeRule.prototype.get style):
>+        (foo.html.CssKeyframeRule):
>+        (foo.html.CssKeyframesRule.prototype.get cssRules):
>+        (foo.html.CssKeyframesRule.prototype.get name):
>+        (foo.html.CssKeyframesRule.prototype.set name):
>+        (foo.html.CssKeyframesRule.prototype.__getter__):
>+        (foo.html.CssKeyframesRule.prototype.appendRule):
>+        (foo.html.CssKeyframesRule.prototype.deleteRule):
>+        (foo.html.CssKeyframesRule.prototype.findRule):
>+        (foo.html.CssKeyframesRule):
>+        (foo.html.CssKeywordValue.new):
>+        (foo.html.CssKeywordValue._create_1):
>+        (foo.html.CssKeywordValue.prototype.get value):
>+        (foo.html.CssKeywordValue.prototype.set value):
>+        (foo.html.CssKeywordValue):
>+        (foo.html.CssTransformComponent.prototype.get is2D):
>+        (foo.html.CssTransformComponent.prototype.set is2D):
>+        (foo.html.CssTransformComponent):
>+        (foo.html.CssMatrixComponent.new):
>+        (foo.html.CssMatrixComponent._create_1):
>+        (foo.html.CssMatrixComponent._create_2):
>+        (foo.html.CssMatrixComponent.prototype.get matrix):
>+        (foo.html.CssMatrixComponent.prototype.set matrix):
>+        (foo.html.CssMatrixComponent):
>+        (foo.html.CssMediaRule.prototype.get media):
>+        (foo.html.CssMediaRule):
>+        (foo.html.CssNamespaceRule.prototype.get namespaceUri):
>+        (foo.html.CssNamespaceRule.prototype.get prefix):
>+        (foo.html.CssNamespaceRule):
>+        (foo.html.CssNumericValue.prototype.add):
>+        (foo.html.CssNumericValue.prototype.div):
>+        (foo.html.CssNumericValue.prototype.mul):
>+        (foo.html.CssNumericValue.prototype.sub):
>+        (foo.html.CssNumericValue.prototype.to):
>+        (foo.html.CssNumericValue):
>+        (foo.html.CssPageRule.prototype.get selectorText):
>+        (foo.html.CssPageRule.prototype.set selectorText):
>+        (foo.html.CssPageRule.prototype.get style):
>+        (foo.html.CssPageRule):
>+        (foo.html.CssPerspective.new):
>+        (foo.html.CssPerspective._create_1):
>+        (foo.html.CssPerspective.prototype.get length):
>+        (foo.html.CssPerspective.prototype.set length):
>+        (foo.html.CssPerspective):
>+        (foo.html.CssPositionValue.new):
>+        (foo.html.CssPositionValue._create_1):
>+        (foo.html.CssPositionValue.prototype.get x):
>+        (foo.html.CssPositionValue.prototype.set x):
>+        (foo.html.CssPositionValue.prototype.get y):
>+        (foo.html.CssPositionValue.prototype.set y):
>+        (foo.html.CssPositionValue):
>+        (foo.html.CssRotation.new):
>+        (foo.html.CssRotation._create_1):
>+        (foo.html.CssRotation._create_2):
>+        (foo.html.CssRotation.prototype.get angle):
>+        (foo.html.CssRotation.prototype.set angle):
>+        (foo.html.CssRotation.prototype.get x):
>+        (foo.html.CssRotation.prototype.set x):
>+        (foo.html.CssRotation.prototype.get y):
>+        (foo.html.CssRotation.prototype.set y):
>+        (foo.html.CssRotation.prototype.get z):
>+        (foo.html.CssRotation.prototype.set z):
>+        (foo.html.CssRotation):
>+        (foo.html.CssScale.new):
>+        (foo.html.CssScale._create_1):
>+        (foo.html.CssScale._create_2):
>+        (foo.html.CssScale.prototype.get x):
>+        (foo.html.CssScale.prototype.set x):
>+        (foo.html.CssScale.prototype.get y):
>+        (foo.html.CssScale.prototype.set y):
>+        (foo.html.CssScale.prototype.get z):
>+        (foo.html.CssScale.prototype.set z):
>+        (foo.html.CssScale):
>+        (foo.html.CssSkew.new):
>+        (foo.html.CssSkew._create_1):
>+        (foo.html.CssSkew.prototype.get ax):
>+        (foo.html.CssSkew.prototype.set ax):
>+        (foo.html.CssSkew.prototype.get ay):
>+        (foo.html.CssSkew.prototype.set ay):
>+        (foo.html.CssSkew):
>+        (foo.html.CssStyleDeclarationBase.prototype.get alignContent):
>+        (foo.html.CssStyleDeclarationBase.prototype.set alignContent):
>+        (foo.html.CssStyleDeclarationBase.prototype.get alignItems):
>+        (foo.html.CssStyleDeclarationBase.prototype.set alignItems):
>+        (foo.html.CssStyleDeclarationBase.prototype.get alignSelf):
>+        (foo.html.CssStyleDeclarationBase.prototype.set alignSelf):
>+        (foo.html.CssStyleDeclarationBase.prototype.get animation):
>+        (foo.html.CssStyleDeclarationBase.prototype.set animation):
>+        (foo.html.CssStyleDeclarationBase.prototype.get animationDelay):
>+        (foo.html.CssStyleDeclarationBase.prototype.set animationDelay):
>+        (foo.html.CssStyleDeclarationBase.prototype.get animationDirection):
>+        (foo.html.CssStyleDeclarationBase.prototype.set animationDirection):
>+        (foo.html.CssStyleDeclarationBase.prototype.get animationDuration):
>+        (foo.html.CssStyleDeclarationBase.prototype.set animationDuration):
>+        (foo.html.CssStyleDeclarationBase.prototype.get animationFillMode):
>+        (foo.html.CssStyleDeclarationBase.prototype.set animationFillMode):
>+        (foo.html.CssStyleDeclarationBase.prototype.get animationIterationCount):
>+        (foo.html.CssStyleDeclarationBase.prototype.set animationIterationCount):
>+        (foo.html.CssStyleDeclarationBase.prototype.get animationName):
>+        (foo.html.CssStyleDeclarationBase.prototype.set animationName):
>+        (foo.html.CssStyleDeclarationBase.prototype.get animationPlayState):
>+        (foo.html.CssStyleDeclarationBase.prototype.set animationPlayState):
>+        (foo.html.CssStyleDeclarationBase.prototype.get animationTimingFunction):
>+        (foo.html.CssStyleDeclarationBase.prototype.set animationTimingFunction):
>+        (foo.html.CssStyleDeclarationBase.prototype.get appRegion):
>+        (foo.html.CssStyleDeclarationBase.prototype.set appRegion):
>+        (foo.html.CssStyleDeclarationBase.prototype.get appearance):
>+        (foo.html.CssStyleDeclarationBase.prototype.set appearance):
>+        (foo.html.CssStyleDeclarationBase.prototype.get aspectRatio):
>+        (foo.html.CssStyleDeclarationBase.prototype.set aspectRatio):
>+        (foo.html.CssStyleDeclarationBase.prototype.get backfaceVisibility):
>+        (foo.html.CssStyleDeclarationBase.prototype.set backfaceVisibility):
>+        (foo.html.CssStyleDeclarationBase.prototype.get background):
>+        (foo.html.CssStyleDeclarationBase.prototype.set background):
>+        (foo.html.CssStyleDeclarationBase.prototype.get backgroundAttachment):
>+        (foo.html.CssStyleDeclarationBase.prototype.set backgroundAttachment):
>+        (foo.html.CssStyleDeclarationBase.prototype.get backgroundBlendMode):
>+        (foo.html.CssStyleDeclarationBase.prototype.set backgroundBlendMode):
>+        (foo.html.CssStyleDeclarationBase.prototype.get backgroundClip):
>+        (foo.html.CssStyleDeclarationBase.prototype.set backgroundClip):
>+        (foo.html.CssStyleDeclarationBase.prototype.get backgroundColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.set backgroundColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.get backgroundComposite):
>+        (foo.html.CssStyleDeclarationBase.prototype.set backgroundComposite):
>+        (foo.html.CssStyleDeclarationBase.prototype.get backgroundImage):
>+        (foo.html.CssStyleDeclarationBase.prototype.set backgroundImage):
>+        (foo.html.CssStyleDeclarationBase.prototype.get backgroundOrigin):
>+        (foo.html.CssStyleDeclarationBase.prototype.set backgroundOrigin):
>+        (foo.html.CssStyleDeclarationBase.prototype.get backgroundPosition):
>+        (foo.html.CssStyleDeclarationBase.prototype.set backgroundPosition):
>+        (foo.html.CssStyleDeclarationBase.prototype.get backgroundPositionX):
>+        (foo.html.CssStyleDeclarationBase.prototype.set backgroundPositionX):
>+        (foo.html.CssStyleDeclarationBase.prototype.get backgroundPositionY):
>+        (foo.html.CssStyleDeclarationBase.prototype.set backgroundPositionY):
>+        (foo.html.CssStyleDeclarationBase.prototype.get backgroundRepeat):
>+        (foo.html.CssStyleDeclarationBase.prototype.set backgroundRepeat):
>+        (foo.html.CssStyleDeclarationBase.prototype.get backgroundRepeatX):
>+        (foo.html.CssStyleDeclarationBase.prototype.set backgroundRepeatX):
>+        (foo.html.CssStyleDeclarationBase.prototype.get backgroundRepeatY):
>+        (foo.html.CssStyleDeclarationBase.prototype.set backgroundRepeatY):
>+        (foo.html.CssStyleDeclarationBase.prototype.get backgroundSize):
>+        (foo.html.CssStyleDeclarationBase.prototype.set backgroundSize):
>+        (foo.html.CssStyleDeclarationBase.prototype.get border):
>+        (foo.html.CssStyleDeclarationBase.prototype.set border):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderAfter):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderAfter):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderAfterColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderAfterColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderAfterStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderAfterStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderAfterWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderAfterWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderBefore):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderBefore):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderBeforeColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderBeforeColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderBeforeStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderBeforeStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderBeforeWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderBeforeWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderBottom):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderBottom):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderBottomColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderBottomColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderBottomLeftRadius):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderBottomLeftRadius):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderBottomRightRadius):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderBottomRightRadius):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderBottomStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderBottomStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderBottomWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderBottomWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderCollapse):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderCollapse):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderEnd):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderEnd):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderEndColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderEndColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderEndStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderEndStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderEndWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderEndWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderFit):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderFit):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderHorizontalSpacing):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderHorizontalSpacing):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderImage):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderImage):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderImageOutset):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderImageOutset):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderImageRepeat):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderImageRepeat):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderImageSlice):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderImageSlice):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderImageSource):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderImageSource):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderImageWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderImageWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderLeft):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderLeft):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderLeftColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderLeftColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderLeftStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderLeftStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderLeftWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderLeftWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderRadius):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderRadius):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderRight):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderRight):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderRightColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderRightColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderRightStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderRightStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderRightWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderRightWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderSpacing):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderSpacing):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderStart):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderStart):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderStartColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderStartColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderStartStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderStartStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderStartWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderStartWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderTop):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderTop):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderTopColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderTopColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderTopLeftRadius):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderTopLeftRadius):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderTopRightRadius):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderTopRightRadius):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderTopStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderTopStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderTopWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderTopWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderVerticalSpacing):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderVerticalSpacing):
>+        (foo.html.CssStyleDeclarationBase.prototype.get borderWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.set borderWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.get bottom):
>+        (foo.html.CssStyleDeclarationBase.prototype.set bottom):
>+        (foo.html.CssStyleDeclarationBase.prototype.get boxAlign):
>+        (foo.html.CssStyleDeclarationBase.prototype.set boxAlign):
>+        (foo.html.CssStyleDeclarationBase.prototype.get boxDecorationBreak):
>+        (foo.html.CssStyleDeclarationBase.prototype.set boxDecorationBreak):
>+        (foo.html.CssStyleDeclarationBase.prototype.get boxDirection):
>+        (foo.html.CssStyleDeclarationBase.prototype.set boxDirection):
>+        (foo.html.CssStyleDeclarationBase.prototype.get boxFlex):
>+        (foo.html.CssStyleDeclarationBase.prototype.set boxFlex):
>+        (foo.html.CssStyleDeclarationBase.prototype.get boxFlexGroup):
>+        (foo.html.CssStyleDeclarationBase.prototype.set boxFlexGroup):
>+        (foo.html.CssStyleDeclarationBase.prototype.get boxLines):
>+        (foo.html.CssStyleDeclarationBase.prototype.set boxLines):
>+        (foo.html.CssStyleDeclarationBase.prototype.get boxOrdinalGroup):
>+        (foo.html.CssStyleDeclarationBase.prototype.set boxOrdinalGroup):
>+        (foo.html.CssStyleDeclarationBase.prototype.get boxOrient):
>+        (foo.html.CssStyleDeclarationBase.prototype.set boxOrient):
>+        (foo.html.CssStyleDeclarationBase.prototype.get boxPack):
>+        (foo.html.CssStyleDeclarationBase.prototype.set boxPack):
>+        (foo.html.CssStyleDeclarationBase.prototype.get boxReflect):
>+        (foo.html.CssStyleDeclarationBase.prototype.set boxReflect):
>+        (foo.html.CssStyleDeclarationBase.prototype.get boxShadow):
>+        (foo.html.CssStyleDeclarationBase.prototype.set boxShadow):
>+        (foo.html.CssStyleDeclarationBase.prototype.get boxSizing):
>+        (foo.html.CssStyleDeclarationBase.prototype.set boxSizing):
>+        (foo.html.CssStyleDeclarationBase.prototype.get captionSide):
>+        (foo.html.CssStyleDeclarationBase.prototype.set captionSide):
>+        (foo.html.CssStyleDeclarationBase.prototype.get clear):
>+        (foo.html.CssStyleDeclarationBase.prototype.set clear):
>+        (foo.html.CssStyleDeclarationBase.prototype.get clip):
>+        (foo.html.CssStyleDeclarationBase.prototype.set clip):
>+        (foo.html.CssStyleDeclarationBase.prototype.get clipPath):
>+        (foo.html.CssStyleDeclarationBase.prototype.set clipPath):
>+        (foo.html.CssStyleDeclarationBase.prototype.get color):
>+        (foo.html.CssStyleDeclarationBase.prototype.set color):
>+        (foo.html.CssStyleDeclarationBase.prototype.get columnBreakAfter):
>+        (foo.html.CssStyleDeclarationBase.prototype.set columnBreakAfter):
>+        (foo.html.CssStyleDeclarationBase.prototype.get columnBreakBefore):
>+        (foo.html.CssStyleDeclarationBase.prototype.set columnBreakBefore):
>+        (foo.html.CssStyleDeclarationBase.prototype.get columnBreakInside):
>+        (foo.html.CssStyleDeclarationBase.prototype.set columnBreakInside):
>+        (foo.html.CssStyleDeclarationBase.prototype.get columnCount):
>+        (foo.html.CssStyleDeclarationBase.prototype.set columnCount):
>+        (foo.html.CssStyleDeclarationBase.prototype.get columnFill):
>+        (foo.html.CssStyleDeclarationBase.prototype.set columnFill):
>+        (foo.html.CssStyleDeclarationBase.prototype.get columnGap):
>+        (foo.html.CssStyleDeclarationBase.prototype.set columnGap):
>+        (foo.html.CssStyleDeclarationBase.prototype.get columnRule):
>+        (foo.html.CssStyleDeclarationBase.prototype.set columnRule):
>+        (foo.html.CssStyleDeclarationBase.prototype.get columnRuleColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.set columnRuleColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.get columnRuleStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.set columnRuleStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.get columnRuleWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.set columnRuleWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.get columnSpan):
>+        (foo.html.CssStyleDeclarationBase.prototype.set columnSpan):
>+        (foo.html.CssStyleDeclarationBase.prototype.get columnWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.set columnWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.get columns):
>+        (foo.html.CssStyleDeclarationBase.prototype.set columns):
>+        (foo.html.CssStyleDeclarationBase.prototype.get content):
>+        (foo.html.CssStyleDeclarationBase.prototype.set content):
>+        (foo.html.CssStyleDeclarationBase.prototype.get counterIncrement):
>+        (foo.html.CssStyleDeclarationBase.prototype.set counterIncrement):
>+        (foo.html.CssStyleDeclarationBase.prototype.get counterReset):
>+        (foo.html.CssStyleDeclarationBase.prototype.set counterReset):
>+        (foo.html.CssStyleDeclarationBase.prototype.get cursor):
>+        (foo.html.CssStyleDeclarationBase.prototype.set cursor):
>+        (foo.html.CssStyleDeclarationBase.prototype.get direction):
>+        (foo.html.CssStyleDeclarationBase.prototype.set direction):
>+        (foo.html.CssStyleDeclarationBase.prototype.get display):
>+        (foo.html.CssStyleDeclarationBase.prototype.set display):
>+        (foo.html.CssStyleDeclarationBase.prototype.get emptyCells):
>+        (foo.html.CssStyleDeclarationBase.prototype.set emptyCells):
>+        (foo.html.CssStyleDeclarationBase.prototype.get filter):
>+        (foo.html.CssStyleDeclarationBase.prototype.set filter):
>+        (foo.html.CssStyleDeclarationBase.prototype.get flex):
>+        (foo.html.CssStyleDeclarationBase.prototype.set flex):
>+        (foo.html.CssStyleDeclarationBase.prototype.get flexBasis):
>+        (foo.html.CssStyleDeclarationBase.prototype.set flexBasis):
>+        (foo.html.CssStyleDeclarationBase.prototype.get flexDirection):
>+        (foo.html.CssStyleDeclarationBase.prototype.set flexDirection):
>+        (foo.html.CssStyleDeclarationBase.prototype.get flexFlow):
>+        (foo.html.CssStyleDeclarationBase.prototype.set flexFlow):
>+        (foo.html.CssStyleDeclarationBase.prototype.get flexGrow):
>+        (foo.html.CssStyleDeclarationBase.prototype.set flexGrow):
>+        (foo.html.CssStyleDeclarationBase.prototype.get flexShrink):
>+        (foo.html.CssStyleDeclarationBase.prototype.set flexShrink):
>+        (foo.html.CssStyleDeclarationBase.prototype.get flexWrap):
>+        (foo.html.CssStyleDeclarationBase.prototype.set flexWrap):
>+        (foo.html.CssStyleDeclarationBase.prototype.get float):
>+        (foo.html.CssStyleDeclarationBase.prototype.set float):
>+        (foo.html.CssStyleDeclarationBase.prototype.get font):
>+        (foo.html.CssStyleDeclarationBase.prototype.set font):
>+        (foo.html.CssStyleDeclarationBase.prototype.get fontFamily):
>+        (foo.html.CssStyleDeclarationBase.prototype.set fontFamily):
>+        (foo.html.CssStyleDeclarationBase.prototype.get fontFeatureSettings):
>+        (foo.html.CssStyleDeclarationBase.prototype.set fontFeatureSettings):
>+        (foo.html.CssStyleDeclarationBase.prototype.get fontKerning):
>+        (foo.html.CssStyleDeclarationBase.prototype.set fontKerning):
>+        (foo.html.CssStyleDeclarationBase.prototype.get fontSize):
>+        (foo.html.CssStyleDeclarationBase.prototype.set fontSize):
>+        (foo.html.CssStyleDeclarationBase.prototype.get fontSizeDelta):
>+        (foo.html.CssStyleDeclarationBase.prototype.set fontSizeDelta):
>+        (foo.html.CssStyleDeclarationBase.prototype.get fontSmoothing):
>+        (foo.html.CssStyleDeclarationBase.prototype.set fontSmoothing):
>+        (foo.html.CssStyleDeclarationBase.prototype.get fontStretch):
>+        (foo.html.CssStyleDeclarationBase.prototype.set fontStretch):
>+        (foo.html.CssStyleDeclarationBase.prototype.get fontStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.set fontStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.get fontVariant):
>+        (foo.html.CssStyleDeclarationBase.prototype.set fontVariant):
>+        (foo.html.CssStyleDeclarationBase.prototype.get fontVariantLigatures):
>+        (foo.html.CssStyleDeclarationBase.prototype.set fontVariantLigatures):
>+        (foo.html.CssStyleDeclarationBase.prototype.get fontWeight):
>+        (foo.html.CssStyleDeclarationBase.prototype.set fontWeight):
>+        (foo.html.CssStyleDeclarationBase.prototype.get grid):
>+        (foo.html.CssStyleDeclarationBase.prototype.set grid):
>+        (foo.html.CssStyleDeclarationBase.prototype.get gridArea):
>+        (foo.html.CssStyleDeclarationBase.prototype.set gridArea):
>+        (foo.html.CssStyleDeclarationBase.prototype.get gridAutoColumns):
>+        (foo.html.CssStyleDeclarationBase.prototype.set gridAutoColumns):
>+        (foo.html.CssStyleDeclarationBase.prototype.get gridAutoFlow):
>+        (foo.html.CssStyleDeclarationBase.prototype.set gridAutoFlow):
>+        (foo.html.CssStyleDeclarationBase.prototype.get gridAutoRows):
>+        (foo.html.CssStyleDeclarationBase.prototype.set gridAutoRows):
>+        (foo.html.CssStyleDeclarationBase.prototype.get gridColumn):
>+        (foo.html.CssStyleDeclarationBase.prototype.set gridColumn):
>+        (foo.html.CssStyleDeclarationBase.prototype.get gridColumnEnd):
>+        (foo.html.CssStyleDeclarationBase.prototype.set gridColumnEnd):
>+        (foo.html.CssStyleDeclarationBase.prototype.get gridColumnStart):
>+        (foo.html.CssStyleDeclarationBase.prototype.set gridColumnStart):
>+        (foo.html.CssStyleDeclarationBase.prototype.get gridRow):
>+        (foo.html.CssStyleDeclarationBase.prototype.set gridRow):
>+        (foo.html.CssStyleDeclarationBase.prototype.get gridRowEnd):
>+        (foo.html.CssStyleDeclarationBase.prototype.set gridRowEnd):
>+        (foo.html.CssStyleDeclarationBase.prototype.get gridRowStart):
>+        (foo.html.CssStyleDeclarationBase.prototype.set gridRowStart):
>+        (foo.html.CssStyleDeclarationBase.prototype.get gridTemplate):
>+        (foo.html.CssStyleDeclarationBase.prototype.set gridTemplate):
>+        (foo.html.CssStyleDeclarationBase.prototype.get gridTemplateAreas):
>+        (foo.html.CssStyleDeclarationBase.prototype.set gridTemplateAreas):
>+        (foo.html.CssStyleDeclarationBase.prototype.get gridTemplateColumns):
>+        (foo.html.CssStyleDeclarationBase.prototype.set gridTemplateColumns):
>+        (foo.html.CssStyleDeclarationBase.prototype.get gridTemplateRows):
>+        (foo.html.CssStyleDeclarationBase.prototype.set gridTemplateRows):
>+        (foo.html.CssStyleDeclarationBase.prototype.get height):
>+        (foo.html.CssStyleDeclarationBase.prototype.set height):
>+        (foo.html.CssStyleDeclarationBase.prototype.get highlight):
>+        (foo.html.CssStyleDeclarationBase.prototype.set highlight):
>+        (foo.html.CssStyleDeclarationBase.prototype.get hyphenateCharacter):
>+        (foo.html.CssStyleDeclarationBase.prototype.set hyphenateCharacter):
>+        (foo.html.CssStyleDeclarationBase.prototype.get imageRendering):
>+        (foo.html.CssStyleDeclarationBase.prototype.set imageRendering):
>+        (foo.html.CssStyleDeclarationBase.prototype.get isolation):
>+        (foo.html.CssStyleDeclarationBase.prototype.set isolation):
>+        (foo.html.CssStyleDeclarationBase.prototype.get justifyContent):
>+        (foo.html.CssStyleDeclarationBase.prototype.set justifyContent):
>+        (foo.html.CssStyleDeclarationBase.prototype.get justifySelf):
>+        (foo.html.CssStyleDeclarationBase.prototype.set justifySelf):
>+        (foo.html.CssStyleDeclarationBase.prototype.get left):
>+        (foo.html.CssStyleDeclarationBase.prototype.set left):
>+        (foo.html.CssStyleDeclarationBase.prototype.get letterSpacing):
>+        (foo.html.CssStyleDeclarationBase.prototype.set letterSpacing):
>+        (foo.html.CssStyleDeclarationBase.prototype.get lineBoxContain):
>+        (foo.html.CssStyleDeclarationBase.prototype.set lineBoxContain):
>+        (foo.html.CssStyleDeclarationBase.prototype.get lineBreak):
>+        (foo.html.CssStyleDeclarationBase.prototype.set lineBreak):
>+        (foo.html.CssStyleDeclarationBase.prototype.get lineClamp):
>+        (foo.html.CssStyleDeclarationBase.prototype.set lineClamp):
>+        (foo.html.CssStyleDeclarationBase.prototype.get lineHeight):
>+        (foo.html.CssStyleDeclarationBase.prototype.set lineHeight):
>+        (foo.html.CssStyleDeclarationBase.prototype.get listStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.set listStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.get listStyleImage):
>+        (foo.html.CssStyleDeclarationBase.prototype.set listStyleImage):
>+        (foo.html.CssStyleDeclarationBase.prototype.get listStylePosition):
>+        (foo.html.CssStyleDeclarationBase.prototype.set listStylePosition):
>+        (foo.html.CssStyleDeclarationBase.prototype.get listStyleType):
>+        (foo.html.CssStyleDeclarationBase.prototype.set listStyleType):
>+        (foo.html.CssStyleDeclarationBase.prototype.get locale):
>+        (foo.html.CssStyleDeclarationBase.prototype.set locale):
>+        (foo.html.CssStyleDeclarationBase.prototype.get logicalHeight):
>+        (foo.html.CssStyleDeclarationBase.prototype.set logicalHeight):
>+        (foo.html.CssStyleDeclarationBase.prototype.get logicalWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.set logicalWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.get margin):
>+        (foo.html.CssStyleDeclarationBase.prototype.set margin):
>+        (foo.html.CssStyleDeclarationBase.prototype.get marginAfter):
>+        (foo.html.CssStyleDeclarationBase.prototype.set marginAfter):
>+        (foo.html.CssStyleDeclarationBase.prototype.get marginAfterCollapse):
>+        (foo.html.CssStyleDeclarationBase.prototype.set marginAfterCollapse):
>+        (foo.html.CssStyleDeclarationBase.prototype.get marginBefore):
>+        (foo.html.CssStyleDeclarationBase.prototype.set marginBefore):
>+        (foo.html.CssStyleDeclarationBase.prototype.get marginBeforeCollapse):
>+        (foo.html.CssStyleDeclarationBase.prototype.set marginBeforeCollapse):
>+        (foo.html.CssStyleDeclarationBase.prototype.get marginBottom):
>+        (foo.html.CssStyleDeclarationBase.prototype.set marginBottom):
>+        (foo.html.CssStyleDeclarationBase.prototype.get marginBottomCollapse):
>+        (foo.html.CssStyleDeclarationBase.prototype.set marginBottomCollapse):
>+        (foo.html.CssStyleDeclarationBase.prototype.get marginCollapse):
>+        (foo.html.CssStyleDeclarationBase.prototype.set marginCollapse):
>+        (foo.html.CssStyleDeclarationBase.prototype.get marginEnd):
>+        (foo.html.CssStyleDeclarationBase.prototype.set marginEnd):
>+        (foo.html.CssStyleDeclarationBase.prototype.get marginLeft):
>+        (foo.html.CssStyleDeclarationBase.prototype.set marginLeft):
>+        (foo.html.CssStyleDeclarationBase.prototype.get marginRight):
>+        (foo.html.CssStyleDeclarationBase.prototype.set marginRight):
>+        (foo.html.CssStyleDeclarationBase.prototype.get marginStart):
>+        (foo.html.CssStyleDeclarationBase.prototype.set marginStart):
>+        (foo.html.CssStyleDeclarationBase.prototype.get marginTop):
>+        (foo.html.CssStyleDeclarationBase.prototype.set marginTop):
>+        (foo.html.CssStyleDeclarationBase.prototype.get marginTopCollapse):
>+        (foo.html.CssStyleDeclarationBase.prototype.set marginTopCollapse):
>+        (foo.html.CssStyleDeclarationBase.prototype.get mask):
>+        (foo.html.CssStyleDeclarationBase.prototype.set mask):
>+        (foo.html.CssStyleDeclarationBase.prototype.get maskBoxImage):
>+        (foo.html.CssStyleDeclarationBase.prototype.set maskBoxImage):
>+        (foo.html.CssStyleDeclarationBase.prototype.get maskBoxImageOutset):
>+        (foo.html.CssStyleDeclarationBase.prototype.set maskBoxImageOutset):
>+        (foo.html.CssStyleDeclarationBase.prototype.get maskBoxImageRepeat):
>+        (foo.html.CssStyleDeclarationBase.prototype.set maskBoxImageRepeat):
>+        (foo.html.CssStyleDeclarationBase.prototype.get maskBoxImageSlice):
>+        (foo.html.CssStyleDeclarationBase.prototype.set maskBoxImageSlice):
>+        (foo.html.CssStyleDeclarationBase.prototype.get maskBoxImageSource):
>+        (foo.html.CssStyleDeclarationBase.prototype.set maskBoxImageSource):
>+        (foo.html.CssStyleDeclarationBase.prototype.get maskBoxImageWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.set maskBoxImageWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.get maskClip):
>+        (foo.html.CssStyleDeclarationBase.prototype.set maskClip):
>+        (foo.html.CssStyleDeclarationBase.prototype.get maskComposite):
>+        (foo.html.CssStyleDeclarationBase.prototype.set maskComposite):
>+        (foo.html.CssStyleDeclarationBase.prototype.get maskImage):
>+        (foo.html.CssStyleDeclarationBase.prototype.set maskImage):
>+        (foo.html.CssStyleDeclarationBase.prototype.get maskOrigin):
>+        (foo.html.CssStyleDeclarationBase.prototype.set maskOrigin):
>+        (foo.html.CssStyleDeclarationBase.prototype.get maskPosition):
>+        (foo.html.CssStyleDeclarationBase.prototype.set maskPosition):
>+        (foo.html.CssStyleDeclarationBase.prototype.get maskPositionX):
>+        (foo.html.CssStyleDeclarationBase.prototype.set maskPositionX):
>+        (foo.html.CssStyleDeclarationBase.prototype.get maskPositionY):
>+        (foo.html.CssStyleDeclarationBase.prototype.set maskPositionY):
>+        (foo.html.CssStyleDeclarationBase.prototype.get maskRepeat):
>+        (foo.html.CssStyleDeclarationBase.prototype.set maskRepeat):
>+        (foo.html.CssStyleDeclarationBase.prototype.get maskRepeatX):
>+        (foo.html.CssStyleDeclarationBase.prototype.set maskRepeatX):
>+        (foo.html.CssStyleDeclarationBase.prototype.get maskRepeatY):
>+        (foo.html.CssStyleDeclarationBase.prototype.set maskRepeatY):
>+        (foo.html.CssStyleDeclarationBase.prototype.get maskSize):
>+        (foo.html.CssStyleDeclarationBase.prototype.set maskSize):
>+        (foo.html.CssStyleDeclarationBase.prototype.get maskSourceType):
>+        (foo.html.CssStyleDeclarationBase.prototype.set maskSourceType):
>+        (foo.html.CssStyleDeclarationBase.prototype.get maxHeight):
>+        (foo.html.CssStyleDeclarationBase.prototype.set maxHeight):
>+        (foo.html.CssStyleDeclarationBase.prototype.get maxLogicalHeight):
>+        (foo.html.CssStyleDeclarationBase.prototype.set maxLogicalHeight):
>+        (foo.html.CssStyleDeclarationBase.prototype.get maxLogicalWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.set maxLogicalWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.get maxWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.set maxWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.get maxZoom):
>+        (foo.html.CssStyleDeclarationBase.prototype.set maxZoom):
>+        (foo.html.CssStyleDeclarationBase.prototype.get minHeight):
>+        (foo.html.CssStyleDeclarationBase.prototype.set minHeight):
>+        (foo.html.CssStyleDeclarationBase.prototype.get minLogicalHeight):
>+        (foo.html.CssStyleDeclarationBase.prototype.set minLogicalHeight):
>+        (foo.html.CssStyleDeclarationBase.prototype.get minLogicalWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.set minLogicalWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.get minWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.set minWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.get minZoom):
>+        (foo.html.CssStyleDeclarationBase.prototype.set minZoom):
>+        (foo.html.CssStyleDeclarationBase.prototype.get mixBlendMode):
>+        (foo.html.CssStyleDeclarationBase.prototype.set mixBlendMode):
>+        (foo.html.CssStyleDeclarationBase.prototype.get objectFit):
>+        (foo.html.CssStyleDeclarationBase.prototype.set objectFit):
>+        (foo.html.CssStyleDeclarationBase.prototype.get objectPosition):
>+        (foo.html.CssStyleDeclarationBase.prototype.set objectPosition):
>+        (foo.html.CssStyleDeclarationBase.prototype.get opacity):
>+        (foo.html.CssStyleDeclarationBase.prototype.set opacity):
>+        (foo.html.CssStyleDeclarationBase.prototype.get order):
>+        (foo.html.CssStyleDeclarationBase.prototype.set order):
>+        (foo.html.CssStyleDeclarationBase.prototype.get orientation):
>+        (foo.html.CssStyleDeclarationBase.prototype.set orientation):
>+        (foo.html.CssStyleDeclarationBase.prototype.get orphans):
>+        (foo.html.CssStyleDeclarationBase.prototype.set orphans):
>+        (foo.html.CssStyleDeclarationBase.prototype.get outline):
>+        (foo.html.CssStyleDeclarationBase.prototype.set outline):
>+        (foo.html.CssStyleDeclarationBase.prototype.get outlineColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.set outlineColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.get outlineOffset):
>+        (foo.html.CssStyleDeclarationBase.prototype.set outlineOffset):
>+        (foo.html.CssStyleDeclarationBase.prototype.get outlineStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.set outlineStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.get outlineWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.set outlineWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.get overflow):
>+        (foo.html.CssStyleDeclarationBase.prototype.set overflow):
>+        (foo.html.CssStyleDeclarationBase.prototype.get overflowWrap):
>+        (foo.html.CssStyleDeclarationBase.prototype.set overflowWrap):
>+        (foo.html.CssStyleDeclarationBase.prototype.get overflowX):
>+        (foo.html.CssStyleDeclarationBase.prototype.set overflowX):
>+        (foo.html.CssStyleDeclarationBase.prototype.get overflowY):
>+        (foo.html.CssStyleDeclarationBase.prototype.set overflowY):
>+        (foo.html.CssStyleDeclarationBase.prototype.get padding):
>+        (foo.html.CssStyleDeclarationBase.prototype.set padding):
>+        (foo.html.CssStyleDeclarationBase.prototype.get paddingAfter):
>+        (foo.html.CssStyleDeclarationBase.prototype.set paddingAfter):
>+        (foo.html.CssStyleDeclarationBase.prototype.get paddingBefore):
>+        (foo.html.CssStyleDeclarationBase.prototype.set paddingBefore):
>+        (foo.html.CssStyleDeclarationBase.prototype.get paddingBottom):
>+        (foo.html.CssStyleDeclarationBase.prototype.set paddingBottom):
>+        (foo.html.CssStyleDeclarationBase.prototype.get paddingEnd):
>+        (foo.html.CssStyleDeclarationBase.prototype.set paddingEnd):
>+        (foo.html.CssStyleDeclarationBase.prototype.get paddingLeft):
>+        (foo.html.CssStyleDeclarationBase.prototype.set paddingLeft):
>+        (foo.html.CssStyleDeclarationBase.prototype.get paddingRight):
>+        (foo.html.CssStyleDeclarationBase.prototype.set paddingRight):
>+        (foo.html.CssStyleDeclarationBase.prototype.get paddingStart):
>+        (foo.html.CssStyleDeclarationBase.prototype.set paddingStart):
>+        (foo.html.CssStyleDeclarationBase.prototype.get paddingTop):
>+        (foo.html.CssStyleDeclarationBase.prototype.set paddingTop):
>+        (foo.html.CssStyleDeclarationBase.prototype.get page):
>+        (foo.html.CssStyleDeclarationBase.prototype.set page):
>+        (foo.html.CssStyleDeclarationBase.prototype.get pageBreakAfter):
>+        (foo.html.CssStyleDeclarationBase.prototype.set pageBreakAfter):
>+        (foo.html.CssStyleDeclarationBase.prototype.get pageBreakBefore):
>+        (foo.html.CssStyleDeclarationBase.prototype.set pageBreakBefore):
>+        (foo.html.CssStyleDeclarationBase.prototype.get pageBreakInside):
>+        (foo.html.CssStyleDeclarationBase.prototype.set pageBreakInside):
>+        (foo.html.CssStyleDeclarationBase.prototype.get perspective):
>+        (foo.html.CssStyleDeclarationBase.prototype.set perspective):
>+        (foo.html.CssStyleDeclarationBase.prototype.get perspectiveOrigin):
>+        (foo.html.CssStyleDeclarationBase.prototype.set perspectiveOrigin):
>+        (foo.html.CssStyleDeclarationBase.prototype.get perspectiveOriginX):
>+        (foo.html.CssStyleDeclarationBase.prototype.set perspectiveOriginX):
>+        (foo.html.CssStyleDeclarationBase.prototype.get perspectiveOriginY):
>+        (foo.html.CssStyleDeclarationBase.prototype.set perspectiveOriginY):
>+        (foo.html.CssStyleDeclarationBase.prototype.get pointerEvents):
>+        (foo.html.CssStyleDeclarationBase.prototype.set pointerEvents):
>+        (foo.html.CssStyleDeclarationBase.prototype.get position):
>+        (foo.html.CssStyleDeclarationBase.prototype.set position):
>+        (foo.html.CssStyleDeclarationBase.prototype.get printColorAdjust):
>+        (foo.html.CssStyleDeclarationBase.prototype.set printColorAdjust):
>+        (foo.html.CssStyleDeclarationBase.prototype.get quotes):
>+        (foo.html.CssStyleDeclarationBase.prototype.set quotes):
>+        (foo.html.CssStyleDeclarationBase.prototype.get resize):
>+        (foo.html.CssStyleDeclarationBase.prototype.set resize):
>+        (foo.html.CssStyleDeclarationBase.prototype.get right):
>+        (foo.html.CssStyleDeclarationBase.prototype.set right):
>+        (foo.html.CssStyleDeclarationBase.prototype.get rtlOrdering):
>+        (foo.html.CssStyleDeclarationBase.prototype.set rtlOrdering):
>+        (foo.html.CssStyleDeclarationBase.prototype.get rubyPosition):
>+        (foo.html.CssStyleDeclarationBase.prototype.set rubyPosition):
>+        (foo.html.CssStyleDeclarationBase.prototype.get scrollBehavior):
>+        (foo.html.CssStyleDeclarationBase.prototype.set scrollBehavior):
>+        (foo.html.CssStyleDeclarationBase.prototype.get shapeImageThreshold):
>+        (foo.html.CssStyleDeclarationBase.prototype.set shapeImageThreshold):
>+        (foo.html.CssStyleDeclarationBase.prototype.get shapeMargin):
>+        (foo.html.CssStyleDeclarationBase.prototype.set shapeMargin):
>+        (foo.html.CssStyleDeclarationBase.prototype.get shapeOutside):
>+        (foo.html.CssStyleDeclarationBase.prototype.set shapeOutside):
>+        (foo.html.CssStyleDeclarationBase.prototype.get size):
>+        (foo.html.CssStyleDeclarationBase.prototype.set size):
>+        (foo.html.CssStyleDeclarationBase.prototype.get speak):
>+        (foo.html.CssStyleDeclarationBase.prototype.set speak):
>+        (foo.html.CssStyleDeclarationBase.prototype.get src):
>+        (foo.html.CssStyleDeclarationBase.prototype.set src):
>+        (foo.html.CssStyleDeclarationBase.prototype.get tabSize):
>+        (foo.html.CssStyleDeclarationBase.prototype.set tabSize):
>+        (foo.html.CssStyleDeclarationBase.prototype.get tableLayout):
>+        (foo.html.CssStyleDeclarationBase.prototype.set tableLayout):
>+        (foo.html.CssStyleDeclarationBase.prototype.get tapHighlightColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.set tapHighlightColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textAlign):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textAlign):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textAlignLast):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textAlignLast):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textCombine):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textCombine):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textDecoration):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textDecoration):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textDecorationColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textDecorationColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textDecorationLine):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textDecorationLine):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textDecorationStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textDecorationStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textDecorationsInEffect):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textDecorationsInEffect):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textEmphasis):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textEmphasis):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textEmphasisColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textEmphasisColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textEmphasisPosition):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textEmphasisPosition):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textEmphasisStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textEmphasisStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textFillColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textFillColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textIndent):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textIndent):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textJustify):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textJustify):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textLineThroughColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textLineThroughColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textLineThroughMode):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textLineThroughMode):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textLineThroughStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textLineThroughStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textLineThroughWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textLineThroughWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textOrientation):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textOrientation):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textOverflow):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textOverflow):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textOverlineColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textOverlineColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textOverlineMode):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textOverlineMode):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textOverlineStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textOverlineStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textOverlineWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textOverlineWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textRendering):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textRendering):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textSecurity):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textSecurity):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textShadow):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textShadow):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textStroke):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textStroke):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textStrokeColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textStrokeColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textStrokeWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textStrokeWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textTransform):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textTransform):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textUnderlineColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textUnderlineColor):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textUnderlineMode):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textUnderlineMode):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textUnderlinePosition):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textUnderlinePosition):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textUnderlineStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textUnderlineStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.get textUnderlineWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.set textUnderlineWidth):
>+        (foo.html.CssStyleDeclarationBase.prototype.get top):
>+        (foo.html.CssStyleDeclarationBase.prototype.set top):
>+        (foo.html.CssStyleDeclarationBase.prototype.get touchAction):
>+        (foo.html.CssStyleDeclarationBase.prototype.set touchAction):
>+        (foo.html.CssStyleDeclarationBase.prototype.get touchActionDelay):
>+        (foo.html.CssStyleDeclarationBase.prototype.set touchActionDelay):
>+        (foo.html.CssStyleDeclarationBase.prototype.get transform):
>+        (foo.html.CssStyleDeclarationBase.prototype.set transform):
>+        (foo.html.CssStyleDeclarationBase.prototype.get transformOrigin):
>+        (foo.html.CssStyleDeclarationBase.prototype.set transformOrigin):
>+        (foo.html.CssStyleDeclarationBase.prototype.get transformOriginX):
>+        (foo.html.CssStyleDeclarationBase.prototype.set transformOriginX):
>+        (foo.html.CssStyleDeclarationBase.prototype.get transformOriginY):
>+        (foo.html.CssStyleDeclarationBase.prototype.set transformOriginY):
>+        (foo.html.CssStyleDeclarationBase.prototype.get transformOriginZ):
>+        (foo.html.CssStyleDeclarationBase.prototype.set transformOriginZ):
>+        (foo.html.CssStyleDeclarationBase.prototype.get transformStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.set transformStyle):
>+        (foo.html.CssStyleDeclarationBase.prototype.get transition):
>+        (foo.html.CssStyleDeclarationBase.prototype.set transition):
>+        (foo.html.CssStyleDeclarationBase.prototype.get transitionDelay):
>+        (foo.html.CssStyleDeclarationBase.prototype.set transitionDelay):
>+        (foo.html.CssStyleDeclarationBase.prototype.get transitionDuration):
>+        (foo.html.CssStyleDeclarationBase.prototype.set transitionDuration):
>+        (foo.html.CssStyleDeclarationBase.prototype.get transitionProperty):
>+        (foo.html.CssStyleDeclarationBase.prototype.set transitionProperty):
>+        (foo.html.CssStyleDeclarationBase.prototype.get transitionTimingFunction):
>+        (foo.html.CssStyleDeclarationBase.prototype.set transitionTimingFunction):
>+        (foo.html.CssStyleDeclarationBase.prototype.get unicodeBidi):
>+        (foo.html.CssStyleDeclarationBase.prototype.set unicodeBidi):
>+        (foo.html.CssStyleDeclarationBase.prototype.get unicodeRange):
>+        (foo.html.CssStyleDeclarationBase.prototype.set unicodeRange):
>+        (foo.html.CssStyleDeclarationBase.prototype.get userDrag):
>+        (foo.html.CssStyleDeclarationBase.prototype.set userDrag):
>+        (foo.html.CssStyleDeclarationBase.prototype.get userModify):
>+        (foo.html.CssStyleDeclarationBase.prototype.set userModify):
>+        (foo.html.CssStyleDeclarationBase.prototype.get userSelect):
>+        (foo.html.CssStyleDeclarationBase.prototype.set userSelect):
>+        (foo.html.CssStyleDeclarationBase.prototype.get userZoom):
>+        (foo.html.CssStyleDeclarationBase.prototype.set userZoom):
>+        (foo.html.CssStyleDeclarationBase.prototype.get verticalAlign):
>+        (foo.html.CssStyleDeclarationBase.prototype.set verticalAlign):
>+        (foo.html.CssStyleDeclarationBase.prototype.get visibility):
>+        (foo.html.CssStyleDeclarationBase.prototype.set visibility):
>+        (foo.html.CssStyleDeclarationBase.prototype.get whiteSpace):
>+        (foo.html.CssStyleDeclarationBase.prototype.set whiteSpace):
>+        (foo.html.CssStyleDeclarationBase.prototype.get widows):
>+        (foo.html.CssStyleDeclarationBase.prototype.set widows):
>+        (foo.html.CssStyleDeclarationBase.prototype.get width):
>+        (foo.html.CssStyleDeclarationBase.prototype.set width):
>+        (foo.html.CssStyleDeclarationBase.prototype.get willChange):
>+        (foo.html.CssStyleDeclarationBase.prototype.set willChange):
>+        (foo.html.CssStyleDeclarationBase.prototype.get wordBreak):
>+        (foo.html.CssStyleDeclarationBase.prototype.set wordBreak):
>+        (foo.html.CssStyleDeclarationBase.prototype.get wordSpacing):
>+        (foo.html.CssStyleDeclarationBase.prototype.set wordSpacing):
>+        (foo.html.CssStyleDeclarationBase.prototype.get wordWrap):
>+        (foo.html.CssStyleDeclarationBase.prototype.set wordWrap):
>+        (foo.html.CssStyleDeclarationBase.prototype.get wrapFlow):
>+        (foo.html.CssStyleDeclarationBase.prototype.set wrapFlow):
>+        (foo.html.CssStyleDeclarationBase.prototype.get wrapThrough):
>+        (foo.html.CssStyleDeclarationBase.prototype.set wrapThrough):
>+        (foo.html.CssStyleDeclarationBase.prototype.get writingMode):
>+        (foo.html.CssStyleDeclarationBase.prototype.set writingMode):
>+        (foo.html.CssStyleDeclarationBase.prototype.get zIndex):
>+        (foo.html.CssStyleDeclarationBase.prototype.set zIndex):
>+        (foo.html.CssStyleDeclarationBase.prototype.get zoom):
>+        (foo.html.CssStyleDeclarationBase.prototype.set zoom):
>+        (foo.html.CssStyleDeclarationBase):
>+        (foo.const.Interceptor_CssStyleDeclarationBase):
>+        (foo.html.CssStyleDeclaration.new):
>+        (foo.html.CssStyleDeclaration.css):
>+        (foo.html.CssStyleDeclaration.prototype.getPropertyValue):
>+        (foo.html.CssStyleDeclaration.prototype._getPropertyValueHelper):
>+        (foo.html.CssStyleDeclaration.prototype.supportsProperty):
>+        (foo.html.CssStyleDeclaration.prototype._supportsProperty):
>+        (foo.html.CssStyleDeclaration.prototype.setProperty):
>+        (foo.html.CssStyleDeclaration.prototype._browserPropertyName):
>+        (foo.html.CssStyleDeclaration.prototype._supportedBrowserPropertyName):
>+        (foo.html.CssStyleDeclaration._readCache):
>+        (foo.html.CssStyleDeclaration._writeCache):
>+        (foo.html.CssStyleDeclaration._camelCase):
>+        (foo.html.CssStyleDeclaration.prototype._setPropertyHelper):
>+        (foo.html.CssStyleDeclaration.get supportsTransitions):
>+        (foo.html.CssStyleDeclaration.prototype.get cssFloat):
>+        (foo.html.CssStyleDeclaration.prototype.set cssFloat):
>+        (foo.html.CssStyleDeclaration.prototype.get cssText):
>+        (foo.html.CssStyleDeclaration.prototype.set cssText):
>+        (foo.html.CssStyleDeclaration.prototype.get length):
>+        (foo.html.CssStyleDeclaration.prototype.get parentRule):
>+        (foo.html.CssStyleDeclaration.prototype.getPropertyPriority):
>+        (foo.html.CssStyleDeclaration.prototype._getPropertyValue):
>+        (foo.html.CssStyleDeclaration.prototype.item):
>+        (foo.html.CssStyleDeclaration.prototype.removeProperty):
>+        (foo.html.CssStyleDeclaration.prototype.get background):
>+        (foo.html.CssStyleDeclaration.prototype.set background):
>+        (foo.html.CssStyleDeclaration.prototype.get _background):
>+        (foo.html.CssStyleDeclaration.prototype.set _background):
>+        (foo.html.CssStyleDeclaration.prototype.get backgroundAttachment):
>+        (foo.html.CssStyleDeclaration.prototype.set backgroundAttachment):
>+        (foo.html.CssStyleDeclaration.prototype.get _backgroundAttachment):
>+        (foo.html.CssStyleDeclaration.prototype.set _backgroundAttachment):
>+        (foo.html.CssStyleDeclaration.prototype.get backgroundColor):
>+        (foo.html.CssStyleDeclaration.prototype.set backgroundColor):
>+        (foo.html.CssStyleDeclaration.prototype.get _backgroundColor):
>+        (foo.html.CssStyleDeclaration.prototype.set _backgroundColor):
>+        (foo.html.CssStyleDeclaration.prototype.get backgroundImage):
>+        (foo.html.CssStyleDeclaration.prototype.set backgroundImage):
>+        (foo.html.CssStyleDeclaration.prototype.get _backgroundImage):
>+        (foo.html.CssStyleDeclaration.prototype.set _backgroundImage):
>+        (foo.html.CssStyleDeclaration.prototype.get backgroundPosition):
>+        (foo.html.CssStyleDeclaration.prototype.set backgroundPosition):
>+        (foo.html.CssStyleDeclaration.prototype.get _backgroundPosition):
>+        (foo.html.CssStyleDeclaration.prototype.set _backgroundPosition):
>+        (foo.html.CssStyleDeclaration.prototype.get backgroundRepeat):
>+        (foo.html.CssStyleDeclaration.prototype.set backgroundRepeat):
>+        (foo.html.CssStyleDeclaration.prototype.get _backgroundRepeat):
>+        (foo.html.CssStyleDeclaration.prototype.set _backgroundRepeat):
>+        (foo.html.CssStyleDeclaration.prototype.get border):
>+        (foo.html.CssStyleDeclaration.prototype.set border):
>+        (foo.html.CssStyleDeclaration.prototype.get _border):
>+        (foo.html.CssStyleDeclaration.prototype.set _border):
>+        (foo.html.CssStyleDeclaration.prototype.get borderBottom):
>+        (foo.html.CssStyleDeclaration.prototype.set borderBottom):
>+        (foo.html.CssStyleDeclaration.prototype.get _borderBottom):
>+        (foo.html.CssStyleDeclaration.prototype.set _borderBottom):
>+        (foo.html.CssStyleDeclaration.prototype.get borderBottomColor):
>+        (foo.html.CssStyleDeclaration.prototype.set borderBottomColor):
>+        (foo.html.CssStyleDeclaration.prototype.get _borderBottomColor):
>+        (foo.html.CssStyleDeclaration.prototype.set _borderBottomColor):
>+        (foo.html.CssStyleDeclaration.prototype.get borderBottomStyle):
>+        (foo.html.CssStyleDeclaration.prototype.set borderBottomStyle):
>+        (foo.html.CssStyleDeclaration.prototype.get _borderBottomStyle):
>+        (foo.html.CssStyleDeclaration.prototype.set _borderBottomStyle):
>+        (foo.html.CssStyleDeclaration.prototype.get borderBottomWidth):
>+        (foo.html.CssStyleDeclaration.prototype.set borderBottomWidth):
>+        (foo.html.CssStyleDeclaration.prototype.get _borderBottomWidth):
>+        (foo.html.CssStyleDeclaration.prototype.set _borderBottomWidth):
>+        (foo.html.CssStyleDeclaration.prototype.get borderCollapse):
>+        (foo.html.CssStyleDeclaration.prototype.set borderCollapse):
>+        (foo.html.CssStyleDeclaration.prototype.get _borderCollapse):
>+        (foo.html.CssStyleDeclaration.prototype.set _borderCollapse):
>+        (foo.html.CssStyleDeclaration.prototype.get borderColor):
>+        (foo.html.CssStyleDeclaration.prototype.set borderColor):
>+        (foo.html.CssStyleDeclaration.prototype.get _borderColor):
>+        (foo.html.CssStyleDeclaration.prototype.set _borderColor):
>+        (foo.html.CssStyleDeclaration.prototype.get borderLeft):
>+        (foo.html.CssStyleDeclaration.prototype.set borderLeft):
>+        (foo.html.CssStyleDeclaration.prototype.get _borderLeft):
>+        (foo.html.CssStyleDeclaration.prototype.set _borderLeft):
>+        (foo.html.CssStyleDeclaration.prototype.get borderLeftColor):
>+        (foo.html.CssStyleDeclaration.prototype.set borderLeftColor):
>+        (foo.html.CssStyleDeclaration.prototype.get _borderLeftColor):
>+        (foo.html.CssStyleDeclaration.prototype.set _borderLeftColor):
>+        (foo.html.CssStyleDeclaration.prototype.get borderLeftStyle):
>+        (foo.html.CssStyleDeclaration.prototype.set borderLeftStyle):
>+        (foo.html.CssStyleDeclaration.prototype.get _borderLeftStyle):
>+        (foo.html.CssStyleDeclaration.prototype.set _borderLeftStyle):
>+        (foo.html.CssStyleDeclaration.prototype.get borderLeftWidth):
>+        (foo.html.CssStyleDeclaration.prototype.set borderLeftWidth):
>+        (foo.html.CssStyleDeclaration.prototype.get _borderLeftWidth):
>+        (foo.html.CssStyleDeclaration.prototype.set _borderLeftWidth):
>+        (foo.html.CssStyleDeclaration.prototype.get borderRight):
>+        (foo.html.CssStyleDeclaration.prototype.set borderRight):
>+        (foo.html.CssStyleDeclaration.prototype.get _borderRight):
>+        (foo.html.CssStyleDeclaration.prototype.set _borderRight):
>+        (foo.html.CssStyleDeclaration.prototype.get borderRightColor):
>+        (foo.html.CssStyleDeclaration.prototype.set borderRightColor):
>+        (foo.html.CssStyleDeclaration.prototype.get _borderRightColor):
>+        (foo.html.CssStyleDeclaration.prototype.set _borderRightColor):
>+        (foo.html.CssStyleDeclaration.prototype.get borderRightStyle):
>+        (foo.html.CssStyleDeclaration.prototype.set borderRightStyle):
>+        (foo.html.CssStyleDeclaration.prototype.get _borderRightStyle):
>+        (foo.html.CssStyleDeclaration.prototype.set _borderRightStyle):
>+        (foo.html.CssStyleDeclaration.prototype.get borderRightWidth):
>+        (foo.html.CssStyleDeclaration.prototype.set borderRightWidth):
>+        (foo.html.CssStyleDeclaration.prototype.get _borderRightWidth):
>+        (foo.html.CssStyleDeclaration.prototype.set _borderRightWidth):
>+        (foo.html.CssStyleDeclaration.prototype.get borderSpacing):
>+        (foo.html.CssStyleDeclaration.prototype.set borderSpacing):
>+        (foo.html.CssStyleDeclaration.prototype.get _borderSpacing):
>+        (foo.html.CssStyleDeclaration.prototype.set _borderSpacing):
>+        (foo.html.CssStyleDeclaration.prototype.get borderStyle):
>+        (foo.html.CssStyleDeclaration.prototype.set borderStyle):
>+        (foo.html.CssStyleDeclaration.prototype.get _borderStyle):
>+        (foo.html.CssStyleDeclaration.prototype.set _borderStyle):
>+        (foo.html.CssStyleDeclaration.prototype.get borderTop):
>+        (foo.html.CssStyleDeclaration.prototype.set borderTop):
>+        (foo.html.CssStyleDeclaration.prototype.get _borderTop):
>+        (foo.html.CssStyleDeclaration.prototype.set _borderTop):
>+        (foo.html.CssStyleDeclaration.prototype.get borderTopColor):
>+        (foo.html.CssStyleDeclaration.prototype.set borderTopColor):
>+        (foo.html.CssStyleDeclaration.prototype.get _borderTopColor):
>+        (foo.html.CssStyleDeclaration.prototype.set _borderTopColor):
>+        (foo.html.CssStyleDeclaration.prototype.get borderTopStyle):
>+        (foo.html.CssStyleDeclaration.prototype.set borderTopStyle):
>+        (foo.html.CssStyleDeclaration.prototype.get _borderTopStyle):
>+        (foo.html.CssStyleDeclaration.prototype.set _borderTopStyle):
>+        (foo.html.CssStyleDeclaration.prototype.get borderTopWidth):
>+        (foo.html.CssStyleDeclaration.prototype.set borderTopWidth):
>+        (foo.html.CssStyleDeclaration.prototype.get _borderTopWidth):
>+        (foo.html.CssStyleDeclaration.prototype.set _borderTopWidth):
>+        (foo.html.CssStyleDeclaration.prototype.get borderWidth):
>+        (foo.html.CssStyleDeclaration.prototype.set borderWidth):
>+        (foo.html.CssStyleDeclaration.prototype.get _borderWidth):
>+        (foo.html.CssStyleDeclaration.prototype.set _borderWidth):
>+        (foo.html.CssStyleDeclaration.prototype.get bottom):
>+        (foo.html.CssStyleDeclaration.prototype.set bottom):
>+        (foo.html.CssStyleDeclaration.prototype.get _bottom):
>+        (foo.html.CssStyleDeclaration.prototype.set _bottom):
>+        (foo.html.CssStyleDeclaration.prototype.get captionSide):
>+        (foo.html.CssStyleDeclaration.prototype.set captionSide):
>+        (foo.html.CssStyleDeclaration.prototype.get _captionSide):
>+        (foo.html.CssStyleDeclaration.prototype.set _captionSide):
>+        (foo.html.CssStyleDeclaration.prototype.get clear):
>+        (foo.html.CssStyleDeclaration.prototype.set clear):
>+        (foo.html.CssStyleDeclaration.prototype.get _clear):
>+        (foo.html.CssStyleDeclaration.prototype.set _clear):
>+        (foo.html.CssStyleDeclaration.prototype.get clip):
>+        (foo.html.CssStyleDeclaration.prototype.set clip):
>+        (foo.html.CssStyleDeclaration.prototype.get _clip):
>+        (foo.html.CssStyleDeclaration.prototype.set _clip):
>+        (foo.html.CssStyleDeclaration.prototype.get color):
>+        (foo.html.CssStyleDeclaration.prototype.set color):
>+        (foo.html.CssStyleDeclaration.prototype.get _color):
>+        (foo.html.CssStyleDeclaration.prototype.set _color):
>+        (foo.html.CssStyleDeclaration.prototype.get content):
>+        (foo.html.CssStyleDeclaration.prototype.set content):
>+        (foo.html.CssStyleDeclaration.prototype.get _content):
>+        (foo.html.CssStyleDeclaration.prototype.set _content):
>+        (foo.html.CssStyleDeclaration.prototype.get cursor):
>+        (foo.html.CssStyleDeclaration.prototype.set cursor):
>+        (foo.html.CssStyleDeclaration.prototype.get _cursor):
>+        (foo.html.CssStyleDeclaration.prototype.set _cursor):
>+        (foo.html.CssStyleDeclaration.prototype.get direction):
>+        (foo.html.CssStyleDeclaration.prototype.set direction):
>+        (foo.html.CssStyleDeclaration.prototype.get _direction):
>+        (foo.html.CssStyleDeclaration.prototype.set _direction):
>+        (foo.html.CssStyleDeclaration.prototype.get display):
>+        (foo.html.CssStyleDeclaration.prototype.set display):
>+        (foo.html.CssStyleDeclaration.prototype.get _display):
>+        (foo.html.CssStyleDeclaration.prototype.set _display):
>+        (foo.html.CssStyleDeclaration.prototype.get emptyCells):
>+        (foo.html.CssStyleDeclaration.prototype.set emptyCells):
>+        (foo.html.CssStyleDeclaration.prototype.get _emptyCells):
>+        (foo.html.CssStyleDeclaration.prototype.set _emptyCells):
>+        (foo.html.CssStyleDeclaration.prototype.get font):
>+        (foo.html.CssStyleDeclaration.prototype.set font):
>+        (foo.html.CssStyleDeclaration.prototype.get _font):
>+        (foo.html.CssStyleDeclaration.prototype.set _font):
>+        (foo.html.CssStyleDeclaration.prototype.get fontFamily):
>+        (foo.html.CssStyleDeclaration.prototype.set fontFamily):
>+        (foo.html.CssStyleDeclaration.prototype.get _fontFamily):
>+        (foo.html.CssStyleDeclaration.prototype.set _fontFamily):
>+        (foo.html.CssStyleDeclaration.prototype.get fontSize):
>+        (foo.html.CssStyleDeclaration.prototype.set fontSize):
>+        (foo.html.CssStyleDeclaration.prototype.get _fontSize):
>+        (foo.html.CssStyleDeclaration.prototype.set _fontSize):
>+        (foo.html.CssStyleDeclaration.prototype.get fontStyle):
>+        (foo.html.CssStyleDeclaration.prototype.set fontStyle):
>+        (foo.html.CssStyleDeclaration.prototype.get _fontStyle):
>+        (foo.html.CssStyleDeclaration.prototype.set _fontStyle):
>+        (foo.html.CssStyleDeclaration.prototype.get fontVariant):
>+        (foo.html.CssStyleDeclaration.prototype.set fontVariant):
>+        (foo.html.CssStyleDeclaration.prototype.get _fontVariant):
>+        (foo.html.CssStyleDeclaration.prototype.set _fontVariant):
>+        (foo.html.CssStyleDeclaration.prototype.get fontWeight):
>+        (foo.html.CssStyleDeclaration.prototype.set fontWeight):
>+        (foo.html.CssStyleDeclaration.prototype.get _fontWeight):
>+        (foo.html.CssStyleDeclaration.prototype.set _fontWeight):
>+        (foo.html.CssStyleDeclaration.prototype.get height):
>+        (foo.html.CssStyleDeclaration.prototype.set height):
>+        (foo.html.CssStyleDeclaration.prototype.get _height):
>+        (foo.html.CssStyleDeclaration.prototype.set _height):
>+        (foo.html.CssStyleDeclaration.prototype.get left):
>+        (foo.html.CssStyleDeclaration.prototype.set left):
>+        (foo.html.CssStyleDeclaration.prototype.get _left):
>+        (foo.html.CssStyleDeclaration.prototype.set _left):
>+        (foo.html.CssStyleDeclaration.prototype.get letterSpacing):
>+        (foo.html.CssStyleDeclaration.prototype.set letterSpacing):
>+        (foo.html.CssStyleDeclaration.prototype.get _letterSpacing):
>+        (foo.html.CssStyleDeclaration.prototype.set _letterSpacing):
>+        (foo.html.CssStyleDeclaration.prototype.get lineHeight):
>+        (foo.html.CssStyleDeclaration.prototype.set lineHeight):
>+        (foo.html.CssStyleDeclaration.prototype.get _lineHeight):
>+        (foo.html.CssStyleDeclaration.prototype.set _lineHeight):
>+        (foo.html.CssStyleDeclaration.prototype.get listStyle):
>+        (foo.html.CssStyleDeclaration.prototype.set listStyle):
>+        (foo.html.CssStyleDeclaration.prototype.get _listStyle):
>+        (foo.html.CssStyleDeclaration.prototype.set _listStyle):
>+        (foo.html.CssStyleDeclaration.prototype.get listStyleImage):
>+        (foo.html.CssStyleDeclaration.prototype.set listStyleImage):
>+        (foo.html.CssStyleDeclaration.prototype.get _listStyleImage):
>+        (foo.html.CssStyleDeclaration.prototype.set _listStyleImage):
>+        (foo.html.CssStyleDeclaration.prototype.get listStylePosition):
>+        (foo.html.CssStyleDeclaration.prototype.set listStylePosition):
>+        (foo.html.CssStyleDeclaration.prototype.get _listStylePosition):
>+        (foo.html.CssStyleDeclaration.prototype.set _listStylePosition):
>+        (foo.html.CssStyleDeclaration.prototype.get listStyleType):
>+        (foo.html.CssStyleDeclaration.prototype.set listStyleType):
>+        (foo.html.CssStyleDeclaration.prototype.get _listStyleType):
>+        (foo.html.CssStyleDeclaration.prototype.set _listStyleType):
>+        (foo.html.CssStyleDeclaration.prototype.get margin):
>+        (foo.html.CssStyleDeclaration.prototype.set margin):
>+        (foo.html.CssStyleDeclaration.prototype.get _margin):
>+        (foo.html.CssStyleDeclaration.prototype.set _margin):
>+        (foo.html.CssStyleDeclaration.prototype.get marginBottom):
>+        (foo.html.CssStyleDeclaration.prototype.set marginBottom):
>+        (foo.html.CssStyleDeclaration.prototype.get _marginBottom):
>+        (foo.html.CssStyleDeclaration.prototype.set _marginBottom):
>+        (foo.html.CssStyleDeclaration.prototype.get marginLeft):
>+        (foo.html.CssStyleDeclaration.prototype.set marginLeft):
>+        (foo.html.CssStyleDeclaration.prototype.get _marginLeft):
>+        (foo.html.CssStyleDeclaration.prototype.set _marginLeft):
>+        (foo.html.CssStyleDeclaration.prototype.get marginRight):
>+        (foo.html.CssStyleDeclaration.prototype.set marginRight):
>+        (foo.html.CssStyleDeclaration.prototype.get _marginRight):
>+        (foo.html.CssStyleDeclaration.prototype.set _marginRight):
>+        (foo.html.CssStyleDeclaration.prototype.get marginTop):
>+        (foo.html.CssStyleDeclaration.prototype.set marginTop):
>+        (foo.html.CssStyleDeclaration.prototype.get _marginTop):
>+        (foo.html.CssStyleDeclaration.prototype.set _marginTop):
>+        (foo.html.CssStyleDeclaration.prototype.get maxHeight):
>+        (foo.html.CssStyleDeclaration.prototype.set maxHeight):
>+        (foo.html.CssStyleDeclaration.prototype.get _maxHeight):
>+        (foo.html.CssStyleDeclaration.prototype.set _maxHeight):
>+        (foo.html.CssStyleDeclaration.prototype.get maxWidth):
>+        (foo.html.CssStyleDeclaration.prototype.set maxWidth):
>+        (foo.html.CssStyleDeclaration.prototype.get _maxWidth):
>+        (foo.html.CssStyleDeclaration.prototype.set _maxWidth):
>+        (foo.html.CssStyleDeclaration.prototype.get minHeight):
>+        (foo.html.CssStyleDeclaration.prototype.set minHeight):
>+        (foo.html.CssStyleDeclaration.prototype.get _minHeight):
>+        (foo.html.CssStyleDeclaration.prototype.set _minHeight):
>+        (foo.html.CssStyleDeclaration.prototype.get minWidth):
>+        (foo.html.CssStyleDeclaration.prototype.set minWidth):
>+        (foo.html.CssStyleDeclaration.prototype.get _minWidth):
>+        (foo.html.CssStyleDeclaration.prototype.set _minWidth):
>+        (foo.html.CssStyleDeclaration.prototype.get outline):
>+        (foo.html.CssStyleDeclaration.prototype.set outline):
>+        (foo.html.CssStyleDeclaration.prototype.get _outline):
>+        (foo.html.CssStyleDeclaration.prototype.set _outline):
>+        (foo.html.CssStyleDeclaration.prototype.get outlineColor):
>+        (foo.html.CssStyleDeclaration.prototype.set outlineColor):
>+        (foo.html.CssStyleDeclaration.prototype.get _outlineColor):
>+        (foo.html.CssStyleDeclaration.prototype.set _outlineColor):
>+        (foo.html.CssStyleDeclaration.prototype.get outlineStyle):
>+        (foo.html.CssStyleDeclaration.prototype.set outlineStyle):
>+        (foo.html.CssStyleDeclaration.prototype.get _outlineStyle):
>+        (foo.html.CssStyleDeclaration.prototype.set _outlineStyle):
>+        (foo.html.CssStyleDeclaration.prototype.get outlineWidth):
>+        (foo.html.CssStyleDeclaration.prototype.set outlineWidth):
>+        (foo.html.CssStyleDeclaration.prototype.get _outlineWidth):
>+        (foo.html.CssStyleDeclaration.prototype.set _outlineWidth):
>+        (foo.html.CssStyleDeclaration.prototype.get overflow):
>+        (foo.html.CssStyleDeclaration.prototype.set overflow):
>+        (foo.html.CssStyleDeclaration.prototype.get _overflow):
>+        (foo.html.CssStyleDeclaration.prototype.set _overflow):
>+        (foo.html.CssStyleDeclaration.prototype.get padding):
>+        (foo.html.CssStyleDeclaration.prototype.set padding):
>+        (foo.html.CssStyleDeclaration.prototype.get _padding):
>+        (foo.html.CssStyleDeclaration.prototype.set _padding):
>+        (foo.html.CssStyleDeclaration.prototype.get paddingBottom):
>+        (foo.html.CssStyleDeclaration.prototype.set paddingBottom):
>+        (foo.html.CssStyleDeclaration.prototype.get _paddingBottom):
>+        (foo.html.CssStyleDeclaration.prototype.set _paddingBottom):
>+        (foo.html.CssStyleDeclaration.prototype.get paddingLeft):
>+        (foo.html.CssStyleDeclaration.prototype.set paddingLeft):
>+        (foo.html.CssStyleDeclaration.prototype.get _paddingLeft):
>+        (foo.html.CssStyleDeclaration.prototype.set _paddingLeft):
>+        (foo.html.CssStyleDeclaration.prototype.get paddingRight):
>+        (foo.html.CssStyleDeclaration.prototype.set paddingRight):
>+        (foo.html.CssStyleDeclaration.prototype.get _paddingRight):
>+        (foo.html.CssStyleDeclaration.prototype.set _paddingRight):
>+        (foo.html.CssStyleDeclaration.prototype.get paddingTop):
>+        (foo.html.CssStyleDeclaration.prototype.set paddingTop):
>+        (foo.html.CssStyleDeclaration.prototype.get _paddingTop):
>+        (foo.html.CssStyleDeclaration.prototype.set _paddingTop):
>+        (foo.html.CssStyleDeclaration.prototype.get pageBreakAfter):
>+        (foo.html.CssStyleDeclaration.prototype.set pageBreakAfter):
>+        (foo.html.CssStyleDeclaration.prototype.get _pageBreakAfter):
>+        (foo.html.CssStyleDeclaration.prototype.set _pageBreakAfter):
>+        (foo.html.CssStyleDeclaration.prototype.get pageBreakBefore):
>+        (foo.html.CssStyleDeclaration.prototype.set pageBreakBefore):
>+        (foo.html.CssStyleDeclaration.prototype.get _pageBreakBefore):
>+        (foo.html.CssStyleDeclaration.prototype.set _pageBreakBefore):
>+        (foo.html.CssStyleDeclaration.prototype.get pageBreakInside):
>+        (foo.html.CssStyleDeclaration.prototype.set pageBreakInside):
>+        (foo.html.CssStyleDeclaration.prototype.get _pageBreakInside):
>+        (foo.html.CssStyleDeclaration.prototype.set _pageBreakInside):
>+        (foo.html.CssStyleDeclaration.prototype.get position):
>+        (foo.html.CssStyleDeclaration.prototype.set position):
>+        (foo.html.CssStyleDeclaration.prototype.get _position):
>+        (foo.html.CssStyleDeclaration.prototype.set _position):
>+        (foo.html.CssStyleDeclaration.prototype.get quotes):
>+        (foo.html.CssStyleDeclaration.prototype.set quotes):
>+        (foo.html.CssStyleDeclaration.prototype.get _quotes):
>+        (foo.html.CssStyleDeclaration.prototype.set _quotes):
>+        (foo.html.CssStyleDeclaration.prototype.get right):
>+        (foo.html.CssStyleDeclaration.prototype.set right):
>+        (foo.html.CssStyleDeclaration.prototype.get _right):
>+        (foo.html.CssStyleDeclaration.prototype.set _right):
>+        (foo.html.CssStyleDeclaration.prototype.get tableLayout):
>+        (foo.html.CssStyleDeclaration.prototype.set tableLayout):
>+        (foo.html.CssStyleDeclaration.prototype.get _tableLayout):
>+        (foo.html.CssStyleDeclaration.prototype.set _tableLayout):
>+        (foo.html.CssStyleDeclaration.prototype.get textAlign):
>+        (foo.html.CssStyleDeclaration.prototype.set textAlign):
>+        (foo.html.CssStyleDeclaration.prototype.get _textAlign):
>+        (foo.html.CssStyleDeclaration.prototype.set _textAlign):
>+        (foo.html.CssStyleDeclaration.prototype.get textDecoration):
>+        (foo.html.CssStyleDeclaration.prototype.set textDecoration):
>+        (foo.html.CssStyleDeclaration.prototype.get _textDecoration):
>+        (foo.html.CssStyleDeclaration.prototype.set _textDecoration):
>+        (foo.html.CssStyleDeclaration.prototype.get textIndent):
>+        (foo.html.CssStyleDeclaration.prototype.set textIndent):
>+        (foo.html.CssStyleDeclaration.prototype.get _textIndent):
>+        (foo.html.CssStyleDeclaration.prototype.set _textIndent):
>+        (foo.html.CssStyleDeclaration.prototype.get textTransform):
>+        (foo.html.CssStyleDeclaration.prototype.set textTransform):
>+        (foo.html.CssStyleDeclaration.prototype.get _textTransform):
>+        (foo.html.CssStyleDeclaration.prototype.set _textTransform):
>+        (foo.html.CssStyleDeclaration.prototype.get top):
>+        (foo.html.CssStyleDeclaration.prototype.set top):
>+        (foo.html.CssStyleDeclaration.prototype.get _top):
>+        (foo.html.CssStyleDeclaration.prototype.set _top):
>+        (foo.html.CssStyleDeclaration.prototype.get unicodeBidi):
>+        (foo.html.CssStyleDeclaration.prototype.set unicodeBidi):
>+        (foo.html.CssStyleDeclaration.prototype.get _unicodeBidi):
>+        (foo.html.CssStyleDeclaration.prototype.set _unicodeBidi):
>+        (foo.html.CssStyleDeclaration.prototype.get verticalAlign):
>+        (foo.html.CssStyleDeclaration.prototype.set verticalAlign):
>+        (foo.html.CssStyleDeclaration.prototype.get _verticalAlign):
>+        (foo.html.CssStyleDeclaration.prototype.set _verticalAlign):
>+        (foo.html.CssStyleDeclaration.prototype.get visibility):
>+        (foo.html.CssStyleDeclaration.prototype.set visibility):
>+        (foo.html.CssStyleDeclaration.prototype.get _visibility):
>+        (foo.html.CssStyleDeclaration.prototype.set _visibility):
>+        (foo.html.CssStyleDeclaration.prototype.get whiteSpace):
>+        (foo.html.CssStyleDeclaration.prototype.set whiteSpace):
>+        (foo.html.CssStyleDeclaration.prototype.get _whiteSpace):
>+        (foo.html.CssStyleDeclaration.prototype.set _whiteSpace):
>+        (foo.html.CssStyleDeclaration.prototype.get width):
>+        (foo.html.CssStyleDeclaration.prototype.set width):
>+        (foo.html.CssStyleDeclaration.prototype.get _width):
>+        (foo.html.CssStyleDeclaration.prototype.set _width):
>+        (foo.html.CssStyleDeclaration.prototype.get wordSpacing):
>+        (foo.html.CssStyleDeclaration.prototype.set wordSpacing):
>+        (foo.html.CssStyleDeclaration.prototype.get _wordSpacing):
>+        (foo.html.CssStyleDeclaration.prototype.set _wordSpacing):
>+        (foo.html.CssStyleDeclaration.prototype.get zIndex):
>+        (foo.html.CssStyleDeclaration.prototype.set zIndex):
>+        (foo.html.CssStyleDeclaration.prototype.get _zIndex):
>+        (foo.html.CssStyleDeclaration.prototype.set _zIndex):
>+        (foo.html.CssStyleDeclaration):
>+        (foo.html.BackgroundFetchManager.prototype.get return):
>+        (foo.html.BackgroundFetchManager):
>+        (foo.const.Object_CssStyleDeclarationBase):
>+        (foo.html._CssStyleDeclarationSet.prototype.getPropertyValue):
>+        (foo.html._CssStyleDeclarationSet.prototype.setProperty):
>+        (foo.html._CssStyleDeclarationSet.prototype._setAll):
>+        (foo.html._CssStyleDeclarationSet.prototype.set background):
>+        (foo.html._CssStyleDeclarationSet.prototype.get background):
>+        (foo.html._CssStyleDeclarationSet.prototype.set backgroundAttachment):
>+        (foo.html._CssStyleDeclarationSet.prototype.get backgroundAttachment):
>+        (foo.html._CssStyleDeclarationSet.prototype.set backgroundColor):
>+        (foo.html._CssStyleDeclarationSet.prototype.get backgroundColor):
>+        (foo.html._CssStyleDeclarationSet.prototype.set backgroundImage):
>+        (foo.html._CssStyleDeclarationSet.prototype.get backgroundImage):
>+        (foo.html._CssStyleDeclarationSet.prototype.set backgroundPosition):
>+        (foo.html._CssStyleDeclarationSet.prototype.get backgroundPosition):
>+        (foo.html._CssStyleDeclarationSet.prototype.set backgroundRepeat):
>+        (foo.html._CssStyleDeclarationSet.prototype.get backgroundRepeat):
>+        (foo.html._CssStyleDeclarationSet.prototype.set border):
>+        (foo.html._CssStyleDeclarationSet.prototype.get border):
>+        (foo.html._CssStyleDeclarationSet.prototype.set borderBottom):
>+        (foo.html._CssStyleDeclarationSet.prototype.get borderBottom):
>+        (foo.html._CssStyleDeclarationSet.prototype.set borderBottomColor):
>+        (foo.html._CssStyleDeclarationSet.prototype.get borderBottomColor):
>+        (foo.html._CssStyleDeclarationSet.prototype.set borderBottomStyle):
>+        (foo.html._CssStyleDeclarationSet.prototype.get borderBottomStyle):
>+        (foo.html._CssStyleDeclarationSet.prototype.set borderBottomWidth):
>+        (foo.html._CssStyleDeclarationSet.prototype.get borderBottomWidth):
>+        (foo.html._CssStyleDeclarationSet.prototype.set borderCollapse):
>+        (foo.html._CssStyleDeclarationSet.prototype.get borderCollapse):
>+        (foo.html._CssStyleDeclarationSet.prototype.set borderColor):
>+        (foo.html._CssStyleDeclarationSet.prototype.get borderColor):
>+        (foo.html._CssStyleDeclarationSet.prototype.set borderLeft):
>+        (foo.html._CssStyleDeclarationSet.prototype.get borderLeft):
>+        (foo.html._CssStyleDeclarationSet.prototype.set borderLeftColor):
>+        (foo.html._CssStyleDeclarationSet.prototype.get borderLeftColor):
>+        (foo.html._CssStyleDeclarationSet.prototype.set borderLeftStyle):
>+        (foo.html._CssStyleDeclarationSet.prototype.get borderLeftStyle):
>+        (foo.html._CssStyleDeclarationSet.prototype.set borderLeftWidth):
>+        (foo.html._CssStyleDeclarationSet.prototype.get borderLeftWidth):
>+        (foo.html._CssStyleDeclarationSet.prototype.set borderRight):
>+        (foo.html._CssStyleDeclarationSet.prototype.get borderRight):
>+        (foo.html._CssStyleDeclarationSet.prototype.set borderRightColor):
>+        (foo.html._CssStyleDeclarationSet.prototype.get borderRightColor):
>+        (foo.html._CssStyleDeclarationSet.prototype.set borderRightStyle):
>+        (foo.html._CssStyleDeclarationSet.prototype.get borderRightStyle):
>+        (foo.html._CssStyleDeclarationSet.prototype.set borderRightWidth):
>+        (foo.html._CssStyleDeclarationSet.prototype.get borderRightWidth):
>+        (foo.html._CssStyleDeclarationSet.prototype.set borderSpacing):
>+        (foo.html._CssStyleDeclarationSet.prototype.get borderSpacing):
>+        (foo.html._CssStyleDeclarationSet.prototype.set borderStyle):
>+        (foo.html._CssStyleDeclarationSet.prototype.get borderStyle):
>+        (foo.html._CssStyleDeclarationSet.prototype.set borderTop):
>+        (foo.html._CssStyleDeclarationSet.prototype.get borderTop):
>+        (foo.html._CssStyleDeclarationSet.prototype.set borderTopColor):
>+        (foo.html._CssStyleDeclarationSet.prototype.get borderTopColor):
>+        (foo.html._CssStyleDeclarationSet.prototype.set borderTopStyle):
>+        (foo.html._CssStyleDeclarationSet.prototype.get borderTopStyle):
>+        (foo.html._CssStyleDeclarationSet.prototype.set borderTopWidth):
>+        (foo.html._CssStyleDeclarationSet.prototype.get borderTopWidth):
>+        (foo.html._CssStyleDeclarationSet.prototype.set borderWidth):
>+        (foo.html._CssStyleDeclarationSet.prototype.get borderWidth):
>+        (foo.html._CssStyleDeclarationSet.prototype.set bottom):
>+        (foo.html._CssStyleDeclarationSet.prototype.get bottom):
>+        (foo.html._CssStyleDeclarationSet.prototype.set captionSide):
>+        (foo.html._CssStyleDeclarationSet.prototype.get captionSide):
>+        (foo.html._CssStyleDeclarationSet.prototype.set clear):
>+        (foo.html._CssStyleDeclarationSet.prototype.get clear):
>+        (foo.html._CssStyleDeclarationSet.prototype.set clip):
>+        (foo.html._CssStyleDeclarationSet.prototype.get clip):
>+        (foo.html._CssStyleDeclarationSet.prototype.set color):
>+        (foo.html._CssStyleDeclarationSet.prototype.get color):
>+        (foo.html._CssStyleDeclarationSet.prototype.set content):
>+        (foo.html._CssStyleDeclarationSet.prototype.get content):
>+        (foo.html._CssStyleDeclarationSet.prototype.set cursor):
>+        (foo.html._CssStyleDeclarationSet.prototype.get cursor):
>+        (foo.html._CssStyleDeclarationSet.prototype.set direction):
>+        (foo.html._CssStyleDeclarationSet.prototype.get direction):
>+        (foo.html._CssStyleDeclarationSet.prototype.set display):
>+        (foo.html._CssStyleDeclarationSet.prototype.get display):
>+        (foo.html._CssStyleDeclarationSet.prototype.set emptyCells):
>+        (foo.html._CssStyleDeclarationSet.prototype.get emptyCells):
>+        (foo.html._CssStyleDeclarationSet.prototype.set font):
>+        (foo.html._CssStyleDeclarationSet.prototype.get font):
>+        (foo.html._CssStyleDeclarationSet.prototype.set fontFamily):
>+        (foo.html._CssStyleDeclarationSet.prototype.get fontFamily):
>+        (foo.html._CssStyleDeclarationSet.prototype.set fontSize):
>+        (foo.html._CssStyleDeclarationSet.prototype.get fontSize):
>+        (foo.html._CssStyleDeclarationSet.prototype.set fontStyle):
>+        (foo.html._CssStyleDeclarationSet.prototype.get fontStyle):
>+        (foo.html._CssStyleDeclarationSet.prototype.set fontVariant):
>+        (foo.html._CssStyleDeclarationSet.prototype.get fontVariant):
>+        (foo.html._CssStyleDeclarationSet.prototype.set fontWeight):
>+        (foo.html._CssStyleDeclarationSet.prototype.get fontWeight):
>+        (foo.html._CssStyleDeclarationSet.prototype.set height):
>+        (foo.html._CssStyleDeclarationSet.prototype.get height):
>+        (foo.html._CssStyleDeclarationSet.prototype.set left):
>+        (foo.html._CssStyleDeclarationSet.prototype.get left):
>+        (foo.html._CssStyleDeclarationSet.prototype.set letterSpacing):
>+        (foo.html._CssStyleDeclarationSet.prototype.get letterSpacing):
>+        (foo.html._CssStyleDeclarationSet.prototype.set lineHeight):
>+        (foo.html._CssStyleDeclarationSet.prototype.get lineHeight):
>+        (foo.html._CssStyleDeclarationSet.prototype.set listStyle):
>+        (foo.html._CssStyleDeclarationSet.prototype.get listStyle):
>+        (foo.html._CssStyleDeclarationSet.prototype.set listStyleImage):
>+        (foo.html._CssStyleDeclarationSet.prototype.get listStyleImage):
>+        (foo.html._CssStyleDeclarationSet.prototype.set listStylePosition):
>+        (foo.html._CssStyleDeclarationSet.prototype.get listStylePosition):
>+        (foo.html._CssStyleDeclarationSet.prototype.set listStyleType):
>+        (foo.html._CssStyleDeclarationSet.prototype.get listStyleType):
>+        (foo.html._CssStyleDeclarationSet.prototype.set margin):
>+        (foo.html._CssStyleDeclarationSet.prototype.get margin):
>+        (foo.html._CssStyleDeclarationSet.prototype.set marginBottom):
>+        (foo.html._CssStyleDeclarationSet.prototype.get marginBottom):
>+        (foo.html._CssStyleDeclarationSet.prototype.set marginLeft):
>+        (foo.html._CssStyleDeclarationSet.prototype.get marginLeft):
>+        (foo.html._CssStyleDeclarationSet.prototype.set marginRight):
>+        (foo.html._CssStyleDeclarationSet.prototype.get marginRight):
>+        (foo.html._CssStyleDeclarationSet.prototype.set marginTop):
>+        (foo.html._CssStyleDeclarationSet.prototype.get marginTop):
>+        (foo.html._CssStyleDeclarationSet.prototype.set maxHeight):
>+        (foo.html._CssStyleDeclarationSet.prototype.get maxHeight):
>+        (foo.html._CssStyleDeclarationSet.prototype.set maxWidth):
>+        (foo.html._CssStyleDeclarationSet.prototype.get maxWidth):
>+        (foo.html._CssStyleDeclarationSet.prototype.set minHeight):
>+        (foo.html._CssStyleDeclarationSet.prototype.get minHeight):
>+        (foo.html._CssStyleDeclarationSet.prototype.set minWidth):
>+        (foo.html._CssStyleDeclarationSet.prototype.get minWidth):
>+        (foo.html._CssStyleDeclarationSet.prototype.set outline):
>+        (foo.html._CssStyleDeclarationSet.prototype.get outline):
>+        (foo.html._CssStyleDeclarationSet.prototype.set outlineColor):
>+        (foo.html._CssStyleDeclarationSet.prototype.get outlineColor):
>+        (foo.html._CssStyleDeclarationSet.prototype.set outlineStyle):
>+        (foo.html._CssStyleDeclarationSet.prototype.get outlineStyle):
>+        (foo.html._CssStyleDeclarationSet.prototype.set outlineWidth):
>+        (foo.html._CssStyleDeclarationSet.prototype.get outlineWidth):
>+        (foo.html._CssStyleDeclarationSet.prototype.set overflow):
>+        (foo.html._CssStyleDeclarationSet.prototype.get overflow):
>+        (foo.html._CssStyleDeclarationSet.prototype.set padding):
>+        (foo.html._CssStyleDeclarationSet.prototype.get padding):
>+        (foo.html._CssStyleDeclarationSet.prototype.set paddingBottom):
>+        (foo.html._CssStyleDeclarationSet.prototype.get paddingBottom):
>+        (foo.html._CssStyleDeclarationSet.prototype.set paddingLeft):
>+        (foo.html._CssStyleDeclarationSet.prototype.get paddingLeft):
>+        (foo.html._CssStyleDeclarationSet.prototype.set paddingRight):
>+        (foo.html._CssStyleDeclarationSet.prototype.get paddingRight):
>+        (foo.html._CssStyleDeclarationSet.prototype.set paddingTop):
>+        (foo.html._CssStyleDeclarationSet.prototype.get paddingTop):
>+        (foo.html._CssStyleDeclarationSet.prototype.set pageBreakAfter):
>+        (foo.html._CssStyleDeclarationSet.prototype.get pageBreakAfter):
>+        (foo.html._CssStyleDeclarationSet.prototype.set pageBreakBefore):
>+        (foo.html._CssStyleDeclarationSet.prototype.get pageBreakBefore):
>+        (foo.html._CssStyleDeclarationSet.prototype.set pageBreakInside):
>+        (foo.html._CssStyleDeclarationSet.prototype.get pageBreakInside):
>+        (foo.html._CssStyleDeclarationSet.prototype.set position):
>+        (foo.html._CssStyleDeclarationSet.prototype.get position):
>+        (foo.html._CssStyleDeclarationSet.prototype.set quotes):
>+        (foo.html._CssStyleDeclarationSet.prototype.get quotes):
>+        (foo.html._CssStyleDeclarationSet.prototype.set right):
>+        (foo.html._CssStyleDeclarationSet.prototype.get right):
>+        (foo.html._CssStyleDeclarationSet.prototype.set tableLayout):
>+        (foo.html._CssStyleDeclarationSet.prototype.get tableLayout):
>+        (foo.html._CssStyleDeclarationSet.prototype.set textAlign):
>+        (foo.html._CssStyleDeclarationSet.prototype.get textAlign):
>+        (foo.html._CssStyleDeclarationSet.prototype.set textDecoration):
>+        (foo.html._CssStyleDeclarationSet.prototype.get textDecoration):
>+        (foo.html._CssStyleDeclarationSet.prototype.set textIndent):
>+        (foo.html._CssStyleDeclarationSet.prototype.get textIndent):
>+        (foo.html._CssStyleDeclarationSet.prototype.set textTransform):
>+        (foo.html._CssStyleDeclarationSet.prototype.get textTransform):
>+        (foo.html._CssStyleDeclarationSet.prototype.set top):
>+        (foo.html._CssStyleDeclarationSet.prototype.get top):
>+        (foo.html._CssStyleDeclarationSet.prototype.set unicodeBidi):
>+        (foo.html._CssStyleDeclarationSet.prototype.get unicodeBidi):
>+        (foo.html._CssStyleDeclarationSet.prototype.set verticalAlign):
>+        (foo.html._CssStyleDeclarationSet.prototype.get verticalAlign):
>+        (foo.html._CssStyleDeclarationSet.prototype.set visibility):
>+        (foo.html._CssStyleDeclarationSet.prototype.get visibility):
>+        (foo.html._CssStyleDeclarationSet.prototype.set whiteSpace):
>+        (foo.html._CssStyleDeclarationSet.prototype.get whiteSpace):
>+        (foo.html._CssStyleDeclarationSet.prototype.set width):
>+        (foo.html._CssStyleDeclarationSet.prototype.get width):
>+        (foo.html._CssStyleDeclarationSet.prototype.set wordSpacing):
>+        (foo.html._CssStyleDeclarationSet.prototype.get wordSpacing):
>+        (foo.html._CssStyleDeclarationSet.prototype.set zIndex):
>+        (foo.html._CssStyleDeclarationSet.prototype.get zIndex):
>+        (foo.html._CssStyleDeclarationSet):
>+        (foo.html.CssStyleRule.prototype.get selectorText):
>+        (foo.html.CssStyleRule.prototype.set selectorText):
>+        (foo.html.CssStyleRule.prototype.get style):
>+        (foo.html.CssStyleRule):
>+        (foo.html.StyleSheet.prototype.get disabled):
>+        (foo.html.StyleSheet.prototype.set disabled):
>+        (foo.html.StyleSheet.prototype.get href):
>+        (foo.html.StyleSheet.prototype.get media):
>+        (foo.html.StyleSheet.prototype.get ownerNode):
>+        (foo.html.StyleSheet.prototype.get parentStyleSheet):
>+        (foo.html.StyleSheet.prototype.get title):
>+        (foo.html.StyleSheet.prototype.get type):
>+        (foo.html.StyleSheet):
>+        (foo.html.CssStyleSheet.prototype.get cssRules):
>+        (foo.html.CssStyleSheet.prototype.get ownerRule):
>+        (foo.html.CssStyleSheet.prototype.get rules):
>+        (foo.html.CssStyleSheet.prototype.addRule):
>+        (foo.html.CssStyleSheet.prototype.deleteRule):
>+        (foo.html.CssStyleSheet.prototype.insertRule):
>+        (foo.html.CssStyleSheet.prototype.removeRule):
>+        (foo.html.CssStyleSheet):
>+        (foo.html.CssSupportsRule):
>+        (foo.html.CssTransformValue.new):
>+        (foo.html.CssTransformValue._create_1):
>+        (foo.html.CssTransformValue._create_2):
>+        (foo.html.CssTransformValue.prototype.get is2D):
>+        (foo.html.CssTransformValue.prototype.get length):
>+        (foo.html.CssTransformValue.prototype.componentAtIndex):
>+        (foo.html.CssTransformValue.prototype.toMatrix):
>+        (foo.html.CssTransformValue):
>+        (foo.html.CssTranslation.new):
>+        (foo.html.CssTranslation._create_1):
>+        (foo.html.CssTranslation._create_2):
>+        (foo.html.CssTranslation.prototype.get x):
>+        (foo.html.CssTranslation.prototype.set x):
>+        (foo.html.CssTranslation.prototype.get y):
>+        (foo.html.CssTranslation.prototype.set y):
>+        (foo.html.CssTranslation.prototype.get z):
>+        (foo.html.CssTranslation.prototype.set z):
>+        (foo.html.CssTranslation):
>+        (foo.html.CssUnitValue.new):
>+        (foo.html.CssUnitValue._create_1):
>+        (foo.html.CssUnitValue.prototype.get type):
>+        (foo.html.CssUnitValue.prototype.get unit):
>+        (foo.html.CssUnitValue.prototype.set unit):
>+        (foo.html.CssUnitValue.prototype.get value):
>+        (foo.html.CssUnitValue.prototype.set value):
>+        (foo.html.CssUnitValue):
>+        (foo.html.CssUnparsedValue.prototype.get length):
>+        (foo.html.CssUnparsedValue.prototype.fragmentAtIndex):
>+        (foo.html.CssUnparsedValue):
>+        (foo.html.CssVariableReferenceValue.prototype.get fallback):
>+        (foo.html.CssVariableReferenceValue.prototype.get variable):
>+        (foo.html.CssVariableReferenceValue):
>+        (foo.html.CssViewportRule.prototype.get style):
>+        (foo.html.CssViewportRule):
>+        (foo.html.CssurlImageValue.new):
>+        (foo.html.CssurlImageValue._create_1):
>+        (foo.html.CssurlImageValue.prototype.get url):
>+        (foo.html.CssurlImageValue):
>+        (foo.html.CustomElementRegistry.define):
>+        (foo.html.CustomElementRegistry._define_1):
>+        (foo.html.CustomElementRegistry.prototype._define_2):
>+        (foo.html.CustomEvent.prototype.get _dartDetail):
>+        (foo.html.CustomEvent.prototype.set _dartDetail):
>+        (foo.html.CustomEvent.new):
>+        (foo.html.CustomEvent.prototype.get detail):
>+        (foo.html.CustomEvent.__):
>+        (foo.html.CustomEvent._create_1):
>+        (foo.html.CustomEvent._create_2):
>+        (foo.html.CustomEvent.prototype.get _detail):
>+        (foo.html.CustomEvent.prototype.get _get__detail):
>+        (foo.html.CustomEvent.prototype._initCustomEvent):
>+        (foo.html.CustomEvent):
>+        (foo.html.DListElement.new):
>+        (foo.html.DListElement):
>+        (foo.html.DataElement.prototype.get value):
>+        (foo.html.DataElement.prototype.set value):
>+        (foo.html.DataElement):
>+        (foo.html.DataListElement.new):
>+        (foo.html.DataListElement.get supported):
>+        (foo.html.DataListElement.prototype.get options):
>+        (foo.html.DataListElement):
>+        (foo.html.DataTransfer.new):
>+        (foo.html.DataTransfer._create_1):
>+        (foo.html.DataTransfer.prototype.get dropEffect):
>+        (foo.html.DataTransfer.prototype.set dropEffect):
>+        (foo.html.DataTransfer.prototype.get effectAllowed):
>+        (foo.html.DataTransfer.prototype.set effectAllowed):
>+        (foo.html.DataTransfer.prototype.get files):
>+        (foo.html.DataTransfer.prototype.get items):
>+        (foo.html.DataTransfer.prototype.get types):
>+        (foo.html.DataTransfer.prototype.clearData):
>+        (foo.html.DataTransfer.prototype.getData):
>+        (foo.html.DataTransfer.prototype.setData):
>+        (foo.html.DataTransfer.prototype.setDragImage):
>+        (foo.html.DataTransfer):
>+        (foo.html.DataTransferItem.prototype.getAsEntry):
>+        (foo.html.DataTransferItem.prototype.get kind):
>+        (foo.html.DataTransferItem.prototype.get type):
>+        (foo.html.DataTransferItem.prototype.getAsFile):
>+        (foo.html.DataTransferItem.prototype._webkitGetAsEntry):
>+        (foo.html.DataTransferItem):
>+        (foo.html.DataTransferItemList.prototype.get length):
>+        (foo.html.DataTransferItemList.prototype.add):
>+        (foo.html.DataTransferItemList.prototype.addData):
>+        (foo.html.DataTransferItemList.prototype.addFile):
>+        (foo.html.DataTransferItemList.prototype.clear):
>+        (foo.html.DataTransferItemList.prototype.item):
>+        (foo.html.DataTransferItemList.prototype.remove):
>+        (foo.html.DataTransferItemList.prototype._get):
>+        (foo.html.DataTransferItemList):
>+        (foo.html.WorkerGlobalScope.prototype.get addressSpace):
>+        (foo.html.WorkerGlobalScope.prototype.get caches):
>+        (foo.html.WorkerGlobalScope.prototype.get crypto):
>+        (foo.html.WorkerGlobalScope.prototype.get indexedDB):
>+        (foo.html.WorkerGlobalScope.prototype.get isSecureContext):
>+        (foo.html.WorkerGlobalScope.prototype.get location):
>+        (foo.html.WorkerGlobalScope.prototype.get navigator):
>+        (foo.html.WorkerGlobalScope.prototype.get origin):
>+        (foo.html.WorkerGlobalScope.prototype.get performance):
>+        (foo.html.WorkerGlobalScope.prototype.get self):
>+        (foo.html.WorkerGlobalScope.prototype.fetch):
>+        (foo.html.WorkerGlobalScope.prototype.importScripts):
>+        (foo.html.WorkerGlobalScope.prototype.atob):
>+        (foo.html.WorkerGlobalScope.prototype.btoa):
>+        (foo.html.WorkerGlobalScope.prototype._setInterval_String):
>+        (foo.html.WorkerGlobalScope.prototype._setTimeout_String):
>+        (foo.html.WorkerGlobalScope.prototype._clearInterval):
>+        (foo.html.WorkerGlobalScope.prototype._clearTimeout):
>+        (foo.html.WorkerGlobalScope.prototype._setInterval):
>+        (foo.html.WorkerGlobalScope.prototype._setTimeout):
>+        (foo.html.WorkerGlobalScope.prototype.get onError):
>+        (foo.html.WorkerGlobalScope.get instance):
>+        (foo.html.WorkerGlobalScope):
>+        (foo.html.DedicatedWorkerGlobalScope.prototype.close):
>+        (foo.html.DedicatedWorkerGlobalScope.prototype.postMessage):
>+        (foo.html.DedicatedWorkerGlobalScope.prototype._postMessage_1):
>+        (foo.html.DedicatedWorkerGlobalScope.prototype._postMessage_2):
>+        (foo.html.DedicatedWorkerGlobalScope.prototype._webkitRequestFileSystem):
>+        (foo.html.DedicatedWorkerGlobalScope.prototype.requestFileSystemSync):
>+        (foo.html.DedicatedWorkerGlobalScope.prototype.resolveLocalFileSystemSyncUrl):
>+        (foo.html.DedicatedWorkerGlobalScope.prototype._webkitResolveLocalFileSystemUrl):
>+        (foo.html.DedicatedWorkerGlobalScope.prototype.get onMessage):
>+        (foo.html.DedicatedWorkerGlobalScope.get instance):
>+        (foo.html.DedicatedWorkerGlobalScope):
>+        (foo.html.DeprecatedStorageInfo.prototype.queryUsageAndQuota):
>+        (foo.html.DeprecatedStorageInfo.prototype.requestQuota):
>+        (foo.html.DeprecatedStorageInfo):
>+        (foo.html.DeprecatedStorageQuota.prototype.queryUsageAndQuota):
>+        (foo.html.DeprecatedStorageQuota.prototype.requestQuota):
>+        (foo.html.DeprecatedStorageQuota):
>+        (foo.html.ReportBody):
>+        (foo.html.DeprecationReport.prototype.get lineNumber):
>+        (foo.html.DeprecationReport.prototype.get message):
>+        (foo.html.DeprecationReport.prototype.get sourceFile):
>+        (foo.html.DeprecationReport):
>+        (foo.html.DetailsElement.new):
>+        (foo.html.DetailsElement.get supported):
>+        (foo.html.DetailsElement.prototype.get open):
>+        (foo.html.DetailsElement.prototype.set open):
>+        (foo.html.DetailsElement):
>+        (foo.html.DetectedBarcode.new):
>+        (foo.html.DetectedBarcode._create_1):
>+        (foo.html.DetectedBarcode.prototype.get boundingBox):
>+        (foo.html.DetectedBarcode.prototype.get cornerPoints):
>+        (foo.html.DetectedBarcode.prototype.get rawValue):
>+        (foo.html.DetectedBarcode):
>+        (foo.html.DetectedFace.new):
>+        (foo.html.DetectedFace._create_1):
>+        (foo.html.DetectedFace.prototype.get boundingBox):
>+        (foo.html.DetectedFace.prototype.get landmarks):
>+        (foo.html.DetectedFace):
>+        (foo.html.DetectedText.new):
>+        (foo.html.DetectedText._create_1):
>+        (foo.html.DetectedText.prototype.get boundingBox):
>+        (foo.html.DetectedText.prototype.get cornerPoints):
>+        (foo.html.DetectedText.prototype.get rawValue):
>+        (foo.html.DetectedText):
>+        (foo.html.DeviceAcceleration.prototype.get x):
>+        (foo.html.DeviceAcceleration.prototype.get y):
>+        (foo.html.DeviceAcceleration.prototype.get z):
>+        (foo.html.DeviceAcceleration):
>+        (foo.html.DeviceMotionEvent.new):
>+        (foo.html.DeviceMotionEvent._create_1):
>+        (foo.html.DeviceMotionEvent._create_2):
>+        (foo.html.DeviceMotionEvent.prototype.get acceleration):
>+        (foo.html.DeviceMotionEvent.prototype.get accelerationIncludingGravity):
>+        (foo.html.DeviceMotionEvent.prototype.get interval):
>+        (foo.html.DeviceMotionEvent.prototype.get rotationRate):
>+        (foo.html.DeviceMotionEvent):
>+        (foo.html.DeviceOrientationEvent.new):
>+        (foo.html.DeviceOrientationEvent._create_1):
>+        (foo.html.DeviceOrientationEvent._create_2):
>+        (foo.html.DeviceOrientationEvent.prototype.get absolute):
>+        (foo.html.DeviceOrientationEvent.prototype.get alpha):
>+        (foo.html.DeviceOrientationEvent.prototype.get beta):
>+        (foo.html.DeviceOrientationEvent.prototype.get gamma):
>+        (foo.html.DeviceOrientationEvent):
>+        (foo.html.DeviceRotationRate.prototype.get alpha):
>+        (foo.html.DeviceRotationRate.prototype.get beta):
>+        (foo.html.DeviceRotationRate.prototype.get gamma):
>+        (foo.html.DeviceRotationRate):
>+        (foo.html.DialogElement.prototype.get open):
>+        (foo.html.DialogElement.prototype.set open):
>+        (foo.html.DialogElement.prototype.get returnValue):
>+        (foo.html.DialogElement.prototype.set returnValue):
>+        (foo.html.DialogElement.prototype.close):
>+        (foo.html.DialogElement.prototype.show):
>+        (foo.html.DialogElement.prototype.showModal):
>+        (foo.html.DialogElement):
>+        (foo.html.Entry.prototype.get filesystem):
>+        (foo.html.Entry.prototype.get fullPath):
>+        (foo.html.Entry.prototype.get isDirectory):
>+        (foo.html.Entry.prototype.get isFile):
>+        (foo.html.Entry.prototype.get name):
>+        (foo.html.Entry.prototype._copyTo):
>+        (foo.html.Entry.prototype.copyTo):
>+        (foo.html.Entry.prototype._getMetadata):
>+        (foo.html.Entry.prototype.getMetadata):
>+        (foo.html.Entry.prototype._getParent):
>+        (foo.html.Entry.prototype.getParent):
>+        (foo.html.Entry.prototype._moveTo):
>+        (foo.html.Entry.prototype.moveTo):
>+        (foo.html.Entry.prototype._remove):
>+        (foo.html.Entry.prototype.remove.let.completer.async Completer):
>+        (foo.html.Entry.prototype.remove):
>+        (foo.html.Entry.prototype.toUrl):
>+        (foo.html.Entry):
>+        (foo.html.DirectoryEntry.prototype.createDirectory):
>+        (foo.html.DirectoryEntry.prototype.createReader):
>+        (foo.html.DirectoryEntry.prototype.getDirectory):
>+        (foo.html.DirectoryEntry.prototype.createFile):
>+        (foo.html.DirectoryEntry.prototype.getFile):
>+        (foo.html.DirectoryEntry.prototype._createReader):
>+        (foo.html.DirectoryEntry.prototype.__getDirectory):
>+        (foo.html.DirectoryEntry.prototype.__getDirectory_1):
>+        (foo.html.DirectoryEntry.prototype.__getDirectory_2):
>+        (foo.html.DirectoryEntry.prototype.__getDirectory_3):
>+        (foo.html.DirectoryEntry.prototype.__getDirectory_4):
>+        (foo.html.DirectoryEntry.prototype._getDirectory):
>+        (foo.html.DirectoryEntry.prototype.__getFile):
>+        (foo.html.DirectoryEntry.prototype.__getFile_1):
>+        (foo.html.DirectoryEntry.prototype.__getFile_2):
>+        (foo.html.DirectoryEntry.prototype.__getFile_3):
>+        (foo.html.DirectoryEntry.prototype.__getFile_4):
>+        (foo.html.DirectoryEntry.prototype._getFile):
>+        (foo.html.DirectoryEntry.prototype._removeRecursively):
>+        (foo.html.DirectoryEntry.prototype.removeRecursively.let.completer.async Completer):
>+        (foo.html.DirectoryEntry.prototype.removeRecursively):
>+        (foo.html.DirectoryEntry):
>+        (foo.html.DirectoryReader.prototype._readEntries):
>+        (foo.html.DirectoryReader.prototype.readEntries):
>+        (foo.html.DirectoryReader):
>+        (foo.html.DivElement.new):
>+        (foo.html.DivElement):
>+        (foo.html.Document.new):
>+        (foo.html.Document._create_1):
>+        (foo.html.Document.prototype.get addressSpace):
>+        (foo.html.Document.prototype.get _body):
>+        (foo.html.Document.prototype.set _body):
>+        (foo.html.Document.prototype.get contentType):
>+        (foo.html.Document.prototype.get cookie):
>+        (foo.html.Document.prototype.set cookie):
>+        (foo.html.Document.prototype.get currentScript):
>+        (foo.html.Document.prototype.get window):
>+        (foo.html.Document.prototype.get _get_window):
>+        (foo.html.Document.prototype.get documentElement):
>+        (foo.html.Document.prototype.get domain):
>+        (foo.html.Document.prototype.get fullscreenEnabled):
>+        (foo.html.Document.prototype.get _head):
>+        (foo.html.Document.prototype.get hidden):
>+        (foo.html.Document.prototype.get implementation):
>+        (foo.html.Document.prototype.get _lastModified):
>+        (foo.html.Document.prototype.get origin):
>+        (foo.html.Document.prototype.get _preferredStylesheetSet):
>+        (foo.html.Document.prototype.get readyState):
>+        (foo.html.Document.prototype.get _referrer):
>+        (foo.html.Document.prototype.get rootElement):
>+        (foo.html.Document.prototype.get rootScroller):
>+        (foo.html.Document.prototype.set rootScroller):
>+        (foo.html.Document.prototype.get scrollingElement):
>+        (foo.html.Document.prototype.get _selectedStylesheetSet):
>+        (foo.html.Document.prototype.set _selectedStylesheetSet):
>+        (foo.html.Document.prototype.get suborigin):
>+        (foo.html.Document.prototype.get timeline):
>+        (foo.html.Document.prototype.get _title):
>+        (foo.html.Document.prototype.set _title):
>+        (foo.html.Document.prototype.get _visibilityState):
>+        (foo.html.Document.prototype.get _webkitFullscreenElement):
>+        (foo.html.Document.prototype.get _webkitFullscreenEnabled):
>+        (foo.html.Document.prototype.get _webkitHidden):
>+        (foo.html.Document.prototype.get _webkitVisibilityState):
>+        (foo.html.Document.prototype.adoptNode):
>+        (foo.html.Document.prototype._caretRangeFromPoint):
>+        (foo.html.Document.prototype.createDocumentFragment):
>+        (foo.html.Document.prototype._createElement):
>+        (foo.html.Document.prototype._createElementNS):
>+        (foo.html.Document.prototype._createEvent):
>+        (foo.html.Document.prototype.createRange):
>+        (foo.html.Document.prototype._createTextNode):
>+        (foo.html.Document.prototype._createTouch):
>+        (foo.html.Document.prototype._createTouch_1):
>+        (foo.html.Document.prototype._createTouch_2):
>+        (foo.html.Document.prototype._createTouch_3):
>+        (foo.html.Document.prototype._createTouch_4):
>+        (foo.html.Document.prototype._createTouch_5):
>+        (foo.html.Document.prototype._createTouchList):
>+        (foo.html.Document.prototype.execCommand):
>+        (foo.html.Document.prototype.exitFullscreen):
>+        (foo.html.Document.prototype.exitPointerLock):
>+        (foo.html.Document.prototype.getAnimations):
>+        (foo.html.Document.prototype.getElementsByClassName):
>+        (foo.html.Document.prototype.getElementsByName):
>+        (foo.html.Document.prototype.getElementsByTagName):
>+        (foo.html.Document.prototype.importNode):
>+        (foo.html.Document.prototype.queryCommandEnabled):
>+        (foo.html.Document.prototype.queryCommandIndeterm):
>+        (foo.html.Document.prototype.queryCommandState):
>+        (foo.html.Document.prototype.queryCommandSupported):
>+        (foo.html.Document.prototype.queryCommandValue):
>+        (foo.html.Document.prototype.registerElement2):
>+        (foo.html.Document.prototype._registerElement2_1):
>+        (foo.html.Document.prototype._registerElement2_2):
>+        (foo.html.Document.prototype._webkitExitFullscreen):
>+        (foo.html.Document.prototype.getElementById):
>+        (foo.html.Document.prototype.get activeElement):
>+        (foo.html.Document.prototype.get fullscreenElement):
>+        (foo.html.Document.prototype.get pointerLockElement):
>+        (foo.html.Document.prototype.get _styleSheets):
>+        (foo.html.Document.prototype._elementFromPoint):
>+        (foo.html.Document.prototype.elementsFromPoint):
>+        (foo.html.Document.prototype.get fonts):
>+        (foo.html.Document.prototype.get _childElementCount):
>+        (foo.html.Document.prototype.get _children):
>+        (foo.html.Document.prototype.get _firstElementChild):
>+        (foo.html.Document.prototype.get _lastElementChild):
>+        (foo.html.Document.prototype.querySelector):
>+        (foo.html.Document.prototype._querySelectorAll):
>+        (foo.html.Document.prototype.get onAbort):
>+        (foo.html.Document.prototype.get onBeforeCopy):
>+        (foo.html.Document.prototype.get onBeforeCut):
>+        (foo.html.Document.prototype.get onBeforePaste):
>+        (foo.html.Document.prototype.get onBlur):
>+        (foo.html.Document.prototype.get onCanPlay):
>+        (foo.html.Document.prototype.get onCanPlayThrough):
>+        (foo.html.Document.prototype.get onChange):
>+        (foo.html.Document.prototype.get onClick):
>+        (foo.html.Document.prototype.get onContextMenu):
>+        (foo.html.Document.prototype.get onCopy):
>+        (foo.html.Document.prototype.get onCut):
>+        (foo.html.Document.prototype.get onDoubleClick):
>+        (foo.html.Document.prototype.get onDrag):
>+        (foo.html.Document.prototype.get onDragEnd):
>+        (foo.html.Document.prototype.get onDragEnter):
>+        (foo.html.Document.prototype.get onDragLeave):
>+        (foo.html.Document.prototype.get onDragOver):
>+        (foo.html.Document.prototype.get onDragStart):
>+        (foo.html.Document.prototype.get onDrop):
>+        (foo.html.Document.prototype.get onDurationChange):
>+        (foo.html.Document.prototype.get onEmptied):
>+        (foo.html.Document.prototype.get onEnded):
>+        (foo.html.Document.prototype.get onError):
>+        (foo.html.Document.prototype.get onFocus):
>+        (foo.html.Document.prototype.get onInput):
>+        (foo.html.Document.prototype.get onInvalid):
>+        (foo.html.Document.prototype.get onKeyDown):
>+        (foo.html.Document.prototype.get onKeyPress):
>+        (foo.html.Document.prototype.get onKeyUp):
>+        (foo.html.Document.prototype.get onLoad):
>+        (foo.html.Document.prototype.get onLoadedData):
>+        (foo.html.Document.prototype.get onLoadedMetadata):
>+        (foo.html.Document.prototype.get onMouseDown):
>+        (foo.html.Document.prototype.get onMouseEnter):
>+        (foo.html.Document.prototype.get onMouseLeave):
>+        (foo.html.Document.prototype.get onMouseMove):
>+        (foo.html.Document.prototype.get onMouseOut):
>+        (foo.html.Document.prototype.get onMouseOver):
>+        (foo.html.Document.prototype.get onMouseUp):
>+        (foo.html.Document.prototype.get onMouseWheel):
>+        (foo.html.Document.prototype.get onPaste):
>+        (foo.html.Document.prototype.get onPause):
>+        (foo.html.Document.prototype.get onPlay):
>+        (foo.html.Document.prototype.get onPlaying):
>+        (foo.html.Document.prototype.get onPointerLockChange):
>+        (foo.html.Document.prototype.get onPointerLockError):
>+        (foo.html.Document.prototype.get onRateChange):
>+        (foo.html.Document.prototype.get onReadyStateChange):
>+        (foo.html.Document.prototype.get onReset):
>+        (foo.html.Document.prototype.get onResize):
>+        (foo.html.Document.prototype.get onScroll):
>+        (foo.html.Document.prototype.get onSearch):
>+        (foo.html.Document.prototype.get onSecurityPolicyViolation):
>+        (foo.html.Document.prototype.get onSeeked):
>+        (foo.html.Document.prototype.get onSeeking):
>+        (foo.html.Document.prototype.get onSelect):
>+        (foo.html.Document.prototype.get onSelectionChange):
>+        (foo.html.Document.prototype.get onSelectStart):
>+        (foo.html.Document.prototype.get onStalled):
>+        (foo.html.Document.prototype.get onSubmit):
>+        (foo.html.Document.prototype.get onSuspend):
>+        (foo.html.Document.prototype.get onTimeUpdate):
>+        (foo.html.Document.prototype.get onTouchCancel):
>+        (foo.html.Document.prototype.get onTouchEnd):
>+        (foo.html.Document.prototype.get onTouchMove):
>+        (foo.html.Document.prototype.get onTouchStart):
>+        (foo.html.Document.prototype.get onVolumeChange):
>+        (foo.html.Document.prototype.get onWaiting):
>+        (foo.html.Document.prototype.get onFullscreenChange):
>+        (foo.html.Document.prototype.get onFullscreenError):
>+        (foo.html.Document.prototype.querySelectorAll):
>+        (foo.html.Document.prototype.get supportsRegisterElement):
>+        (foo.html.Document.prototype.get supportsRegister):
>+        (foo.html.Document.prototype.registerElement):
>+        (foo.html.Document.prototype.createElement):
>+        (foo.html.Document.prototype._createElement_2):
>+        (foo.html.Document.prototype._createElementNS_2):
>+        (foo.html.Document.prototype.createElementNS):
>+        (foo.html.Document.prototype._createNodeIterator):
>+        (foo.html.Document.prototype._createTreeWalker):
>+        (foo.html.Document.prototype.get visibilityState):
>+        (foo.html.Document):
>+        (foo.html.DocumentFragment.new):
>+        (foo.html.DocumentFragment.html):
>+        (foo.html.DocumentFragment.svg):
>+        (foo.html.DocumentFragment.prototype.get _children):
>+        (foo.html.DocumentFragment.prototype.get _docChildren):
>+        (foo.html.DocumentFragment.prototype.set _docChildren):
>+        (foo.html.DocumentFragment.prototype.get children):
>+        (foo.html.DocumentFragment.prototype.set children):
>+        (foo.html.DocumentFragment.prototype.querySelectorAll):
>+        (foo.html.DocumentFragment.prototype.get innerHtml):
>+        (foo.html.DocumentFragment.prototype.set innerHtml):
>+        (foo.html.DocumentFragment.prototype.setInnerHtml):
>+        (foo.html.DocumentFragment.prototype.appendText):
>+        (foo.html.DocumentFragment.prototype.appendHtml):
>+        (foo.html.DocumentFragment.prototype.getElementById):
>+        (foo.html.DocumentFragment.prototype.get _childElementCount):
>+        (foo.html.DocumentFragment.prototype.get _firstElementChild):
>+        (foo.html.DocumentFragment.prototype.get _lastElementChild):
>+        (foo.html.DocumentFragment.prototype.querySelector):
>+        (foo.html.DocumentFragment.prototype._querySelectorAll):
>+        (foo.html.DocumentFragment):
>+        (foo.html.DocumentOrShadowRoot.prototype.get activeElement):
>+        (foo.html.DocumentOrShadowRoot.prototype.get fullscreenElement):
>+        (foo.html.DocumentOrShadowRoot.prototype.get pointerLockElement):
>+        (foo.html.DocumentOrShadowRoot.prototype.get styleSheets):
>+        (foo.html.DocumentOrShadowRoot.prototype.elementFromPoint):
>+        (foo.html.DocumentOrShadowRoot.prototype.elementsFromPoint):
>+        (foo.html.DocumentOrShadowRoot.prototype.getSelection):
>+        (foo.html.DocumentOrShadowRoot):
>+        (foo.html.DocumentTimeline.new):
>+        (foo.html.DocumentTimeline._create_1):
>+        (foo.html.DocumentTimeline._create_2):
>+        (foo.html.DocumentTimeline):
>+        (foo.html.DomError.new):
>+        (foo.html.DomError._create_1):
>+        (foo.html.DomError._create_2):
>+        (foo.html.DomError.prototype.get message):
>+        (foo.html.DomError.prototype.get name):
>+        (foo.html.DomError):
>+        (foo.html.DomException.prototype.get name):
>+        (foo.html.DomException.prototype.get message):
>+        (foo.html.DomException.prototype.toString):
>+        (foo.html.DomException):
>+        (foo.html.DomImplementation.prototype.createDocument):
>+        (foo.html.DomImplementation.prototype.createDocumentType):
>+        (foo.html.DomImplementation.prototype.createHtmlDocument):
>+        (foo.html.DomImplementation.prototype.hasFeature):
>+        (foo.html.DomImplementation):
>+        (foo.html.DomIterator.prototype.next):
>+        (foo.html.DomIterator):
>+        (foo.html.DomMatrixReadOnly.new):
>+        (foo.html.DomMatrixReadOnly._create_1):
>+        (foo.html.DomMatrixReadOnly._create_2):
>+        (foo.html.DomMatrixReadOnly.prototype.get a):
>+        (foo.html.DomMatrixReadOnly.prototype.get b):
>+        (foo.html.DomMatrixReadOnly.prototype.get c):
>+        (foo.html.DomMatrixReadOnly.prototype.get d):
>+        (foo.html.DomMatrixReadOnly.prototype.get e):
>+        (foo.html.DomMatrixReadOnly.prototype.get f):
>+        (foo.html.DomMatrixReadOnly.prototype.get is2D):
>+        (foo.html.DomMatrixReadOnly.prototype.get isIdentity):
>+        (foo.html.DomMatrixReadOnly.prototype.get m11):
>+        (foo.html.DomMatrixReadOnly.prototype.get m12):
>+        (foo.html.DomMatrixReadOnly.prototype.get m13):
>+        (foo.html.DomMatrixReadOnly.prototype.get m14):
>+        (foo.html.DomMatrixReadOnly.prototype.get m21):
>+        (foo.html.DomMatrixReadOnly.prototype.get m22):
>+        (foo.html.DomMatrixReadOnly.prototype.get m23):
>+        (foo.html.DomMatrixReadOnly.prototype.get m24):
>+        (foo.html.DomMatrixReadOnly.prototype.get m31):
>+        (foo.html.DomMatrixReadOnly.prototype.get m32):
>+        (foo.html.DomMatrixReadOnly.prototype.get m33):
>+        (foo.html.DomMatrixReadOnly.prototype.get m34):
>+        (foo.html.DomMatrixReadOnly.prototype.get m41):
>+        (foo.html.DomMatrixReadOnly.prototype.get m42):
>+        (foo.html.DomMatrixReadOnly.prototype.get m43):
>+        (foo.html.DomMatrixReadOnly.prototype.get m44):
>+        (foo.html.DomMatrixReadOnly.prototype.flipX):
>+        (foo.html.DomMatrixReadOnly.prototype.flipY):
>+        (foo.html.DomMatrixReadOnly.fromMatrix):
>+        (foo.html.DomMatrixReadOnly.prototype.inverse):
>+        (foo.html.DomMatrixReadOnly.prototype.multiply):
>+        (foo.html.DomMatrixReadOnly.prototype._multiply_1):
>+        (foo.html.DomMatrixReadOnly.prototype._multiply_2):
>+        (foo.html.DomMatrixReadOnly.prototype.rotate):
>+        (foo.html.DomMatrixReadOnly.prototype.rotateAxisAngle):
>+        (foo.html.DomMatrixReadOnly.prototype.rotateFromVector):
>+        (foo.html.DomMatrixReadOnly.prototype.scale):
>+        (foo.html.DomMatrixReadOnly.prototype.scale3d):
>+        (foo.html.DomMatrixReadOnly.prototype.skewX):
>+        (foo.html.DomMatrixReadOnly.prototype.skewY):
>+        (foo.html.DomMatrixReadOnly.prototype.toFloat32Array):
>+        (foo.html.DomMatrixReadOnly.prototype.toFloat64Array):
>+        (foo.html.DomMatrixReadOnly.prototype.transformPoint):
>+        (foo.html.DomMatrixReadOnly.prototype._transformPoint_1):
>+        (foo.html.DomMatrixReadOnly.prototype._transformPoint_2):
>+        (foo.html.DomMatrixReadOnly.prototype.translate):
>+        (foo.html.DomMatrixReadOnly):
>+        (foo.html.DomMatrix.new):
>+        (foo.html.DomMatrix._create_1):
>+        (foo.html.DomMatrix._create_2):
>+        (foo.html.DomMatrix.prototype.get a):
>+        (foo.html.DomMatrix.prototype.set a):
>+        (foo.html.DomMatrix.prototype.get b):
>+        (foo.html.DomMatrix.prototype.set b):
>+        (foo.html.DomMatrix.prototype.get c):
>+        (foo.html.DomMatrix.prototype.set c):
>+        (foo.html.DomMatrix.prototype.get d):
>+        (foo.html.DomMatrix.prototype.set d):
>+        (foo.html.DomMatrix.prototype.get e):
>+        (foo.html.DomMatrix.prototype.set e):
>+        (foo.html.DomMatrix.prototype.get f):
>+        (foo.html.DomMatrix.prototype.set f):
>+        (foo.html.DomMatrix.prototype.get m11):
>+        (foo.html.DomMatrix.prototype.set m11):
>+        (foo.html.DomMatrix.prototype.get m12):
>+        (foo.html.DomMatrix.prototype.set m12):
>+        (foo.html.DomMatrix.prototype.get m13):
>+        (foo.html.DomMatrix.prototype.set m13):
>+        (foo.html.DomMatrix.prototype.get m14):
>+        (foo.html.DomMatrix.prototype.set m14):
>+        (foo.html.DomMatrix.prototype.get m21):
>+        (foo.html.DomMatrix.prototype.set m21):
>+        (foo.html.DomMatrix.prototype.get m22):
>+        (foo.html.DomMatrix.prototype.set m22):
>+        (foo.html.DomMatrix.prototype.get m23):
>+        (foo.html.DomMatrix.prototype.set m23):
>+        (foo.html.DomMatrix.prototype.get m24):
>+        (foo.html.DomMatrix.prototype.set m24):
>+        (foo.html.DomMatrix.prototype.get m31):
>+        (foo.html.DomMatrix.prototype.set m31):
>+        (foo.html.DomMatrix.prototype.get m32):
>+        (foo.html.DomMatrix.prototype.set m32):
>+        (foo.html.DomMatrix.prototype.get m33):
>+        (foo.html.DomMatrix.prototype.set m33):
>+        (foo.html.DomMatrix.prototype.get m34):
>+        (foo.html.DomMatrix.prototype.set m34):
>+        (foo.html.DomMatrix.prototype.get m41):
>+        (foo.html.DomMatrix.prototype.set m41):
>+        (foo.html.DomMatrix.prototype.get m42):
>+        (foo.html.DomMatrix.prototype.set m42):
>+        (foo.html.DomMatrix.prototype.get m43):
>+        (foo.html.DomMatrix.prototype.set m43):
>+        (foo.html.DomMatrix.prototype.get m44):
>+        (foo.html.DomMatrix.prototype.set m44):
>+        (foo.html.DomMatrix.fromMatrix):
>+        (foo.html.DomMatrix.prototype.invertSelf):
>+        (foo.html.DomMatrix.prototype.multiplySelf):
>+        (foo.html.DomMatrix.prototype._multiplySelf_1):
>+        (foo.html.DomMatrix.prototype._multiplySelf_2):
>+        (foo.html.DomMatrix.prototype.preMultiplySelf):
>+        (foo.html.DomMatrix.prototype._preMultiplySelf_1):
>+        (foo.html.DomMatrix.prototype._preMultiplySelf_2):
>+        (foo.html.DomMatrix.prototype.rotateAxisAngleSelf):
>+        (foo.html.DomMatrix.prototype.rotateFromVectorSelf):
>+        (foo.html.DomMatrix.prototype.rotateSelf):
>+        (foo.html.DomMatrix.prototype.scale3dSelf):
>+        (foo.html.DomMatrix.prototype.scaleSelf):
>+        (foo.html.DomMatrix.prototype.setMatrixValue):
>+        (foo.html.DomMatrix.prototype.skewXSelf):
>+        (foo.html.DomMatrix.prototype.skewYSelf):
>+        (foo.html.DomMatrix.prototype.translateSelf):
>+        (foo.html.DomMatrix):
>+        (foo.html.DomParser.new):
>+        (foo.html.DomParser._create_1):
>+        (foo.html.DomParser.prototype.parseFromString):
>+        (foo.html.DomParser):
>+        (foo.html.DomPointReadOnly.new):
>+        (foo.html.DomPointReadOnly._create_1):
>+        (foo.html.DomPointReadOnly._create_2):
>+        (foo.html.DomPointReadOnly._create_3):
>+        (foo.html.DomPointReadOnly._create_4):
>+        (foo.html.DomPointReadOnly._create_5):
>+        (foo.html.DomPointReadOnly.prototype.get w):
>+        (foo.html.DomPointReadOnly.prototype.get x):
>+        (foo.html.DomPointReadOnly.prototype.get y):
>+        (foo.html.DomPointReadOnly.prototype.get z):
>+        (foo.html.DomPointReadOnly.fromPoint):
>+        (foo.html.DomPointReadOnly.prototype.matrixTransform):
>+        (foo.html.DomPointReadOnly.prototype._matrixTransform_1):
>+        (foo.html.DomPointReadOnly.prototype._matrixTransform_2):
>+        (foo.html.DomPointReadOnly):
>+        (foo.html.DomPoint.new):
>+        (foo.html.DomPoint._create_1):
>+        (foo.html.DomPoint._create_2):
>+        (foo.html.DomPoint._create_3):
>+        (foo.html.DomPoint._create_4):
>+        (foo.html.DomPoint._create_5):
>+        (foo.html.DomPoint.get supported):
>+        (foo.html.DomPoint.prototype.get w):
>+        (foo.html.DomPoint.prototype.set w):
>+        (foo.html.DomPoint.prototype.get x):
>+        (foo.html.DomPoint.prototype.set x):
>+        (foo.html.DomPoint.prototype.get y):
>+        (foo.html.DomPoint.prototype.set y):
>+        (foo.html.DomPoint.prototype.get z):
>+        (foo.html.DomPoint.prototype.set z):
>+        (foo.html.DomPoint.fromPoint):
>+        (foo.html.DomPoint):
>+        (foo.html.DomQuad.new):
>+        (foo.html.DomQuad._create_1):
>+        (foo.html.DomQuad._create_2):
>+        (foo.html.DomQuad._create_3):
>+        (foo.html.DomQuad._create_4):
>+        (foo.html.DomQuad._create_5):
>+        (foo.html.DomQuad.prototype.get p1):
>+        (foo.html.DomQuad.prototype.get p2):
>+        (foo.html.DomQuad.prototype.get p3):
>+        (foo.html.DomQuad.prototype.get p4):
>+        (foo.html.DomQuad.fromQuad):
>+        (foo.html.DomQuad.fromRect):
>+        (foo.html.DomQuad.prototype.getBounds):
>+        (foo.html.DomQuad):
>+        (foo.html.CustomElementRegistry.prototype.get return):
>+        (foo.html.ImmutableListMixin.dart.generic):
>+        (foo.html.CustomElementRegistry):
>+        (foo.const.Interceptor_ListMixin):
>+        (foo.const.Interceptor_ImmutableListMixin):
>+        (foo.html.DomRectList.prototype.get length):
>+        (foo.html.DomRectList.prototype._get):
>+        (foo.html.DomRectList.prototype._set):
>+        (foo.html.DomRectList.prototype.set length):
>+        (foo.html.DomRectList.prototype.get first):
>+        (foo.html.DomRectList.prototype.set first):
>+        (foo.html.DomRectList.prototype.get last):
>+        (foo.html.DomRectList.prototype.set last):
>+        (foo.html.DomRectList.prototype.get single):
>+        (foo.html.DomRectList.prototype.elementAt):
>+        (foo.html.DomRectList.prototype.item):
>+        (foo.html.DomRectList):
>+        (foo.html.DomRectReadOnly.prototype.toString):
>+        (foo.html.DomRectReadOnly.prototype._equals):
>+        (foo.html.DomRectReadOnly.prototype.get hashCode):
>+        (foo.html.DomRectReadOnly.prototype.intersection):
>+        (foo.html.DomRectReadOnly.prototype.intersects):
>+        (foo.html.DomRectReadOnly.prototype.boundingBox):
>+        (foo.html.DomRectReadOnly.prototype.containsRectangle):
>+        (foo.html.DomRectReadOnly.prototype.containsPoint):
>+        (foo.html.DomRectReadOnly.prototype.get topLeft):
>+        (foo.html.DomRectReadOnly.prototype.get topRight):
>+        (foo.html.DomRectReadOnly.prototype.get bottomRight):
>+        (foo.html.DomRectReadOnly.prototype.get bottomLeft):
>+        (foo.html.DomRectReadOnly.new):
>+        (foo.html.DomRectReadOnly._create_1):
>+        (foo.html.DomRectReadOnly._create_2):
>+        (foo.html.DomRectReadOnly._create_3):
>+        (foo.html.DomRectReadOnly._create_4):
>+        (foo.html.DomRectReadOnly._create_5):
>+        (foo.html.DomRectReadOnly.prototype.get bottom):
>+        (foo.html.DomRectReadOnly.prototype.get height):
>+        (foo.html.DomRectReadOnly.prototype.get left):
>+        (foo.html.DomRectReadOnly.prototype.get right):
>+        (foo.html.DomRectReadOnly.prototype.get top):
>+        (foo.html.DomRectReadOnly.prototype.get width):
>+        (foo.html.DomRectReadOnly.prototype.get x):
>+        (foo.html.DomRectReadOnly.prototype.get y):
>+        (foo.html.DomRectReadOnly.fromRect):
>+        (foo.html.DomRectReadOnly):
>+        (foo.html.DomStringList.prototype.get length):
>+        (foo.html.DomStringList.prototype._get):
>+        (foo.html.DomStringList.prototype._set):
>+        (foo.html.DomStringList.prototype.set length):
>+        (foo.html.DomStringList.prototype.get first):
>+        (foo.html.DomStringList.prototype.set first):
>+        (foo.html.DomStringList.prototype.get last):
>+        (foo.html.DomStringList.prototype.set last):
>+        (foo.html.DomStringList.prototype.get single):
>+        (foo.html.DomStringList.prototype.elementAt):
>+        (foo.html.DomStringList.prototype.item):
>+        (foo.html.DomStringList):
>+        (foo.html.DomStringMap.prototype.__delete__):
>+        (foo.html.DomStringMap.prototype.__setter__):
>+        (foo.html.DomStringMap.prototype.item):
>+        (foo.html.DomStringMap):
>+        (foo.html.DomTokenList.prototype.get length):
>+        (foo.html.DomTokenList.prototype.get value):
>+        (foo.html.DomTokenList.prototype.set value):
>+        (foo.html.DomTokenList.prototype.add):
>+        (foo.html.DomTokenList.prototype.contains):
>+        (foo.html.DomTokenList.prototype.item):
>+        (foo.html.DomTokenList.prototype.remove):
>+        (foo.html.DomTokenList.prototype.replace):
>+        (foo.html.DomTokenList.prototype.supports):
>+        (foo.html.DomTokenList.prototype.toggle):
>+        (foo.html.DomTokenList):
>+        (foo.html._ChildrenElementList.prototype.contains):
>+        (foo.html._ChildrenElementList.prototype.get isEmpty):
>+        (foo.html._ChildrenElementList.prototype.get length):
>+        (foo.html._ChildrenElementList.prototype._get):
>+        (foo.html._ChildrenElementList.prototype._set):
>+        (foo.html._ChildrenElementList.prototype.set length):
>+        (foo.html._ChildrenElementList.prototype.add):
>+        (foo.html._ChildrenElementList.prototype.get iterator):
>+        (foo.html._ChildrenElementList.prototype.addAll):
>+        (foo.html._ChildrenElementList.prototype.sort):
>+        (foo.html._ChildrenElementList.prototype.shuffle):
>+        (foo.html._ChildrenElementList.prototype.removeWhere):
>+        (foo.html._ChildrenElementList.prototype.retainWhere):
>+        (foo.html._ChildrenElementList.prototype._filter.0):
>+        (foo.html._ChildrenElementList.prototype.fillRange):
>+        (foo.html._ChildrenElementList.prototype.replaceRange):
>+        (foo.html._ChildrenElementList.prototype.removeRange):
>+        (foo.html._ChildrenElementList.prototype.setRange):
>+        (foo.html._ChildrenElementList.prototype.remove):
>+        (foo.html._ChildrenElementList.prototype.insert):
>+        (foo.html._ChildrenElementList.prototype.setAll):
>+        (foo.html._ChildrenElementList.prototype.clear):
>+        (foo.html._ChildrenElementList.prototype.removeAt):
>+        (foo.html._ChildrenElementList.prototype.removeLast):
>+        (foo.html._ChildrenElementList.prototype.get first):
>+        (foo.html._ChildrenElementList.prototype.set first):
>+        (foo.html._ChildrenElementList.prototype.get last):
>+        (foo.html._ChildrenElementList.prototype.set last):
>+        (foo.html._ChildrenElementList.prototype.get single):
>+        (foo.html._ChildrenElementList.prototype.get rawList):
>+        (foo.html._ChildrenElementList):
>+        (foo.html.ElementList.dart.generic):
>+        (foo.html._FrozenElementList.dart.generic):
>+        (foo.html._ElementFactoryProvider.createElement_tag):
>+        (foo.html._ElementFactoryProvider):
>+        (foo.html.ScrollAlignment.prototype.toString):
>+        (foo.html.ScrollAlignment):
>+        (foo.get html.EmbedElement.new):
>+        (foo.get html.EmbedElement.get supported):
>+        (foo.get html.EmbedElement.prototype.get height):
>+        (foo.get html.EmbedElement.prototype.set height):
>+        (foo.get html.EmbedElement.prototype.get name):
>+        (foo.get html.EmbedElement.prototype.set name):
>+        (foo.get html.EmbedElement.prototype.get src):
>+        (foo.get html.EmbedElement.prototype.set src):
>+        (foo.get html.EmbedElement.prototype.get type):
>+        (foo.get html.EmbedElement.prototype.set type):
>+        (foo.get html.EmbedElement.prototype.get width):
>+        (foo.get html.EmbedElement.prototype.set width):
>+        (foo.get html.EmbedElement.prototype.__getter__):
>+        (foo.get html.EmbedElement.prototype.__setter__):
>+        (foo.get html.EmbedElement):
>+        (foo.html.ErrorEvent.new):
>+        (foo.html.ErrorEvent._create_1):
>+        (foo.html.ErrorEvent._create_2):
>+        (foo.html.ErrorEvent.prototype.get colno):
>+        (foo.html.ErrorEvent.prototype.get error):
>+        (foo.html.ErrorEvent.prototype.get filename):
>+        (foo.html.ErrorEvent.prototype.get lineno):
>+        (foo.html.ErrorEvent.prototype.get message):
>+        (foo.html.ErrorEvent):
>+        (foo.html.EventSource.new):
>+        (foo.html.EventSource._factoryEventSource):
>+        (foo.html.EventSource._create_1):
>+        (foo.html.EventSource._create_2):
>+        (foo.html.EventSource.prototype.get readyState):
>+        (foo.html.EventSource.prototype.get url):
>+        (foo.html.EventSource.prototype.get withCredentials):
>+        (foo.html.EventSource.prototype.close):
>+        (foo.html.EventSource.prototype.get onError):
>+        (foo.html.EventSource.prototype.get onMessage):
>+        (foo.html.EventSource.prototype.get onOpen):
>+        (foo.html.EventSource):
>+        (foo.html.Events.prototype._get):
>+        (foo.html.Events):
>+        (foo.html.ElementEvents.prototype._get):
>+        (foo.html.ElementEvents):
>+        (foo.get html.ExtendableMessageEvent.prototype.get data):
>+        (foo.get html.ExtendableMessageEvent.prototype.get lastEventId):
>+        (foo.get html.ExtendableMessageEvent.prototype.get origin):
>+        (foo.get html.ExtendableMessageEvent.prototype.get ports):
>+        (foo.get html.ExtendableMessageEvent.prototype.get source):
>+        (foo.get html.ExtendableMessageEvent):
>+        (foo.html.External.prototype.AddSearchProvider):
>+        (foo.html.External.prototype.IsSearchProviderInstalled):
>+        (foo.html.External):
>+        (foo.html.FaceDetector.new):
>+        (foo.html.FaceDetector._create_1):
>+        (foo.html.FaceDetector._create_2):
>+        (foo.html.FaceDetector.prototype.detect):
>+        (foo.html.FaceDetector):
>+        (foo.html.FederatedCredential.new):
>+        (foo.html.FederatedCredential._create_1):
>+        (foo.html.FederatedCredential.prototype.get protocol):
>+        (foo.html.FederatedCredential.prototype.get provider):
>+        (foo.html.FederatedCredential.prototype.get iconUrl):
>+        (foo.html.FederatedCredential.prototype.get name):
>+        (foo.html.FederatedCredential):
>+        (foo.html.FetchEvent.new):
>+        (foo.html.FetchEvent._create_1):
>+        (foo.html.FetchEvent.prototype.get clientId):
>+        (foo.html.FetchEvent.prototype.get isReload):
>+        (foo.html.FetchEvent.prototype.get preloadResponse):
>+        (foo.html.FetchEvent.prototype.get request):
>+        (foo.html.FetchEvent.prototype.respondWith):
>+        (foo.html.FetchEvent):
>+        (foo.html.FieldSetElement.new):
>+        (foo.html.FieldSetElement.prototype.get disabled):
>+        (foo.html.FieldSetElement.prototype.set disabled):
>+        (foo.html.FieldSetElement.prototype.get elements):
>+        (foo.html.FieldSetElement.prototype.get form):
>+        (foo.html.FieldSetElement.prototype.get name):
>+        (foo.html.FieldSetElement.prototype.set name):
>+        (foo.html.FieldSetElement.prototype.get type):
>+        (foo.html.FieldSetElement.prototype.get validationMessage):
>+        (foo.html.FieldSetElement.prototype.get validity):
>+        (foo.html.FieldSetElement.prototype.get willValidate):
>+        (foo.html.FieldSetElement.prototype.checkValidity):
>+        (foo.html.FieldSetElement.prototype.reportValidity):
>+        (foo.html.FieldSetElement.prototype.setCustomValidity):
>+        (foo.html.FieldSetElement):
>+        (foo.html.File.new):
>+        (foo.html.File._create_1):
>+        (foo.html.File._create_2):
>+        (foo.html.File.prototype.get lastModified):
>+        (foo.html.File.prototype.get lastModifiedDate):
>+        (foo.html.File.prototype.get _get_lastModifiedDate):
>+        (foo.html.File.prototype.get name):
>+        (foo.html.File.prototype.get relativePath):
>+        (foo.html.File):
>+        (foo.html.FileEntry.prototype._createWriter):
>+        (foo.html.FileEntry.prototype.createWriter):
>+        (foo.html.FileEntry.prototype._file):
>+        (foo.html.FileEntry.prototype.file):
>+        (foo.html.FileEntry):
>+        (foo.const.Interceptor_ListMixin.0):
>+        (foo.const.Interceptor_ImmutableListMixin.0):
>+        (foo.html.FileList.prototype.get length):
>+        (foo.html.FileList.prototype._get):
>+        (foo.html.FileList.prototype._set):
>+        (foo.html.FileList.prototype.set length):
>+        (foo.html.FileList.prototype.get first):
>+        (foo.html.FileList.prototype.set first):
>+        (foo.html.FileList.prototype.get last):
>+        (foo.html.FileList.prototype.set last):
>+        (foo.html.FileList.prototype.get single):
>+        (foo.html.FileList.prototype.elementAt):
>+        (foo.html.FileList.prototype.item):
>+        (foo.html.FileList):
>+        (foo.html.FileReader.prototype.get result):
>+        (foo.html.FileReader.new):
>+        (foo.html.FileReader._create_1):
>+        (foo.html.FileReader.prototype.get error):
>+        (foo.html.FileReader.prototype.get readyState):
>+        (foo.html.FileReader.prototype.abort):
>+        (foo.html.FileReader.prototype.readAsArrayBuffer):
>+        (foo.html.FileReader.prototype.readAsDataUrl):
>+        (foo.html.FileReader.prototype.readAsText):
>+        (foo.html.FileReader.prototype.get onAbort):
>+        (foo.html.FileReader.prototype.get onError):
>+        (foo.html.FileReader.prototype.get onLoad):
>+        (foo.html.FileReader.prototype.get onLoadEnd):
>+        (foo.html.FileReader.prototype.get onLoadStart):
>+        (foo.html.FileReader.prototype.get onProgress):
>+        (foo.html.FileReader):
>+        (foo.html.FileSystem.get supported):
>+        (foo.html.FileSystem.prototype.get name):
>+        (foo.html.FileSystem.prototype.get root):
>+        (foo.html.FileSystem):
>+        (foo.html.FileWriter.prototype.get error):
>+        (foo.html.FileWriter.prototype.get length):
>+        (foo.html.FileWriter.prototype.get position):
>+        (foo.html.FileWriter.prototype.get readyState):
>+        (foo.html.FileWriter.prototype.abort):
>+        (foo.html.FileWriter.prototype.seek):
>+        (foo.html.FileWriter.prototype.truncate):
>+        (foo.html.FileWriter.prototype.write):
>+        (foo.html.FileWriter.prototype.get onAbort):
>+        (foo.html.FileWriter.prototype.get onError):
>+        (foo.html.FileWriter.prototype.get onProgress):
>+        (foo.html.FileWriter.prototype.get onWrite):
>+        (foo.html.FileWriter.prototype.get onWriteEnd):
>+        (foo.html.FileWriter.prototype.get onWriteStart):
>+        (foo.html.FileWriter):
>+        (foo.html.FocusEvent.new):
>+        (foo.html.FocusEvent._create_1):
>+        (foo.html.FocusEvent._create_2):
>+        (foo.html.FocusEvent.prototype.get relatedTarget):
>+        (foo.html.FocusEvent.prototype.get _get_relatedTarget):
>+        (foo.html.FocusEvent):
>+        (foo.html.FontFace.new):
>+        (foo.html.FontFace._create_1):
>+        (foo.html.FontFace._create_2):
>+        (foo.html.FontFace.prototype.get display):
>+        (foo.html.FontFace.prototype.set display):
>+        (foo.html.FontFace.prototype.get family):
>+        (foo.html.FontFace.prototype.set family):
>+        (foo.html.FontFace.prototype.get featureSettings):
>+        (foo.html.FontFace.prototype.set featureSettings):
>+        (foo.html.FontFace.prototype.get loaded):
>+        (foo.html.FontFace.prototype.get status):
>+        (foo.html.FontFace.prototype.get stretch):
>+        (foo.html.FontFace.prototype.set stretch):
>+        (foo.html.FontFace.prototype.get style):
>+        (foo.html.FontFace.prototype.set style):
>+        (foo.html.FontFace.prototype.get unicodeRange):
>+        (foo.html.FontFace.prototype.set unicodeRange):
>+        (foo.html.FontFace.prototype.get variant):
>+        (foo.html.FontFace.prototype.set variant):
>+        (foo.html.FontFace.prototype.get weight):
>+        (foo.html.FontFace.prototype.set weight):
>+        (foo.html.FontFace.prototype.load):
>+        (foo.html.FontFace):
>+        (foo.html.FontFaceSet.prototype.get status):
>+        (foo.html.FontFaceSet.prototype.add):
>+        (foo.html.FontFaceSet.prototype.check):
>+        (foo.html.FontFaceSet.prototype.clear):
>+        (foo.html.FontFaceSet.prototype.delete):
>+        (foo.html.FontFaceSet.prototype.forEach):
>+        (foo.html.FontFaceSet.prototype.has):
>+        (foo.html.FontFaceSet.prototype.get onLoading):
>+        (foo.html.FontFaceSet.prototype.get onLoadingDone):
>+        (foo.html.FontFaceSet.prototype.get onLoadingError):
>+        (foo.html.FontFaceSet):
>+        (foo.html.FontFaceSetLoadEvent.new):
>+        (foo.html.FontFaceSetLoadEvent._create_1):
>+        (foo.html.FontFaceSetLoadEvent._create_2):
>+        (foo.html.FontFaceSetLoadEvent.prototype.get fontfaces):
>+        (foo.html.FontFaceSetLoadEvent):
>+        (foo.html.FontFaceSource.prototype.get fonts):
>+        (foo.html.FontFaceSource):
>+        (foo.html.ForeignFetchEvent.new):
>+        (foo.html.ForeignFetchEvent._create_1):
>+        (foo.html.ForeignFetchEvent.prototype.get origin):
>+        (foo.html.ForeignFetchEvent.prototype.get request):
>+        (foo.html.ForeignFetchEvent.prototype.respondWith):
>+        (foo.html.ForeignFetchEvent):
>+        (foo.html.FormData.new):
>+        (foo.html.FormData._create_1):
>+        (foo.html.FormData._create_2):
>+        (foo.html.FormData.get supported):
>+        (foo.html.FormData.prototype.append):
>+        (foo.html.FormData.prototype.appendBlob):
>+        (foo.html.FormData.prototype.delete):
>+        (foo.html.FormElement.new):
>+        (foo.html.FormElement.prototype.get acceptCharset):
>+        (foo.html.FormElement.prototype.set acceptCharset):
>+        (foo.html.FormElement.prototype.get action):
>+        (foo.html.FormElement.prototype.set action):
>+        (foo.html.FormElement.prototype.get autocomplete):
>+        (foo.html.FormElement.prototype.set autocomplete):
>+        (foo.html.FormElement.prototype.get encoding):
>+        (foo.html.FormElement.prototype.set encoding):
>+        (foo.html.FormElement.prototype.get enctype):
>+        (foo.html.FormElement.prototype.set enctype):
>+        (foo.html.FormElement.prototype.get length):
>+        (foo.html.FormElement.prototype.get method):
>+        (foo.html.FormElement.prototype.set method):
>+        (foo.html.FormElement.prototype.get name):
>+        (foo.html.FormElement.prototype.set name):
>+        (foo.html.FormElement.prototype.get noValidate):
>+        (foo.html.FormElement.prototype.set noValidate):
>+        (foo.html.FormElement.prototype.get target):
>+        (foo.html.FormElement.prototype.set target):
>+        (foo.html.FormElement.prototype.__getter__):
>+        (foo.html.FormElement.prototype.checkValidity):
>+        (foo.html.FormElement.prototype.item):
>+        (foo.html.FormElement.prototype.reportValidity):
>+        (foo.html.FormElement.prototype.requestAutocomplete):
>+        (foo.html.FormElement.prototype._requestAutocomplete_1):
>+        (foo.html.FormElement.prototype.reset):
>+        (foo.html.FormElement.prototype.submit):
>+        (foo.html.FormElement):
>+        (foo.html.Gamepad.prototype.get axes):
>+        (foo.html.Gamepad.prototype.get buttons):
>+        (foo.html.Gamepad.prototype.get connected):
>+        (foo.html.Gamepad.prototype.get displayId):
>+        (foo.html.Gamepad.prototype.get hand):
>+        (foo.html.Gamepad.prototype.get id):
>+        (foo.html.Gamepad.prototype.get index):
>+        (foo.html.Gamepad.prototype.get mapping):
>+        (foo.html.Gamepad.prototype.get pose):
>+        (foo.html.Gamepad.prototype.get timestamp):
>+        (foo.html.Gamepad):
>+        (foo.html.GamepadButton.prototype.get pressed):
>+        (foo.html.GamepadButton.prototype.get touched):
>+        (foo.html.GamepadButton.prototype.get value):
>+        (foo.html.GamepadButton):
>+        (foo.html.GamepadEvent.new):
>+        (foo.html.GamepadEvent._create_1):
>+        (foo.html.GamepadEvent._create_2):
>+        (foo.html.GamepadEvent.prototype.get gamepad):
>+        (foo.html.GamepadEvent):
>+        (foo.html.GamepadPose.prototype.get angularAcceleration):
>+        (foo.html.GamepadPose.prototype.get angularVelocity):
>+        (foo.html.GamepadPose.prototype.get hasOrientation):
>+        (foo.html.GamepadPose.prototype.get hasPosition):
>+        (foo.html.GamepadPose.prototype.get linearAcceleration):
>+        (foo.html.GamepadPose.prototype.get linearVelocity):
>+        (foo.html.GamepadPose.prototype.get orientation):
>+        (foo.html.GamepadPose.prototype.get position):
>+        (foo.html.GamepadPose):
>+        (foo.html.Geolocation.prototype.getCurrentPosition):
>+        (foo.html.Geolocation.prototype.watchPosition):
>+        (foo.html.Geolocation.prototype._ensurePosition):
>+        (foo.html.Geolocation.prototype._clearWatch):
>+        (foo.html.Geolocation.prototype._getCurrentPosition):
>+        (foo.html.Geolocation.prototype._getCurrentPosition_1):
>+        (foo.html.Geolocation.prototype._getCurrentPosition_2):
>+        (foo.html.Geolocation.prototype._getCurrentPosition_3):
>+        (foo.html.Geolocation.prototype._watchPosition):
>+        (foo.html.Geolocation.prototype._watchPosition_1):
>+        (foo.html.Geolocation.prototype._watchPosition_2):
>+        (foo.html.Geolocation.prototype._watchPosition_3):
>+        (foo.html.Geolocation):
>+        (foo.html._GeopositionWrapper.prototype.get coords):
>+        (foo.html._GeopositionWrapper.prototype.get timestamp):
>+        (foo.html._GeopositionWrapper):
>+        (foo.html.Geoposition.prototype.get coords):
>+        (foo.html.Geoposition.prototype.get timestamp):
>+        (foo.html.Geoposition):
>+        (foo.html.GlobalEventHandlers.prototype.get onAbort):
>+        (foo.html.GlobalEventHandlers.prototype.get onBlur):
>+        (foo.html.GlobalEventHandlers.prototype.get onCanPlay):
>+        (foo.html.GlobalEventHandlers.prototype.get onCanPlayThrough):
>+        (foo.html.GlobalEventHandlers.prototype.get onChange):
>+        (foo.html.GlobalEventHandlers.prototype.get onClick):
>+        (foo.html.GlobalEventHandlers.prototype.get onContextMenu):
>+        (foo.html.GlobalEventHandlers.prototype.get onDoubleClick):
>+        (foo.html.GlobalEventHandlers.prototype.get onDrag):
>+        (foo.html.GlobalEventHandlers.prototype.get onDragEnd):
>+        (foo.html.GlobalEventHandlers.prototype.get onDragEnter):
>+        (foo.html.GlobalEventHandlers.prototype.get onDragLeave):
>+        (foo.html.GlobalEventHandlers.prototype.get onDragOver):
>+        (foo.html.GlobalEventHandlers.prototype.get onDragStart):
>+        (foo.html.GlobalEventHandlers.prototype.get onDrop):
>+        (foo.html.GlobalEventHandlers.prototype.get onDurationChange):
>+        (foo.html.GlobalEventHandlers.prototype.get onEmptied):
>+        (foo.html.GlobalEventHandlers.prototype.get onEnded):
>+        (foo.html.GlobalEventHandlers.prototype.get onError):
>+        (foo.html.GlobalEventHandlers.prototype.get onFocus):
>+        (foo.html.GlobalEventHandlers.prototype.get onInput):
>+        (foo.html.GlobalEventHandlers.prototype.get onInvalid):
>+        (foo.html.GlobalEventHandlers.prototype.get onKeyDown):
>+        (foo.html.GlobalEventHandlers.prototype.get onKeyPress):
>+        (foo.html.GlobalEventHandlers.prototype.get onKeyUp):
>+        (foo.html.GlobalEventHandlers.prototype.get onLoad):
>+        (foo.html.GlobalEventHandlers.prototype.get onLoadedData):
>+        (foo.html.GlobalEventHandlers.prototype.get onLoadedMetadata):
>+        (foo.html.GlobalEventHandlers.prototype.get onMouseDown):
>+        (foo.html.GlobalEventHandlers.prototype.get onMouseEnter):
>+        (foo.html.GlobalEventHandlers.prototype.get onMouseLeave):
>+        (foo.html.GlobalEventHandlers.prototype.get onMouseMove):
>+        (foo.html.GlobalEventHandlers.prototype.get onMouseOut):
>+        (foo.html.GlobalEventHandlers.prototype.get onMouseOver):
>+        (foo.html.GlobalEventHandlers.prototype.get onMouseUp):
>+        (foo.html.GlobalEventHandlers.prototype.get onMouseWheel):
>+        (foo.html.GlobalEventHandlers.prototype.get onPause):
>+        (foo.html.GlobalEventHandlers.prototype.get onPlay):
>+        (foo.html.GlobalEventHandlers.prototype.get onPlaying):
>+        (foo.html.GlobalEventHandlers.prototype.get onRateChange):
>+        (foo.html.GlobalEventHandlers.prototype.get onReset):
>+        (foo.html.GlobalEventHandlers.prototype.get onResize):
>+        (foo.html.GlobalEventHandlers.prototype.get onScroll):
>+        (foo.html.GlobalEventHandlers.prototype.get onSeeked):
>+        (foo.html.GlobalEventHandlers.prototype.get onSeeking):
>+        (foo.html.GlobalEventHandlers.prototype.get onSelect):
>+        (foo.html.GlobalEventHandlers.prototype.get onStalled):
>+        (foo.html.GlobalEventHandlers.prototype.get onSubmit):
>+        (foo.html.GlobalEventHandlers.prototype.get onSuspend):
>+        (foo.html.GlobalEventHandlers.prototype.get onTimeUpdate):
>+        (foo.html.GlobalEventHandlers.prototype.get onTouchCancel):
>+        (foo.html.GlobalEventHandlers.prototype.get onTouchEnd):
>+        (foo.html.GlobalEventHandlers.prototype.get onTouchMove):
>+        (foo.html.GlobalEventHandlers.prototype.get onTouchStart):
>+        (foo.html.GlobalEventHandlers.prototype.get onVolumeChange):
>+        (foo.html.GlobalEventHandlers.prototype.get onWaiting):
>+        (foo.html.GlobalEventHandlers.prototype.get onWheel):
>+        (foo.html.GlobalEventHandlers):
>+        (foo.get html.Gyroscope.new):
>+        (foo.get html.Gyroscope._create_1):
>+        (foo.get html.Gyroscope._create_2):
>+        (foo.get html.Gyroscope.prototype.get x):
>+        (foo.get html.Gyroscope.prototype.get y):
>+        (foo.get html.Gyroscope.prototype.get z):
>+        (foo.get html.Gyroscope):
>+        (foo.html.HRElement.new):
>+        (foo.html.HRElement.prototype.get color):
>+        (foo.html.HRElement.prototype.set color):
>+        (foo.html.HRElement):
>+        (foo.html.HashChangeEvent.new):
>+        (foo.html.HashChangeEvent.__):
>+        (foo.html.HashChangeEvent._create_1):
>+        (foo.html.HashChangeEvent._create_2):
>+        (foo.html.HashChangeEvent.get supported):
>+        (foo.html.HashChangeEvent.prototype.get newUrl):
>+        (foo.html.HashChangeEvent.prototype.get oldUrl):
>+        (foo.html.HashChangeEvent):
>+        (foo.html.HeadElement.new):
>+        (foo.html.HeadElement):
>+        (foo.html.Headers.new):
>+        (foo.html.Headers._create_1):
>+        (foo.html.Headers._create_2):
>+        (foo.html.Headers):
>+        (foo.html.HeadingElement.h1):
>+        (foo.html.HeadingElement.h2):
>+        (foo.html.HeadingElement.h3):
>+        (foo.html.HeadingElement.h4):
>+        (foo.html.HeadingElement.h5):
>+        (foo.html.HeadingElement.h6):
>+        (foo.html.HeadingElement):
>+        (foo.html.History.get supportsState):
>+        (foo.html.History.prototype.get length):
>+        (foo.html.History.prototype.get scrollRestoration):
>+        (foo.html.History.prototype.set scrollRestoration):
>+        (foo.html.History.prototype.get state):
>+        (foo.html.History.prototype.get _get_state):
>+        (foo.html.History.prototype.back):
>+        (foo.html.History.prototype.forward):
>+        (foo.html.History.prototype.go):
>+        (foo.html.History.prototype.pushState):
>+        (foo.html.History.prototype._pushState_1):
>+        (foo.html.History.prototype.replaceState):
>+        (foo.html.History.prototype._replaceState_1):
>+        (foo.html.History):
>+        (foo.const.Interceptor_ListMixin.1):
>+        (foo.const.Interceptor_ImmutableListMixin.1):
>+        (foo.html.HtmlCollection.prototype.get length):
>+        (foo.html.HtmlCollection.prototype._get):
>+        (foo.html.HtmlCollection.prototype._set):
>+        (foo.html.HtmlCollection.prototype.set length):
>+        (foo.html.HtmlCollection.prototype.get first):
>+        (foo.html.HtmlCollection.prototype.set first):
>+        (foo.html.HtmlCollection.prototype.get last):
>+        (foo.html.HtmlCollection.prototype.set last):
>+        (foo.html.HtmlCollection.prototype.get single):
>+        (foo.html.HtmlCollection.prototype.elementAt):
>+        (foo.html.HtmlCollection.prototype.item):
>+        (foo.html.HtmlCollection.prototype.namedItem):
>+        (foo.html.HtmlCollection):
>+        (foo.html.HtmlDocument.prototype.get body):
>+        (foo.html.HtmlDocument.prototype.set body):
>+        (foo.html.HtmlDocument.prototype.caretRangeFromPoint):
>+        (foo.html.HtmlDocument.prototype.elementFromPoint):
>+        (foo.html.HtmlDocument.prototype.get head):
>+        (foo.html.HtmlDocument.prototype.get lastModified):
>+        (foo.html.HtmlDocument.prototype.get preferredStylesheetSet):
>+        (foo.html.HtmlDocument.prototype.get referrer):
>+        (foo.html.HtmlDocument.prototype.get selectedStylesheetSet):
>+        (foo.html.HtmlDocument.prototype.set selectedStylesheetSet):
>+        (foo.html.HtmlDocument.prototype.get styleSheets):
>+        (foo.html.HtmlDocument.prototype.get title):
>+        (foo.html.HtmlDocument.prototype.set title):
>+        (foo.html.HtmlDocument.prototype.exitFullscreen):
>+        (foo.html.HtmlDocument.prototype.registerElement2):
>+        (foo.html.HtmlDocument.prototype.register):
>+        (foo.html.HtmlDocument._determineVisibilityChangeEventType):
>+        (foo.html.HtmlDocument.prototype.get onVisibilityChange):
>+        (foo.html.HtmlDocument.prototype.createElementUpgrader):
>+        (foo.html.HtmlDocument):
>+        (foo.html.HtmlFormControlsCollection.prototype.item):
>+        (foo.html.HtmlFormControlsCollection.prototype.namedItem):
>+        (foo.html.HtmlFormControlsCollection):
>+        (foo.html.HtmlHtmlElement.new):
>+        (foo.html.HtmlHtmlElement):
>+        (foo.html.HtmlHyperlinkElementUtils.prototype.get hash):
>+        (foo.html.HtmlHyperlinkElementUtils.prototype.set hash):
>+        (foo.html.HtmlHyperlinkElementUtils.prototype.get host):
>+        (foo.html.HtmlHyperlinkElementUtils.prototype.set host):
>+        (foo.html.HtmlHyperlinkElementUtils.prototype.get hostname):
>+        (foo.html.HtmlHyperlinkElementUtils.prototype.set hostname):
>+        (foo.html.HtmlHyperlinkElementUtils.prototype.get href):
>+        (foo.html.HtmlHyperlinkElementUtils.prototype.set href):
>+        (foo.html.HtmlHyperlinkElementUtils.prototype.get origin):
>+        (foo.html.HtmlHyperlinkElementUtils.prototype.get password):
>+        (foo.html.HtmlHyperlinkElementUtils.prototype.set password):
>+        (foo.html.HtmlHyperlinkElementUtils.prototype.get pathname):
>+        (foo.html.HtmlHyperlinkElementUtils.prototype.set pathname):
>+        (foo.html.HtmlHyperlinkElementUtils.prototype.get port):
>+        (foo.html.HtmlHyperlinkElementUtils.prototype.set port):
>+        (foo.html.HtmlHyperlinkElementUtils.prototype.get protocol):
>+        (foo.html.HtmlHyperlinkElementUtils.prototype.set protocol):
>+        (foo.html.HtmlHyperlinkElementUtils.prototype.get search):
>+        (foo.html.HtmlHyperlinkElementUtils.prototype.set search):
>+        (foo.html.HtmlHyperlinkElementUtils.prototype.get username):
>+        (foo.html.HtmlHyperlinkElementUtils.prototype.set username):
>+        (foo.html.HtmlHyperlinkElementUtils):
>+        (foo.html.HtmlOptionsCollection.prototype._item):
>+        (foo.html.HtmlOptionsCollection):
>+        (foo.html.HttpRequestEventTarget.prototype.get onAbort):
>+        (foo.html.HttpRequestEventTarget.prototype.get onError):
>+        (foo.html.HttpRequestEventTarget.prototype.get onLoad):
>+        (foo.html.HttpRequestEventTarget.prototype.get onLoadEnd):
>+        (foo.html.HttpRequestEventTarget.prototype.get onLoadStart):
>+        (foo.html.HttpRequestEventTarget.prototype.get onProgress):
>+        (foo.html.HttpRequestEventTarget.prototype.get onTimeout):
>+        (foo.html.HttpRequestEventTarget):
>+        (foo.html.HttpRequest.getString):
>+        (foo.html.HttpRequest.postFormData):
>+        (foo.html.HttpRequest.request.async if):
>+        (foo.html.HttpRequest.request):
>+        (foo.html.HttpRequest.get supportsProgressEvent):
>+        (foo.html.HttpRequest.get supportsCrossOrigin):
>+        (foo.html.HttpRequest.get supportsLoadEndEvent):
>+        (foo.html.HttpRequest.get supportsOverrideMimeType):
>+        (foo.html.HttpRequest.requestCrossOrigin):
>+        (foo.html.HttpRequest.prototype.get responseHeaders):
>+        (foo.html.HttpRequest.prototype.open):
>+        (foo.html.HttpRequest.new):
>+        (foo.html.HttpRequest._create_1):
>+        (foo.html.HttpRequest.prototype.get readyState):
>+        (foo.html.HttpRequest.prototype.get response):
>+        (foo.html.HttpRequest.prototype.get _get_response):
>+        (foo.html.HttpRequest.prototype.get responseText):
>+        (foo.html.HttpRequest.prototype.get responseType):
>+        (foo.html.HttpRequest.prototype.set responseType):
>+        (foo.html.HttpRequest.prototype.get responseUrl):
>+        (foo.html.HttpRequest.prototype.get responseXml):
>+        (foo.html.HttpRequest.prototype.get status):
>+        (foo.html.HttpRequest.prototype.get statusText):
>+        (foo.html.HttpRequest.prototype.get timeout):
>+        (foo.html.HttpRequest.prototype.set timeout):
>+        (foo.html.HttpRequest.prototype.get upload):
>+        (foo.html.HttpRequest.prototype.get withCredentials):
>+        (foo.html.HttpRequest.prototype.set withCredentials):
>+        (foo.html.HttpRequest.prototype.abort):
>+        (foo.html.HttpRequest.prototype.getAllResponseHeaders):
>+        (foo.html.HttpRequest.prototype.getResponseHeader):
>+        (foo.html.HttpRequest.prototype.overrideMimeType):
>+        (foo.html.HttpRequest.prototype.send):
>+        (foo.html.HttpRequest.prototype.setRequestHeader):
>+        (foo.html.HttpRequest.prototype.get onReadyStateChange):
>+        (foo.html.HttpRequest):
>+        (foo.html.HttpRequestUpload):
>+        (foo.html.IFrameElement.new):
>+        (foo.html.IFrameElement.prototype.get allow):
>+        (foo.html.IFrameElement.prototype.set allow):
>+        (foo.html.IFrameElement.prototype.get allowFullscreen):
>+        (foo.html.IFrameElement.prototype.set allowFullscreen):
>+        (foo.html.IFrameElement.prototype.get allowPaymentRequest):
>+        (foo.html.IFrameElement.prototype.set allowPaymentRequest):
>+        (foo.html.IFrameElement.prototype.get contentWindow):
>+        (foo.html.IFrameElement.prototype.get _get_contentWindow):
>+        (foo.html.IFrameElement.prototype.get csp):
>+        (foo.html.IFrameElement.prototype.set csp):
>+        (foo.html.IFrameElement.prototype.get height):
>+        (foo.html.IFrameElement.prototype.set height):
>+        (foo.html.IFrameElement.prototype.get name):
>+        (foo.html.IFrameElement.prototype.set name):
>+        (foo.html.IFrameElement.prototype.get referrerPolicy):
>+        (foo.html.IFrameElement.prototype.set referrerPolicy):
>+        (foo.html.IFrameElement.prototype.get sandbox):
>+        (foo.html.IFrameElement.prototype.get src):
>+        (foo.html.IFrameElement.prototype.set src):
>+        (foo.html.IFrameElement.prototype.get srcdoc):
>+        (foo.html.IFrameElement.prototype.set srcdoc):
>+        (foo.html.IFrameElement.prototype.get width):
>+        (foo.html.IFrameElement.prototype.set width):
>+        (foo.html.IFrameElement):
>+        (foo.html.IdleDeadline.prototype.get didTimeout):
>+        (foo.html.IdleDeadline.prototype.timeRemaining):
>+        (foo.html.IdleDeadline):
>+        (foo.html.ImageBitmap.prototype.get height):
>+        (foo.html.ImageBitmap.prototype.get width):
>+        (foo.html.ImageBitmap.prototype.close):
>+        (foo.html.ImageBitmap):
>+        (foo.html.ImageBitmapRenderingContext.prototype.get canvas):
>+        (foo.html.ImageBitmapRenderingContext.prototype.transferFromImageBitmap):
>+        (foo.html.ImageBitmapRenderingContext):
>+        (foo.html.ImageCapture.new):
>+        (foo.html.ImageCapture._create_1):
>+        (foo.html.ImageCapture.prototype.get track):
>+        (foo.html.ImageCapture.prototype.getPhotoCapabilities):
>+        (foo.html.ImageCapture.prototype.getPhotoSettings):
>+        (foo.html.ImageCapture.prototype.grabFrame):
>+        (foo.html.ImageCapture.prototype.setOptions):
>+        (foo.html.ImageCapture.prototype.takePhoto):
>+        (foo.html.ImageCapture):
>+        (foo.html.ImageData.new):
>+        (foo.html.ImageData._create_1):
>+        (foo.html.ImageData._create_2):
>+        (foo.html.ImageData._create_3):
>+        (foo.html.ImageData.prototype.get data):
>+        (foo.html.ImageData.prototype.get height):
>+        (foo.html.ImageData.prototype.get width):
>+        (foo.html.ImageData):
>+        (foo.html.ImageElement.new):
>+        (foo.html.ImageElement.prototype.get alt):
>+        (foo.html.ImageElement.prototype.set alt):
>+        (foo.html.ImageElement.get complete):
>+        (foo.html.ImageElement.get crossOrigin):
>+        (foo.html.ImageElement.set crossOrigin):
>+        (foo.html.ImageElement.get currentSrc):
>+        (foo.html.ImageElement.get height):
>+        (foo.html.ImageElement.set height):
>+        (foo.html.ImageElement.get isMap):
>+        (foo.html.ImageElement.set isMap):
>+        (foo.html.ImageElement.get naturalHeight):
>+        (foo.html.ImageElement.get naturalWidth):
>+        (foo.html.ImageElement.get referrerPolicy):
>+        (foo.html.ImageElement.set referrerPolicy):
>+        (foo.html.ImageElement.get sizes):
>+        (foo.html.ImageElement.set sizes):
>+        (foo.html.ImageElement.get src):
>+        (foo.html.ImageElement.set src):
>+        (foo.html.ImageElement.get srcset):
>+        (foo.html.ImageElement.set srcset):
>+        (foo.html.ImageElement.get useMap):
>+        (foo.html.ImageElement.set useMap):
>+        (foo.html.ImageElement.get width):
>+        (foo.html.ImageElement.set width):
>+        (foo.const.async Symbol):
>+        (foo.html.InputDeviceCapabilities.new):
>+        (foo.html.InputDeviceCapabilities._create_1):
>+        (foo.html.InputDeviceCapabilities._create_2):
>+        (foo.html.InputDeviceCapabilities.prototype.get firesTouchEvents):
>+        (foo.html.InputDeviceCapabilities):
>+        (foo.html.InputElement.new):
>+        (foo.html.InputElement.prototype.get accept):
>+        (foo.html.InputElement.prototype.set accept):
>+        (foo.html.InputElement.prototype.get alt):
>+        (foo.html.InputElement.prototype.set alt):
>+        (foo.html.InputElement.prototype.get autocapitalize):
>+        (foo.html.InputElement.prototype.set autocapitalize):
>+        (foo.html.InputElement.prototype.get autocomplete):
>+        (foo.html.InputElement.prototype.set autocomplete):
>+        (foo.html.InputElement.prototype.get autofocus):
>+        (foo.html.InputElement.prototype.set autofocus):
>+        (foo.html.InputElement.prototype.get capture):
>+        (foo.html.InputElement.prototype.set capture):
>+        (foo.html.InputElement.prototype.get checked):
>+        (foo.html.InputElement.prototype.set checked):
>+        (foo.html.InputElement.prototype.get defaultChecked):
>+        (foo.html.InputElement.prototype.set defaultChecked):
>+        (foo.html.InputElement.prototype.get defaultValue):
>+        (foo.html.InputElement.prototype.set defaultValue):
>+        (foo.html.InputElement.prototype.get dirName):
>+        (foo.html.InputElement.prototype.set dirName):
>+        (foo.html.InputElement.prototype.get disabled):
>+        (foo.html.InputElement.prototype.set disabled):
>+        (foo.html.InputElement.prototype.get files):
>+        (foo.html.InputElement.prototype.set files):
>+        (foo.html.InputElement.prototype.get form):
>+        (foo.html.InputElement.prototype.get formAction):
>+        (foo.html.InputElement.prototype.set formAction):
>+        (foo.html.InputElement.prototype.get formEnctype):
>+        (foo.html.InputElement.prototype.set formEnctype):
>+        (foo.html.InputElement.prototype.get formMethod):
>+        (foo.html.InputElement.prototype.set formMethod):
>+        (foo.html.InputElement.prototype.get formNoValidate):
>+        (foo.html.InputElement.prototype.set formNoValidate):
>+        (foo.html.InputElement.prototype.get formTarget):
>+        (foo.html.InputElement.prototype.set formTarget):
>+        (foo.html.InputElement.prototype.get height):
>+        (foo.html.InputElement.prototype.set height):
>+        (foo.html.InputElement.prototype.get incremental):
>+        (foo.html.InputElement.prototype.set incremental):
>+        (foo.html.InputElement.prototype.get indeterminate):
>+        (foo.html.InputElement.prototype.set indeterminate):
>+        (foo.html.InputElement.prototype.get labels):
>+        (foo.html.InputElement.prototype.get list):
>+        (foo.html.InputElement.prototype.get max):
>+        (foo.html.InputElement.prototype.set max):
>+        (foo.html.InputElement.prototype.get maxLength):
>+        (foo.html.InputElement.prototype.set maxLength):
>+        (foo.html.InputElement.prototype.get min):
>+        (foo.html.InputElement.prototype.set min):
>+        (foo.html.InputElement.prototype.get minLength):
>+        (foo.html.InputElement.prototype.set minLength):
>+        (foo.html.InputElement.prototype.get multiple):
>+        (foo.html.InputElement.prototype.set multiple):
>+        (foo.html.InputElement.prototype.get name):
>+        (foo.html.InputElement.prototype.set name):
>+        (foo.html.InputElement.prototype.get pattern):
>+        (foo.html.InputElement.prototype.set pattern):
>+        (foo.html.InputElement.prototype.get placeholder):
>+        (foo.html.InputElement.prototype.set placeholder):
>+        (foo.html.InputElement.prototype.get readOnly):
>+        (foo.html.InputElement.prototype.set readOnly):
>+        (foo.html.InputElement.prototype.get required):
>+        (foo.html.InputElement.prototype.set required):
>+        (foo.html.InputElement.prototype.get selectionDirection):
>+        (foo.html.InputElement.prototype.set selectionDirection):
>+        (foo.html.InputElement.prototype.get selectionEnd):
>+        (foo.html.InputElement.prototype.set selectionEnd):
>+        (foo.html.InputElement.prototype.get selectionStart):
>+        (foo.html.InputElement.prototype.set selectionStart):
>+        (foo.html.InputElement.prototype.get size):
>+        (foo.html.InputElement.prototype.set size):
>+        (foo.html.InputElement.prototype.get src):
>+        (foo.html.InputElement.prototype.set src):
>+        (foo.html.InputElement.prototype.get step):
>+        (foo.html.InputElement.prototype.set step):
>+        (foo.html.InputElement.prototype.get type):
>+        (foo.html.InputElement.prototype.set type):
>+        (foo.html.InputElement.prototype.get validationMessage):
>+        (foo.html.InputElement.prototype.get validity):
>+        (foo.html.InputElement.prototype.get value):
>+        (foo.html.InputElement.prototype.set value):
>+        (foo.html.InputElement.prototype.get valueAsDate):
>+        (foo.html.InputElement.prototype.get _get_valueAsDate):
>+        (foo.html.InputElement.prototype.set valueAsDate):
>+        (foo.html.InputElement.prototype.set _set_valueAsDate):
>+        (foo.html.InputElement.prototype.get valueAsNumber):
>+        (foo.html.InputElement.prototype.set valueAsNumber):
>+        (foo.html.InputElement.prototype.get entries):
>+        (foo.html.InputElement.prototype.get directory):
>+        (foo.html.InputElement.prototype.set directory):
>+        (foo.html.InputElement.prototype.get width):
>+        (foo.html.InputElement.prototype.set width):
>+        (foo.html.InputElement.prototype.get willValidate):
>+        (foo.html.InputElement.prototype.checkValidity):
>+        (foo.html.InputElement.prototype.reportValidity):
>+        (foo.html.InputElement.prototype.select):
>+        (foo.html.InputElement.prototype.setCustomValidity):
>+        (foo.html.InputElement.prototype.setRangeText):
>+        (foo.html.InputElement.prototype.setSelectionRange):
>+        (foo.html.InputElement.prototype.stepDown):
>+        (foo.html.InputElement.prototype.stepUp):
>+        (foo.html.InputElement):
>+        (foo.html.InputElementBase.prototype.get autofocus):
>+        (foo.html.InputElementBase.prototype.set autofocus):
>+        (foo.html.InputElementBase.prototype.get disabled):
>+        (foo.html.InputElementBase.prototype.set disabled):
>+        (foo.html.InputElementBase.prototype.get incremental):
>+        (foo.html.InputElementBase.prototype.set incremental):
>+        (foo.html.InputElementBase.prototype.get indeterminate):
>+        (foo.html.InputElementBase.prototype.set indeterminate):
>+        (foo.html.InputElementBase.prototype.get name):
>+        (foo.html.InputElementBase.prototype.set name):
>+        (foo.html.InputElementBase.prototype.get value):
>+        (foo.html.InputElementBase.prototype.set value):
>+        (foo.html.InputElementBase):
>+        (foo.html.HiddenInputElement.new):
>+        (foo.html.HiddenInputElement):
>+        (foo.html.TextInputElementBase.prototype.get autocomplete):
>+        (foo.html.TextInputElementBase.prototype.set autocomplete):
>+        (foo.html.TextInputElementBase.prototype.get maxLength):
>+        (foo.html.TextInputElementBase.prototype.set maxLength):
>+        (foo.html.TextInputElementBase.prototype.get pattern):
>+        (foo.html.TextInputElementBase.prototype.set pattern):
>+        (foo.html.TextInputElementBase.prototype.get placeholder):
>+        (foo.html.TextInputElementBase.prototype.set placeholder):
>+        (foo.html.TextInputElementBase.prototype.get readOnly):
>+        (foo.html.TextInputElementBase.prototype.set readOnly):
>+        (foo.html.TextInputElementBase.prototype.get required):
>+        (foo.html.TextInputElementBase.prototype.set required):
>+        (foo.html.TextInputElementBase.prototype.get size):
>+        (foo.html.TextInputElementBase.prototype.set size):
>+        (foo.html.TextInputElementBase.prototype.get selectionDirection):
>+        (foo.html.TextInputElementBase.prototype.set selectionDirection):
>+        (foo.html.TextInputElementBase.prototype.get selectionEnd):
>+        (foo.html.TextInputElementBase.prototype.set selectionEnd):
>+        (foo.html.TextInputElementBase.prototype.get selectionStart):
>+        (foo.html.TextInputElementBase.prototype.set selectionStart):
>+        (foo.html.TextInputElementBase):
>+        (foo.html.SearchInputElement.new):
>+        (foo.html.SearchInputElement.prototype.get dirName):
>+        (foo.html.SearchInputElement.prototype.set dirName):
>+        (foo.html.SearchInputElement.get supported):
>+        (foo.html.SearchInputElement):
>+        (foo.html.TextInputElement.new):
>+        (foo.html.TextInputElement.prototype.get dirName):
>+        (foo.html.TextInputElement.prototype.set dirName):
>+        (foo.html.TextInputElement):
>+        (foo.html.UrlInputElement.new):
>+        (foo.html.UrlInputElement.get supported):
>+        (foo.html.UrlInputElement):
>+        (foo.html.TelephoneInputElement.new):
>+        (foo.html.TelephoneInputElement.get supported):
>+        (foo.html.TelephoneInputElement):
>+        (foo.html.EmailInputElement.new):
>+        (foo.html.EmailInputElement.prototype.get autocomplete):
>+        (foo.html.EmailInputElement.prototype.set autocomplete):
>+        (foo.html.EmailInputElement.prototype.get autofocus):
>+        (foo.html.EmailInputElement.prototype.set autofocus):
>+        (foo.html.EmailInputElement.prototype.get maxLength):
>+        (foo.html.EmailInputElement.prototype.set maxLength):
>+        (foo.html.EmailInputElement.prototype.get multiple):
>+        (foo.html.EmailInputElement.prototype.set multiple):
>+        (foo.html.EmailInputElement.prototype.get pattern):
>+        (foo.html.EmailInputElement.prototype.set pattern):
>+        (foo.html.EmailInputElement.prototype.get placeholder):
>+        (foo.html.EmailInputElement.prototype.set placeholder):
>+        (foo.html.EmailInputElement.prototype.get readOnly):
>+        (foo.html.EmailInputElement.prototype.set readOnly):
>+        (foo.html.EmailInputElement.prototype.get required):
>+        (foo.html.EmailInputElement.prototype.set required):
>+        (foo.html.EmailInputElement.prototype.get size):
>+        (foo.html.EmailInputElement.prototype.set size):
>+        (foo.html.EmailInputElement.get supported):
>+        (foo.html.EmailInputElement):
>+        (foo.html.PasswordInputElement.new):
>+        (foo.html.PasswordInputElement):
>+        (foo.html.RangeInputElementBase.prototype.get max):
>+        (foo.html.RangeInputElementBase.prototype.set max):
>+        (foo.html.RangeInputElementBase.prototype.get min):
>+        (foo.html.RangeInputElementBase.prototype.set min):
>+        (foo.html.RangeInputElementBase.prototype.get step):
>+        (foo.html.RangeInputElementBase.prototype.set step):
>+        (foo.html.RangeInputElementBase.prototype.get valueAsNumber):
>+        (foo.html.RangeInputElementBase.prototype.set valueAsNumber):
>+        (foo.html.RangeInputElementBase):
>+        (foo.html.DateInputElement.new):
>+        (foo.html.DateInputElement.prototype.get valueAsDate):
>+        (foo.html.DateInputElement.prototype.set valueAsDate):
>+        (foo.html.DateInputElement.prototype.get readOnly):
>+        (foo.html.DateInputElement.prototype.set readOnly):
>+        (foo.html.DateInputElement.prototype.get required):
>+        (foo.html.DateInputElement.prototype.set required):
>+        (foo.html.DateInputElement.get supported):
>+        (foo.html.DateInputElement):
>+        (foo.html.MonthInputElement.new):
>+        (foo.html.MonthInputElement.prototype.get valueAsDate):
>+        (foo.html.MonthInputElement.prototype.set valueAsDate):
>+        (foo.html.MonthInputElement.prototype.get readOnly):
>+        (foo.html.MonthInputElement.prototype.set readOnly):
>+        (foo.html.MonthInputElement.prototype.get required):
>+        (foo.html.MonthInputElement.prototype.set required):
>+        (foo.html.MonthInputElement.get supported):
>+        (foo.html.MonthInputElement):
>+        (foo.html.WeekInputElement.new):
>+        (foo.html.WeekInputElement.prototype.get valueAsDate):
>+        (foo.html.WeekInputElement.prototype.set valueAsDate):
>+        (foo.html.WeekInputElement.prototype.get readOnly):
>+        (foo.html.WeekInputElement.prototype.set readOnly):
>+        (foo.html.WeekInputElement.prototype.get required):
>+        (foo.html.WeekInputElement.prototype.set required):
>+        (foo.html.WeekInputElement.get supported):
>+        (foo.html.WeekInputElement):
>+        (foo.html.TimeInputElement.new):
>+        (foo.html.TimeInputElement.prototype.get valueAsDate):
>+        (foo.html.TimeInputElement.prototype.set valueAsDate):
>+        (foo.html.TimeInputElement.prototype.get readOnly):
>+        (foo.html.TimeInputElement.prototype.set readOnly):
>+        (foo.html.TimeInputElement.prototype.get required):
>+        (foo.html.TimeInputElement.prototype.set required):
>+        (foo.html.TimeInputElement.get supported):
>+        (foo.html.TimeInputElement):
>+        (foo.html.LocalDateTimeInputElement.new):
>+        (foo.html.LocalDateTimeInputElement.prototype.get readOnly):
>+        (foo.html.LocalDateTimeInputElement.prototype.set readOnly):
>+        (foo.html.LocalDateTimeInputElement.prototype.get required):
>+        (foo.html.LocalDateTimeInputElement.prototype.set required):
>+        (foo.html.LocalDateTimeInputElement.get supported):
>+        (foo.html.LocalDateTimeInputElement):
>+        (foo.html.NumberInputElement.new):
>+        (foo.html.NumberInputElement.prototype.get placeholder):
>+        (foo.html.NumberInputElement.prototype.set placeholder):
>+        (foo.html.NumberInputElement.prototype.get readOnly):
>+        (foo.html.NumberInputElement.prototype.set readOnly):
>+        (foo.html.NumberInputElement.prototype.get required):
>+        (foo.html.NumberInputElement.prototype.set required):
>+        (foo.html.NumberInputElement.get supported):
>+        (foo.html.NumberInputElement):
>+        (foo.html.RangeInputElement.new):
>+        (foo.html.RangeInputElement.get supported):
>+        (foo.html.RangeInputElement):
>+        (foo.html.CheckboxInputElement.new):
>+        (foo.html.CheckboxInputElement.prototype.get checked):
>+        (foo.html.CheckboxInputElement.prototype.set checked):
>+        (foo.html.CheckboxInputElement.prototype.get required):
>+        (foo.html.CheckboxInputElement.prototype.set required):
>+        (foo.html.CheckboxInputElement):
>+        (foo.html.RadioButtonInputElement.new):
>+        (foo.html.RadioButtonInputElement.prototype.get checked):
>+        (foo.html.RadioButtonInputElement.prototype.set checked):
>+        (foo.html.RadioButtonInputElement.prototype.get required):
>+        (foo.html.RadioButtonInputElement.prototype.set required):
>+        (foo.html.RadioButtonInputElement):
>+        (foo.html.FileUploadInputElement.new):
>+        (foo.html.FileUploadInputElement.prototype.get accept):
>+        (foo.html.FileUploadInputElement.prototype.set accept):
>+        (foo.html.FileUploadInputElement.prototype.get multiple):
>+        (foo.html.FileUploadInputElement.prototype.set multiple):
>+        (foo.html.FileUploadInputElement.prototype.get required):
>+        (foo.html.FileUploadInputElement.prototype.set required):
>+        (foo.html.FileUploadInputElement.prototype.get files):
>+        (foo.html.FileUploadInputElement.prototype.set files):
>+        (foo.html.FileUploadInputElement):
>+        (foo.html.SubmitButtonInputElement.new):
>+        (foo.html.SubmitButtonInputElement.prototype.get formAction):
>+        (foo.html.SubmitButtonInputElement.prototype.set formAction):
>+        (foo.html.SubmitButtonInputElement.prototype.get formEnctype):
>+        (foo.html.SubmitButtonInputElement.prototype.set formEnctype):
>+        (foo.html.SubmitButtonInputElement.prototype.get formMethod):
>+        (foo.html.SubmitButtonInputElement.prototype.set formMethod):
>+        (foo.html.SubmitButtonInputElement.prototype.get formNoValidate):
>+        (foo.html.SubmitButtonInputElement.prototype.set formNoValidate):
>+        (foo.html.SubmitButtonInputElement.prototype.get formTarget):
>+        (foo.html.SubmitButtonInputElement.prototype.set formTarget):
>+        (foo.html.SubmitButtonInputElement):
>+        (foo.html.ImageButtonInputElement.new):
>+        (foo.html.ImageButtonInputElement.prototype.get alt):
>+        (foo.html.ImageButtonInputElement.prototype.set alt):
>+        (foo.html.ImageButtonInputElement.prototype.get formAction):
>+        (foo.html.ImageButtonInputElement.prototype.set formAction):
>+        (foo.html.ImageButtonInputElement.prototype.get formEnctype):
>+        (foo.html.ImageButtonInputElement.prototype.set formEnctype):
>+        (foo.html.ImageButtonInputElement.prototype.get formMethod):
>+        (foo.html.ImageButtonInputElement.prototype.set formMethod):
>+        (foo.html.ImageButtonInputElement.prototype.get formNoValidate):
>+        (foo.html.ImageButtonInputElement.prototype.set formNoValidate):
>+        (foo.html.ImageButtonInputElement.prototype.get formTarget):
>+        (foo.html.ImageButtonInputElement.prototype.set formTarget):
>+        (foo.html.ImageButtonInputElement.prototype.get height):
>+        (foo.html.ImageButtonInputElement.prototype.set height):
>+        (foo.html.ImageButtonInputElement.prototype.get src):
>+        (foo.html.ImageButtonInputElement.prototype.set src):
>+        (foo.html.ImageButtonInputElement.prototype.get width):
>+        (foo.html.ImageButtonInputElement.prototype.set width):
>+        (foo.html.ImageButtonInputElement):
>+        (foo.html.ResetButtonInputElement.new):
>+        (foo.html.ResetButtonInputElement):
>+        (foo.html.ButtonInputElement.new):
>+        (foo.html.ButtonInputElement):
>+        (foo.html.InstallEvent.new):
>+        (foo.html.InstallEvent._create_1):
>+        (foo.html.InstallEvent._create_2):
>+        (foo.html.InstallEvent.prototype.registerForeignFetch):
>+        (foo.html.InstallEvent.prototype._registerForeignFetch_1):
>+        (foo.html.InstallEvent):
>+        (foo.html.IntersectionObserver.new):
>+        (foo.html.IntersectionObserver._create_1):
>+        (foo.html.IntersectionObserver._create_2):
>+        (foo.html.IntersectionObserver.prototype.get root):
>+        (foo.html.IntersectionObserver.prototype.get rootMargin):
>+        (foo.html.IntersectionObserver.prototype.get thresholds):
>+        (foo.html.IntersectionObserver.prototype.disconnect):
>+        (foo.html.IntersectionObserver.prototype.observe):
>+        (foo.html.IntersectionObserver.prototype.takeRecords):
>+        (foo.html.IntersectionObserver.prototype.unobserve):
>+        (foo.html.IntersectionObserver):
>+        (foo.html.IntersectionObserverEntry.prototype.get boundingClientRect):
>+        (foo.html.IntersectionObserverEntry.prototype.get intersectionRatio):
>+        (foo.html.IntersectionObserverEntry.prototype.get intersectionRect):
>+        (foo.html.IntersectionObserverEntry.prototype.get isIntersecting):
>+        (foo.html.IntersectionObserverEntry.prototype.get rootBounds):
>+        (foo.html.IntersectionObserverEntry.prototype.get target):
>+        (foo.html.IntersectionObserverEntry.prototype.get time):
>+        (foo.html.IntersectionObserverEntry):
>+        (foo.html.InterventionReport.prototype.get lineNumber):
>+        (foo.html.InterventionReport.prototype.get message):
>+        (foo.html.InterventionReport.prototype.get sourceFile):
>+        (foo.html.InterventionReport):
>+        (foo.html.KeyboardEvent.new):
>+        (foo.html.KeyboardEvent.prototype._initKeyboardEvent):
>+        (foo.html.KeyboardEvent.prototype.get keyCode):
>+        (foo.html.KeyboardEvent.prototype.get charCode):
>+        (foo.html.KeyboardEvent.prototype.get which):
>+        (foo.html.KeyboardEvent.__):
>+        (foo.html.KeyboardEvent._create_1):
>+        (foo.html.KeyboardEvent._create_2):
>+        (foo.html.KeyboardEvent.prototype.get altKey):
>+        (foo.html.KeyboardEvent.prototype.get _charCode):
>+        (foo.html.KeyboardEvent.prototype.get code):
>+        (foo.html.KeyboardEvent.prototype.get ctrlKey):
>+        (foo.html.KeyboardEvent.prototype.get isComposing):
>+        (foo.html.KeyboardEvent.prototype.get key):
>+        (foo.html.KeyboardEvent.prototype.get _keyCode):
>+        (foo.html.KeyboardEvent.prototype.get location):
>+        (foo.html.KeyboardEvent.prototype.get metaKey):
>+        (foo.html.KeyboardEvent.prototype.get repeat):
>+        (foo.html.KeyboardEvent.prototype.get shiftKey):
>+        (foo.html.KeyboardEvent.prototype.getModifierState):
>+        (foo.html.KeyboardEvent):
>+        (foo.html.KeyframeEffectReadOnly.new):
>+        (foo.html.KeyframeEffectReadOnly._create_1):
>+        (foo.html.KeyframeEffectReadOnly._create_2):
>+        (foo.html.KeyframeEffectReadOnly):
>+        (foo.html.KeyframeEffect.new):
>+        (foo.html.KeyframeEffect._create_1):
>+        (foo.html.KeyframeEffect._create_2):
>+        (foo.html.KeyframeEffect):
>+        (foo.html.LIElement.new):
>+        (foo.html.LIElement.prototype.get value):
>+        (foo.html.LIElement.prototype.set value):
>+        (foo.html.LIElement):
>+        (foo.html.LabelElement.new):
>+        (foo.html.LabelElement.prototype.get control):
>+        (foo.html.LabelElement.prototype.get form):
>+        (foo.html.LabelElement.prototype.get htmlFor):
>+        (foo.html.LabelElement.prototype.set htmlFor):
>+        (foo.html.LabelElement):
>+        (foo.html.LegendElement.new):
>+        (foo.html.LegendElement.prototype.get form):
>+        (foo.html.LegendElement):
>+        (foo.html.LinearAccelerationSensor.new):
>+        (foo.html.LinearAccelerationSensor._create_1):
>+        (foo.html.LinearAccelerationSensor._create_2):
>+        (foo.html.LinearAccelerationSensor):
>+        (foo.html.LinkElement.new):
>+        (foo.html.LinkElement.prototype.get as):
>+        (foo.html.LinkElement.prototype.set as):
>+        (foo.html.LinkElement.prototype.get crossOrigin):
>+        (foo.html.LinkElement.prototype.set crossOrigin):
>+        (foo.html.LinkElement.prototype.get disabled):
>+        (foo.html.LinkElement.prototype.set disabled):
>+        (foo.html.LinkElement.prototype.get href):
>+        (foo.html.LinkElement.prototype.set href):
>+        (foo.html.LinkElement.prototype.get hreflang):
>+        (foo.html.LinkElement.prototype.set hreflang):
>+        (foo.html.LinkElement.prototype.get import):
>+        (foo.html.LinkElement.prototype.get integrity):
>+        (foo.html.LinkElement.prototype.set integrity):
>+        (foo.html.LinkElement.prototype.get media):
>+        (foo.html.LinkElement.prototype.set media):
>+        (foo.html.LinkElement.prototype.get referrerPolicy):
>+        (foo.html.LinkElement.prototype.set referrerPolicy):
>+        (foo.html.LinkElement.prototype.get rel):
>+        (foo.html.LinkElement.prototype.set rel):
>+        (foo.html.LinkElement.prototype.get relList):
>+        (foo.html.LinkElement.prototype.get scope):
>+        (foo.html.LinkElement.prototype.set scope):
>+        (foo.html.LinkElement.prototype.get sheet):
>+        (foo.html.LinkElement.prototype.get sizes):
>+        (foo.html.LinkElement.prototype.get type):
>+        (foo.html.LinkElement.prototype.set type):
>+        (foo.html.LinkElement.prototype.get supportsImport):
>+        (foo.html.LinkElement):
>+        (foo.html.Location.prototype.get ancestorOrigins):
>+        (foo.html.Location.prototype.get hash):
>+        (foo.html.Location.prototype.set hash):
>+        (foo.html.Location.prototype.get host):
>+        (foo.html.Location.prototype.set host):
>+        (foo.html.Location.prototype.get hostname):
>+        (foo.html.Location.prototype.set hostname):
>+        (foo.html.Location.prototype.get href):
>+        (foo.html.Location.prototype.set href):
>+        (foo.html.Location.prototype.get pathname):
>+        (foo.html.Location.prototype.set pathname):
>+        (foo.html.Location.prototype.get port):
>+        (foo.html.Location.prototype.set port):
>+        (foo.html.Location.prototype.get protocol):
>+        (foo.html.Location.prototype.set protocol):
>+        (foo.html.Location.prototype.get search):
>+        (foo.html.Location.prototype.set search):
>+        (foo.html.Location.prototype.get trustedHref):
>+        (foo.html.Location.prototype.set trustedHref):
>+        (foo.html.Location.prototype.assign):
>+        (foo.html.Location.prototype.reload):
>+        (foo.html.Location.prototype.replace):
>+        (foo.html.Location.prototype.get origin):
>+        (foo.html.Location.prototype.toString):
>+        (foo.html.Location):
>+        (foo.html.Magnetometer.new):
>+        (foo.html.Magnetometer._create_1):
>+        (foo.html.Magnetometer._create_2):
>+        (foo.html.Magnetometer.prototype.get x):
>+        (foo.html.Magnetometer.prototype.get y):
>+        (foo.html.Magnetometer.prototype.get z):
>+        (foo.html.Magnetometer):
>+        (foo.html.MapElement.new):
>+        (foo.html.MapElement.prototype.get areas):
>+        (foo.html.MapElement.prototype.get name):
>+        (foo.html.MapElement.prototype.set name):
>+        (foo.html.MapElement):
>+        (foo.html.MediaCapabilities.prototype.decodingInfo):
>+        (foo.html.MediaCapabilities.prototype.encodingInfo):
>+        (foo.html.MediaCapabilities):
>+        (foo.html.MediaCapabilitiesInfo.prototype.get powerEfficient):
>+        (foo.html.MediaCapabilitiesInfo.prototype.get smooth):
>+        (foo.html.MediaCapabilitiesInfo.prototype.get supported):
>+        (foo.html.MediaCapabilitiesInfo):
>+        (foo.html.MediaDeviceInfo.prototype.get deviceId):
>+        (foo.html.MediaDeviceInfo.prototype.get groupId):
>+        (foo.html.MediaDeviceInfo.prototype.get kind):
>+        (foo.html.MediaDeviceInfo.prototype.get label):
>+        (foo.html.MediaDeviceInfo):
>+        (foo.html.MediaDevices.prototype.enumerateDevices):
>+        (foo.html.MediaDevices.prototype.getSupportedConstraints):
>+        (foo.html.MediaDevices.prototype._getSupportedConstraints_1):
>+        (foo.html.MediaDevices):
>+        (foo.html.MediaEncryptedEvent.new):
>+        (foo.html.MediaEncryptedEvent._create_1):
>+        (foo.html.MediaEncryptedEvent._create_2):
>+        (foo.html.MediaEncryptedEvent.prototype.get initData):
>+        (foo.html.MediaEncryptedEvent.prototype.get initDataType):
>+        (foo.html.MediaEncryptedEvent):
>+        (foo.html.MediaError.prototype.get code):
>+        (foo.html.MediaError.prototype.get message):
>+        (foo.html.MediaError):
>+        (foo.html.MediaKeyMessageEvent.new):
>+        (foo.html.MediaKeyMessageEvent._create_1):
>+        (foo.html.MediaKeyMessageEvent.prototype.get message):
>+        (foo.html.MediaKeyMessageEvent.prototype.get messageType):
>+        (foo.html.MediaKeyMessageEvent):
>+        (foo.html.MediaKeySession.prototype.get closed):
>+        (foo.html.MediaKeySession.prototype.get expiration):
>+        (foo.html.MediaKeySession.prototype.get keyStatuses):
>+        (foo.html.MediaKeySession.prototype.get sessionId):
>+        (foo.html.MediaKeySession.prototype.close):
>+        (foo.html.MediaKeySession.prototype.generateRequest):
>+        (foo.html.MediaKeySession.prototype.load):
>+        (foo.html.MediaKeySession.prototype.remove):
>+        (foo.html.MediaKeySession.prototype._update):
>+        (foo.html.MediaKeySession.prototype.get onMessage):
>+        (foo.html.MediaKeySession):
>+        (foo.html.MediaKeyStatusMap.prototype.get size):
>+        (foo.html.MediaKeySystemAccess.prototype.get keySystem):
>+        (foo.html.MediaKeySystemAccess.prototype.createMediaKeys):
>+        (foo.html.MediaKeySystemAccess.prototype.getConfiguration):
>+        (foo.html.MediaKeySystemAccess.prototype._getConfiguration_1):
>+        (foo.html.MediaKeySystemAccess):
>+        (foo.html.MediaKeys.prototype._createSession):
>+        (foo.html.MediaKeys.prototype.getStatusForPolicy):
>+        (foo.html.MediaKeys.prototype.setServerCertificate):
>+        (foo.html.MediaKeys):
>+        (foo.html.MediaKeysPolicy.new):
>+        (foo.html.MediaKeysPolicy._create_1):
>+        (foo.html.MediaKeysPolicy.prototype.get minHdcpVersion):
>+        (foo.html.MediaKeysPolicy):
>+        (foo.html.MediaList.prototype.get length):
>+        (foo.html.MediaList.prototype.get mediaText):
>+        (foo.html.MediaList.prototype.set mediaText):
>+        (foo.html.MediaList.prototype.appendMedium):
>+        (foo.html.MediaList.prototype.deleteMedium):
>+        (foo.html.MediaList.prototype.item):
>+        (foo.html.MediaList):
>+        (foo.html.MediaMetadata.new):
>+        (foo.html.MediaMetadata._create_1):
>+        (foo.html.MediaMetadata._create_2):
>+        (foo.html.MediaMetadata.prototype.get album):
>+        (foo.html.MediaMetadata.prototype.set album):
>+        (foo.html.MediaMetadata.prototype.get artist):
>+        (foo.html.MediaMetadata.prototype.set artist):
>+        (foo.html.MediaMetadata.prototype.get artwork):
>+        (foo.html.MediaMetadata.prototype.set artwork):
>+        (foo.html.MediaMetadata.prototype.get title):
>+        (foo.html.MediaMetadata.prototype.set title):
>+        (foo.html.MediaMetadata):
>+        (foo.html.MediaQueryList.prototype.get matches):
>+        (foo.html.MediaQueryList.prototype.get media):
>+        (foo.html.MediaQueryList.prototype.addListener):
>+        (foo.html.MediaQueryList.prototype.removeListener):
>+        (foo.html.MediaQueryList.prototype.get onChange):
>+        (foo.html.MediaQueryList):
>+        (foo.html.MediaQueryListEvent.new):
>+        (foo.html.MediaQueryListEvent._create_1):
>+        (foo.html.MediaQueryListEvent._create_2):
>+        (foo.html.MediaQueryListEvent.prototype.get matches):
>+        (foo.html.MediaQueryListEvent.prototype.get media):
>+        (foo.html.MediaQueryListEvent):
>+        (foo.html.MediaRecorder.new):
>+        (foo.html.MediaRecorder._create_1):
>+        (foo.html.MediaRecorder._create_2):
>+        (foo.html.MediaRecorder.prototype.get audioBitsPerSecond):
>+        (foo.html.MediaRecorder.prototype.get mimeType):
>+        (foo.html.MediaRecorder.prototype.get state):
>+        (foo.html.MediaRecorder.prototype.get stream):
>+        (foo.html.MediaRecorder.prototype.get videoBitsPerSecond):
>+        (foo.html.MediaRecorder.prototype.pause):
>+        (foo.html.MediaRecorder.prototype.requestData):
>+        (foo.html.MediaRecorder.prototype.resume):
>+        (foo.html.MediaRecorder.prototype.start):
>+        (foo.html.MediaRecorder.prototype.stop):
>+        (foo.html.MediaRecorder.prototype.get onError):
>+        (foo.html.MediaRecorder.prototype.get onPause):
>+        (foo.html.MediaRecorder):
>+        (foo.html.MediaSession.prototype.get metadata):
>+        (foo.html.MediaSession.prototype.set metadata):
>+        (foo.html.MediaSession.prototype.get playbackState):
>+        (foo.html.MediaSession.prototype.set playbackState):
>+        (foo.html.MediaSession.prototype.setActionHandler):
>+        (foo.html.MediaSession):
>+        (foo.html.MediaSettingsRange.prototype.get max):
>+        (foo.html.MediaSettingsRange.prototype.get min):
>+        (foo.html.MediaSettingsRange.prototype.get step):
>+        (foo.html.MediaSettingsRange):
>+        (foo.html.MediaSource.new):
>+        (foo.html.MediaSource._create_1):
>+        (foo.html.MediaSource.get supported):
>+        (foo.html.MediaSource.prototype.get activeSourceBuffers):
>+        (foo.html.MediaSource.prototype.get duration):
>+        (foo.html.MediaSource.prototype.set duration):
>+        (foo.html.MediaSource.prototype.get readyState):
>+        (foo.html.MediaSource.prototype.get sourceBuffers):
>+        (foo.html.MediaSource.prototype.addSourceBuffer):
>+        (foo.html.MediaSource.prototype.clearLiveSeekableRange):
>+        (foo.html.MediaSource.prototype.endOfStream):
>+        (foo.html.MediaSource.prototype.removeSourceBuffer):
>+        (foo.html.MediaSource.prototype.setLiveSeekableRange):
>+        (foo.html.MediaSource):
>+        (foo.html.MediaStream.new):
>+        (foo.html.MediaStream._create_1):
>+        (foo.html.MediaStream._create_2):
>+        (foo.html.MediaStream._create_3):
>+        (foo.html.MediaStream.prototype.get active):
>+        (foo.html.MediaStream.prototype.get id):
>+        (foo.html.MediaStream.prototype.addTrack):
>+        (foo.html.MediaStream.prototype.clone):
>+        (foo.html.MediaStream.prototype.getAudioTracks):
>+        (foo.html.MediaStream.prototype.getTrackById):
>+        (foo.html.MediaStream.prototype.getTracks):
>+        (foo.html.MediaStream.prototype.getVideoTracks):
>+        (foo.html.MediaStream.prototype.removeTrack):
>+        (foo.html.MediaStream.prototype.get onAddTrack):
>+        (foo.html.MediaStream.prototype.get onRemoveTrack):
>+        (foo.html.MediaStream.get supported):
>+        (foo.html.MediaStream):
>+        (foo.html.MediaStreamEvent.new):
>+        (foo.html.MediaStreamEvent._create_1):
>+        (foo.html.MediaStreamEvent._create_2):
>+        (foo.html.MediaStreamEvent.get supported):
>+        (foo.html.MediaStreamEvent.prototype.get stream):
>+        (foo.html.MediaStreamEvent):
>+        (foo.html.MediaStreamTrackEvent.new):
>+        (foo.html.MediaStreamTrackEvent._create_1):
>+        (foo.html.MediaStreamTrackEvent.get supported):
>+        (foo.html.MediaStreamTrackEvent.prototype.get track):
>+        (foo.html.MediaStreamTrackEvent):
>+        (foo.html.MemoryInfo.prototype.get jsHeapSizeLimit):
>+        (foo.html.MemoryInfo.prototype.get totalJSHeapSize):
>+        (foo.html.MemoryInfo.prototype.get usedJSHeapSize):
>+        (foo.html.MemoryInfo):
>+        (foo.html.MenuElement.new):
>+        (foo.html.MenuElement):
>+        (foo.html.MessageChannel.new):
>+        (foo.html.MessageChannel._create_1):
>+        (foo.html.MessageChannel.prototype.get port1):
>+        (foo.html.MessageChannel.prototype.get port2):
>+        (foo.html.MessageChannel):
>+        (foo.html.MessageEvent.new):
>+        (foo.html.MessageEvent.prototype.get data):
>+        (foo.html.MessageEvent.prototype.get _get_data):
>+        (foo.html.MessageEvent.__):
>+        (foo.html.MessageEvent._create_1):
>+        (foo.html.MessageEvent._create_2):
>+        (foo.html.MessageEvent.prototype.get lastEventId):
>+        (foo.html.MessageEvent.prototype.get origin):
>+        (foo.html.MessageEvent.prototype.get ports):
>+        (foo.html.MessageEvent.prototype.get source):
>+        (foo.html.MessageEvent.prototype.get _get_source):
>+        (foo.html.MessageEvent.prototype.get suborigin):
>+        (foo.html.MessageEvent.prototype._initMessageEvent):
>+        (foo.html.MessageEvent.prototype._initMessageEvent_1):
>+        (foo.html.MessageEvent):
>+        (foo.html.MessagePort.prototype.addEventListener):
>+        (foo.html.MessagePort.prototype.close):
>+        (foo.html.MessagePort.prototype.postMessage):
>+        (foo.html.MessagePort.prototype._postMessage_1):
>+        (foo.html.MessagePort.prototype._postMessage_2):
>+        (foo.html.MessagePort.prototype._start.3):
>+        (foo.html.MessagePort.prototype.get onMessage):
>+        (foo.html.MessagePort):
>+        (foo.html.MetaElement.new):
>+        (foo.html.MetaElement.prototype.get content):
>+        (foo.html.MetaElement.prototype.set content):
>+        (foo.html.MetaElement.prototype.get httpEquiv):
>+        (foo.html.MetaElement.prototype.set httpEquiv):
>+        (foo.html.MetaElement.prototype.get name):
>+        (foo.html.MetaElement.prototype.set name):
>+        (foo.html.MetaElement):
>+        (foo.html.Metadata.prototype.get modificationTime):
>+        (foo.html.Metadata.prototype.get _get_modificationTime):
>+        (foo.html.Metadata.prototype.get size):
>+        (foo.html.Metadata):
>+        (foo.html.MeterElement.new):
>+        (foo.html.MeterElement.get supported):
>+        (foo.html.MeterElement.prototype.get high):
>+        (foo.html.MeterElement.prototype.set high):
>+        (foo.html.MeterElement.prototype.get labels):
>+        (foo.html.MeterElement.prototype.get low):
>+        (foo.html.MeterElement.prototype.set low):
>+        (foo.html.MeterElement.prototype.get max):
>+        (foo.html.MeterElement.prototype.set max):
>+        (foo.html.MeterElement.prototype.get min):
>+        (foo.html.MeterElement.prototype.set min):
>+        (foo.html.MeterElement.prototype.get optimum):
>+        (foo.html.MeterElement.prototype.set optimum):
>+        (foo.html.MeterElement.prototype.get value):
>+        (foo.html.MeterElement.prototype.set value):
>+        (foo.html.MeterElement):
>+        (foo.html.MidiAccess.prototype.get inputs):
>+        (foo.html.MidiAccess.prototype.get outputs):
>+        (foo.html.MidiAccess.prototype.get sysexEnabled):
>+        (foo.html.MidiAccess):
>+        (foo.html.MidiConnectionEvent.new):
>+        (foo.html.MidiConnectionEvent._create_1):
>+        (foo.html.MidiConnectionEvent._create_2):
>+        (foo.html.MidiConnectionEvent.prototype.get port):
>+        (foo.html.MidiConnectionEvent):
>+        (foo.html.MidiPort.prototype.get connection):
>+        (foo.html.MidiPort.prototype.get id):
>+        (foo.html.MidiPort.prototype.get manufacturer):
>+        (foo.html.MidiPort.prototype.get name):
>+        (foo.html.MidiPort.prototype.get state):
>+        (foo.html.MidiPort.prototype.get type):
>+        (foo.html.MidiPort.prototype.get version):
>+        (foo.html.MidiPort.prototype.close):
>+        (foo.html.MidiPort.prototype.open):
>+        (foo.html.MidiPort):
>+        (foo.html.MidiInput.prototype.get onMidiMessage):
>+        (foo.html.MidiInput):
>+        (foo.const.Interceptor_MapMixin):
>+        (foo.html.MidiInputMap.prototype._getItem):
>+        (foo.html.MidiInputMap.prototype.addAll):
>+        (foo.html.MidiInputMap.prototype.containsValue):
>+        (foo.html.MidiInputMap.prototype.containsKey):
>+        (foo.html.MidiInputMap.prototype._get):
>+        (foo.html.MidiInputMap.prototype.forEach):
>+        (foo.html.MidiInputMap.prototype.get keys):
>+        (foo.html.MidiInputMap.prototype.get values):
>+        (foo.html.MidiInputMap.prototype.get length):
>+        (foo.html.MidiInputMap.prototype.get isEmpty):
>+        (foo.html.MidiInputMap.prototype.get isNotEmpty):
>+        (foo.html.MidiInputMap.prototype._set):
>+        (foo.html.MidiInputMap.prototype.putIfAbsent):
>+        (foo.html.MidiInputMap.prototype.remove):
>+        (foo.html.MidiInputMap.prototype.clear):
>+        (foo.html.MidiInputMap):
>+        (foo.html.MidiMessageEvent.new):
>+        (foo.html.MidiMessageEvent._create_1):
>+        (foo.html.MidiMessageEvent._create_2):
>+        (foo.html.MidiMessageEvent.prototype.get data):
>+        (foo.html.MidiMessageEvent):
>+        (foo.html.MidiOutput.prototype.send):
>+        (foo.html.MidiOutput):
>+        (foo.html.MidiOutputMap.prototype._getItem):
>+        (foo.html.MidiOutputMap.prototype.addAll):
>+        (foo.html.MidiOutputMap.prototype.containsValue):
>+        (foo.html.MidiOutputMap.prototype.containsKey):
>+        (foo.html.MidiOutputMap.prototype._get):
>+        (foo.html.MidiOutputMap.prototype.forEach):
>+        (foo.html.MidiOutputMap.prototype.get keys):
>+        (foo.html.MidiOutputMap.prototype.get values):
>+        (foo.html.MidiOutputMap.prototype.get length):
>+        (foo.html.MidiOutputMap.prototype.get isEmpty):
>+        (foo.html.MidiOutputMap.prototype.get isNotEmpty):
>+        (foo.html.MidiOutputMap.prototype._set):
>+        (foo.html.MidiOutputMap.prototype.putIfAbsent):
>+        (foo.html.MidiOutputMap.prototype.remove):
>+        (foo.html.MidiOutputMap.prototype.clear):
>+        (foo.html.MidiOutputMap):
>+        (foo.html.MimeType.prototype.get description):
>+        (foo.html.MimeType.prototype.get enabledPlugin):
>+        (foo.html.MimeType.prototype.get suffixes):
>+        (foo.html.MimeType.prototype.get type):
>+        (foo.html.MimeType):
>+        (foo.const.Interceptor_ListMixin.2):
>+        (foo.const.Interceptor_ImmutableListMixin.2):
>+        (foo.html.MimeTypeArray.prototype.get length):
>+        (foo.html.MimeTypeArray.prototype._get):
>+        (foo.html.MimeTypeArray.prototype._set):
>+        (foo.html.MimeTypeArray.prototype.set length):
>+        (foo.html.MimeTypeArray.prototype.get first):
>+        (foo.html.MimeTypeArray.prototype.set first):
>+        (foo.html.MimeTypeArray.prototype.get last):
>+        (foo.html.MimeTypeArray.prototype.set last):
>+        (foo.html.MimeTypeArray.prototype.get single):
>+        (foo.html.MimeTypeArray.prototype.elementAt):
>+        (foo.html.MimeTypeArray.prototype.item):
>+        (foo.html.MimeTypeArray.prototype.namedItem):
>+        (foo.html.MimeTypeArray):
>+        (foo.html.ModElement.prototype.get cite):
>+        (foo.html.ModElement.prototype.set cite):
>+        (foo.html.ModElement.prototype.get dateTime):
>+        (foo.html.ModElement.prototype.set dateTime):
>+        (foo.html.ModElement):
>+        (foo.html.MouseEvent.new):
>+        (foo.html.MouseEvent.__):
>+        (foo.html.MouseEvent._create_1):
>+        (foo.html.MouseEvent._create_2):
>+        (foo.html.MouseEvent.prototype.get altKey):
>+        (foo.html.MouseEvent.prototype.get button):
>+        (foo.html.MouseEvent.prototype.get buttons):
>+        (foo.html.MouseEvent.prototype.get _clientX):
>+        (foo.html.MouseEvent.prototype.get _clientY):
>+        (foo.html.MouseEvent.prototype.get ctrlKey):
>+        (foo.html.MouseEvent.prototype.get fromElement):
>+        (foo.html.MouseEvent.prototype.get _layerX):
>+        (foo.html.MouseEvent.prototype.get _layerY):
>+        (foo.html.MouseEvent.prototype.get metaKey):
>+        (foo.html.MouseEvent.prototype.get _movementX):
>+        (foo.html.MouseEvent.prototype.get _movementY):
>+        (foo.html.MouseEvent.prototype.get _pageX):
>+        (foo.html.MouseEvent.prototype.get _pageY):
>+        (foo.html.MouseEvent.prototype.get region):
>+        (foo.html.MouseEvent.prototype.get relatedTarget):
>+        (foo.html.MouseEvent.prototype.get _get_relatedTarget):
>+        (foo.html.MouseEvent.prototype.get _screenX):
>+        (foo.html.MouseEvent.prototype.get _screenY):
>+        (foo.html.MouseEvent.prototype.get shiftKey):
>+        (foo.html.MouseEvent.prototype.get toElement):
>+        (foo.html.MouseEvent.prototype.getModifierState):
>+        (foo.html.MouseEvent.prototype._initMouseEvent):
>+        (foo.html.MouseEvent.prototype._initMouseEvent_1):
>+        (foo.html.MouseEvent.prototype.get client):
>+        (foo.html.MouseEvent.prototype.get movement):
>+        (foo.html.MouseEvent.prototype.get offset):
>+        (foo.html.MouseEvent.prototype.get screen):
>+        (foo.html.MouseEvent.prototype.get layer):
>+        (foo.html.MouseEvent.prototype.get page):
>+        (foo.html.MouseEvent.prototype.get dataTransfer):
>+        (foo.html.MouseEvent):
>+        (foo.html.MutationEvent.prototype.get attrChange):
>+        (foo.html.MutationEvent.prototype.get attrName):
>+        (foo.html.MutationEvent.prototype.get newValue):
>+        (foo.html.MutationEvent.prototype.get prevValue):
>+        (foo.html.MutationEvent.prototype.get relatedNode):
>+        (foo.html.MutationEvent.prototype.initMutationEvent):
>+        (foo.html.MutationEvent):
>+        (foo.html.MutationObserver.prototype.disconnect):
>+        (foo.html.MutationObserver.prototype._observe):
>+        (foo.html.MutationObserver.prototype._observe_1):
>+        (foo.html.MutationObserver.prototype._observe_2):
>+        (foo.html.MutationObserver.prototype.takeRecords):
>+        (foo.html.MutationObserver.get supported):
>+        (foo.html.MutationObserver.prototype.observe.override):
>+        (foo.html.MutationObserver.prototype.observe):
>+        (foo.html.MutationObserver._createDict):
>+        (foo.html.MutationObserver._add):
>+        (foo.html.MutationObserver._fixupList):
>+        (foo.html.MutationObserver.prototype._call):
>+        (foo.html.MutationObserver.new):
>+        (foo.html.MutationObserver):
>+        (foo.html.MutationRecord.prototype.get addedNodes):
>+        (foo.html.MutationRecord.prototype.get attributeName):
>+        (foo.html.MutationRecord.prototype.get attributeNamespace):
>+        (foo.html.MutationRecord.prototype.get nextSibling):
>+        (foo.html.MutationRecord.prototype.get oldValue):
>+        (foo.html.MutationRecord.prototype.get previousSibling):
>+        (foo.html.MutationRecord.prototype.get removedNodes):
>+        (foo.html.MutationRecord.prototype.get target):
>+        (foo.html.MutationRecord.prototype.get type):
>+        (foo.html.MutationRecord):
>+        (foo.html.NavigationPreloadManager.prototype.disable):
>+        (foo.html.NavigationPreloadManager.prototype.enable):
>+        (foo.html.NavigationPreloadManager.prototype.getState):
>+        (foo.html.NavigationPreloadManager):
>+        (foo.html.NavigatorConcurrentHardware.prototype.get hardwareConcurrency):
>+        (foo.html.NavigatorConcurrentHardware):
>+        (foo.html.Navigator.prototype.getGamepads):
>+        (foo.html.Navigator.prototype.get language):
>+        (foo.html.Navigator.prototype.getUserMedia):
>+        (foo.html.Navigator.prototype._ensureGetUserMedia):
>+        (foo.html.Navigator.prototype._getUserMedia):
>+        (foo.html.Navigator.prototype.get budget):
>+        (foo.html.Navigator.prototype.get clipboard):
>+        (foo.html.Navigator.prototype.get connection):
>+        (foo.html.Navigator.prototype.get credentials):
>+        (foo.html.Navigator.prototype.get deviceMemory):
>+        (foo.html.Navigator.prototype.get doNotTrack):
>+        (foo.html.Navigator.prototype.get geolocation):
>+        (foo.html.Navigator.prototype.get maxTouchPoints):
>+        (foo.html.Navigator.prototype.get mediaCapabilities):
>+        (foo.html.Navigator.prototype.get mediaDevices):
>+        (foo.html.Navigator.prototype.get mediaSession):
>+        (foo.html.Navigator.prototype.get mimeTypes):
>+        (foo.html.Navigator.prototype.get nfc):
>+        (foo.html.Navigator.prototype.get permissions):
>+        (foo.html.Navigator.prototype.get presentation):
>+        (foo.html.Navigator.prototype.get productSub):
>+        (foo.html.Navigator.prototype.get serviceWorker):
>+        (foo.html.Navigator.prototype.get storage):
>+        (foo.html.Navigator.prototype.get vendor):
>+        (foo.html.Navigator.prototype.get vendorSub):
>+        (foo.html.Navigator.prototype.get vr):
>+        (foo.html.Navigator.prototype.get persistentStorage):
>+        (foo.html.Navigator.prototype.get temporaryStorage):
>+        (foo.html.Navigator.prototype.cancelKeyboardLock):
>+        (foo.html.Navigator.prototype.getBattery):
>+        (foo.html.Navigator.prototype._getGamepads):
>+        (foo.html.Navigator.prototype.getInstalledRelatedApps):
>+        (foo.html.Navigator.prototype.getVRDisplays):
>+        (foo.html.Navigator.prototype.registerProtocolHandler):
>+        (foo.html.Navigator.prototype.requestKeyboardLock):
>+        (foo.html.Navigator.prototype._requestKeyboardLock_1):
>+        (foo.html.Navigator.prototype._requestKeyboardLock_2):
>+        (foo.html.Navigator.prototype.requestMidiAccess):
>+        (foo.html.Navigator.prototype.requestMediaKeySystemAccess):
>+        (foo.html.Navigator.prototype.sendBeacon):
>+        (foo.html.Navigator.prototype.share):
>+        (foo.html.Navigator.prototype.get webdriver):
>+        (foo.html.Navigator.prototype.get cookieEnabled):
>+        (foo.html.Navigator.prototype.get appCodeName):
>+        (foo.html.Navigator.prototype.get appName):
>+        (foo.html.Navigator.prototype.get appVersion):
>+        (foo.html.Navigator.prototype.get dartEnabled):
>+        (foo.html.Navigator.prototype.get platform):
>+        (foo.html.Navigator.prototype.get product):
>+        (foo.html.Navigator.prototype.get userAgent):
>+        (foo.html.Navigator.prototype.get languages):
>+        (foo.html.Navigator.prototype.get onLine):
>+        (foo.html.Navigator):
>+        (foo.html.NavigatorAutomationInformation.prototype.get webdriver):
>+        (foo.html.NavigatorAutomationInformation):
>+        (foo.html.NavigatorCookies.prototype.get cookieEnabled):
>+        (foo.html.NavigatorCookies):
>+        (foo.html.NavigatorID.prototype.get appCodeName):
>+        (foo.html.NavigatorID.prototype.set appCodeName):
>+        (foo.html.NavigatorID.prototype.get appName):
>+        (foo.html.NavigatorID.prototype.set appName):
>+        (foo.html.NavigatorID.prototype.get appVersion):
>+        (foo.html.NavigatorID.prototype.set appVersion):
>+        (foo.html.NavigatorID.prototype.get dartEnabled):
>+        (foo.html.NavigatorID.prototype.set dartEnabled):
>+        (foo.html.NavigatorID.prototype.get platform):
>+        (foo.html.NavigatorID.prototype.set platform):
>+        (foo.html.NavigatorID.prototype.get product):
>+        (foo.html.NavigatorID.prototype.set product):
>+        (foo.html.NavigatorID.prototype.get userAgent):
>+        (foo.html.NavigatorID.prototype.set userAgent):
>+        (foo.html.NavigatorID):
>+        (foo.html.NavigatorLanguage.prototype.get language):
>+        (foo.html.NavigatorLanguage.prototype.set language):
>+        (foo.html.NavigatorLanguage.prototype.get languages):
>+        (foo.html.NavigatorLanguage.prototype.set languages):
>+        (foo.html.NavigatorLanguage):
>+        (foo.html.NavigatorOnLine.prototype.get onLine):
>+        (foo.html.NavigatorOnLine.prototype.set onLine):
>+        (foo.html.NavigatorOnLine):
>+        (foo.html.NavigatorUserMediaError.prototype.get constraintName):
>+        (foo.html.NavigatorUserMediaError.prototype.get message):
>+        (foo.html.NavigatorUserMediaError.prototype.get name):
>+        (foo.html.NavigatorUserMediaError):
>+        (foo.html.NetworkInformation.prototype.get downlink):
>+        (foo.html.NetworkInformation.prototype.get downlinkMax):
>+        (foo.html.NetworkInformation.prototype.get effectiveType):
>+        (foo.html.NetworkInformation.prototype.get rtt):
>+        (foo.html.NetworkInformation.prototype.get type):
>+        (foo.html.NetworkInformation.prototype.get onChange):
>+        (foo.html.NetworkInformation):
>+        (foo.html._ChildNodeListLazy.prototype.get first):
>+        (foo.html._ChildNodeListLazy.prototype.set first):
>+        (foo.html._ChildNodeListLazy.prototype.get last):
>+        (foo.html._ChildNodeListLazy.prototype.set last):
>+        (foo.html._ChildNodeListLazy.prototype.get single):
>+        (foo.html._ChildNodeListLazy.prototype.add):
>+        (foo.html._ChildNodeListLazy.prototype.addAll):
>+        (foo.html._ChildNodeListLazy.prototype.insert):
>+        (foo.html._ChildNodeListLazy.prototype.insertAll):
>+        (foo.html._ChildNodeListLazy.prototype.setAll):
>+        (foo.html._ChildNodeListLazy.prototype.removeLast):
>+        (foo.html._ChildNodeListLazy.prototype.removeAt):
>+        (foo.html._ChildNodeListLazy.prototype.remove):
>+        (foo.html._ChildNodeListLazy.prototype._filter.0):
>+        (foo.html._ChildNodeListLazy.prototype.removeWhere):
>+        (foo.html._ChildNodeListLazy.prototype.retainWhere):
>+        (foo.html._ChildNodeListLazy.prototype.clear):
>+        (foo.html._ChildNodeListLazy.prototype._set):
>+        (foo.html._ChildNodeListLazy.prototype.get iterator):
>+        (foo.html._ChildNodeListLazy.prototype.sort):
>+        (foo.html._ChildNodeListLazy.prototype.shuffle):
>+        (foo.html._ChildNodeListLazy.prototype.setRange):
>+        (foo.html._ChildNodeListLazy.prototype.fillRange):
>+        (foo.html._ChildNodeListLazy.prototype.removeRange):
>+        (foo.html._ChildNodeListLazy.prototype.get length):
>+        (foo.html._ChildNodeListLazy.prototype.set length):
>+        (foo.html._ChildNodeListLazy.prototype._get):
>+        (foo.html._ChildNodeListLazy.prototype.get rawList):
>+        (foo.html._ChildNodeListLazy):
>+        (foo.html.NodeFilter):
>+        (foo.html.NodeIterator.new):
>+        (foo.html.NodeIterator.prototype.get pointerBeforeReferenceNode):
>+        (foo.html.NodeIterator.prototype.get referenceNode):
>+        (foo.html.NodeIterator.prototype.get root):
>+        (foo.html.NodeIterator.prototype.get whatToShow):
>+        (foo.html.NodeIterator.prototype.detach):
>+        (foo.html.NodeIterator.prototype.nextNode):
>+        (foo.html.NodeIterator.prototype.previousNode):
>+        (foo.html.NodeIterator):
>+        (foo.const.Interceptor_ListMixin.3):
>+        (foo.const.Interceptor_ImmutableListMixin.3):
>+        (foo.html.NodeList.prototype.get length):
>+        (foo.html.NodeList.prototype._get):
>+        (foo.html.NodeList.prototype._set):
>+        (foo.html.NodeList.prototype.set length):
>+        (foo.html.NodeList.prototype.get first):
>+        (foo.html.NodeList.prototype.set first):
>+        (foo.html.NodeList.prototype.get last):
>+        (foo.html.NodeList.prototype.set last):
>+        (foo.html.NodeList.prototype.get single):
>+        (foo.html.NodeList.prototype.elementAt):
>+        (foo.html.NodeList.prototype._item):
>+        (foo.html.NodeList):
>+        (foo.html.NonDocumentTypeChildNode.prototype.get nextElementSibling):
>+        (foo.html.NonDocumentTypeChildNode.prototype.get previousElementSibling):
>+        (foo.html.NonDocumentTypeChildNode):
>+        (foo.html.NonElementParentNode.prototype.getElementById):
>+        (foo.html.NonElementParentNode):
>+        (foo.html.NoncedElement.prototype.get nonce):
>+        (foo.html.NoncedElement.prototype.set nonce):
>+        (foo.html.NoncedElement):
>+        (foo.html.Notification.new):
>+        (foo.html.Notification._factoryNotification):
>+        (foo.html.Notification._create_1):
>+        (foo.html.Notification._create_2):
>+        (foo.html.Notification.get supported):
>+        (foo.html.Notification.prototype.get actions):
>+        (foo.html.Notification.prototype.get badge):
>+        (foo.html.Notification.prototype.get body):
>+        (foo.html.Notification.prototype.get data):
>+        (foo.html.Notification.prototype.get dir):
>+        (foo.html.Notification.prototype.get icon):
>+        (foo.html.Notification.prototype.get image):
>+        (foo.html.Notification.prototype.get lang):
>+        (foo.html.Notification.prototype.get renotify):
>+        (foo.html.Notification.prototype.get requireInteraction):
>+        (foo.html.Notification.prototype.get silent):
>+        (foo.html.Notification.prototype.get tag):
>+        (foo.html.Notification.prototype.get timestamp):
>+        (foo.html.Notification.prototype.get title):
>+        (foo.html.Notification.prototype.get vibrate):
>+        (foo.html.Notification.prototype.close):
>+        (foo.html.Notification.requestPermission):
>+        (foo.html.Notification.prototype.get onClick):
>+        (foo.html.Notification.prototype.get onClose):
>+        (foo.html.Notification.prototype.get onError):
>+        (foo.html.Notification.prototype.get onShow):
>+        (foo.html.Notification):
>+        (foo.html.NotificationEvent.new):
>+        (foo.html.NotificationEvent._create_1):
>+        (foo.html.NotificationEvent.prototype.get action):
>+        (foo.html.NotificationEvent.prototype.get notification):
>+        (foo.html.NotificationEvent.prototype.get reply):
>+        (foo.html.NotificationEvent):
>+        (foo.html.OListElement.new):
>+        (foo.html.OListElement.prototype.get reversed):
>+        (foo.html.OListElement.prototype.set reversed):
>+        (foo.html.OListElement.prototype.get start):
>+        (foo.html.OListElement.prototype.set start):
>+        (foo.html.OListElement.prototype.get type):
>+        (foo.html.OListElement.prototype.set type):
>+        (foo.html.OListElement):
>+        (foo.html.ObjectElement.new):
>+        (foo.html.ObjectElement.get supported):
>+        (foo.html.ObjectElement.prototype.get contentWindow):
>+        (foo.html.ObjectElement.prototype.get _get_contentWindow):
>+        (foo.html.ObjectElement.prototype.get data):
>+        (foo.html.ObjectElement.prototype.set data):
>+        (foo.html.ObjectElement.prototype.get form):
>+        (foo.html.ObjectElement.prototype.get height):
>+        (foo.html.ObjectElement.prototype.set height):
>+        (foo.html.ObjectElement.prototype.get name):
>+        (foo.html.ObjectElement.prototype.set name):
>+        (foo.html.ObjectElement.prototype.get type):
>+        (foo.html.ObjectElement.prototype.set type):
>+        (foo.html.ObjectElement.prototype.get useMap):
>+        (foo.html.ObjectElement.prototype.set useMap):
>+        (foo.html.ObjectElement.prototype.get validationMessage):
>+        (foo.html.ObjectElement.prototype.get validity):
>+        (foo.html.ObjectElement.prototype.get width):
>+        (foo.html.ObjectElement.prototype.set width):
>+        (foo.html.ObjectElement.prototype.get willValidate):
>+        (foo.html.ObjectElement.prototype.__getter__):
>+        (foo.html.ObjectElement.prototype.__setter__):
>+        (foo.html.ObjectElement.prototype.checkValidity):
>+        (foo.html.ObjectElement.prototype.reportValidity):
>+        (foo.html.ObjectElement.prototype.setCustomValidity):
>+        (foo.html.ObjectElement):
>+        (foo.html.OffscreenCanvas.new):
>+        (foo.html.OffscreenCanvas._create_1):
>+        (foo.html.OffscreenCanvas.prototype.get height):
>+        (foo.html.OffscreenCanvas.prototype.set height):
>+        (foo.html.OffscreenCanvas.prototype.get width):
>+        (foo.html.OffscreenCanvas.prototype.set width):
>+        (foo.html.OffscreenCanvas.prototype.convertToBlob):
>+        (foo.html.OffscreenCanvas.prototype.getContext):
>+        (foo.html.OffscreenCanvas.prototype._getContext_1):
>+        (foo.html.OffscreenCanvas.prototype._getContext_2):
>+        (foo.html.OffscreenCanvas.prototype.transferToImageBitmap):
>+        (foo.html.OffscreenCanvas):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.get canvas):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.get direction):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.set direction):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.get fillStyle):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.set fillStyle):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.get filter):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.set filter):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.get font):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.set font):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.get globalAlpha):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.set globalAlpha):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.get globalCompositeOperation):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.set globalCompositeOperation):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.get imageSmoothingEnabled):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.set imageSmoothingEnabled):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.get imageSmoothingQuality):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.set imageSmoothingQuality):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.get lineCap):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.set lineCap):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.get lineDashOffset):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.set lineDashOffset):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.get lineJoin):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.set lineJoin):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.get lineWidth):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.set lineWidth):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.get miterLimit):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.set miterLimit):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.get shadowBlur):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.set shadowBlur):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.get shadowColor):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.set shadowColor):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.get shadowOffsetX):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.set shadowOffsetX):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.get shadowOffsetY):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.set shadowOffsetY):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.get strokeStyle):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.set strokeStyle):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.get textAlign):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.set textAlign):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.get textBaseline):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.set textBaseline):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.beginPath):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.clearRect):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.clip):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.commit):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.createImageData):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype._createImageData_1):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype._createImageData_2):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype._createImageData_3):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype._createImageData_4):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.createLinearGradient):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.createPattern):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.createRadialGradient):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.drawImage):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.fill):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.fillRect):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.fillText):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.getImageData):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype._getImageData_1):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.getLineDash):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.isPointInPath):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.isPointInStroke):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.measureText):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.putImageData):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype._putImageData_1):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype._putImageData_2):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.resetTransform):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.restore):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.rotate):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.save):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.scale):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.setLineDash):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.setTransform):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.stroke):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.strokeRect):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.strokeText):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.transform):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.translate):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.arc):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.arcTo):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.bezierCurveTo):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.closePath):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.ellipse):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.lineTo):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.moveTo):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.quadraticCurveTo):
>+        (foo.html.OffscreenCanvasRenderingContext2D.prototype.rect):
>+        (foo.html.OffscreenCanvasRenderingContext2D):
>+        (foo.html.OptGroupElement.new):
>+        (foo.html.OptGroupElement.prototype.get disabled):
>+        (foo.html.OptGroupElement.prototype.set disabled):
>+        (foo.html.OptGroupElement.prototype.get label):
>+        (foo.html.OptGroupElement.prototype.set label):
>+        (foo.html.OptGroupElement):
>+        (foo.html.OptionElement.new):
>+        (foo.html.OptionElement.__):
>+        (foo.html.OptionElement._create_1):
>+        (foo.html.OptionElement._create_2):
>+        (foo.html.OptionElement._create_3):
>+        (foo.html.OptionElement._create_4):
>+        (foo.html.OptionElement._create_5):
>+        (foo.html.OptionElement.prototype.get defaultSelected):
>+        (foo.html.OptionElement.prototype.set defaultSelected):
>+        (foo.html.OptionElement.prototype.get disabled):
>+        (foo.html.OptionElement.prototype.set disabled):
>+        (foo.html.OptionElement.prototype.get form):
>+        (foo.html.OptionElement.prototype.get index):
>+        (foo.html.OptionElement.prototype.get label):
>+        (foo.html.OptionElement.prototype.set label):
>+        (foo.html.OptionElement.prototype.get selected):
>+        (foo.html.OptionElement.prototype.set selected):
>+        (foo.html.OptionElement.prototype.get value):
>+        (foo.html.OptionElement.prototype.set value):
>+        (foo.html.OptionElement):
>+        (foo.html.OutputElement.new):
>+        (foo.html.OutputElement.get supported):
>+        (foo.html.OutputElement.prototype.get defaultValue):
>+        (foo.html.OutputElement.prototype.set defaultValue):
>+        (foo.html.OutputElement.prototype.get form):
>+        (foo.html.OutputElement.prototype.get htmlFor):
>+        (foo.html.OutputElement.prototype.get labels):
>+        (foo.html.OutputElement.prototype.get name):
>+        (foo.html.OutputElement.prototype.set name):
>+        (foo.html.OutputElement.prototype.get type):
>+        (foo.html.OutputElement.prototype.get validationMessage):
>+        (foo.html.OutputElement.prototype.get validity):
>+        (foo.html.OutputElement.prototype.get value):
>+        (foo.html.OutputElement.prototype.set value):
>+        (foo.html.OutputElement.prototype.get willValidate):
>+        (foo.html.OutputElement.prototype.checkValidity):
>+        (foo.html.OutputElement.prototype.reportValidity):
>+        (foo.html.OutputElement.prototype.setCustomValidity):
>+        (foo.html.OutputElement):
>+        (foo.html.OverconstrainedError.new):
>+        (foo.html.OverconstrainedError._create_1):
>+        (foo.html.OverconstrainedError.prototype.get constraint):
>+        (foo.html.OverconstrainedError.prototype.get message):
>+        (foo.html.OverconstrainedError.prototype.get name):
>+        (foo.html.OverconstrainedError):
>+        (foo.html.PageTransitionEvent.new):
>+        (foo.html.PageTransitionEvent._create_1):
>+        (foo.html.PageTransitionEvent._create_2):
>+        (foo.html.PageTransitionEvent.prototype.get persisted):
>+        (foo.html.PageTransitionEvent):
>+        (foo.html.PaintRenderingContext2D.prototype.get currentTransform):
>+        (foo.html.PaintRenderingContext2D.prototype.set currentTransform):
>+        (foo.html.PaintRenderingContext2D.prototype.get fillStyle):
>+        (foo.html.PaintRenderingContext2D.prototype.set fillStyle):
>+        (foo.html.PaintRenderingContext2D.prototype.get filter):
>+        (foo.html.PaintRenderingContext2D.prototype.set filter):
>+        (foo.html.PaintRenderingContext2D.prototype.get globalAlpha):
>+        (foo.html.PaintRenderingContext2D.prototype.set globalAlpha):
>+        (foo.html.PaintRenderingContext2D.prototype.get globalCompositeOperation):
>+        (foo.html.PaintRenderingContext2D.prototype.set globalCompositeOperation):
>+        (foo.html.PaintRenderingContext2D.prototype.get imageSmoothingEnabled):
>+        (foo.html.PaintRenderingContext2D.prototype.set imageSmoothingEnabled):
>+        (foo.html.PaintRenderingContext2D.prototype.get imageSmoothingQuality):
>+        (foo.html.PaintRenderingContext2D.prototype.set imageSmoothingQuality):
>+        (foo.html.PaintRenderingContext2D.prototype.get lineCap):
>+        (foo.html.PaintRenderingContext2D.prototype.set lineCap):
>+        (foo.html.PaintRenderingContext2D.prototype.get lineDashOffset):
>+        (foo.html.PaintRenderingContext2D.prototype.set lineDashOffset):
>+        (foo.html.PaintRenderingContext2D.prototype.get lineJoin):
>+        (foo.html.PaintRenderingContext2D.prototype.set lineJoin):
>+        (foo.html.PaintRenderingContext2D.prototype.get lineWidth):
>+        (foo.html.PaintRenderingContext2D.prototype.set lineWidth):
>+        (foo.html.PaintRenderingContext2D.prototype.get miterLimit):
>+        (foo.html.PaintRenderingContext2D.prototype.set miterLimit):
>+        (foo.html.PaintRenderingContext2D.prototype.get shadowBlur):
>+        (foo.html.PaintRenderingContext2D.prototype.set shadowBlur):
>+        (foo.html.PaintRenderingContext2D.prototype.get shadowColor):
>+        (foo.html.PaintRenderingContext2D.prototype.set shadowColor):
>+        (foo.html.PaintRenderingContext2D.prototype.get shadowOffsetX):
>+        (foo.html.PaintRenderingContext2D.prototype.set shadowOffsetX):
>+        (foo.html.PaintRenderingContext2D.prototype.get shadowOffsetY):
>+        (foo.html.PaintRenderingContext2D.prototype.set shadowOffsetY):
>+        (foo.html.PaintRenderingContext2D.prototype.get strokeStyle):
>+        (foo.html.PaintRenderingContext2D.prototype.set strokeStyle):
>+        (foo.html.PaintRenderingContext2D.prototype.beginPath):
>+        (foo.html.PaintRenderingContext2D.prototype.clearRect):
>+        (foo.html.PaintRenderingContext2D.prototype.clip):
>+        (foo.html.PaintRenderingContext2D.prototype.createLinearGradient):
>+        (foo.html.PaintRenderingContext2D.prototype.createPattern):
>+        (foo.html.PaintRenderingContext2D.prototype.createRadialGradient):
>+        (foo.html.PaintRenderingContext2D.prototype.drawImage):
>+        (foo.html.PaintRenderingContext2D.prototype.fill):
>+        (foo.html.PaintRenderingContext2D.prototype.fillRect):
>+        (foo.html.PaintRenderingContext2D.prototype.getLineDash):
>+        (foo.html.PaintRenderingContext2D.prototype.isPointInPath):
>+        (foo.html.PaintRenderingContext2D.prototype.isPointInStroke):
>+        (foo.html.PaintRenderingContext2D.prototype.resetTransform):
>+        (foo.html.PaintRenderingContext2D.prototype.restore):
>+        (foo.html.PaintRenderingContext2D.prototype.rotate):
>+        (foo.html.PaintRenderingContext2D.prototype.save):
>+        (foo.html.PaintRenderingContext2D.prototype.scale):
>+        (foo.html.PaintRenderingContext2D.prototype.setLineDash):
>+        (foo.html.PaintRenderingContext2D.prototype.setTransform):
>+        (foo.html.PaintRenderingContext2D.prototype.stroke):
>+        (foo.html.PaintRenderingContext2D.prototype.strokeRect):
>+        (foo.html.PaintRenderingContext2D.prototype.transform):
>+        (foo.html.PaintRenderingContext2D.prototype.translate):
>+        (foo.html.PaintRenderingContext2D.prototype.arc):
>+        (foo.html.PaintRenderingContext2D.prototype.arcTo):
>+        (foo.html.PaintRenderingContext2D.prototype.bezierCurveTo):
>+        (foo.html.PaintRenderingContext2D.prototype.closePath):
>+        (foo.html.PaintRenderingContext2D.prototype.ellipse):
>+        (foo.html.PaintRenderingContext2D.prototype.lineTo):
>+        (foo.html.PaintRenderingContext2D.prototype.moveTo):
>+        (foo.html.PaintRenderingContext2D.prototype.quadraticCurveTo):
>+        (foo.html.PaintRenderingContext2D.prototype.rect):
>+        (foo.html.PaintRenderingContext2D):
>+        (foo.html.PaintSize.prototype.get height):
>+        (foo.html.PaintSize.prototype.get width):
>+        (foo.html.PaintSize):
>+        (foo.html.PaintWorkletGlobalScope.prototype.get devicePixelRatio):
>+        (foo.html.PaintWorkletGlobalScope.prototype.registerPaint):
>+        (foo.html.PaintWorkletGlobalScope):
>+        (foo.html.ParagraphElement.new):
>+        (foo.html.ParagraphElement):
>+        (foo.html.ParamElement.new):
>+        (foo.html.ParamElement.prototype.get name):
>+        (foo.html.ParamElement.prototype.set name):
>+        (foo.html.ParamElement.prototype.get value):
>+        (foo.html.ParamElement.prototype.set value):
>+        (foo.html.ParamElement):
>+        (foo.html.ParentNode):
>+        (foo.html.PasswordCredential.new):
>+        (foo.html.PasswordCredential._create_1):
>+        (foo.html.PasswordCredential._create_2):
>+        (foo.html.PasswordCredential.prototype.get additionalData):
>+        (foo.html.PasswordCredential.prototype.set additionalData):
>+        (foo.html.PasswordCredential.prototype.get idName):
>+        (foo.html.PasswordCredential.prototype.set idName):
>+        (foo.html.PasswordCredential.prototype.get password):
>+        (foo.html.PasswordCredential.prototype.get passwordName):
>+        (foo.html.PasswordCredential.prototype.set passwordName):
>+        (foo.html.PasswordCredential.prototype.get iconUrl):
>+        (foo.html.PasswordCredential.prototype.get name):
>+        (foo.html.PasswordCredential):
>+        (foo.html.Path2D.new):
>+        (foo.html.Path2D._create_1):
>+        (foo.html.Path2D._create_2):
>+        (foo.html.Path2D._create_3):
>+        (foo.html.Path2D.prototype.addPath):
>+        (foo.html.Path2D.prototype.arc):
>+        (foo.html.Path2D.prototype.arcTo):
>+        (foo.html.Path2D.prototype.bezierCurveTo):
>+        (foo.html.Path2D.prototype.closePath):
>+        (foo.html.Path2D.prototype.ellipse):
>+        (foo.html.Path2D.prototype.lineTo):
>+        (foo.html.Path2D.prototype.moveTo):
>+        (foo.html.Path2D.prototype.quadraticCurveTo):
>+        (foo.html.Path2D.prototype.rect):
>+        (foo.html.Path2D):
>+        (foo.html.PaymentAddress.prototype.get addressLine):
>+        (foo.html.PaymentAddress.prototype.get city):
>+        (foo.html.PaymentAddress.prototype.get country):
>+        (foo.html.PaymentAddress.prototype.get dependentLocality):
>+        (foo.html.PaymentAddress.prototype.get languageCode):
>+        (foo.html.PaymentAddress.prototype.get organization):
>+        (foo.html.PaymentAddress.prototype.get phone):
>+        (foo.html.PaymentAddress.prototype.get postalCode):
>+        (foo.html.PaymentAddress.prototype.get recipient):
>+        (foo.html.PaymentAddress.prototype.get region):
>+        (foo.html.PaymentAddress.prototype.get sortingCode):
>+        (foo.html.PaymentAddress):
>+        (foo.html.PaymentInstruments.prototype.clear):
>+        (foo.html.PaymentInstruments.prototype.delete):
>+        (foo.html.PaymentManager.prototype.get instruments):
>+        (foo.html.PaymentManager.prototype.get userHint):
>+        (foo.html.PaymentManager.prototype.set userHint):
>+        (foo.html.PaymentManager):
>+        (foo.html.PaymentRequest.new):
>+        (foo.html.PaymentRequest._create_1):
>+        (foo.html.PaymentRequest._create_2):
>+        (foo.html.PaymentRequest.prototype.get id):
>+        (foo.html.PaymentRequest.prototype.get shippingAddress):
>+        (foo.html.PaymentRequest.prototype.get shippingOption):
>+        (foo.html.PaymentRequest.prototype.get shippingType):
>+        (foo.html.PaymentRequest.prototype.abort):
>+        (foo.html.PaymentRequest.prototype.canMakePayment):
>+        (foo.html.PaymentRequest.prototype.show):
>+        (foo.html.PaymentRequest):
>+        (foo.html.PaymentRequestEvent.new):
>+        (foo.html.PaymentRequestEvent._create_1):
>+        (foo.html.PaymentRequestEvent.prototype.get instrumentKey):
>+        (foo.html.PaymentRequestEvent.prototype.get methodData):
>+        (foo.html.PaymentRequestEvent.prototype.get modifiers):
>+        (foo.html.PaymentRequestEvent.prototype.get paymentRequestId):
>+        (foo.html.PaymentRequestEvent.prototype.get paymentRequestOrigin):
>+        (foo.html.PaymentRequestEvent.prototype.get topLevelOrigin):
>+        (foo.html.PaymentRequestEvent.prototype.get total):
>+        (foo.html.PaymentRequestEvent.prototype.openWindow):
>+        (foo.html.PaymentRequestEvent.prototype.respondWith):
>+        (foo.html.PaymentRequestEvent):
>+        (foo.html.PaymentRequestUpdateEvent.new):
>+        (foo.html.PaymentRequestUpdateEvent._create_1):
>+        (foo.html.PaymentRequestUpdateEvent._create_2):
>+        (foo.html.PaymentRequestUpdateEvent.prototype.updateWith):
>+        (foo.html.PaymentRequestUpdateEvent):
>+        (foo.html.PaymentResponse.prototype.get details):
>+        (foo.html.PaymentResponse.prototype.get methodName):
>+        (foo.html.PaymentResponse.prototype.get payerEmail):
>+        (foo.html.PaymentResponse.prototype.get payerName):
>+        (foo.html.PaymentResponse.prototype.get payerPhone):
>+        (foo.html.PaymentResponse.prototype.get requestId):
>+        (foo.html.PaymentResponse.prototype.get shippingAddress):
>+        (foo.html.PaymentResponse.prototype.get shippingOption):
>+        (foo.html.PaymentResponse.prototype.complete):
>+        (foo.html.PaymentResponse):
>+        (foo.html.Performance.get supported):
>+        (foo.html.Performance.prototype.get memory):
>+        (foo.html.Performance.prototype.get navigation):
>+        (foo.html.Performance.prototype.get timeOrigin):
>+        (foo.html.Performance.prototype.get timing):
>+        (foo.html.Performance.prototype.clearMarks):
>+        (foo.html.Performance.prototype.clearMeasures):
>+        (foo.html.Performance.prototype.clearResourceTimings):
>+        (foo.html.Performance.prototype.getEntries):
>+        (foo.html.Performance.prototype.getEntriesByName):
>+        (foo.html.Performance.prototype.getEntriesByType):
>+        (foo.html.Performance.prototype.mark):
>+        (foo.html.Performance.prototype.measure):
>+        (foo.html.Performance.prototype.now):
>+        (foo.html.Performance.prototype.setResourceTimingBufferSize):
>+        (foo.html.Performance):
>+        (foo.html.PerformanceEntry.prototype.get duration):
>+        (foo.html.PerformanceEntry.prototype.get entryType):
>+        (foo.html.PerformanceEntry.prototype.get name):
>+        (foo.html.PerformanceEntry.prototype.get startTime):
>+        (foo.html.PerformanceEntry):
>+        (foo.html.PerformanceLongTaskTiming.prototype.get attribution):
>+        (foo.html.PerformanceLongTaskTiming):
>+        (foo.html.PerformanceMark):
>+        (foo.html.PerformanceMeasure):
>+        (foo.html.PerformanceNavigation.prototype.get redirectCount):
>+        (foo.html.PerformanceNavigation.prototype.get type):
>+        (foo.html.PerformanceNavigation):
>+        (foo.html.PerformanceResourceTiming.prototype.get connectEnd):
>+        (foo.html.PerformanceResourceTiming.prototype.get connectStart):
>+        (foo.html.PerformanceResourceTiming.prototype.get decodedBodySize):
>+        (foo.html.PerformanceResourceTiming.prototype.get domainLookupEnd):
>+        (foo.html.PerformanceResourceTiming.prototype.get domainLookupStart):
>+        (foo.html.PerformanceResourceTiming.prototype.get encodedBodySize):
>+        (foo.html.PerformanceResourceTiming.prototype.get fetchStart):
>+        (foo.html.PerformanceResourceTiming.prototype.get initiatorType):
>+        (foo.html.PerformanceResourceTiming.prototype.get nextHopProtocol):
>+        (foo.html.PerformanceResourceTiming.prototype.get redirectEnd):
>+        (foo.html.PerformanceResourceTiming.prototype.get redirectStart):
>+        (foo.html.PerformanceResourceTiming.prototype.get requestStart):
>+        (foo.html.PerformanceResourceTiming.prototype.get responseEnd):
>+        (foo.html.PerformanceResourceTiming.prototype.get responseStart):
>+        (foo.html.PerformanceResourceTiming.prototype.get secureConnectionStart):
>+        (foo.html.PerformanceResourceTiming.prototype.get serverTiming):
>+        (foo.html.PerformanceResourceTiming.prototype.get transferSize):
>+        (foo.html.PerformanceResourceTiming.prototype.get workerStart):
>+        (foo.html.PerformanceResourceTiming):
>+        (foo.html.PerformanceNavigationTiming.prototype.get domComplete):
>+        (foo.html.PerformanceNavigationTiming.prototype.get domContentLoadedEventEnd):
>+        (foo.html.PerformanceNavigationTiming.prototype.get domContentLoadedEventStart):
>+        (foo.html.PerformanceNavigationTiming.prototype.get domInteractive):
>+        (foo.html.PerformanceNavigationTiming.prototype.get loadEventEnd):
>+        (foo.html.PerformanceNavigationTiming.prototype.get loadEventStart):
>+        (foo.html.PerformanceNavigationTiming.prototype.get redirectCount):
>+        (foo.html.PerformanceNavigationTiming.prototype.get type):
>+        (foo.html.PerformanceNavigationTiming.prototype.get unloadEventEnd):
>+        (foo.html.PerformanceNavigationTiming.prototype.get unloadEventStart):
>+        (foo.html.PerformanceNavigationTiming):
>+        (foo.html.PerformanceObserver.new):
>+        (foo.html.PerformanceObserver._create_1):
>+        (foo.html.PerformanceObserver.prototype.disconnect):
>+        (foo.html.PerformanceObserver.prototype.observe):
>+        (foo.html.PerformanceObserver.prototype._observe_1):
>+        (foo.html.PerformanceObserver):
>+        (foo.html.PerformanceObserverEntryList.prototype.getEntries):
>+        (foo.html.PerformanceObserverEntryList.prototype.getEntriesByName):
>+        (foo.html.PerformanceObserverEntryList.prototype.getEntriesByType):
>+        (foo.html.PerformanceObserverEntryList):
>+        (foo.html.PerformancePaintTiming):
>+        (foo.html.PerformanceServerTiming.prototype.get description):
>+        (foo.html.PerformanceServerTiming.prototype.get duration):
>+        (foo.html.PerformanceServerTiming.prototype.get name):
>+        (foo.html.PerformanceServerTiming):
>+        (foo.html.PerformanceTiming.prototype.get connectEnd):
>+        (foo.html.PerformanceTiming.prototype.get connectStart):
>+        (foo.html.PerformanceTiming.prototype.get domComplete):
>+        (foo.html.PerformanceTiming.prototype.get domContentLoadedEventEnd):
>+        (foo.html.PerformanceTiming.prototype.get domContentLoadedEventStart):
>+        (foo.html.PerformanceTiming.prototype.get domInteractive):
>+        (foo.html.PerformanceTiming.prototype.get domLoading):
>+        (foo.html.PerformanceTiming.prototype.get domainLookupEnd):
>+        (foo.html.PerformanceTiming.prototype.get domainLookupStart):
>+        (foo.html.PerformanceTiming.prototype.get fetchStart):
>+        (foo.html.PerformanceTiming.prototype.get loadEventEnd):
>+        (foo.html.PerformanceTiming.prototype.get loadEventStart):
>+        (foo.html.PerformanceTiming.prototype.get navigationStart):
>+        (foo.html.PerformanceTiming.prototype.get redirectEnd):
>+        (foo.html.PerformanceTiming.prototype.get redirectStart):
>+        (foo.html.PerformanceTiming.prototype.get requestStart):
>+        (foo.html.PerformanceTiming.prototype.get responseEnd):
>+        (foo.html.PerformanceTiming.prototype.get responseStart):
>+        (foo.html.PerformanceTiming.prototype.get secureConnectionStart):
>+        (foo.html.PerformanceTiming.prototype.get unloadEventEnd):
>+        (foo.html.PerformanceTiming.prototype.get unloadEventStart):
>+        (foo.html.PerformanceTiming):
>+        (foo.html.PermissionStatus.prototype.get state):
>+        (foo.html.PermissionStatus.prototype.get onChange):
>+        (foo.html.PermissionStatus):
>+        (foo.html.Permissions.prototype.query):
>+        (foo.html.Permissions.prototype.request):
>+        (foo.html.Permissions.prototype.requestAll):
>+        (foo.html.Permissions.prototype.revoke):
>+        (foo.html.Permissions):
>+        (foo.html.PhotoCapabilities.prototype.get fillLightMode):
>+        (foo.html.PhotoCapabilities.prototype.get imageHeight):
>+        (foo.html.PhotoCapabilities.prototype.get imageWidth):
>+        (foo.html.PhotoCapabilities.prototype.get redEyeReduction):
>+        (foo.html.PhotoCapabilities):
>+        (foo.html.PictureElement):
>+        (foo.html.Plugin.prototype.get description):
>+        (foo.html.Plugin.prototype.get filename):
>+        (foo.html.Plugin.prototype.get length):
>+        (foo.html.Plugin.prototype.get name):
>+        (foo.html.Plugin.prototype.item):
>+        (foo.html.Plugin.prototype.namedItem):
>+        (foo.html.Plugin):
>+        (foo.const.Interceptor_ListMixin.4):
>+        (foo.const.Interceptor_ImmutableListMixin.4):
>+        (foo.html.PluginArray.prototype.get length):
>+        (foo.html.PluginArray.prototype._get):
>+        (foo.html.PluginArray.prototype._set):
>+        (foo.html.PluginArray.prototype.set length):
>+        (foo.html.PluginArray.prototype.get first):
>+        (foo.html.PluginArray.prototype.set first):
>+        (foo.html.PluginArray.prototype.get last):
>+        (foo.html.PluginArray.prototype.set last):
>+        (foo.html.PluginArray.prototype.get single):
>+        (foo.html.PluginArray.prototype.elementAt):
>+        (foo.html.PluginArray.prototype.item):
>+        (foo.html.PluginArray.prototype.namedItem):
>+        (foo.html.PluginArray.prototype.refresh):
>+        (foo.html.PluginArray):
>+        (foo.html.PointerEvent.new):
>+        (foo.html.PointerEvent._create_1):
>+        (foo.html.PointerEvent._create_2):
>+        (foo.html.PointerEvent.prototype.get height):
>+        (foo.html.PointerEvent.prototype.get isPrimary):
>+        (foo.html.PointerEvent.prototype.get pointerId):
>+        (foo.html.PointerEvent.prototype.get pointerType):
>+        (foo.html.PointerEvent.prototype.get pressure):
>+        (foo.html.PointerEvent.prototype.get tangentialPressure):
>+        (foo.html.PointerEvent.prototype.get tiltX):
>+        (foo.html.PointerEvent.prototype.get tiltY):
>+        (foo.html.PointerEvent.prototype.get twist):
>+        (foo.html.PointerEvent.prototype.get width):
>+        (foo.html.PointerEvent.prototype.getCoalescedEvents):
>+        (foo.html.PointerEvent):
>+        (foo.html.PopStateEvent.new):
>+        (foo.html.PopStateEvent._create_1):
>+        (foo.html.PopStateEvent._create_2):
>+        (foo.html.PopStateEvent.prototype.get state):
>+        (foo.html.PopStateEvent.prototype.get _get_state):
>+        (foo.html.PopStateEvent):
>+        (foo.html.PositionError.prototype.get code):
>+        (foo.html.PositionError.prototype.get message):
>+        (foo.html.PositionError):
>+        (foo.html.PreElement.new):
>+        (foo.html.PreElement):
>+        (foo.html.Presentation.prototype.get defaultRequest):
>+        (foo.html.Presentation.prototype.set defaultRequest):
>+        (foo.html.Presentation.prototype.get receiver):
>+        (foo.html.Presentation):
>+        (foo.html.PresentationAvailability.prototype.get value):
>+        (foo.html.PresentationAvailability.prototype.get onChange):
>+        (foo.html.PresentationAvailability):
>+        (foo.html.PresentationConnection.prototype.get binaryType):
>+        (foo.html.PresentationConnection.prototype.set binaryType):
>+        (foo.html.PresentationConnection.prototype.get id):
>+        (foo.html.PresentationConnection.prototype.get state):
>+        (foo.html.PresentationConnection.prototype.get url):
>+        (foo.html.PresentationConnection.prototype.close):
>+        (foo.html.PresentationConnection.prototype.send):
>+        (foo.html.PresentationConnection.prototype.terminate):
>+        (foo.html.PresentationConnection.prototype.get onMessage):
>+        (foo.html.PresentationConnection):
>+        (foo.html.PresentationConnectionAvailableEvent.new):
>+        (foo.html.PresentationConnectionAvailableEvent._create_1):
>+        (foo.html.PresentationConnectionAvailableEvent.prototype.get connection):
>+        (foo.html.PresentationConnectionAvailableEvent):
>+        (foo.html.PresentationConnectionCloseEvent.new):
>+        (foo.html.PresentationConnectionCloseEvent._create_1):
>+        (foo.html.PresentationConnectionCloseEvent.prototype.get message):
>+        (foo.html.PresentationConnectionCloseEvent.prototype.get reason):
>+        (foo.html.PresentationConnectionCloseEvent):
>+        (foo.html.PresentationConnectionList.prototype.get connections):
>+        (foo.html.PresentationConnectionList):
>+        (foo.html.PresentationReceiver.prototype.get connectionList):
>+        (foo.html.PresentationReceiver):
>+        (foo.html.PresentationRequest.new):
>+        (foo.html.PresentationRequest._create_1):
>+        (foo.html.PresentationRequest._create_2):
>+        (foo.html.PresentationRequest.prototype.getAvailability):
>+        (foo.html.PresentationRequest.prototype.reconnect):
>+        (foo.html.PresentationRequest.prototype.start):
>+        (foo.html.PresentationRequest):
>+        (foo.html.ProcessingInstruction.prototype.get sheet):
>+        (foo.html.ProcessingInstruction.prototype.get target):
>+        (foo.html.ProcessingInstruction):
>+        (foo.html.ProgressElement.new):
>+        (foo.html.ProgressElement.get supported):
>+        (foo.html.ProgressElement.prototype.get labels):
>+        (foo.html.ProgressElement.prototype.get max):
>+        (foo.html.ProgressElement.prototype.set max):
>+        (foo.html.ProgressElement.prototype.get position):
>+        (foo.html.ProgressElement.prototype.get value):
>+        (foo.html.ProgressElement.prototype.set value):
>+        (foo.html.ProgressElement):
>+        (foo.html.ProgressEvent.new):
>+        (foo.html.ProgressEvent._create_1):
>+        (foo.html.ProgressEvent._create_2):
>+        (foo.html.ProgressEvent.prototype.get lengthComputable):
>+        (foo.html.ProgressEvent.prototype.get loaded):
>+        (foo.html.ProgressEvent.prototype.get total):
>+        (foo.html.ProgressEvent):
>+        (foo.html.PromiseRejectionEvent.new):
>+        (foo.html.PromiseRejectionEvent._create_1):
>+        (foo.html.PromiseRejectionEvent.prototype.get promise):
>+        (foo.html.PromiseRejectionEvent.prototype.get reason):
>+        (foo.html.PromiseRejectionEvent):
>+        (foo.html.PublicKeyCredential.prototype.get rawId):
>+        (foo.html.PublicKeyCredential.prototype.get response):
>+        (foo.html.PublicKeyCredential):
>+        (foo.html.PushEvent.new):
>+        (foo.html.PushEvent._create_1):
>+        (foo.html.PushEvent._create_2):
>+        (foo.html.PushEvent.prototype.get data):
>+        (foo.html.PushEvent):
>+        (foo.html.PushManager.prototype.getSubscription):
>+        (foo.html.PushManager.prototype.permissionState):
>+        (foo.html.PushManager.prototype.subscribe):
>+        (foo.html.PushManager):
>+        (foo.html.PushMessageData.prototype.arrayBuffer):
>+        (foo.html.PushMessageData.prototype.blob):
>+        (foo.html.PushMessageData.prototype.json):
>+        (foo.html.PushMessageData.prototype.text):
>+        (foo.html.PushMessageData):
>+        (foo.html.PushSubscription.prototype.get endpoint):
>+        (foo.html.PushSubscription.prototype.get expirationTime):
>+        (foo.html.PushSubscription.prototype.get options):
>+        (foo.html.PushSubscription.prototype.getKey):
>+        (foo.html.PushSubscription.prototype.unsubscribe):
>+        (foo.html.PushSubscription):
>+        (foo.html.PushSubscriptionOptions.prototype.get applicationServerKey):
>+        (foo.html.PushSubscriptionOptions.prototype.get userVisibleOnly):
>+        (foo.html.PushSubscriptionOptions):
>+        (foo.html.QuoteElement.new):
>+        (foo.html.QuoteElement.prototype.get cite):
>+        (foo.html.QuoteElement.prototype.set cite):
>+        (foo.html.QuoteElement):
>+        (foo.html.Range.new):
>+        (foo.html.Range.fromPoint):
>+        (foo.html.Range.prototype.get collapsed):
>+        (foo.html.Range.prototype.get commonAncestorContainer):
>+        (foo.html.Range.prototype.get endContainer):
>+        (foo.html.Range.prototype.get endOffset):
>+        (foo.html.Range.prototype.get startContainer):
>+        (foo.html.Range.prototype.get startOffset):
>+        (foo.html.Range.prototype.cloneContents):
>+        (foo.html.Range.prototype.cloneRange):
>+        (foo.html.Range.prototype.collapse):
>+        (foo.html.Range.prototype.compareBoundaryPoints):
>+        (foo.html.Range.prototype.comparePoint):
>+        (foo.html.Range.prototype.createContextualFragment):
>+        (foo.html.Range.prototype.deleteContents):
>+        (foo.html.Range.prototype.detach):
>+        (foo.html.Range.prototype.expand):
>+        (foo.html.Range.prototype.extractContents):
>+        (foo.html.Range.prototype.getBoundingClientRect):
>+        (foo.html.Range.prototype._getClientRects):
>+        (foo.html.Range.prototype.insertNode):
>+        (foo.html.Range.prototype.isPointInRange):
>+        (foo.html.Range.prototype.selectNode):
>+        (foo.html.Range.prototype.selectNodeContents):
>+        (foo.html.Range.prototype.setEnd):
>+        (foo.html.Range.prototype.setEndAfter):
>+        (foo.html.Range.prototype.setEndBefore):
>+        (foo.html.Range.prototype.setStart):
>+        (foo.html.Range.prototype.setStartAfter):
>+        (foo.html.Range.prototype.setStartBefore):
>+        (foo.html.Range.prototype.surroundContents):
>+        (foo.html.Range.prototype.getClientRects):
>+        (foo.html.Range.get supportsCreateContextualFragment):
>+        (foo.html.Range):
>+        (foo.html.RelatedApplication.prototype.get id):
>+        (foo.html.RelatedApplication.prototype.get platform):
>+        (foo.html.RelatedApplication.prototype.get url):
>+        (foo.html.RelatedApplication):
>+        (foo.html.RelativeOrientationSensor.new):
>+        (foo.html.RelativeOrientationSensor._create_1):
>+        (foo.html.RelativeOrientationSensor._create_2):
>+        (foo.html.RelativeOrientationSensor):
>+        (foo.html.RemotePlayback.prototype.get state):
>+        (foo.html.RemotePlayback.prototype.cancelWatchAvailability):
>+        (foo.html.RemotePlayback.prototype.prompt):
>+        (foo.html.RemotePlayback.prototype.watchAvailability):
>+        (foo.html.RemotePlayback):
>+        (foo.html.ReportingObserver.new):
>+        (foo.html.ReportingObserver._create_1):
>+        (foo.html.ReportingObserver.prototype.disconnect):
>+        (foo.html.ReportingObserver.prototype.observe):
>+        (foo.html.ReportingObserver):
>+        (foo.html.ResizeObserver.new):
>+        (foo.html.ResizeObserver._create_1):
>+        (foo.html.ResizeObserver.prototype.disconnect):
>+        (foo.html.ResizeObserver.prototype.observe):
>+        (foo.html.ResizeObserver.prototype.unobserve):
>+        (foo.html.ResizeObserver):
>+        (foo.html.ResizeObserverEntry.prototype.get contentRect):
>+        (foo.html.ResizeObserverEntry.prototype.get target):
>+        (foo.html.ResizeObserverEntry):
>+        (foo.html.RtcCertificate.prototype.get expires):
>+        (foo.html.RtcCertificate.prototype.getFingerprints):
>+        (foo.html.RtcCertificate):
>+        (foo.html.RtcDataChannel.prototype.get binaryType):
>+        (foo.html.RtcDataChannel.prototype.set binaryType):
>+        (foo.html.RtcDataChannel.prototype.get bufferedAmount):
>+        (foo.html.RtcDataChannel.prototype.get bufferedAmountLowThreshold):
>+        (foo.html.RtcDataChannel.prototype.set bufferedAmountLowThreshold):
>+        (foo.html.RtcDataChannel.prototype.get id):
>+        (foo.html.RtcDataChannel.prototype.get label):
>+        (foo.html.RtcDataChannel.prototype.get maxRetransmitTime):
>+        (foo.html.RtcDataChannel.prototype.get maxRetransmits):
>+        (foo.html.RtcDataChannel.prototype.get negotiated):
>+        (foo.html.RtcDataChannel.prototype.get ordered):
>+        (foo.html.RtcDataChannel.prototype.get protocol):
>+        (foo.html.RtcDataChannel.prototype.get readyState):
>+        (foo.html.RtcDataChannel.prototype.get reliable):
>+        (foo.html.RtcDataChannel.prototype.close):
>+        (foo.html.RtcDataChannel.prototype.send):
>+        (foo.html.RtcDataChannel.prototype.sendBlob):
>+        (foo.html.RtcDataChannel.prototype.sendByteBuffer):
>+        (foo.html.RtcDataChannel.prototype.sendString):
>+        (foo.html.RtcDataChannel.prototype.sendTypedData):
>+        (foo.html.RtcDataChannel.prototype.get onClose):
>+        (foo.html.RtcDataChannel.prototype.get onError):
>+        (foo.html.RtcDataChannel.prototype.get onMessage):
>+        (foo.html.RtcDataChannel.prototype.get onOpen):
>+        (foo.html.RtcDataChannel):
>+        (foo.html.RtcDataChannelEvent.new):
>+        (foo.html.RtcDataChannelEvent._create_1):
>+        (foo.html.RtcDataChannelEvent.prototype.get channel):
>+        (foo.html.RtcDataChannelEvent):
>+        (foo.html.RtcDtmfSender.prototype.get canInsertDtmf):
>+        (foo.html.RtcDtmfSender.prototype.get duration):
>+        (foo.html.RtcDtmfSender.prototype.get interToneGap):
>+        (foo.html.RtcDtmfSender.prototype.get toneBuffer):
>+        (foo.html.RtcDtmfSender.prototype.get track):
>+        (foo.html.RtcDtmfSender.prototype.insertDtmf):
>+        (foo.html.RtcDtmfSender.prototype.get onToneChange):
>+        (foo.html.RtcDtmfSender):
>+        (foo.html.RtcDtmfToneChangeEvent.new):
>+        (foo.html.RtcDtmfToneChangeEvent._create_1):
>+        (foo.html.RtcDtmfToneChangeEvent.prototype.get tone):
>+        (foo.html.RtcDtmfToneChangeEvent):
>+        (foo.html.RtcIceCandidate.new):
>+        (foo.html.RtcIceCandidate.prototype.get candidate):
>+        (foo.html.RtcIceCandidate.prototype.set candidate):
>+        (foo.html.RtcIceCandidate.prototype.get sdpMLineIndex):
>+        (foo.html.RtcIceCandidate.prototype.set sdpMLineIndex):
>+        (foo.html.RtcIceCandidate.prototype.get sdpMid):
>+        (foo.html.RtcIceCandidate.prototype.set sdpMid):
>+        (foo.html.RtcIceCandidate):
>+        (foo.html.RtcLegacyStatsReport.prototype.get id):
>+        (foo.html.RtcLegacyStatsReport.prototype.get timestamp):
>+        (foo.html.RtcLegacyStatsReport.prototype.get _get_timestamp):
>+        (foo.html.RtcLegacyStatsReport.prototype.get type):
>+        (foo.html.RtcLegacyStatsReport.prototype.names):
>+        (foo.html.RtcLegacyStatsReport.prototype.stat):
>+        (foo.html.RtcLegacyStatsReport):
>+        (foo.html.RtcPeerConnection.new):
>+        (foo.html.RtcPeerConnection.get supported):
>+        (foo.html.RtcPeerConnection.prototype.getLegacyStats):
>+        (foo.html.RtcPeerConnection.prototype._getStats):
>+        (foo.html.RtcPeerConnection.generateCertificate):
>+        (foo.html.RtcPeerConnection.prototype.get iceConnectionState):
>+        (foo.html.RtcPeerConnection.prototype.get iceGatheringState):
>+        (foo.html.RtcPeerConnection.prototype.get localDescription):
>+        (foo.html.RtcPeerConnection.prototype.get remoteDescription):
>+        (foo.html.RtcPeerConnection.prototype.get signalingState):
>+        (foo.html.RtcPeerConnection.prototype.addIceCandidate):
>+        (foo.html.RtcPeerConnection.prototype.addStream):
>+        (foo.html.RtcPeerConnection.prototype._addStream_1):
>+        (foo.html.RtcPeerConnection.prototype._addStream_2):
>+        (foo.html.RtcPeerConnection.prototype.addTrack):
>+        (foo.html.RtcPeerConnection.prototype.close):
>+        (foo.html.RtcPeerConnection.prototype.createAnswer):
>+        (foo.html.RtcPeerConnection.prototype.createDtmfSender):
>+        (foo.html.RtcPeerConnection.prototype.createDataChannel):
>+        (foo.html.RtcPeerConnection.prototype._createDataChannel_1):
>+        (foo.html.RtcPeerConnection.prototype._createDataChannel_2):
>+        (foo.html.RtcPeerConnection.prototype.createOffer):
>+        (foo.html.RtcPeerConnection.prototype.getLocalStreams):
>+        (foo.html.RtcPeerConnection.prototype.getReceivers):
>+        (foo.html.RtcPeerConnection.prototype.getRemoteStreams):
>+        (foo.html.RtcPeerConnection.prototype.getSenders):
>+        (foo.html.RtcPeerConnection.prototype.getStats):
>+        (foo.html.RtcPeerConnection.prototype.removeStream):
>+        (foo.html.RtcPeerConnection.prototype.removeTrack):
>+        (foo.html.RtcPeerConnection.prototype.setConfiguration):
>+        (foo.html.RtcPeerConnection.prototype._setConfiguration_1):
>+        (foo.html.RtcPeerConnection.prototype.setLocalDescription):
>+        (foo.html.RtcPeerConnection.prototype.setRemoteDescription):
>+        (foo.html.RtcPeerConnection.prototype.get onAddStream):
>+        (foo.html.RtcPeerConnection.prototype.get onDataChannel):
>+        (foo.html.RtcPeerConnection.prototype.get onIceCandidate):
>+        (foo.html.RtcPeerConnection.prototype.get onIceConnectionStateChange):
>+        (foo.html.RtcPeerConnection.prototype.get onNegotiationNeeded):
>+        (foo.html.RtcPeerConnection.prototype.get onRemoveStream):
>+        (foo.html.RtcPeerConnection.prototype.get onSignalingStateChange):
>+        (foo.html.RtcPeerConnection):
>+        (foo.html.RtcPeerConnectionIceEvent.new):
>+        (foo.html.RtcPeerConnectionIceEvent._create_1):
>+        (foo.html.RtcPeerConnectionIceEvent._create_2):
>+        (foo.html.RtcPeerConnectionIceEvent.prototype.get candidate):
>+        (foo.html.RtcPeerConnectionIceEvent):
>+        (foo.html.RtcRtpContributingSource.prototype.get source):
>+        (foo.html.RtcRtpContributingSource.prototype.get timestamp):
>+        (foo.html.RtcRtpContributingSource):
>+        (foo.html.RtcRtpReceiver.prototype.get track):
>+        (foo.html.RtcRtpReceiver.prototype.getContributingSources):
>+        (foo.html.RtcRtpReceiver):
>+        (foo.html.RtcRtpSender.prototype.get track):
>+        (foo.html.RtcRtpSender):
>+        (foo.html.RtcSessionDescription.new):
>+        (foo.html.RtcSessionDescription.prototype.get sdp):
>+        (foo.html.RtcSessionDescription.prototype.set sdp):
>+        (foo.html.RtcSessionDescription.prototype.get type):
>+        (foo.html.RtcSessionDescription.prototype.set type):
>+        (foo.html.RtcSessionDescription):
>+        (foo.const.Interceptor_MapMixin.0):
>+        (foo.html.RtcStatsReport.prototype._getItem):
>+        (foo.html.RtcStatsReport.prototype.addAll):
>+        (foo.html.RtcStatsReport.prototype.containsValue):
>+        (foo.html.RtcStatsReport.prototype.containsKey):
>+        (foo.html.RtcStatsReport.prototype._get):
>+        (foo.html.RtcStatsReport.prototype.forEach):
>+        (foo.html.RtcStatsReport.prototype.get keys):
>+        (foo.html.RtcStatsReport.prototype.get values):
>+        (foo.html.RtcStatsReport.prototype.get length):
>+        (foo.html.RtcStatsReport.prototype.get isEmpty):
>+        (foo.html.RtcStatsReport.prototype.get isNotEmpty):
>+        (foo.html.RtcStatsReport.prototype._set):
>+        (foo.html.RtcStatsReport.prototype.putIfAbsent):
>+        (foo.html.RtcStatsReport.prototype.remove):
>+        (foo.html.RtcStatsReport.prototype.clear):
>+        (foo.html.RtcStatsReport):
>+        (foo.html.RtcStatsResponse.prototype.namedItem):
>+        (foo.html.RtcStatsResponse.prototype.result):
>+        (foo.html.RtcStatsResponse):
>+        (foo.html.RtcTrackEvent.new):
>+        (foo.html.RtcTrackEvent._create_1):
>+        (foo.html.RtcTrackEvent.prototype.get receiver):
>+        (foo.html.RtcTrackEvent.prototype.get streams):
>+        (foo.html.RtcTrackEvent.prototype.get track):
>+        (foo.html.RtcTrackEvent):
>+        (foo.html.Screen.prototype.get available):
>+        (foo.html.Screen.prototype.get _availHeight):
>+        (foo.html.Screen.prototype.get _availLeft):
>+        (foo.html.Screen.prototype.get _availTop):
>+        (foo.html.Screen.prototype.get _availWidth):
>+        (foo.html.Screen.prototype.get colorDepth):
>+        (foo.html.Screen.prototype.get height):
>+        (foo.html.Screen.prototype.get keepAwake):
>+        (foo.html.Screen.prototype.set keepAwake):
>+        (foo.html.Screen.prototype.get orientation):
>+        (foo.html.Screen.prototype.get pixelDepth):
>+        (foo.html.Screen.prototype.get width):
>+        (foo.html.Screen):
>+        (foo.html.ScreenOrientation.prototype.get angle):
>+        (foo.html.ScreenOrientation.prototype.get type):
>+        (foo.html.ScreenOrientation.prototype.lock):
>+        (foo.html.ScreenOrientation.prototype.unlock):
>+        (foo.html.ScreenOrientation.prototype.get onChange):
>+        (foo.html.ScreenOrientation):
>+        (foo.html.ScriptElement.new):
>+        (foo.html.ScriptElement.get charset):
>+        (foo.html.ScriptElement.set charset):
>+        (foo.html.ScriptElement.get crossOrigin):
>+        (foo.html.ScriptElement.set crossOrigin):
>+        (foo.html.ScriptElement.get defer):
>+        (foo.html.ScriptElement.set defer):
>+        (foo.html.ScriptElement.get integrity):
>+        (foo.html.ScriptElement.set integrity):
>+        (foo.html.ScriptElement.get noModule):
>+        (foo.html.ScriptElement.set noModule):
>+        (foo.html.ScriptElement.get src):
>+        (foo.html.ScriptElement.set src):
>+        (foo.html.ScriptElement.get type):
>+        (foo.html.ScriptElement.set type):
>+        (foo.const.async 0):
>+        (foo.html.ScrollState.new):
>+        (foo.html.ScrollState._create_1):
>+        (foo.html.ScrollState._create_2):
>+        (foo.html.ScrollState.prototype.get deltaGranularity):
>+        (foo.html.ScrollState.prototype.get deltaX):
>+        (foo.html.ScrollState.prototype.get deltaY):
>+        (foo.html.ScrollState.prototype.get fromUserInput):
>+        (foo.html.ScrollState.prototype.get inInertialPhase):
>+        (foo.html.ScrollState.prototype.get isBeginning):
>+        (foo.html.ScrollState.prototype.get isDirectManipulation):
>+        (foo.html.ScrollState.prototype.get isEnding):
>+        (foo.html.ScrollState.prototype.get positionX):
>+        (foo.html.ScrollState.prototype.get positionY):
>+        (foo.html.ScrollState.prototype.get velocityX):
>+        (foo.html.ScrollState.prototype.get velocityY):
>+        (foo.html.ScrollState.prototype.consumeDelta):
>+        (foo.html.ScrollState.prototype.distributeToScrollChainDescendant):
>+        (foo.html.ScrollState):
>+        (foo.html.ScrollTimeline.new):
>+        (foo.html.ScrollTimeline._create_1):
>+        (foo.html.ScrollTimeline._create_2):
>+        (foo.html.ScrollTimeline.prototype.get orientation):
>+        (foo.html.ScrollTimeline.prototype.get scrollSource):
>+        (foo.html.ScrollTimeline.prototype.get timeRange):
>+        (foo.html.ScrollTimeline):
>+        (foo.html.SecurityPolicyViolationEvent.new):
>+        (foo.html.SecurityPolicyViolationEvent._create_1):
>+        (foo.html.SecurityPolicyViolationEvent._create_2):
>+        (foo.html.SecurityPolicyViolationEvent.prototype.get blockedUri):
>+        (foo.html.SecurityPolicyViolationEvent.prototype.get columnNumber):
>+        (foo.html.SecurityPolicyViolationEvent.prototype.get disposition):
>+        (foo.html.SecurityPolicyViolationEvent.prototype.get documentUri):
>+        (foo.html.SecurityPolicyViolationEvent.prototype.get effectiveDirective):
>+        (foo.html.SecurityPolicyViolationEvent.prototype.get lineNumber):
>+        (foo.html.SecurityPolicyViolationEvent.prototype.get originalPolicy):
>+        (foo.html.SecurityPolicyViolationEvent.prototype.get referrer):
>+        (foo.html.SecurityPolicyViolationEvent.prototype.get sample):
>+        (foo.html.SecurityPolicyViolationEvent.prototype.get sourceFile):
>+        (foo.html.SecurityPolicyViolationEvent.prototype.get statusCode):
>+        (foo.html.SecurityPolicyViolationEvent.prototype.get violatedDirective):
>+        (foo.html.SecurityPolicyViolationEvent):
>+        (foo.html.SelectElement.new):
>+        (foo.html.SelectElement.prototype.get autofocus):
>+        (foo.html.SelectElement.prototype.set autofocus):
>+        (foo.html.SelectElement.prototype.get disabled):
>+        (foo.html.SelectElement.prototype.set disabled):
>+        (foo.html.SelectElement.prototype.get form):
>+        (foo.html.SelectElement.prototype.get labels):
>+        (foo.html.SelectElement.prototype.get length):
>+        (foo.html.SelectElement.prototype.set length):
>+        (foo.html.SelectElement.prototype.get multiple):
>+        (foo.html.SelectElement.prototype.set multiple):
>+        (foo.html.SelectElement.prototype.get name):
>+        (foo.html.SelectElement.prototype.set name):
>+        (foo.html.SelectElement.prototype.get required):
>+        (foo.html.SelectElement.prototype.set required):
>+        (foo.html.SelectElement.prototype.get selectedIndex):
>+        (foo.html.SelectElement.prototype.set selectedIndex):
>+        (foo.html.SelectElement.prototype.get size):
>+        (foo.html.SelectElement.prototype.set size):
>+        (foo.html.SelectElement.prototype.get type):
>+        (foo.html.SelectElement.prototype.get validationMessage):
>+        (foo.html.SelectElement.prototype.get validity):
>+        (foo.html.SelectElement.prototype.get value):
>+        (foo.html.SelectElement.prototype.set value):
>+        (foo.html.SelectElement.prototype.get willValidate):
>+        (foo.html.SelectElement.prototype.__setter__):
>+        (foo.html.SelectElement.prototype.add):
>+        (foo.html.SelectElement.prototype.checkValidity):
>+        (foo.html.SelectElement.prototype.item):
>+        (foo.html.SelectElement.prototype.namedItem):
>+        (foo.html.SelectElement.prototype.reportValidity):
>+        (foo.html.SelectElement.prototype.setCustomValidity):
>+        (foo.html.SelectElement.prototype.get options):
>+        (foo.html.SelectElement.prototype.get selectedOptions):
>+        (foo.html.SelectElement):
>+        (foo.html.Selection.prototype.get anchorNode):
>+        (foo.html.Selection.prototype.get anchorOffset):
>+        (foo.html.Selection.prototype.get baseNode):
>+        (foo.html.Selection.prototype.get baseOffset):
>+        (foo.html.Selection.prototype.get extentNode):
>+        (foo.html.Selection.prototype.get extentOffset):
>+        (foo.html.Selection.prototype.get focusNode):
>+        (foo.html.Selection.prototype.get focusOffset):
>+        (foo.html.Selection.prototype.get isCollapsed):
>+        (foo.html.Selection.prototype.get rangeCount):
>+        (foo.html.Selection.prototype.get type):
>+        (foo.html.Selection.prototype.addRange):
>+        (foo.html.Selection.prototype.collapse):
>+        (foo.html.Selection.prototype.collapseToEnd):
>+        (foo.html.Selection.prototype.collapseToStart):
>+        (foo.html.Selection.prototype.containsNode):
>+        (foo.html.Selection.prototype.deleteFromDocument):
>+        (foo.html.Selection.prototype.empty):
>+        (foo.html.Selection.prototype.extend):
>+        (foo.html.Selection.prototype.getRangeAt):
>+        (foo.html.Selection.prototype.modify):
>+        (foo.html.Selection.prototype.removeAllRanges):
>+        (foo.html.Selection.prototype.removeRange):
>+        (foo.html.Selection.prototype.selectAllChildren):
>+        (foo.html.Selection.prototype.setBaseAndExtent):
>+        (foo.html.Selection.prototype.setPosition):
>+        (foo.html.Selection):
>+        (foo.html.SensorErrorEvent.new):
>+        (foo.html.SensorErrorEvent._create_1):
>+        (foo.html.SensorErrorEvent.prototype.get error):
>+        (foo.html.SensorErrorEvent):
>+        (foo.html.ServiceWorker.prototype.get scriptUrl):
>+        (foo.html.ServiceWorker.prototype.get state):
>+        (foo.html.ServiceWorker.prototype.postMessage):
>+        (foo.html.ServiceWorker.prototype._postMessage_1):
>+        (foo.html.ServiceWorker.prototype._postMessage_2):
>+        (foo.html.ServiceWorker.prototype.get onError):
>+        (foo.html.ServiceWorker):
>+        (foo.html.ServiceWorkerContainer.prototype.get controller):
>+        (foo.html.ServiceWorkerContainer.prototype.get ready):
>+        (foo.html.ServiceWorkerContainer.prototype.getRegistration):
>+        (foo.html.ServiceWorkerContainer.prototype.getRegistrations):
>+        (foo.html.ServiceWorkerContainer.prototype.register):
>+        (foo.html.ServiceWorkerContainer.prototype.get onMessage):
>+        (foo.html.ServiceWorkerContainer):
>+        (foo.html.ServiceWorkerGlobalScope.prototype.get clients):
>+        (foo.html.ServiceWorkerGlobalScope.prototype.get registration):
>+        (foo.html.ServiceWorkerGlobalScope.prototype.skipWaiting):
>+        (foo.html.ServiceWorkerGlobalScope.prototype.get onActivate):
>+        (foo.html.ServiceWorkerGlobalScope.prototype.get onFetch):
>+        (foo.html.ServiceWorkerGlobalScope.prototype.get onForeignfetch):
>+        (foo.html.ServiceWorkerGlobalScope.prototype.get onInstall):
>+        (foo.html.ServiceWorkerGlobalScope.prototype.get onMessage):
>+        (foo.html.ServiceWorkerGlobalScope.get instance):
>+        (foo.html.ServiceWorkerGlobalScope):
>+        (foo.html.ServiceWorkerRegistration.prototype.get active):
>+        (foo.html.ServiceWorkerRegistration.prototype.get backgroundFetch):
>+        (foo.html.ServiceWorkerRegistration.prototype.get installing):
>+        (foo.html.ServiceWorkerRegistration.prototype.get navigationPreload):
>+        (foo.html.ServiceWorkerRegistration.prototype.get paymentManager):
>+        (foo.html.ServiceWorkerRegistration.prototype.get pushManager):
>+        (foo.html.ServiceWorkerRegistration.prototype.get scope):
>+        (foo.html.ServiceWorkerRegistration.prototype.get sync):
>+        (foo.html.ServiceWorkerRegistration.prototype.get waiting):
>+        (foo.html.ServiceWorkerRegistration.prototype.getNotifications):
>+        (foo.html.ServiceWorkerRegistration.prototype.showNotification):
>+        (foo.html.ServiceWorkerRegistration.prototype.unregister):
>+        (foo.html.ServiceWorkerRegistration.prototype.update):
>+        (foo.html.ServiceWorkerRegistration):
>+        (foo.html.ShadowElement.new):
>+        (foo.html.ShadowElement.get supported):
>+        (foo.html.ShadowElement.prototype.getDistributedNodes):
>+        (foo.html.ShadowElement):
>+        (foo.html.ShadowRoot.prototype.get delegatesFocus):
>+        (foo.html.ShadowRoot.prototype.get host):
>+        (foo.html.ShadowRoot.prototype.get innerHtml):
>+        (foo.html.ShadowRoot.prototype.set innerHtml):
>+        (foo.html.ShadowRoot.prototype.get mode):
>+        (foo.html.ShadowRoot.prototype.get olderShadowRoot):
>+        (foo.html.ShadowRoot.prototype.get activeElement):
>+        (foo.html.ShadowRoot.prototype.get fullscreenElement):
>+        (foo.html.ShadowRoot.prototype.get pointerLockElement):
>+        (foo.html.ShadowRoot.prototype.get styleSheets):
>+        (foo.html.ShadowRoot.prototype.elementFromPoint):
>+        (foo.html.ShadowRoot.prototype.elementsFromPoint):
>+        (foo.html.ShadowRoot.prototype.getSelection):
>+        (foo.html.ShadowRoot.get supported):
>+        (foo.html.ShadowRoot._shadowRootDeprecationReport):
>+        (foo.html.ShadowRoot.prototype.get resetStyleInheritance):
>+        (foo.html.ShadowRoot.prototype.set resetStyleInheritance):
>+        (foo.html.ShadowRoot.prototype.get applyAuthorStyles):
>+        (foo.html.ShadowRoot.prototype.set applyAuthorStyles):
>+        (foo.html.ShadowRoot):
>+        (foo.html.SharedArrayBuffer.prototype.get byteLength):
>+        (foo.html.SharedArrayBuffer):
>+        (foo.html.SharedWorker.new):
>+        (foo.html.SharedWorker._create_1):
>+        (foo.html.SharedWorker._create_2):
>+        (foo.html.SharedWorker.prototype.get port):
>+        (foo.html.SharedWorker.prototype.get onError):
>+        (foo.html.SharedWorker):
>+        (foo.html.SharedWorkerGlobalScope.prototype.get name):
>+        (foo.html.SharedWorkerGlobalScope.prototype.close):
>+        (foo.html.SharedWorkerGlobalScope.prototype._webkitRequestFileSystem):
>+        (foo.html.SharedWorkerGlobalScope.prototype.requestFileSystemSync):
>+        (foo.html.SharedWorkerGlobalScope.prototype.resolveLocalFileSystemSyncUrl):
>+        (foo.html.SharedWorkerGlobalScope.prototype._webkitResolveLocalFileSystemUrl):
>+        (foo.html.SharedWorkerGlobalScope.prototype.get onConnect):
>+        (foo.html.SharedWorkerGlobalScope.get instance):
>+        (foo.html.SharedWorkerGlobalScope):
>+        (foo.html.SlotElement.prototype.get name):
>+        (foo.html.SlotElement.prototype.set name):
>+        (foo.html.SlotElement.prototype.assignedNodes):
>+        (foo.html.SlotElement.prototype._assignedNodes_1):
>+        (foo.html.SlotElement.prototype._assignedNodes_2):
>+        (foo.html.SlotElement):
>+        (foo.html.SourceBuffer.prototype.get appendWindowEnd):
>+        (foo.html.SourceBuffer.prototype.set appendWindowEnd):
>+        (foo.html.SourceBuffer.prototype.get appendWindowStart):
>+        (foo.html.SourceBuffer.prototype.set appendWindowStart):
>+        (foo.html.SourceBuffer.prototype.get audioTracks):
>+        (foo.html.SourceBuffer.prototype.get buffered):
>+        (foo.html.SourceBuffer.prototype.get mode):
>+        (foo.html.SourceBuffer.prototype.set mode):
>+        (foo.html.SourceBuffer.prototype.get timestampOffset):
>+        (foo.html.SourceBuffer.prototype.set timestampOffset):
>+        (foo.html.SourceBuffer.prototype.get trackDefaults):
>+        (foo.html.SourceBuffer.prototype.set trackDefaults):
>+        (foo.html.SourceBuffer.prototype.get updating):
>+        (foo.html.SourceBuffer.prototype.get videoTracks):
>+        (foo.html.SourceBuffer.prototype.abort):
>+        (foo.html.SourceBuffer.prototype.appendBuffer):
>+        (foo.html.SourceBuffer.prototype.appendTypedData):
>+        (foo.html.SourceBuffer.prototype.remove):
>+        (foo.html.SourceBuffer.prototype.get onAbort):
>+        (foo.html.SourceBuffer.prototype.get onError):
>+        (foo.html.SourceBuffer):
>+        (foo.const.EventTarget_ListMixin):
>+        (foo.const.EventTarget_ImmutableListMixin):
>+        (foo.html.SourceBufferList.prototype.get length):
>+        (foo.html.SourceBufferList.prototype._get):
>+        (foo.html.SourceBufferList.prototype._set):
>+        (foo.html.SourceBufferList.prototype.set length):
>+        (foo.html.SourceBufferList.prototype.get first):
>+        (foo.html.SourceBufferList.prototype.set first):
>+        (foo.html.SourceBufferList.prototype.get last):
>+        (foo.html.SourceBufferList.prototype.set last):
>+        (foo.html.SourceBufferList.prototype.get single):
>+        (foo.html.SourceBufferList.prototype.elementAt):
>+        (foo.html.SourceBufferList.prototype.item):
>+        (foo.html.SourceBufferList):
>+        (foo.html.SourceElement.new):
>+        (foo.html.SourceElement.prototype.get media):
>+        (foo.html.SourceElement.prototype.set media):
>+        (foo.html.SourceElement.prototype.get sizes):
>+        (foo.html.SourceElement.prototype.set sizes):
>+        (foo.html.SourceElement.prototype.get src):
>+        (foo.html.SourceElement.prototype.set src):
>+        (foo.html.SourceElement.prototype.get srcset):
>+        (foo.html.SourceElement.prototype.set srcset):
>+        (foo.html.SourceElement.prototype.get type):
>+        (foo.html.SourceElement.prototype.set type):
>+        (foo.html.SourceElement):
>+        (foo.html.SpanElement.new):
>+        (foo.html.SpanElement):
>+        (foo.html.SpeechGrammar.new):
>+        (foo.html.SpeechGrammar._create_1):
>+        (foo.html.SpeechGrammar.prototype.get src):
>+        (foo.html.SpeechGrammar.prototype.set src):
>+        (foo.html.SpeechGrammar.prototype.get weight):
>+        (foo.html.SpeechGrammar.prototype.set weight):
>+        (foo.html.SpeechGrammar):
>+        (foo.const.Interceptor_ListMixin.5):
>+        (foo.const.Interceptor_ImmutableListMixin.5):
>+        (foo.html.SpeechGrammarList.new):
>+        (foo.html.SpeechGrammarList._create_1):
>+        (foo.html.SpeechGrammarList.prototype.get length):
>+        (foo.html.SpeechGrammarList.prototype._get):
>+        (foo.html.SpeechGrammarList.prototype._set):
>+        (foo.html.SpeechGrammarList.prototype.set length):
>+        (foo.html.SpeechGrammarList.prototype.get first):
>+        (foo.html.SpeechGrammarList.prototype.set first):
>+        (foo.html.SpeechGrammarList.prototype.get last):
>+        (foo.html.SpeechGrammarList.prototype.set last):
>+        (foo.html.SpeechGrammarList.prototype.get single):
>+        (foo.html.SpeechGrammarList.prototype.elementAt):
>+        (foo.html.SpeechGrammarList.prototype.addFromString):
>+        (foo.html.SpeechGrammarList.prototype.addFromUri):
>+        (foo.html.SpeechGrammarList.prototype.item):
>+        (foo.html.SpeechGrammarList):
>+        (foo.html.SpeechRecognition.get supported):
>+        (foo.html.SpeechRecognition.prototype.get audioTrack):
>+        (foo.html.SpeechRecognition.prototype.set audioTrack):
>+        (foo.html.SpeechRecognition.prototype.get continuous):
>+        (foo.html.SpeechRecognition.prototype.set continuous):
>+        (foo.html.SpeechRecognition.prototype.get grammars):
>+        (foo.html.SpeechRecognition.prototype.set grammars):
>+        (foo.html.SpeechRecognition.prototype.get interimResults):
>+        (foo.html.SpeechRecognition.prototype.set interimResults):
>+        (foo.html.SpeechRecognition.prototype.get lang):
>+        (foo.html.SpeechRecognition.prototype.set lang):
>+        (foo.html.SpeechRecognition.prototype.get maxAlternatives):
>+        (foo.html.SpeechRecognition.prototype.set maxAlternatives):
>+        (foo.html.SpeechRecognition.prototype.abort):
>+        (foo.html.SpeechRecognition.prototype.start):
>+        (foo.html.SpeechRecognition.prototype.stop):
>+        (foo.html.SpeechRecognition.prototype.get onAudioEnd):
>+        (foo.html.SpeechRecognition.prototype.get onAudioStart):
>+        (foo.html.SpeechRecognition.prototype.get onEnd):
>+        (foo.html.SpeechRecognition.prototype.get onError):
>+        (foo.html.SpeechRecognition.prototype.get onNoMatch):
>+        (foo.html.SpeechRecognition.prototype.get onResult):
>+        (foo.html.SpeechRecognition.prototype.get onSoundEnd):
>+        (foo.html.SpeechRecognition.prototype.get onSoundStart):
>+        (foo.html.SpeechRecognition.prototype.get onSpeechEnd):
>+        (foo.html.SpeechRecognition.prototype.get onSpeechStart):
>+        (foo.html.SpeechRecognition.prototype.get onStart):
>+        (foo.html.SpeechRecognition.new):
>+        (foo.html.SpeechRecognition):
>+        (foo.html.SpeechRecognitionAlternative.prototype.get confidence):
>+        (foo.html.SpeechRecognitionAlternative.prototype.get transcript):
>+        (foo.html.SpeechRecognitionAlternative):
>+        (foo.html.SpeechRecognitionError.new):
>+        (foo.html.SpeechRecognitionError._create_1):
>+        (foo.html.SpeechRecognitionError._create_2):
>+        (foo.html.SpeechRecognitionError.prototype.get error):
>+        (foo.html.SpeechRecognitionError.prototype.get message):
>+        (foo.html.SpeechRecognitionError):
>+        (foo.html.SpeechRecognitionEvent.new):
>+        (foo.html.SpeechRecognitionEvent._create_1):
>+        (foo.html.SpeechRecognitionEvent._create_2):
>+        (foo.html.SpeechRecognitionEvent.prototype.get emma):
>+        (foo.html.SpeechRecognitionEvent.prototype.get interpretation):
>+        (foo.html.SpeechRecognitionEvent.prototype.get resultIndex):
>+        (foo.html.SpeechRecognitionEvent.prototype.get results):
>+        (foo.html.SpeechRecognitionEvent):
>+        (foo.html.SpeechRecognitionResult.prototype.get isFinal):
>+        (foo.html.SpeechRecognitionResult.prototype.get length):
>+        (foo.html.SpeechRecognitionResult.prototype.item):
>+        (foo.html.SpeechRecognitionResult):
>+        (foo.html.SpeechSynthesis.prototype.getVoices):
>+        (foo.html.SpeechSynthesis.prototype.get paused):
>+        (foo.html.SpeechSynthesis.prototype.get pending):
>+        (foo.html.SpeechSynthesis.prototype.get speaking):
>+        (foo.html.SpeechSynthesis.prototype.cancel):
>+        (foo.html.SpeechSynthesis.prototype._getVoices):
>+        (foo.html.SpeechSynthesis.prototype.pause):
>+        (foo.html.SpeechSynthesis.prototype.resume):
>+        (foo.html.SpeechSynthesis.prototype.speak):
>+        (foo.html.SpeechSynthesis):
>+        (foo.html.SpeechSynthesisEvent.prototype.get charIndex):
>+        (foo.html.SpeechSynthesisEvent.prototype.get elapsedTime):
>+        (foo.html.SpeechSynthesisEvent.prototype.get name):
>+        (foo.html.SpeechSynthesisEvent.prototype.get utterance):
>+        (foo.html.SpeechSynthesisEvent):
>+        (foo.html.SpeechSynthesisUtterance.new):
>+        (foo.html.SpeechSynthesisUtterance._create_1):
>+        (foo.html.SpeechSynthesisUtterance._create_2):
>+        (foo.html.SpeechSynthesisUtterance.prototype.get lang):
>+        (foo.html.SpeechSynthesisUtterance.prototype.set lang):
>+        (foo.html.SpeechSynthesisUtterance.prototype.get pitch):
>+        (foo.html.SpeechSynthesisUtterance.prototype.set pitch):
>+        (foo.html.SpeechSynthesisUtterance.prototype.get rate):
>+        (foo.html.SpeechSynthesisUtterance.prototype.set rate):
>+        (foo.html.SpeechSynthesisUtterance.prototype.get text):
>+        (foo.html.SpeechSynthesisUtterance.prototype.set text):
>+        (foo.html.SpeechSynthesisUtterance.prototype.get voice):
>+        (foo.html.SpeechSynthesisUtterance.prototype.set voice):
>+        (foo.html.SpeechSynthesisUtterance.prototype.get volume):
>+        (foo.html.SpeechSynthesisUtterance.prototype.set volume):
>+        (foo.html.SpeechSynthesisUtterance.prototype.get onBoundary):
>+        (foo.html.SpeechSynthesisUtterance.prototype.get onEnd):
>+        (foo.html.SpeechSynthesisUtterance.prototype.get onError):
>+        (foo.html.SpeechSynthesisUtterance.prototype.get onMark):
>+        (foo.html.SpeechSynthesisUtterance.prototype.get onPause):
>+        (foo.html.SpeechSynthesisUtterance.prototype.get onResume):
>+        (foo.html.SpeechSynthesisUtterance.prototype.get onStart):
>+        (foo.html.SpeechSynthesisUtterance):
>+        (foo.html.SpeechSynthesisVoice.prototype.get defaultValue):
>+        (foo.html.SpeechSynthesisVoice.prototype.get lang):
>+        (foo.html.SpeechSynthesisVoice.prototype.get localService):
>+        (foo.html.SpeechSynthesisVoice.prototype.get name):
>+        (foo.html.SpeechSynthesisVoice.prototype.get voiceUri):
>+        (foo.html.SpeechSynthesisVoice):
>+        (foo.html.StaticRange.prototype.get collapsed):
>+        (foo.html.StaticRange.prototype.get endContainer):
>+        (foo.html.StaticRange.prototype.get endOffset):
>+        (foo.html.StaticRange.prototype.get startContainer):
>+        (foo.html.StaticRange.prototype.get startOffset):
>+        (foo.html.StaticRange):
>+        (foo.const.Interceptor_MapMixin.1):
>+        (foo.html.Storage.prototype.addAll):
>+        (foo.html.Storage.prototype.containsValue):
>+        (foo.html.Storage.prototype.containsKey):
>+        (foo.html.Storage.prototype._get):
>+        (foo.html.Storage.prototype._set):
>+        (foo.html.Storage.prototype.putIfAbsent):
>+        (foo.html.Storage.prototype.remove):
>+        (foo.html.Storage.prototype.clear):
>+        (foo.html.Storage.prototype.forEach):
>+        (foo.html.Storage.prototype.get keys):
>+        (foo.html.Storage.prototype.get values):
>+        (foo.html.Storage.prototype.get length):
>+        (foo.html.Storage.prototype.get isEmpty):
>+        (foo.html.Storage.prototype.get isNotEmpty):
>+        (foo.html.Storage.prototype.get _length):
>+        (foo.html.Storage.prototype._clear.0):
>+        (foo.html.Storage.prototype._getItem):
>+        (foo.html.Storage.prototype._key):
>+        (foo.html.Storage.prototype._removeItem):
>+        (foo.html.Storage.prototype._setItem):
>+        (foo.html.Storage):
>+        (foo.html.StorageEvent.new):
>+        (foo.html.StorageEvent.__):
>+        (foo.html.StorageEvent._create_1):
>+        (foo.html.StorageEvent._create_2):
>+        (foo.html.StorageEvent.prototype.get key):
>+        (foo.html.StorageEvent.prototype.get newValue):
>+        (foo.html.StorageEvent.prototype.get oldValue):
>+        (foo.html.StorageEvent.prototype.get storageArea):
>+        (foo.html.StorageEvent.prototype.get url):
>+        (foo.html.StorageEvent.prototype._initStorageEvent):
>+        (foo.html.StorageEvent):
>+        (foo.html.StorageManager.prototype.estimate):
>+        (foo.html.StorageManager.prototype.persist):
>+        (foo.html.StorageManager.prototype.persisted):
>+        (foo.html.StorageManager):
>+        (foo.html.StyleElement.new):
>+        (foo.html.StyleElement.prototype.get disabled):
>+        (foo.html.StyleElement.prototype.set disabled):
>+        (foo.html.StyleElement.prototype.get media):
>+        (foo.html.StyleElement.prototype.set media):
>+        (foo.html.StyleElement.prototype.get sheet):
>+        (foo.html.StyleElement.prototype.get type):
>+        (foo.html.StyleElement.prototype.set type):
>+        (foo.html.StyleElement):
>+        (foo.html.StyleMedia.prototype.get type):
>+        (foo.html.StyleMedia.prototype.matchMedium):
>+        (foo.html.StyleMedia):
>+        (foo.html.StylePropertyMap.prototype.append):
>+        (foo.html.StylePropertyMap.prototype.delete):
>+        (foo.html.SyncEvent.new):
>+        (foo.html.SyncEvent._create_1):
>+        (foo.html.SyncEvent.prototype.get lastChance):
>+        (foo.html.SyncEvent.prototype.get tag):
>+        (foo.html.SyncEvent):
>+        (foo.set dart):
>+        (foo.html.SyncManager.prototype.getTags):
>+        (foo.html.SyncManager.prototype.register):
>+        (foo.html.SyncManager):
>+        (foo.html.TableCaptionElement.new):
>+        (foo.html.TableCaptionElement):
>+        (foo.html.TableCellElement.new):
>+        (foo.html.TableCellElement.prototype.get cellIndex):
>+        (foo.html.TableCellElement.prototype.get colSpan):
>+        (foo.html.TableCellElement.prototype.set colSpan):
>+        (foo.html.TableCellElement.prototype.get headers):
>+        (foo.html.TableCellElement.prototype.set headers):
>+        (foo.html.TableCellElement.prototype.get rowSpan):
>+        (foo.html.TableCellElement.prototype.set rowSpan):
>+        (foo.html.TableCellElement):
>+        (foo.html.TableColElement.new):
>+        (foo.html.TableColElement.prototype.get span):
>+        (foo.html.TableColElement.prototype.set span):
>+        (foo.html.TableColElement):
>+        (foo.html.TableElement.prototype.get tBodies):
>+        (foo.html.TableElement.prototype.get rows):
>+        (foo.html.TableElement.prototype.addRow):
>+        (foo.html.TableElement.prototype.createCaption):
>+        (foo.html.TableElement.prototype.createTBody):
>+        (foo.html.TableElement.prototype.createTFoot):
>+        (foo.html.TableElement.prototype.createTHead):
>+        (foo.html.TableElement.prototype.insertRow):
>+        (foo.html.TableElement.prototype._createTBody):
>+        (foo.html.TableElement.prototype._nativeCreateTBody):
>+        (foo.html.TableElement.prototype.createFragment):
>+        (foo.html.TableElement.new):
>+        (foo.html.TableElement.prototype.get caption):
>+        (foo.html.TableElement.prototype.set caption):
>+        (foo.html.TableElement.prototype.get _rows):
>+        (foo.html.TableElement.prototype.get _tBodies):
>+        (foo.html.TableElement.prototype.get tFoot):
>+        (foo.html.TableElement.prototype.set tFoot):
>+        (foo.html.TableElement.prototype.get tHead):
>+        (foo.html.TableElement.prototype.set tHead):
>+        (foo.html.TableElement.prototype._createCaption):
>+        (foo.html.TableElement.prototype._createTFoot):
>+        (foo.html.TableElement.prototype._createTHead):
>+        (foo.html.TableElement.prototype.deleteCaption):
>+        (foo.html.TableElement.prototype.deleteRow):
>+        (foo.html.TableElement.prototype.deleteTFoot):
>+        (foo.html.TableElement.prototype.deleteTHead):
>+        (foo.html.TableElement.prototype._insertRow):
>+        (foo.html.TableElement):
>+        (foo.html.TableRowElement.prototype.get cells):
>+        (foo.html.TableRowElement.prototype.addCell):
>+        (foo.html.TableRowElement.prototype.insertCell):
>+        (foo.html.TableRowElement.prototype.createFragment):
>+        (foo.html.TableRowElement.new):
>+        (foo.html.TableRowElement.prototype.get _cells):
>+        (foo.html.TableRowElement.prototype.get rowIndex):
>+        (foo.html.TableRowElement.prototype.get sectionRowIndex):
>+        (foo.html.TableRowElement.prototype.deleteCell):
>+        (foo.html.TableRowElement.prototype._insertCell):
>+        (foo.html.TableRowElement):
>+        (foo.html.TableSectionElement.prototype.get rows):
>+        (foo.html.TableSectionElement.prototype.addRow):
>+        (foo.html.TableSectionElement.prototype.insertRow):
>+        (foo.html.TableSectionElement.prototype.createFragment):
>+        (foo.html.TableSectionElement.prototype.get _rows):
>+        (foo.html.TableSectionElement.prototype.deleteRow):
>+        (foo.html.TableSectionElement.prototype._insertRow):
>+        (foo.html.TableSectionElement):
>+        (foo.html.TaskAttributionTiming.prototype.get containerId):
>+        (foo.html.TaskAttributionTiming.prototype.get containerName):
>+        (foo.html.TaskAttributionTiming.prototype.get containerSrc):
>+        (foo.html.TaskAttributionTiming.prototype.get containerType):
>+        (foo.html.TaskAttributionTiming.prototype.get scriptUrl):
>+        (foo.html.TaskAttributionTiming):
>+        (foo.html.TemplateElement.new):
>+        (foo.html.TemplateElement.get supported):
>+        (foo.html.TemplateElement.prototype.get content):
>+        (foo.html.TemplateElement.prototype.setInnerHtml):
>+        (foo.html.TemplateElement):
>+        (foo.html.TextAreaElement.new):
>+        (foo.html.TextAreaElement.prototype.get autocapitalize):
>+        (foo.html.TextAreaElement.prototype.set autocapitalize):
>+        (foo.html.TextAreaElement.prototype.get autofocus):
>+        (foo.html.TextAreaElement.prototype.set autofocus):
>+        (foo.html.TextAreaElement.prototype.get cols):
>+        (foo.html.TextAreaElement.prototype.set cols):
>+        (foo.html.TextAreaElement.prototype.get defaultValue):
>+        (foo.html.TextAreaElement.prototype.set defaultValue):
>+        (foo.html.TextAreaElement.prototype.get dirName):
>+        (foo.html.TextAreaElement.prototype.set dirName):
>+        (foo.html.TextAreaElement.prototype.get disabled):
>+        (foo.html.TextAreaElement.prototype.set disabled):
>+        (foo.html.TextAreaElement.prototype.get form):
>+        (foo.html.TextAreaElement.prototype.get labels):
>+        (foo.html.TextAreaElement.prototype.get maxLength):
>+        (foo.html.TextAreaElement.prototype.set maxLength):
>+        (foo.html.TextAreaElement.prototype.get minLength):
>+        (foo.html.TextAreaElement.prototype.set minLength):
>+        (foo.html.TextAreaElement.prototype.get name):
>+        (foo.html.TextAreaElement.prototype.set name):
>+        (foo.html.TextAreaElement.prototype.get placeholder):
>+        (foo.html.TextAreaElement.prototype.set placeholder):
>+        (foo.html.TextAreaElement.prototype.get readOnly):
>+        (foo.html.TextAreaElement.prototype.set readOnly):
>+        (foo.html.TextAreaElement.prototype.get required):
>+        (foo.html.TextAreaElement.prototype.set required):
>+        (foo.html.TextAreaElement.prototype.get rows):
>+        (foo.html.TextAreaElement.prototype.set rows):
>+        (foo.html.TextAreaElement.prototype.get selectionDirection):
>+        (foo.html.TextAreaElement.prototype.set selectionDirection):
>+        (foo.html.TextAreaElement.prototype.get selectionEnd):
>+        (foo.html.TextAreaElement.prototype.set selectionEnd):
>+        (foo.html.TextAreaElement.prototype.get selectionStart):
>+        (foo.html.TextAreaElement.prototype.set selectionStart):
>+        (foo.html.TextAreaElement.prototype.get textLength):
>+        (foo.html.TextAreaElement.prototype.get type):
>+        (foo.html.TextAreaElement.prototype.get validationMessage):
>+        (foo.html.TextAreaElement.prototype.get validity):
>+        (foo.html.TextAreaElement.prototype.get value):
>+        (foo.html.TextAreaElement.prototype.set value):
>+        (foo.html.TextAreaElement.prototype.get willValidate):
>+        (foo.html.TextAreaElement.prototype.get wrap):
>+        (foo.html.TextAreaElement.prototype.set wrap):
>+        (foo.html.TextAreaElement.prototype.checkValidity):
>+        (foo.html.TextAreaElement.prototype.reportValidity):
>+        (foo.html.TextAreaElement.prototype.select):
>+        (foo.html.TextAreaElement.prototype.setCustomValidity):
>+        (foo.html.TextAreaElement.prototype.setRangeText):
>+        (foo.html.TextAreaElement.prototype.setSelectionRange):
>+        (foo.html.TextAreaElement):
>+        (foo.html.TextDetector.new):
>+        (foo.html.TextDetector._create_1):
>+        (foo.html.TextDetector.prototype.detect):
>+        (foo.html.TextDetector):
>+        (foo.html.TextEvent.new):
>+        (foo.html.TextEvent.prototype.get data):
>+        (foo.html.TextEvent.prototype._initTextEvent):
>+        (foo.html.TextEvent):
>+        (foo.html.TextMetrics.prototype.get actualBoundingBoxAscent):
>+        (foo.html.TextMetrics.prototype.get actualBoundingBoxDescent):
>+        (foo.html.TextMetrics.prototype.get actualBoundingBoxLeft):
>+        (foo.html.TextMetrics.prototype.get actualBoundingBoxRight):
>+        (foo.html.TextMetrics.prototype.get alphabeticBaseline):
>+        (foo.html.TextMetrics.prototype.get emHeightAscent):
>+        (foo.html.TextMetrics.prototype.get emHeightDescent):
>+        (foo.html.TextMetrics.prototype.get fontBoundingBoxAscent):
>+        (foo.html.TextMetrics.prototype.get fontBoundingBoxDescent):
>+        (foo.html.TextMetrics.prototype.get hangingBaseline):
>+        (foo.html.TextMetrics.prototype.get ideographicBaseline):
>+        (foo.html.TextMetrics.prototype.get width):
>+        (foo.html.TextMetrics):
>+        (foo.html.TextTrack.prototype.get activeCues):
>+        (foo.html.TextTrack.prototype.get cues):
>+        (foo.html.TextTrack.prototype.get id):
>+        (foo.html.TextTrack.prototype.get kind):
>+        (foo.html.TextTrack.prototype.get label):
>+        (foo.html.TextTrack.prototype.get language):
>+        (foo.html.TextTrack.prototype.get mode):
>+        (foo.html.TextTrack.prototype.set mode):
>+        (foo.html.TextTrack.prototype.addCue):
>+        (foo.html.TextTrack.prototype.removeCue):
>+        (foo.html.TextTrack.prototype.get onCueChange):
>+        (foo.html.TextTrack):
>+        (foo.html.TextTrackCue.prototype.get endTime):
>+        (foo.html.TextTrackCue.prototype.set endTime):
>+        (foo.html.TextTrackCue.prototype.get id):
>+        (foo.html.TextTrackCue.prototype.set id):
>+        (foo.html.TextTrackCue.prototype.get pauseOnExit):
>+        (foo.html.TextTrackCue.prototype.set pauseOnExit):
>+        (foo.html.TextTrackCue.prototype.get startTime):
>+        (foo.html.TextTrackCue.prototype.set startTime):
>+        (foo.html.TextTrackCue.prototype.get track):
>+        (foo.html.TextTrackCue.prototype.get onEnter):
>+        (foo.html.TextTrackCue.prototype.get onExit):
>+        (foo.html.TextTrackCue):
>+        (foo.const.Interceptor_ListMixin.6):
>+        (foo.const.Interceptor_ImmutableListMixin.6):
>+        (foo.html.TextTrackCueList.prototype.get length):
>+        (foo.html.TextTrackCueList.prototype._get):
>+        (foo.html.TextTrackCueList.prototype._set):
>+        (foo.html.TextTrackCueList.prototype.set length):
>+        (foo.html.TextTrackCueList.prototype.get first):
>+        (foo.html.TextTrackCueList.prototype.set first):
>+        (foo.html.TextTrackCueList.prototype.get last):
>+        (foo.html.TextTrackCueList.prototype.set last):
>+        (foo.html.TextTrackCueList.prototype.get single):
>+        (foo.html.TextTrackCueList.prototype.elementAt):
>+        (foo.html.TextTrackCueList.prototype.__getter__):
>+        (foo.html.TextTrackCueList.prototype.getCueById):
>+        (foo.html.TextTrackCueList):
>+        (foo.html.TextTrackList.prototype.get length):
>+        (foo.html.TextTrackList.prototype._get):
>+        (foo.html.TextTrackList.prototype._set):
>+        (foo.html.TextTrackList.prototype.set length):
>+        (foo.html.TextTrackList.prototype.get first):
>+        (foo.html.TextTrackList.prototype.set first):
>+        (foo.html.TextTrackList.prototype.get last):
>+        (foo.html.TextTrackList.prototype.set last):
>+        (foo.html.TextTrackList.prototype.get single):
>+        (foo.html.TextTrackList.prototype.elementAt):
>+        (foo.html.TextTrackList.prototype.__getter__):
>+        (foo.html.TextTrackList.prototype.getTrackById):
>+        (foo.html.TextTrackList.prototype.get onAddTrack):
>+        (foo.html.TextTrackList.prototype.get onChange):
>+        (foo.html.TextTrackList):
>+        (foo.html.TimeElement.prototype.get dateTime):
>+        (foo.html.TimeElement.prototype.set dateTime):
>+        (foo.html.TimeElement):
>+        (foo.html.TimeRanges.prototype.get length):
>+        (foo.html.TimeRanges.prototype.end):
>+        (foo.html.TimeRanges.prototype.start):
>+        (foo.html.TimeRanges):
>+        (foo.html.TitleElement.new):
>+        (foo.html.TitleElement):
>+        (foo.html.Touch.new):
>+        (foo.html.Touch._create_1):
>+        (foo.html.Touch.prototype.get _clientX):
>+        (foo.html.Touch.prototype.get _clientY):
>+        (foo.html.Touch.prototype.get force):
>+        (foo.html.Touch.prototype.get identifier):
>+        (foo.html.Touch.prototype.get _pageX):
>+        (foo.html.Touch.prototype.get _pageY):
>+        (foo.html.Touch.prototype.get _radiusX):
>+        (foo.html.Touch.prototype.get _radiusY):
>+        (foo.html.Touch.prototype.get region):
>+        (foo.html.Touch.prototype.get rotationAngle):
>+        (foo.html.Touch.prototype.get _screenX):
>+        (foo.html.Touch.prototype.get _screenY):
>+        (foo.html.Touch.prototype.get target):
>+        (foo.html.Touch.prototype.get _get_target):
>+        (foo.html.Touch.prototype.get __clientX):
>+        (foo.html.Touch.prototype.get __clientY):
>+        (foo.html.Touch.prototype.get __screenX):
>+        (foo.html.Touch.prototype.get __screenY):
>+        (foo.html.Touch.prototype.get __pageX):
>+        (foo.html.Touch.prototype.get __pageY):
>+        (foo.html.Touch.prototype.get __radiusX):
>+        (foo.html.Touch.prototype.get __radiusY):
>+        (foo.html.Touch.prototype.get client):
>+        (foo.html.Touch.prototype.get page):
>+        (foo.html.Touch.prototype.get screen):
>+        (foo.html.Touch.prototype.get radiusX):
>+        (foo.html.Touch.prototype.get radiusY):
>+        (foo.html.Touch):
>+        (foo.html.TouchEvent.new):
>+        (foo.html.TouchEvent._create_1):
>+        (foo.html.TouchEvent._create_2):
>+        (foo.html.TouchEvent.prototype.get altKey):
>+        (foo.html.TouchEvent.prototype.get changedTouches):
>+        (foo.html.TouchEvent.prototype.get ctrlKey):
>+        (foo.html.TouchEvent.prototype.get metaKey):
>+        (foo.html.TouchEvent.prototype.get shiftKey):
>+        (foo.html.TouchEvent.prototype.get targetTouches):
>+        (foo.html.TouchEvent.prototype.get touches):
>+        (foo.html.TouchEvent.get supported):
>+        (foo.html.TouchEvent):
>+        (foo.const.Interceptor_ListMixin.7):
>+        (foo.const.Interceptor_ImmutableListMixin.7):
>+        (foo.html.TouchList.new):
>+        (foo.html.TouchList.get supported):
>+        (foo.html.TouchList.prototype.get length):
>+        (foo.html.TouchList.prototype._get):
>+        (foo.html.TouchList.prototype._set):
>+        (foo.html.TouchList.prototype.set length):
>+        (foo.html.TouchList.prototype.get first):
>+        (foo.html.TouchList.prototype.set first):
>+        (foo.html.TouchList.prototype.get last):
>+        (foo.html.TouchList.prototype.set last):
>+        (foo.html.TouchList.prototype.get single):
>+        (foo.html.TouchList.prototype.elementAt):
>+        (foo.html.TouchList.prototype.item):
>+        (foo.html.TouchList):
>+        (foo.html.TrackDefault.new):
>+        (foo.html.TrackDefault._create_1):
>+        (foo.html.TrackDefault._create_2):
>+        (foo.html.TrackDefault.prototype.get byteStreamTrackID):
>+        (foo.html.TrackDefault.prototype.get kinds):
>+        (foo.html.TrackDefault.prototype.get label):
>+        (foo.html.TrackDefault.prototype.get language):
>+        (foo.html.TrackDefault.prototype.get type):
>+        (foo.html.TrackDefault):
>+        (foo.html.TrackDefaultList.new):
>+        (foo.html.TrackDefaultList._create_1):
>+        (foo.html.TrackDefaultList._create_2):
>+        (foo.html.TrackDefaultList.prototype.get length):
>+        (foo.html.TrackDefaultList.prototype.item):
>+        (foo.html.TrackDefaultList):
>+        (foo.html.TrackElement.new):
>+        (foo.html.TrackElement.get supported):
>+        (foo.html.TrackElement.prototype.get defaultValue):
>+        (foo.html.TrackElement.prototype.set defaultValue):
>+        (foo.html.TrackElement.prototype.get kind):
>+        (foo.html.TrackElement.prototype.set kind):
>+        (foo.html.TrackElement.prototype.get label):
>+        (foo.html.TrackElement.prototype.set label):
>+        (foo.html.TrackElement.prototype.get readyState):
>+        (foo.html.TrackElement.prototype.get src):
>+        (foo.html.TrackElement.prototype.set src):
>+        (foo.html.TrackElement.prototype.get srclang):
>+        (foo.html.TrackElement.prototype.set srclang):
>+        (foo.html.TrackElement.prototype.get track):
>+        (foo.html.TrackElement):
>+        (foo.html.TrackEvent.new):
>+        (foo.html.TrackEvent._create_1):
>+        (foo.html.TrackEvent._create_2):
>+        (foo.html.TrackEvent.prototype.get track):
>+        (foo.html.TrackEvent):
>+        (foo.html.TransitionEvent.new):
>+        (foo.html.TransitionEvent._create_1):
>+        (foo.html.TransitionEvent._create_2):
>+        (foo.html.TransitionEvent.prototype.get elapsedTime):
>+        (foo.html.TransitionEvent.prototype.get propertyName):
>+        (foo.html.TransitionEvent.prototype.get pseudoElement):
>+        (foo.html.TransitionEvent):
>+        (foo.html.TreeWalker.new):
>+        (foo.html.TreeWalker.prototype.get currentNode):
>+        (foo.html.TreeWalker.prototype.set currentNode):
>+        (foo.html.TreeWalker.prototype.get filter):
>+        (foo.html.TreeWalker.prototype.get root):
>+        (foo.html.TreeWalker.prototype.get whatToShow):
>+        (foo.html.TreeWalker.prototype.firstChild):
>+        (foo.html.TreeWalker.prototype.lastChild):
>+        (foo.html.TreeWalker.prototype.nextNode):
>+        (foo.html.TreeWalker.prototype.nextSibling):
>+        (foo.html.TreeWalker.prototype.parentNode):
>+        (foo.html.TreeWalker.prototype.previousNode):
>+        (foo.html.TreeWalker.prototype.previousSibling):
>+        (foo.html.TreeWalker):
>+        (foo.html.TrustedHtml):
>+        (foo.html.TrustedScriptUrl):
>+        (foo.html.TrustedUrl):
>+        (foo.html.UListElement.new):
>+        (foo.html.UListElement):
>+        (foo.html.UnderlyingSourceBase.prototype.cancel):
>+        (foo.html.UnderlyingSourceBase.prototype.notifyLockAcquired):
>+        (foo.html.UnderlyingSourceBase.prototype.notifyLockReleased):
>+        (foo.html.UnderlyingSourceBase.prototype.pull):
>+        (foo.html.UnderlyingSourceBase.prototype.start):
>+        (foo.html.UnderlyingSourceBase):
>+        (foo.html.UnknownElement):
>+        (foo.html.Url.createObjectUrl):
>+        (foo.html.Url.createObjectUrlFromSource):
>+        (foo.html.Url.createObjectUrlFromStream):
>+        (foo.html.Url.createObjectUrlFromBlob):
>+        (foo.html.Url.revokeObjectUrl):
>+        (foo.html.Url.prototype.toString):
>+        (foo.html.Url.prototype.get hash):
>+        (foo.html.Url.prototype.set hash):
>+        (foo.html.Url.prototype.get host):
>+        (foo.html.Url.prototype.set host):
>+        (foo.html.Url.prototype.get hostname):
>+        (foo.html.Url.prototype.set hostname):
>+        (foo.html.Url.prototype.get href):
>+        (foo.html.Url.prototype.set href):
>+        (foo.html.Url.prototype.get origin):
>+        (foo.html.Url.prototype.get password):
>+        (foo.html.Url.prototype.set password):
>+        (foo.html.Url.prototype.get pathname):
>+        (foo.html.Url.prototype.set pathname):
>+        (foo.html.Url.prototype.get port):
>+        (foo.html.Url.prototype.set port):
>+        (foo.html.Url.prototype.get protocol):
>+        (foo.html.Url.prototype.set protocol):
>+        (foo.html.Url.prototype.get search):
>+        (foo.html.Url.prototype.set search):
>+        (foo.html.Url.prototype.get searchParams):
>+        (foo.html.Url.prototype.get username):
>+        (foo.html.Url.prototype.set username):
>+        (foo.html.Url):
>+        (foo.html.UrlSearchParams.new):
>+        (foo.html.UrlSearchParams._create_1):
>+        (foo.html.UrlSearchParams._create_2):
>+        (foo.html.UrlSearchParams.prototype.append):
>+        (foo.html.UrlSearchParams.prototype.delete):
>+        (foo.html.UrlUtilsReadOnly.prototype.get hash):
>+        (foo.html.UrlUtilsReadOnly.prototype.set hash):
>+        (foo.html.UrlUtilsReadOnly.prototype.get host):
>+        (foo.html.UrlUtilsReadOnly.prototype.set host):
>+        (foo.html.UrlUtilsReadOnly.prototype.get hostname):
>+        (foo.html.UrlUtilsReadOnly.prototype.set hostname):
>+        (foo.html.UrlUtilsReadOnly.prototype.get href):
>+        (foo.html.UrlUtilsReadOnly.prototype.set href):
>+        (foo.html.UrlUtilsReadOnly.prototype.get origin):
>+        (foo.html.UrlUtilsReadOnly.prototype.set origin):
>+        (foo.html.UrlUtilsReadOnly.prototype.get pathname):
>+        (foo.html.UrlUtilsReadOnly.prototype.set pathname):
>+        (foo.html.UrlUtilsReadOnly.prototype.get port):
>+        (foo.html.UrlUtilsReadOnly.prototype.set port):
>+        (foo.html.UrlUtilsReadOnly.prototype.get protocol):
>+        (foo.html.UrlUtilsReadOnly.prototype.set protocol):
>+        (foo.html.UrlUtilsReadOnly.prototype.get search):
>+        (foo.html.UrlUtilsReadOnly.prototype.set search):
>+        (foo.html.UrlUtilsReadOnly):
>+        (foo.html.VR.prototype.getDevices):
>+        (foo.html.VR):
>+        (foo.html.VRCoordinateSystem.prototype.getTransformTo):
>+        (foo.html.VRCoordinateSystem):
>+        (foo.html.VRDevice.prototype.get deviceName):
>+        (foo.html.VRDevice.prototype.get isExternal):
>+        (foo.html.VRDevice.prototype.requestSession):
>+        (foo.html.VRDevice.prototype.supportsSession):
>+        (foo.html.VRDevice):
>+        (foo.html.VRDeviceEvent.new):
>+        (foo.html.VRDeviceEvent._create_1):
>+        (foo.html.VRDeviceEvent.prototype.get device):
>+        (foo.html.VRDeviceEvent):
>+        (foo.html.VRDisplay.prototype.get capabilities):
>+        (foo.html.VRDisplay.prototype.get depthFar):
>+        (foo.html.VRDisplay.prototype.set depthFar):
>+        (foo.html.VRDisplay.prototype.get depthNear):
>+        (foo.html.VRDisplay.prototype.set depthNear):
>+        (foo.html.VRDisplay.prototype.get displayId):
>+        (foo.html.VRDisplay.prototype.get displayName):
>+        (foo.html.VRDisplay.prototype.get isPresenting):
>+        (foo.html.VRDisplay.prototype.get stageParameters):
>+        (foo.html.VRDisplay.prototype.cancelAnimationFrame):
>+        (foo.html.VRDisplay.prototype.exitPresent):
>+        (foo.html.VRDisplay.prototype.getEyeParameters):
>+        (foo.html.VRDisplay.prototype.getFrameData):
>+        (foo.html.VRDisplay.prototype.getLayers):
>+        (foo.html.VRDisplay.prototype.requestAnimationFrame):
>+        (foo.html.VRDisplay.prototype.requestPresent):
>+        (foo.html.VRDisplay.prototype.submitFrame):
>+        (foo.html.VRDisplay):
>+        (foo.html.VRDisplayCapabilities.prototype.get canPresent):
>+        (foo.html.VRDisplayCapabilities.prototype.get hasExternalDisplay):
>+        (foo.html.VRDisplayCapabilities.prototype.get hasPosition):
>+        (foo.html.VRDisplayCapabilities.prototype.get maxLayers):
>+        (foo.html.VRDisplayCapabilities):
>+        (foo.html.VRDisplayEvent.new):
>+        (foo.html.VRDisplayEvent._create_1):
>+        (foo.html.VRDisplayEvent._create_2):
>+        (foo.html.VRDisplayEvent.prototype.get display):
>+        (foo.html.VRDisplayEvent.prototype.get reason):
>+        (foo.html.VRDisplayEvent):
>+        (foo.html.VREyeParameters.prototype.get offset):
>+        (foo.html.VREyeParameters.prototype.get renderHeight):
>+        (foo.html.VREyeParameters.prototype.get renderWidth):
>+        (foo.html.VREyeParameters):
>+        (foo.html.VRFrameData.new):
>+        (foo.html.VRFrameData._create_1):
>+        (foo.html.VRFrameData.prototype.get leftProjectionMatrix):
>+        (foo.html.VRFrameData.prototype.get leftViewMatrix):
>+        (foo.html.VRFrameData.prototype.get pose):
>+        (foo.html.VRFrameData.prototype.get rightProjectionMatrix):
>+        (foo.html.VRFrameData.prototype.get rightViewMatrix):
>+        (foo.html.VRFrameData):
>+        (foo.html.VRFrameOfReference.prototype.get bounds):
>+        (foo.html.VRFrameOfReference.prototype.get emulatedHeight):
>+        (foo.html.VRFrameOfReference):
>+        (foo.html.VRPose.prototype.get angularAcceleration):
>+        (foo.html.VRPose.prototype.get angularVelocity):
>+        (foo.html.VRPose.prototype.get linearAcceleration):
>+        (foo.html.VRPose.prototype.get linearVelocity):
>+        (foo.html.VRPose.prototype.get orientation):
>+        (foo.html.VRPose.prototype.get position):
>+        (foo.html.VRPose):
>+        (foo.html.VRSession.prototype.get depthFar):
>+        (foo.html.VRSession.prototype.set depthFar):
>+        (foo.html.VRSession.prototype.get depthNear):
>+        (foo.html.VRSession.prototype.set depthNear):
>+        (foo.html.VRSession.prototype.get device):
>+        (foo.html.VRSession.prototype.get exclusive):
>+        (foo.html.VRSession.prototype.end):
>+        (foo.html.VRSession.prototype.requestFrameOfReference):
>+        (foo.html.VRSession.prototype.get onBlur):
>+        (foo.html.VRSession.prototype.get onFocus):
>+        (foo.html.VRSession):
>+        (foo.html.VRSessionEvent.new):
>+        (foo.html.VRSessionEvent._create_1):
>+        (foo.html.VRSessionEvent.prototype.get session):
>+        (foo.html.VRSessionEvent):
>+        (foo.html.VRStageBounds.prototype.get geometry):
>+        (foo.html.VRStageBounds):
>+        (foo.html.VRStageBoundsPoint.prototype.get x):
>+        (foo.html.VRStageBoundsPoint.prototype.get z):
>+        (foo.html.VRStageBoundsPoint):
>+        (foo.html.VRStageParameters.prototype.get sittingToStandingTransform):
>+        (foo.html.VRStageParameters.prototype.get sizeX):
>+        (foo.html.VRStageParameters.prototype.get sizeZ):
>+        (foo.html.VRStageParameters):
>+        (foo.html.ValidityState.prototype.get badInput):
>+        (foo.html.ValidityState.prototype.get customError):
>+        (foo.html.ValidityState.prototype.get patternMismatch):
>+        (foo.html.ValidityState.prototype.get rangeOverflow):
>+        (foo.html.ValidityState.prototype.get rangeUnderflow):
>+        (foo.html.ValidityState.prototype.get stepMismatch):
>+        (foo.html.ValidityState.prototype.get tooLong):
>+        (foo.html.ValidityState.prototype.get tooShort):
>+        (foo.html.ValidityState.prototype.get typeMismatch):
>+        (foo.html.ValidityState.prototype.get valid):
>+        (foo.html.ValidityState.prototype.get valueMissing):
>+        (foo.html.ValidityState):
>+        (foo.html.VideoElement.new):
>+        (foo.html.VideoElement.prototype.get height):
>+        (foo.html.VideoElement.prototype.set height):
>+        (foo.html.VideoElement.prototype.get poster):
>+        (foo.html.VideoElement.prototype.set poster):
>+        (foo.html.VideoElement.prototype.get videoHeight):
>+        (foo.html.VideoElement.prototype.get videoWidth):
>+        (foo.html.VideoElement.prototype.get decodedFrameCount):
>+        (foo.html.VideoElement.prototype.get droppedFrameCount):
>+        (foo.html.VideoElement.prototype.get width):
>+        (foo.html.VideoElement.prototype.set width):
>+        (foo.html.VideoElement.prototype.getVideoPlaybackQuality):
>+        (foo.html.VideoElement.prototype.enterFullscreen):
>+        (foo.html.VideoElement.prototype.exitFullscreen):
>+        (foo.html.VideoElement):
>+        (foo.html.VideoPlaybackQuality.prototype.get corruptedVideoFrames):
>+        (foo.html.VideoPlaybackQuality.prototype.get creationTime):
>+        (foo.html.VideoPlaybackQuality.prototype.get droppedVideoFrames):
>+        (foo.html.VideoPlaybackQuality.prototype.get totalVideoFrames):
>+        (foo.html.VideoPlaybackQuality):
>+        (foo.html.VideoTrack.prototype.get id):
>+        (foo.html.VideoTrack.prototype.get kind):
>+        (foo.html.VideoTrack.prototype.get label):
>+        (foo.html.VideoTrack.prototype.get language):
>+        (foo.html.VideoTrack.prototype.get selected):
>+        (foo.html.VideoTrack.prototype.set selected):
>+        (foo.html.VideoTrack.prototype.get sourceBuffer):
>+        (foo.html.VideoTrack):
>+        (foo.html.VideoTrackList.prototype.get length):
>+        (foo.html.VideoTrackList.prototype.get selectedIndex):
>+        (foo.html.VideoTrackList.prototype.__getter__):
>+        (foo.html.VideoTrackList.prototype.getTrackById):
>+        (foo.html.VideoTrackList.prototype.get onChange):
>+        (foo.html.VideoTrackList):
>+        (foo.html.VisualViewport.prototype.get height):
>+        (foo.html.VisualViewport.prototype.get offsetLeft):
>+        (foo.html.VisualViewport.prototype.get offsetTop):
>+        (foo.html.VisualViewport.prototype.get pageLeft):
>+        (foo.html.VisualViewport.prototype.get pageTop):
>+        (foo.html.VisualViewport.prototype.get scale):
>+        (foo.html.VisualViewport.prototype.get width):
>+        (foo.html.VisualViewport.prototype.get onResize):
>+        (foo.html.VisualViewport.prototype.get onScroll):
>+        (foo.html.VisualViewport):
>+        (foo.html.VttCue.new):
>+        (foo.html.VttCue._create_1):
>+        (foo.html.VttCue.prototype.get align):
>+        (foo.html.VttCue.prototype.set align):
>+        (foo.html.VttCue.prototype.get line):
>+        (foo.html.VttCue.prototype.set line):
>+        (foo.html.VttCue.prototype.get position):
>+        (foo.html.VttCue.prototype.set position):
>+        (foo.html.VttCue.prototype.get region):
>+        (foo.html.VttCue.prototype.set region):
>+        (foo.html.VttCue.prototype.get size):
>+        (foo.html.VttCue.prototype.set size):
>+        (foo.html.VttCue.prototype.get snapToLines):
>+        (foo.html.VttCue.prototype.set snapToLines):
>+        (foo.html.VttCue.prototype.get text):
>+        (foo.html.VttCue.prototype.set text):
>+        (foo.html.VttCue.prototype.get vertical):
>+        (foo.html.VttCue.prototype.set vertical):
>+        (foo.html.VttCue.prototype.getCueAsHtml):
>+        (foo.html.VttCue):
>+        (foo.html.VttRegion.new):
>+        (foo.html.VttRegion._create_1):
>+        (foo.html.VttRegion.prototype.get id):
>+        (foo.html.VttRegion.prototype.set id):
>+        (foo.html.VttRegion.prototype.get lines):
>+        (foo.html.VttRegion.prototype.set lines):
>+        (foo.html.VttRegion.prototype.get regionAnchorX):
>+        (foo.html.VttRegion.prototype.set regionAnchorX):
>+        (foo.html.VttRegion.prototype.get regionAnchorY):
>+        (foo.html.VttRegion.prototype.set regionAnchorY):
>+        (foo.html.VttRegion.prototype.get scroll):
>+        (foo.html.VttRegion.prototype.set scroll):
>+        (foo.html.VttRegion.prototype.get viewportAnchorX):
>+        (foo.html.VttRegion.prototype.set viewportAnchorX):
>+        (foo.html.VttRegion.prototype.get viewportAnchorY):
>+        (foo.html.VttRegion.prototype.set viewportAnchorY):
>+        (foo.html.VttRegion.prototype.get width):
>+        (foo.html.VttRegion.prototype.set width):
>+        (foo.html.VttRegion):
>+        (foo.html.WebSocket.new):
>+        (foo.html.WebSocket._create_1):
>+        (foo.html.WebSocket._create_2):
>+        (foo.html.WebSocket.get supported):
>+        (foo.html.WebSocket.prototype.get binaryType):
>+        (foo.html.WebSocket.prototype.set binaryType):
>+        (foo.html.WebSocket.prototype.get bufferedAmount):
>+        (foo.html.WebSocket.prototype.get extensions):
>+        (foo.html.WebSocket.prototype.get protocol):
>+        (foo.html.WebSocket.prototype.get readyState):
>+        (foo.html.WebSocket.prototype.get url):
>+        (foo.html.WebSocket.prototype.close):
>+        (foo.html.WebSocket.prototype.send):
>+        (foo.html.WebSocket.prototype.sendBlob):
>+        (foo.html.WebSocket.prototype.sendByteBuffer):
>+        (foo.html.WebSocket.prototype.sendString):
>+        (foo.html.WebSocket.prototype.sendTypedData):
>+        (foo.html.WebSocket.prototype.get onClose):
>+        (foo.html.WebSocket.prototype.get onError):
>+        (foo.html.WebSocket.prototype.get onMessage):
>+        (foo.html.WebSocket.prototype.get onOpen):
>+        (foo.html.WebSocket):
>+        (foo.html.WheelEvent.new):
>+        (foo.html.WheelEvent.__):
>+        (foo.html.WheelEvent._create_1):
>+        (foo.html.WheelEvent._create_2):
>+        (foo.html.WheelEvent.prototype.get _deltaX):
>+        (foo.html.WheelEvent.prototype.get _deltaY):
>+        (foo.html.WheelEvent.prototype.get deltaZ):
>+        (foo.html.WheelEvent.prototype.get deltaY):
>+        (foo.html.WheelEvent.prototype.get deltaX):
>+        (foo.html.WheelEvent.prototype.get deltaMode):
>+        (foo.html.WheelEvent.prototype.get _wheelDelta):
>+        (foo.html.WheelEvent.prototype.get _wheelDeltaX):
>+        (foo.html.WheelEvent.prototype.get _detail):
>+        (foo.html.WheelEvent.prototype.get _hasInitMouseScrollEvent):
>+        (foo.html.WheelEvent.prototype._initMouseScrollEvent):
>+        (foo.html.WheelEvent.prototype.get _hasInitWheelEvent):
>+        (foo.html.WheelEvent.prototype._initWheelEvent):
>+        (foo.html.WheelEvent):
>+        (foo.html.Window.prototype.get animationFrame):
>+        (foo.html.Window.prototype.get document):
>+        (foo.html.Window.prototype._open2):
>+        (foo.html.Window.prototype._open3):
>+        (foo.html.Window.prototype.open):
>+        (foo.html.Window.prototype.get location):
>+        (foo.html.Window.prototype.set location):
>+        (foo.html.Window.prototype.get _location):
>+        (foo.html.Window.prototype.set _location):
>+        (foo.html.Window.prototype.requestAnimationFrame):
>+        (foo.html.Window.prototype.cancelAnimationFrame):
>+        (foo.html.Window.prototype._requestAnimationFrame):
>+        (foo.html.Window.prototype._cancelAnimationFrame):
>+        (foo.html.Window.prototype._ensureRequestAnimationFrame.):
>+        (foo.html.Window.prototype._ensureRequestAnimationFrame):
>+        (foo.html.Window.prototype.get indexedDB):
>+        (foo.html.Window.prototype.get console):
>+        (foo.html.Window.prototype.requestFileSystem):
>+        (foo.html.Window.get supportsPointConversions):
>+        (foo.html.Window.prototype.get animationWorklet):
>+        (foo.html.Window.prototype.get applicationCache):
>+        (foo.html.Window.prototype.get audioWorklet):
>+        (foo.html.Window.prototype.get caches):
>+        (foo.html.Window.prototype.get closed):
>+        (foo.html.Window.prototype.get cookieStore):
>+        (foo.html.Window.prototype.get crypto):
>+        (foo.html.Window.prototype.get customElements):
>+        (foo.html.Window.prototype.get defaultStatus):
>+        (foo.html.Window.prototype.set defaultStatus):
>+        (foo.html.Window.prototype.get defaultstatus):
>+        (foo.html.Window.prototype.set defaultstatus):
>+        (foo.html.Window.prototype.get devicePixelRatio):
>+        (foo.html.Window.prototype.get external):
>+        (foo.html.Window.prototype.get history):
>+        (foo.html.Window.prototype.get innerHeight):
>+        (foo.html.Window.prototype.get innerWidth):
>+        (foo.html.Window.prototype.get isSecureContext):
>+        (foo.html.Window.prototype.get localStorage):
>+        (foo.html.Window.prototype.get locationbar):
>+        (foo.html.Window.prototype.get menubar):
>+        (foo.html.Window.prototype.get name):
>+        (foo.html.Window.prototype.set name):
>+        (foo.html.Window.prototype.get navigator):
>+        (foo.html.Window.prototype.get offscreenBuffering):
>+        (foo.html.Window.prototype.get opener):
>+        (foo.html.Window.prototype.get _get_opener):
>+        (foo.html.Window.prototype.set opener):
>+        (foo.html.Window.prototype.get orientation):
>+        (foo.html.Window.prototype.get origin):
>+        (foo.html.Window.prototype.get outerHeight):
>+        (foo.html.Window.prototype.get outerWidth):
>+        (foo.html.Window.prototype.get _pageXOffset):
>+        (foo.html.Window.prototype.get _pageYOffset):
>+        (foo.html.Window.prototype.get parent):
>+        (foo.html.Window.prototype.get _get_parent):
>+        (foo.html.Window.prototype.get performance):
>+        (foo.html.Window.prototype.get screen):
>+        (foo.html.Window.prototype.get screenLeft):
>+        (foo.html.Window.prototype.get screenTop):
>+        (foo.html.Window.prototype.get screenX):
>+        (foo.html.Window.prototype.get screenY):
>+        (foo.html.Window.prototype.get scrollbars):
>+        (foo.html.Window.prototype.get self):
>+        (foo.html.Window.prototype.get _get_self):
>+        (foo.html.Window.prototype.get sessionStorage):
>+        (foo.html.Window.prototype.get speechSynthesis):
>+        (foo.html.Window.prototype.get status):
>+        (foo.html.Window.prototype.set status):
>+        (foo.html.Window.prototype.get statusbar):
>+        (foo.html.Window.prototype.get styleMedia):
>+        (foo.html.Window.prototype.get toolbar):
>+        (foo.html.Window.prototype.get top):
>+        (foo.html.Window.prototype.get _get_top):
>+        (foo.html.Window.prototype.get visualViewport):
>+        (foo.html.Window.prototype.get window):
>+        (foo.html.Window.prototype.get _get_window):
>+        (foo.html.Window.prototype.__getter__):
>+        (foo.html.Window.prototype.__getter___1):
>+        (foo.html.Window.prototype.__getter___2):
>+        (foo.html.Window.prototype.alert):
>+        (foo.html.Window.prototype.cancelIdleCallback):
>+        (foo.html.Window.prototype.close):
>+        (foo.html.Window.prototype.confirm):
>+        (foo.html.Window.prototype.fetch):
>+        (foo.html.Window.prototype.find):
>+        (foo.html.Window.prototype._getComputedStyle):
>+        (foo.html.Window.prototype.getComputedStyleMap):
>+        (foo.html.Window.prototype.getMatchedCssRules):
>+        (foo.html.Window.prototype.getSelection):
>+        (foo.html.Window.prototype.matchMedia):
>+        (foo.html.Window.prototype.moveBy):
>+        (foo.html.Window.prototype._moveTo):
>+        (foo.html.Window.prototype._openDatabase):
>+        (foo.html.Window.prototype.postMessage):
>+        (foo.html.Window.prototype._postMessage_1):
>+        (foo.html.Window.prototype._postMessage_2):
>+        (foo.html.Window.prototype.print):
>+        (foo.html.Window.prototype.requestIdleCallback):
>+        (foo.html.Window.prototype._requestIdleCallback_1):
>+        (foo.html.Window.prototype._requestIdleCallback_2):
>+        (foo.html.Window.prototype.resizeBy):
>+        (foo.html.Window.prototype.resizeTo):
>+        (foo.html.Window.prototype.scroll):
>+        (foo.html.Window.prototype._scroll_1):
>+        (foo.html.Window.prototype._scroll_2):
>+        (foo.html.Window.prototype._scroll_3):
>+        (foo.html.Window.prototype._scroll_4):
>+        (foo.html.Window.prototype._scroll_5):
>+        (foo.html.Window.prototype.scrollBy):
>+        (foo.html.Window.prototype._scrollBy_1):
>+        (foo.html.Window.prototype._scrollBy_2):
>+        (foo.html.Window.prototype._scrollBy_3):
>+        (foo.html.Window.prototype._scrollBy_4):
>+        (foo.html.Window.prototype._scrollBy_5):
>+        (foo.html.Window.prototype.scrollTo):
>+        (foo.html.Window.prototype._scrollTo_1):
>+        (foo.html.Window.prototype._scrollTo_2):
>+        (foo.html.Window.prototype._scrollTo_3):
>+        (foo.html.Window.prototype._scrollTo_4):
>+        (foo.html.Window.prototype._scrollTo_5):
>+        (foo.html.Window.prototype.stop):
>+        (foo.html.Window.prototype.__requestFileSystem):
>+        (foo.html.Window.prototype._requestFileSystem):
>+        (foo.html.Window.prototype._resolveLocalFileSystemUrl):
>+        (foo.html.Window.prototype.resolveLocalFileSystemUrl):
>+        (foo.html.Window.prototype.atob):
>+        (foo.html.Window.prototype.btoa):
>+        (foo.html.Window.prototype._setInterval_String):
>+        (foo.html.Window.prototype._setTimeout_String):
>+        (foo.html.Window.prototype._clearInterval):
>+        (foo.html.Window.prototype._clearTimeout):
>+        (foo.html.Window.prototype._setInterval):
>+        (foo.html.Window.prototype._setTimeout):
>+        (foo.html.Window.prototype.get onContentLoaded):
>+        (foo.html.Window.prototype.get onAbort):
>+        (foo.html.Window.prototype.get onBlur):
>+        (foo.html.Window.prototype.get onCanPlay):
>+        (foo.html.Window.prototype.get onCanPlayThrough):
>+        (foo.html.Window.prototype.get onChange):
>+        (foo.html.Window.prototype.get onClick):
>+        (foo.html.Window.prototype.get onContextMenu):
>+        (foo.html.Window.prototype.get onDoubleClick):
>+        (foo.html.Window.prototype.get onDeviceMotion):
>+        (foo.html.Window.prototype.get onDeviceOrientation):
>+        (foo.html.Window.prototype.get onDrag):
>+        (foo.html.Window.prototype.get onDragEnd):
>+        (foo.html.Window.prototype.get onDragEnter):
>+        (foo.html.Window.prototype.get onDragLeave):
>+        (foo.html.Window.prototype.get onDragOver):
>+        (foo.html.Window.prototype.get onDragStart):
>+        (foo.html.Window.prototype.get onDrop):
>+        (foo.html.Window.prototype.get onDurationChange):
>+        (foo.html.Window.prototype.get onEmptied):
>+        (foo.html.Window.prototype.get onEnded):
>+        (foo.html.Window.prototype.get onError):
>+        (foo.html.Window.prototype.get onFocus):
>+        (foo.html.Window.prototype.get onHashChange):
>+        (foo.html.Window.prototype.get onInput):
>+        (foo.html.Window.prototype.get onInvalid):
>+        (foo.html.Window.prototype.get onKeyDown):
>+        (foo.html.Window.prototype.get onKeyPress):
>+        (foo.html.Window.prototype.get onKeyUp):
>+        (foo.html.Window.prototype.get onLoad):
>+        (foo.html.Window.prototype.get onLoadedData):
>+        (foo.html.Window.prototype.get onLoadedMetadata):
>+        (foo.html.Window.prototype.get onLoadStart):
>+        (foo.html.Window.prototype.get onMessage):
>+        (foo.html.Window.prototype.get onMouseDown):
>+        (foo.html.Window.prototype.get onMouseEnter):
>+        (foo.html.Window.prototype.get onMouseLeave):
>+        (foo.html.Window.prototype.get onMouseMove):
>+        (foo.html.Window.prototype.get onMouseOut):
>+        (foo.html.Window.prototype.get onMouseOver):
>+        (foo.html.Window.prototype.get onMouseUp):
>+        (foo.html.Window.prototype.get onMouseWheel):
>+        (foo.html.Window.prototype.get onOffline):
>+        (foo.html.Window.prototype.get onOnline):
>+        (foo.html.Window.prototype.get onPageHide):
>+        (foo.html.Window.prototype.get onPageShow):
>+        (foo.html.Window.prototype.get onPause):
>+        (foo.html.Window.prototype.get onPlay):
>+        (foo.html.Window.prototype.get onPlaying):
>+        (foo.html.Window.prototype.get onPopState):
>+        (foo.html.Window.prototype.get onProgress):
>+        (foo.html.Window.prototype.get onRateChange):
>+        (foo.html.Window.prototype.get onReset):
>+        (foo.html.Window.prototype.get onResize):
>+        (foo.html.Window.prototype.get onScroll):
>+        (foo.html.Window.prototype.get onSearch):
>+        (foo.html.Window.prototype.get onSeeked):
>+        (foo.html.Window.prototype.get onSeeking):
>+        (foo.html.Window.prototype.get onSelect):
>+        (foo.html.Window.prototype.get onStalled):
>+        (foo.html.Window.prototype.get onStorage):
>+        (foo.html.Window.prototype.get onSubmit):
>+        (foo.html.Window.prototype.get onSuspend):
>+        (foo.html.Window.prototype.get onTimeUpdate):
>+        (foo.html.Window.prototype.get onTouchCancel):
>+        (foo.html.Window.prototype.get onTouchEnd):
>+        (foo.html.Window.prototype.get onTouchMove):
>+        (foo.html.Window.prototype.get onTouchStart):
>+        (foo.html.Window.prototype.get onTransitionEnd):
>+        (foo.html.Window.prototype.get onUnload):
>+        (foo.html.Window.prototype.get onVolumeChange):
>+        (foo.html.Window.prototype.get onWaiting):
>+        (foo.html.Window.prototype.get onAnimationEnd):
>+        (foo.html.Window.prototype.get onAnimationIteration):
>+        (foo.html.Window.prototype.get onAnimationStart):
>+        (foo.html.Window.prototype.get onBeforeUnload):
>+        (foo.html.Window.prototype.get onWheel):
>+        (foo.html.Window.prototype.moveTo):
>+        (foo.html.Window.prototype.openDatabase):
>+        (foo.html.Window.prototype.get pageXOffset):
>+        (foo.html.Window.prototype.get pageYOffset):
>+        (foo.html.Window.prototype.get scrollX):
>+        (foo.html.Window.prototype.get scrollY):
>+        (foo.html.Window):
>+        (foo.html._WrappedEvent.prototype.get wrapped):
>+        (foo.html._WrappedEvent.prototype.set wrapped):
>+        (foo.html._WrappedEvent.prototype.get bubbles):
>+        (foo.html._WrappedEvent.prototype.get cancelable):
>+        (foo.html._WrappedEvent.prototype.get composed):
>+        (foo.html._WrappedEvent.prototype.get currentTarget):
>+        (foo.html._WrappedEvent.prototype.get defaultPrevented):
>+        (foo.html._WrappedEvent.prototype.get eventPhase):
>+        (foo.html._WrappedEvent.prototype.get isTrusted):
>+        (foo.html._WrappedEvent.prototype.get target):
>+        (foo.html._WrappedEvent.prototype.get timeStamp):
>+        (foo.html._WrappedEvent.prototype.get type):
>+        (foo.html._WrappedEvent.prototype._initEvent):
>+        (foo.html._WrappedEvent.prototype.preventDefault):
>+        (foo.html._WrappedEvent.prototype.stopImmediatePropagation):
>+        (foo.html._WrappedEvent.prototype.stopPropagation):
>+        (foo.html._WrappedEvent.prototype.composedPath):
>+        (foo.html._WrappedEvent.prototype.get matchingTarget):
>+        (foo.html._WrappedEvent.prototype.get path):
>+        (foo.html._WrappedEvent.prototype.get _get_currentTarget):
>+        (foo.html._WrappedEvent.prototype.get _get_target):
>+        (foo.html._WrappedEvent):
>+        (foo.html._BeforeUnloadEvent.prototype.get returnValue):
>+        (foo.html._BeforeUnloadEvent.prototype.set returnValue):
>+        (foo.html._BeforeUnloadEvent):
>+        (foo.html._BeforeUnloadEventStreamProvider.prototype.forTarget):
>+        (foo.html._BeforeUnloadEventStreamProvider.prototype.getEventType):
>+        (foo.html._BeforeUnloadEventStreamProvider.prototype.forElement):
>+        (foo.html._BeforeUnloadEventStreamProvider.prototype._forElementList):
>+        (foo.html._BeforeUnloadEventStreamProvider):
>+        (foo.html.WindowBase64):
>+        (foo.html.WindowClient.prototype.get focused):
>+        (foo.html.WindowClient.prototype.get visibilityState):
>+        (foo.html.WindowClient.prototype.focus):
>+        (foo.html.WindowClient.prototype.navigate):
>+        (foo.html.WindowClient):
>+        (foo.html.WindowEventHandlers.prototype.get onHashChange):
>+        (foo.html.WindowEventHandlers.prototype.get onMessage):
>+        (foo.html.WindowEventHandlers.prototype.get onOffline):
>+        (foo.html.WindowEventHandlers.prototype.get onOnline):
>+        (foo.html.WindowEventHandlers.prototype.get onPopState):
>+        (foo.html.WindowEventHandlers.prototype.get onStorage):
>+        (foo.html.WindowEventHandlers.prototype.get onUnload):
>+        (foo.html.WindowEventHandlers):
>+        (foo.get html.Worker.new):
>+        (foo.get html.Worker._create_1):
>+        (foo.get html.Worker.get supported):
>+        (foo.get html.Worker.prototype.postMessage):
>+        (foo.get html.Worker.prototype._postMessage_1):
>+        (foo.get html.Worker.prototype._postMessage_2):
>+        (foo.get html.Worker.prototype.terminate):
>+        (foo.get html.Worker.prototype.get onError):
>+        (foo.get html.Worker.prototype.get onMessage):
>+        (foo.get html.Worker):
>+        (foo.html.WorkerPerformance.prototype.get memory):
>+        (foo.html.WorkerPerformance.prototype.get timeOrigin):
>+        (foo.html.WorkerPerformance.prototype.clearMarks):
>+        (foo.html.WorkerPerformance.prototype.clearMeasures):
>+        (foo.html.WorkerPerformance.prototype.clearResourceTimings):
>+        (foo.html.WorkerPerformance.prototype.getEntries):
>+        (foo.html.WorkerPerformance.prototype.getEntriesByName):
>+        (foo.html.WorkerPerformance.prototype.getEntriesByType):
>+        (foo.html.WorkerPerformance.prototype.mark):
>+        (foo.html.WorkerPerformance.prototype.measure):
>+        (foo.html.WorkerPerformance.prototype.now):
>+        (foo.html.WorkerPerformance.prototype.setResourceTimingBufferSize):
>+        (foo.html.WorkerPerformance):
>+        (foo.html.WorkletAnimation.new):
>+        (foo.html.WorkletAnimation._create_1):
>+        (foo.html.WorkletAnimation.prototype.get playState):
>+        (foo.html.WorkletAnimation.prototype.cancel):
>+        (foo.html.WorkletAnimation.prototype.play):
>+        (foo.html.WorkletAnimation):
>+        (foo.html.XPathEvaluator.new):
>+        (foo.html.XPathEvaluator._create_1):
>+        (foo.html.XPathEvaluator.prototype.createExpression):
>+        (foo.html.XPathEvaluator.prototype.createNSResolver):
>+        (foo.html.XPathEvaluator.prototype.evaluate):
>+        (foo.html.XPathEvaluator):
>+        (foo.html.XPathExpression.prototype.evaluate):
>+        (foo.html.XPathExpression):
>+        (foo.html.XPathNSResolver.prototype.lookupNamespaceUri):
>+        (foo.html.XPathNSResolver):
>+        (foo.html.XPathResult.prototype.get booleanValue):
>+        (foo.html.XPathResult.prototype.get invalidIteratorState):
>+        (foo.html.XPathResult.prototype.get numberValue):
>+        (foo.html.XPathResult.prototype.get resultType):
>+        (foo.html.XPathResult.prototype.get singleNodeValue):
>+        (foo.html.XPathResult.prototype.get snapshotLength):
>+        (foo.html.XPathResult.prototype.get stringValue):
>+        (foo.html.XPathResult.prototype.iterateNext):
>+        (foo.html.XPathResult.prototype.snapshotItem):
>+        (foo.html.XPathResult):
>+        (foo.html.XmlDocument):
>+        (foo.html.XmlSerializer.new):
>+        (foo.html.XmlSerializer._create_1):
>+        (foo.html.XmlSerializer.prototype.serializeToString):
>+        (foo.html.XmlSerializer):
>+        (foo.html.XsltProcessor.new):
>+        (foo.html.XsltProcessor._create_1):
>+        (foo.html.XsltProcessor.get supported):
>+        (foo.html.XsltProcessor.prototype.clearParameters):
>+        (foo.html.XsltProcessor.prototype.getParameter):
>+        (foo.html.XsltProcessor.prototype.importStylesheet):
>+        (foo.html.XsltProcessor.prototype.removeParameter):
>+        (foo.html.XsltProcessor.prototype.reset):
>+        (foo.html.XsltProcessor.prototype.setParameter):
>+        (foo.html.XsltProcessor.prototype.transformToDocument):
>+        (foo.html.XsltProcessor.prototype.transformToFragment):
>+        (foo.html.XsltProcessor):
>+        (foo.html._Attr.prototype.get _localName):
>+        (foo.html._Attr.prototype.get name):
>+        (foo.html._Attr.prototype.get _namespaceUri):
>+        (foo.html._Attr.prototype.get value):
>+        (foo.html._Attr.prototype.set value):
>+        (foo.html._Attr):
>+        (foo.html._Bluetooth):
>+        (foo.html._BluetoothCharacteristicProperties):
>+        (foo.html._BluetoothDevice):
>+        (foo.html._BluetoothRemoteGATTCharacteristic):
>+        (foo.html._BluetoothRemoteGATTServer):
>+        (foo.html._BluetoothRemoteGATTService):
>+        (foo.html._BluetoothUUID):
>+        (foo.html._BudgetService.prototype.getBudget):
>+        (foo.html._BudgetService.prototype.getCost):
>+        (foo.html._BudgetService.prototype.reserve):
>+        (foo.html._BudgetService):
>+        (foo.html._Cache):
>+        (foo.html._CanvasPath):
>+        (foo.html._Clipboard.prototype.read):
>+        (foo.html._Clipboard.prototype.readText):
>+        (foo.html._Clipboard.prototype.write):
>+        (foo.html._Clipboard.prototype.writeText):
>+        (foo.html._Clipboard):
>+        (foo.const.Interceptor_ListMixin.8):
>+        (foo.const.Interceptor_ImmutableListMixin.8):
>+        (foo.html._CssRuleList.prototype.get length):
>+        (foo.html._CssRuleList.prototype._get):
>+        (foo.html._CssRuleList.prototype._set):
>+        (foo.html._CssRuleList.prototype.set length):
>+        (foo.html._CssRuleList.prototype.get first):
>+        (foo.html._CssRuleList.prototype.set first):
>+        (foo.html._CssRuleList.prototype.get last):
>+        (foo.html._CssRuleList.prototype.set last):
>+        (foo.html._CssRuleList.prototype.get single):
>+        (foo.html._CssRuleList.prototype.elementAt):
>+        (foo.html._CssRuleList.prototype.item):
>+        (foo.html._CssRuleList):
>+        (foo.html._DOMFileSystemSync):
>+        (foo.html._EntrySync):
>+        (foo.html._DirectoryEntrySync):
>+        (foo.html._DirectoryReaderSync):
>+        (foo.html._DocumentType):
>+        (foo.html._DomRect.prototype.toString):
>+        (foo.html._DomRect.prototype._equals):
>+        (foo.html._DomRect.prototype.get hashCode):
>+        (foo.html._DomRect.prototype.intersection):
>+        (foo.html._DomRect.prototype.intersects):
>+        (foo.html._DomRect.prototype.boundingBox):
>+        (foo.html._DomRect.prototype.containsRectangle):
>+        (foo.html._DomRect.prototype.containsPoint):
>+        (foo.html._DomRect.prototype.get topLeft):
>+        (foo.html._DomRect.prototype.get topRight):
>+        (foo.html._DomRect.prototype.get bottomRight):
>+        (foo.html._DomRect.prototype.get bottomLeft):
>+        (foo.html._DomRect.new):
>+        (foo.html._DomRect._create_1):
>+        (foo.html._DomRect._create_2):
>+        (foo.html._DomRect._create_3):
>+        (foo.html._DomRect._create_4):
>+        (foo.html._DomRect._create_5):
>+        (foo.html._DomRect.prototype.get height):
>+        (foo.html._DomRect.prototype.set height):
>+        (foo.html._DomRect.prototype.get width):
>+        (foo.html._DomRect.prototype.set width):
>+        (foo.html._DomRect.prototype.get x):
>+        (foo.html._DomRect.prototype.set x):
>+        (foo.html._DomRect.prototype.get y):
>+        (foo.html._DomRect.prototype.set y):
>+        (foo.html._DomRect):
>+        (foo.html._JenkinsSmiHash.combine):
>+        (foo.html._JenkinsSmiHash.finish):
>+        (foo.html._JenkinsSmiHash.hash2):
>+        (foo.html._JenkinsSmiHash.hash4):
>+        (foo.html._JenkinsSmiHash):
>+        (foo.html._FileEntrySync):
>+        (foo.html._FileReaderSync.new):
>+        (foo.html._FileReaderSync._create_1):
>+        (foo.html._FileReaderSync):
>+        (foo.html._FileWriterSync):
>+        (foo.const.Interceptor_ListMixin.9):
>+        (foo.const.Interceptor_ImmutableListMixin.9):
>+        (foo.html._GamepadList.prototype.get length):
>+        (foo.html._GamepadList.prototype._get):
>+        (foo.html._GamepadList.prototype._set):
>+        (foo.html._GamepadList.prototype.set length):
>+        (foo.html._GamepadList.prototype.get first):
>+        (foo.html._GamepadList.prototype.set first):
>+        (foo.html._GamepadList.prototype.get last):
>+        (foo.html._GamepadList.prototype.set last):
>+        (foo.html._GamepadList.prototype.get single):
>+        (foo.html._GamepadList.prototype.elementAt):
>+        (foo.html._GamepadList.prototype.item):
>+        (foo.html._GamepadList):
>+        (foo.html._HTMLAllCollection.prototype._item):
>+        (foo.html._HTMLAllCollection):
>+        (foo.html._HTMLDirectoryElement):
>+        (foo.html._HTMLFontElement):
>+        (foo.html._HTMLFrameElement):
>+        (foo.html._HTMLFrameSetElement):
>+        (foo.html._HTMLMarqueeElement):
>+        (foo.html._Mojo):
>+        (foo.html._MojoHandle):
>+        (foo.html._MojoInterfaceInterceptor.new):
>+        (foo.html._MojoInterfaceInterceptor._create_1):
>+        (foo.html._MojoInterfaceInterceptor._create_2):
>+        (foo.html._MojoInterfaceInterceptor):
>+        (foo.html._MojoInterfaceRequestEvent.new):
>+        (foo.html._MojoInterfaceRequestEvent._create_1):
>+        (foo.html._MojoInterfaceRequestEvent._create_2):
>+        (foo.html._MojoInterfaceRequestEvent):
>+        (foo.html._MojoWatcher):
>+        (foo.html._NFC):
>+        (foo.const.Interceptor_ListMixin.10):
>+        (foo.const.Interceptor_ImmutableListMixin.10):
>+        (foo.html._NamedNodeMap.prototype.get length):
>+        (foo.html._NamedNodeMap.prototype._get):
>+        (foo.html._NamedNodeMap.prototype._set):
>+        (foo.html._NamedNodeMap.prototype.set length):
>+        (foo.html._NamedNodeMap.prototype.get first):
>+        (foo.html._NamedNodeMap.prototype.set first):
>+        (foo.html._NamedNodeMap.prototype.get last):
>+        (foo.html._NamedNodeMap.prototype.set last):
>+        (foo.html._NamedNodeMap.prototype.get single):
>+        (foo.html._NamedNodeMap.prototype.elementAt):
>+        (foo.html._NamedNodeMap.prototype.getNamedItem):
>+        (foo.html._NamedNodeMap.prototype.getNamedItemNS):
>+        (foo.html._NamedNodeMap.prototype.item):
>+        (foo.html._NamedNodeMap.prototype.removeNamedItem):
>+        (foo.html._NamedNodeMap.prototype.removeNamedItemNS):
>+        (foo.html._NamedNodeMap.prototype.setNamedItem):
>+        (foo.html._NamedNodeMap.prototype.setNamedItemNS):
>+        (foo.html._NamedNodeMap):
>+        (foo.html._PagePopupController):
>+        (foo.html._Report.prototype.get body):
>+        (foo.html._Report.prototype.get type):
>+        (foo.html._Report.prototype.get url):
>+        (foo.html._Report):
>+        (foo.html._Request.new):
>+        (foo.html._Request._create_1):
>+        (foo.html._Request._create_2):
>+        (foo.html._Request.prototype.get cache):
>+        (foo.html._Request.prototype.get credentials):
>+        (foo.html._Request.prototype.get headers):
>+        (foo.html._Request.prototype.get integrity):
>+        (foo.html._Request.prototype.get mode):
>+        (foo.html._Request.prototype.get redirect):
>+        (foo.html._Request.prototype.get referrer):
>+        (foo.html._Request.prototype.get referrerPolicy):
>+        (foo.html._Request.prototype.get url):
>+        (foo.html._Request.prototype.clone):
>+        (foo.html._Request):
>+        (foo.html._ResourceProgressEvent):
>+        (foo.html._Response.new):
>+        (foo.html._Response._create_1):
>+        (foo.html._Response._create_2):
>+        (foo.html._Response._create_3):
>+        (foo.html._Response):
>+        (foo.const.Interceptor_ListMixin.11):
>+        (foo.const.Interceptor_ImmutableListMixin.11):
>+        (foo.html._SpeechRecognitionResultList.prototype.get length):
>+        (foo.html._SpeechRecognitionResultList.prototype._get):
>+        (foo.html._SpeechRecognitionResultList.prototype._set):
>+        (foo.html._SpeechRecognitionResultList.prototype.set length):
>+        (foo.html._SpeechRecognitionResultList.prototype.get first):
>+        (foo.html._SpeechRecognitionResultList.prototype.set first):
>+        (foo.html._SpeechRecognitionResultList.prototype.get last):
>+        (foo.html._SpeechRecognitionResultList.prototype.set last):
>+        (foo.html._SpeechRecognitionResultList.prototype.get single):
>+        (foo.html._SpeechRecognitionResultList.prototype.elementAt):
>+        (foo.html._SpeechRecognitionResultList.prototype.item):
>+        (foo.html._SpeechRecognitionResultList):
>+        (foo.const.Interceptor_ListMixin.12):
>+        (foo.const.Interceptor_ImmutableListMixin.12):
>+        (foo.html._StyleSheetList.prototype.get length):
>+        (foo.html._StyleSheetList.prototype._get):
>+        (foo.html._StyleSheetList.prototype._set):
>+        (foo.html._StyleSheetList.prototype.set length):
>+        (foo.html._StyleSheetList.prototype.get first):
>+        (foo.html._StyleSheetList.prototype.set first):
>+        (foo.html._StyleSheetList.prototype.get last):
>+        (foo.html._StyleSheetList.prototype.set last):
>+        (foo.html._StyleSheetList.prototype.get single):
>+        (foo.html._StyleSheetList.prototype.elementAt):
>+        (foo.html._StyleSheetList.prototype.__getter__):
>+        (foo.html._StyleSheetList.prototype.item):
>+        (foo.html._StyleSheetList):
>+        (foo.html._SubtleCrypto):
>+        (foo.html._USB):
>+        (foo.html._USBAlternateInterface.new):
>+        (foo.html._USBAlternateInterface._create_1):
>+        (foo.html._USBAlternateInterface):
>+        (foo.html._USBConfiguration.new):
>+        (foo.html._USBConfiguration._create_1):
>+        (foo.html._USBConfiguration):
>+        (foo.html._USBConnectionEvent.new):
>+        (foo.html._USBConnectionEvent._create_1):
>+        (foo.html._USBConnectionEvent):
>+        (foo.html._USBDevice):
>+        (foo.html._USBEndpoint.new):
>+        (foo.html._USBEndpoint._create_1):
>+        (foo.html._USBEndpoint):
>+        (foo.html._USBInTransferResult.new):
>+        (foo.html._USBInTransferResult._create_1):
>+        (foo.html._USBInTransferResult._create_2):
>+        (foo.html._USBInTransferResult):
>+        (foo.html._USBInterface.new):
>+        (foo.html._USBInterface._create_1):
>+        (foo.html._USBInterface):
>+        (foo.html._USBIsochronousInTransferPacket.new):
>+        (foo.html._USBIsochronousInTransferPacket._create_1):
>+        (foo.html._USBIsochronousInTransferPacket._create_2):
>+        (foo.html._USBIsochronousInTransferPacket):
>+        (foo.html._USBIsochronousInTransferResult.new):
>+        (foo.html._USBIsochronousInTransferResult._create_1):
>+        (foo.html._USBIsochronousInTransferResult._create_2):
>+        (foo.html._USBIsochronousInTransferResult):
>+        (foo.html._USBIsochronousOutTransferPacket.new):
>+        (foo.html._USBIsochronousOutTransferPacket._create_1):
>+        (foo.html._USBIsochronousOutTransferPacket._create_2):
>+        (foo.html._USBIsochronousOutTransferPacket):
>+        (foo.html._USBIsochronousOutTransferResult.new):
>+        (foo.html._USBIsochronousOutTransferResult._create_1):
>+        (foo.html._USBIsochronousOutTransferResult):
>+        (foo.html._USBOutTransferResult.new):
>+        (foo.html._USBOutTransferResult._create_1):
>+        (foo.html._USBOutTransferResult._create_2):
>+        (foo.html._USBOutTransferResult):
>+        (foo.html._WindowTimers):
>+        (foo.html._WorkerLocation):
>+        (foo.html._WorkerNavigator):
>+        (foo.html._Worklet):
>+        (foo.html._AttributeMap.prototype.addAll):
>+        (foo.html._AttributeMap.prototype.cast):
>+        (foo.html._AttributeMap.prototype.containsValue):
>+        (foo.html._AttributeMap.prototype.putIfAbsent):
>+        (foo.html._AttributeMap.prototype.clear):
>+        (foo.html._AttributeMap.prototype.forEach):
>+        (foo.html._AttributeMap.prototype.get keys):
>+        (foo.html._AttributeMap.prototype.get values):
>+        (foo.html._AttributeMap.prototype.get isEmpty):
>+        (foo.html._AttributeMap.prototype.get isNotEmpty):
>+        (foo.html._AttributeMap):
>+        (foo.html._ElementAttributeMap.prototype.containsKey):
>+        (foo.html._ElementAttributeMap.prototype._get):
>+        (foo.html._ElementAttributeMap.prototype._set):
>+        (foo.html._ElementAttributeMap.prototype.remove):
>+        (foo.html._ElementAttributeMap.prototype.get length):
>+        (foo.html._ElementAttributeMap.prototype._matches):
>+        (foo.html._ElementAttributeMap._remove):
>+        (foo.html._ElementAttributeMap):
>+        (foo.html._NamespacedAttributeMap.prototype.containsKey):
>+        (foo.html._NamespacedAttributeMap.prototype._get):
>+        (foo.html._NamespacedAttributeMap.prototype._set):
>+        (foo.html._NamespacedAttributeMap.prototype.remove):
>+        (foo.html._NamespacedAttributeMap.prototype.get length):
>+        (foo.html._NamespacedAttributeMap.prototype._matches):
>+        (foo.html._NamespacedAttributeMap._remove):
>+        (foo.html._NamespacedAttributeMap):
>+        (foo.html._DataAttributeMap.prototype.addAll):
>+        (foo.html._DataAttributeMap.prototype.cast):
>+        (foo.html._DataAttributeMap.prototype.containsValue):
>+        (foo.html._DataAttributeMap.prototype.containsKey):
>+        (foo.html._DataAttributeMap.prototype._get):
>+        (foo.html._DataAttributeMap.prototype._set):
>+        (foo.html._DataAttributeMap.prototype.putIfAbsent):
>+        (foo.html._DataAttributeMap.prototype.remove):
>+        (foo.html._DataAttributeMap.prototype.clear):
>+        (foo.html._DataAttributeMap.prototype.forEach):
>+        (foo.html._DataAttributeMap.prototype.get keys):
>+        (foo.html._DataAttributeMap.prototype.get values):
>+        (foo.html._DataAttributeMap.prototype.get length):
>+        (foo.html._DataAttributeMap.prototype.get isEmpty):
>+        (foo.html._DataAttributeMap.prototype.get isNotEmpty):
>+        (foo.html._DataAttributeMap.prototype._attr):
>+        (foo.html._DataAttributeMap.prototype._matches):
>+        (foo.html._DataAttributeMap.prototype._strip):
>+        (foo.html._DataAttributeMap.prototype._toCamelCase):
>+        (foo.html._DataAttributeMap.prototype._toHyphenedName):
>+        (foo.html._DataAttributeMap):
>+        (foo.html.CanvasImageSource):
>+        (foo.html.WindowBase):
>+        (foo.html.LocationBase):
>+        (foo.html.HistoryBase):
>+        (foo.html.CssClassSet):
>+        (foo.html.CssRect.prototype.set height):
>+        (foo.html.CssRect.prototype.set width):
>+        (foo.html.CssRect.prototype._addOrSubtractToBoxModel):
>+        (foo.html.CssRect.prototype.get right):
>+        (foo.html.CssRect.prototype.get bottom):
>+        (foo.html.CssRect.prototype.toString):
>+        (foo.html.CssRect.prototype._equals):
>+        (foo.html.CssRect.prototype.get hashCode):
>+        (foo.html.CssRect.prototype.intersection):
>+        (foo.html.CssRect.prototype.intersects):
>+        (foo.html.CssRect.prototype.boundingBox):
>+        (foo.html.CssRect.prototype.containsRectangle):
>+        (foo.html.CssRect.prototype.containsPoint):
>+        (foo.html.CssRect.prototype.get topLeft):
>+        (foo.html.CssRect.prototype.get topRight):
>+        (foo.html.CssRect.prototype.get bottomRight):
>+        (foo.html.CssRect.prototype.get bottomLeft):
>+        (foo.html.CssRect):
>+        (foo.html._ContentCssRect.prototype.get height):
>+        (foo.html._ContentCssRect.prototype.get width):
>+        (foo.html._ContentCssRect.prototype.set height):
>+        (foo.html._ContentCssRect.prototype.set width):
>+        (foo.html._ContentCssRect.prototype.get left):
>+        (foo.html._ContentCssRect.prototype.get top):
>+        (foo.html._ContentCssRect):
>+        (foo.html._ContentCssListRect.prototype.set height):
>+        (foo.html._ContentCssListRect.prototype.get height):
>+        (foo.html._ContentCssListRect.prototype.set width):
>+        (foo.html._ContentCssListRect.prototype.get width):
>+        (foo.html._ContentCssListRect):
>+        (foo.html._PaddingCssRect.prototype.get height):
>+        (foo.html._PaddingCssRect.prototype.set height):
>+        (foo.html._PaddingCssRect.prototype.get width):
>+        (foo.html._PaddingCssRect.prototype.set width):
>+        (foo.html._PaddingCssRect.prototype.get left):
>+        (foo.html._PaddingCssRect.prototype.get top):
>+        (foo.html._PaddingCssRect):
>+        (foo.html._BorderCssRect.prototype.get height):
>+        (foo.html._BorderCssRect.prototype.set height):
>+        (foo.html._BorderCssRect.prototype.get width):
>+        (foo.html._BorderCssRect.prototype.set width):
>+        (foo.html._BorderCssRect.prototype.get left):
>+        (foo.html._BorderCssRect.prototype.get top):
>+        (foo.html._BorderCssRect):
>+        (foo.html._MarginCssRect.prototype.get height):
>+        (foo.html._MarginCssRect.prototype.set height):
>+        (foo.html._MarginCssRect.prototype.get width):
>+        (foo.html._MarginCssRect.prototype.set width):
>+        (foo.html._MarginCssRect.prototype.get left):
>+        (foo.html._MarginCssRect.prototype.get top):
>+        (foo.html._MarginCssRect):
>+        (foo.html_common.CssClassSetImpl.prototype._validateToken):
>+        (foo.html_common.CssClassSetImpl.prototype.toString):
>+        (foo.html_common.CssClassSetImpl.prototype.toggle):
>+        (foo.html_common.CssClassSetImpl.prototype.get frozen):
>+        (foo.html_common.CssClassSetImpl.prototype.get iterator):
>+        (foo.html_common.CssClassSetImpl.prototype.forEach):
>+        (foo.html_common.CssClassSetImpl.prototype.join):
>+        (foo.html_common.CssClassSetImpl.prototype.map):
>+        (foo.html_common.CssClassSetImpl.prototype.where):
>+        (foo.html_common.CssClassSetImpl.prototype.expand):
>+        (foo.html_common.CssClassSetImpl.prototype.every):
>+        (foo.html_common.CssClassSetImpl.prototype.any):
>+        (foo.html_common.CssClassSetImpl.prototype.get isEmpty):
>+        (foo.html_common.CssClassSetImpl.prototype.get isNotEmpty):
>+        (foo.html_common.CssClassSetImpl.prototype.get length):
>+        (foo.html_common.CssClassSetImpl.prototype.reduce):
>+        (foo.html_common.CssClassSetImpl.prototype.fold):
>+        (foo.html_common.CssClassSetImpl.prototype.contains):
>+        (foo.html_common.CssClassSetImpl.prototype.lookup):
>+        (foo.html_common.CssClassSetImpl.prototype.add):
>+        (foo.html_common.CssClassSetImpl.prototype.remove):
>+        (foo.html_common.CssClassSetImpl.prototype.addAll):
>+        (foo.html_common.CssClassSetImpl.prototype.removeAll):
>+        (foo.html_common.CssClassSetImpl.prototype.toggleAll):
>+        (foo.html_common.CssClassSetImpl.prototype.retainAll):
>+        (foo.html_common.CssClassSetImpl.prototype.removeWhere):
>+        (foo.html_common.CssClassSetImpl.prototype.retainWhere):
>+        (foo.html_common.CssClassSetImpl.prototype.containsAll):
>+        (foo.html_common.CssClassSetImpl.prototype.intersection):
>+        (foo.html_common.CssClassSetImpl.prototype.union):
>+        (foo.html_common.CssClassSetImpl.prototype.difference):
>+        (foo.html_common.CssClassSetImpl.prototype.get first):
>+        (foo.html_common.CssClassSetImpl.prototype.get last):
>+        (foo.html_common.CssClassSetImpl.prototype.get single):
>+        (foo.html_common.CssClassSetImpl.prototype.toList):
>+        (foo.html_common.CssClassSetImpl.prototype.toSet):
>+        (foo.html_common.CssClassSetImpl.prototype.take):
>+        (foo.html_common.CssClassSetImpl.prototype.takeWhile):
>+        (foo.html_common.CssClassSetImpl.prototype.skip):
>+        (foo.html_common.CssClassSetImpl.prototype.skipWhile):
>+        (foo.html_common.CssClassSetImpl.prototype.firstWhere):
>+        (foo.html_common.CssClassSetImpl.prototype.lastWhere):
>+        (foo.html_common.CssClassSetImpl.prototype.singleWhere):
>+        (foo.html_common.CssClassSetImpl.prototype.elementAt):
>+        (foo.html_common.CssClassSetImpl.prototype.clear):
>+        (foo.html_common.CssClassSetImpl.prototype.modify):
>+        (foo.html_common.CssClassSetImpl):
>+        (foo.get html._MultiElementCssClassSet.new):
>+        (foo.get html._MultiElementCssClassSet.prototype.readClasses):
>+        (foo.get html._MultiElementCssClassSet.prototype.writeClasses):
>+        (foo.get html._MultiElementCssClassSet.prototype.modify):
>+        (foo.get html._MultiElementCssClassSet.prototype.toggle):
>+        (foo.get html._MultiElementCssClassSet.prototype.remove):
>+        (foo.get html._MultiElementCssClassSet):
>+        (foo.html._ElementCssClassSet.prototype.readClasses):
>+        (foo.html._ElementCssClassSet.prototype.writeClasses):
>+        (foo.html._ElementCssClassSet.prototype.get length):
>+        (foo.html._ElementCssClassSet.prototype.get isEmpty):
>+        (foo.html._ElementCssClassSet.prototype.get isNotEmpty):
>+        (foo.html._ElementCssClassSet.prototype.clear):
>+        (foo.html._ElementCssClassSet.prototype.contains):
>+        (foo.html._ElementCssClassSet.prototype.add):
>+        (foo.html._ElementCssClassSet.prototype.remove):
>+        (foo.html._ElementCssClassSet.prototype.toggle):
>+        (foo.html._ElementCssClassSet.prototype.addAll):
>+        (foo.html._ElementCssClassSet.prototype.removeAll):
>+        (foo.html._ElementCssClassSet.prototype.retainAll):
>+        (foo.html._ElementCssClassSet.prototype.removeWhere):
>+        (foo.html._ElementCssClassSet.prototype.retainWhere):
>+        (foo.html._ElementCssClassSet._contains):
>+        (foo.html._ElementCssClassSet._add):
>+        (foo.html._ElementCssClassSet._remove):
>+        (foo.html._ElementCssClassSet._toggle):
>+        (foo.html._ElementCssClassSet._toggleDefault):
>+        (foo.html._ElementCssClassSet._toggleOnOff):
>+        (foo.html._ElementCssClassSet._addAll):
>+        (foo.html._ElementCssClassSet._removeAll):
>+        (foo.html._ElementCssClassSet._removeWhere):
>+        (foo.html._ElementCssClassSet._classListOf):
>+        (foo.html._ElementCssClassSet._classListLength):
>+        (foo.html._ElementCssClassSet._classListContains):
>+        (foo.html._ElementCssClassSet._classListContainsBeforeAddOrRemove):
>+        (foo.html._ElementCssClassSet._classListAdd):
>+        (foo.html._ElementCssClassSet._classListRemove):
>+        (foo.html._ElementCssClassSet._classListToggle1):
>+        (foo.html._ElementCssClassSet._classListToggle2):
>+        (foo.html._ElementCssClassSet):
>+        (foo.html.Dimension.prototype.toString):
>+        (foo.html.Dimension.prototype.get value):
>+        (foo.html.Dimension):
>+        (foo.html.UrlSearchParams.set return):
>+        (foo.html.UrlSearchParams.prototype.get return):
>+        (foo.html.EventStreamProvider.dart.generic):
>+        (foo.html.UrlSearchParams):
>+        (foo.html.ElementStream.dart.generic):
>+        (foo.html._EventStream.dart.generic):
>+        (foo.html._matchesWithAncestors):
>+        (foo.html._ElementEventStreamImpl.dart.generic):
>+        (foo.html._ElementListEventStreamImpl.dart.generic):
>+        (foo.html._EventStreamSubscription.dart.generic):
>+        (foo.html.CustomStream.dart.generic):
>+        (foo.html._CustomEventStreamImpl.dart.generic):
>+        (foo.html.KeyEvent.prototype.get keyCode):
>+        (foo.html.KeyEvent.prototype.get charCode):
>+        (foo.html.KeyEvent.prototype.get altKey):
>+        (foo.html.KeyEvent.prototype.get which):
>+        (foo.html.KeyEvent.prototype.get _realKeyCode):
>+        (foo.html.KeyEvent.prototype.get _realCharCode):
>+        (foo.html.KeyEvent.prototype.get _realAltKey):
>+        (foo.html.KeyEvent.prototype.get sourceCapabilities):
>+        (foo.html.KeyEvent.prototype.set sourceCapabilities):
>+        (foo.html.KeyEvent._makeRecord):
>+        (foo.html.KeyEvent.new.):
>+        (foo.html.KeyEvent.new.get Object):
>+        (foo.html.KeyEvent.new.get let):
>+        (foo.html.KeyEvent.new):
>+        (foo.html.KeyEvent.get canUseDispatchEvent):
>+        (foo.html.KeyEvent.prototype.get currentTarget):
>+        (foo.html.KeyEvent._convertToHexString):
>+        (foo.html.KeyEvent.prototype.get code):
>+        (foo.html.KeyEvent.prototype.get ctrlKey):
>+        (foo.html.KeyEvent.prototype.get detail):
>+        (foo.html.KeyEvent.prototype.get isComposing):
>+        (foo.html.KeyEvent.prototype.get key):
>+        (foo.html.KeyEvent.prototype.get location):
>+        (foo.html.KeyEvent.prototype.get metaKey):
>+        (foo.html.KeyEvent.prototype.get shiftKey):
>+        (foo.html.KeyEvent.prototype.get view):
>+        (foo.html.KeyEvent.prototype._initUIEvent):
>+        (foo.html.KeyEvent.prototype.get _shadowKeyIdentifier):
>+        (foo.html.KeyEvent.prototype.get _charCode):
>+        (foo.html.KeyEvent.prototype.get _keyCode):
>+        (foo.html.KeyEvent.prototype.get _which):
>+        (foo.html.KeyEvent.prototype.get _keyIdentifier):
>+        (foo.html.KeyEvent.prototype._initKeyboardEvent):
>+        (foo.html.KeyEvent.prototype.getModifierState):
>+        (foo.html.KeyEvent.prototype.get repeat):
>+        (foo.html.KeyEvent.prototype.get isComposed):
>+        (foo.html.KeyEvent.prototype.get _get_view):
>+        (foo.html.KeyEvent):
>+        (foo.set get html._CustomKeyEventStreamImpl.prototype.add):
>+        (foo.set get html._CustomKeyEventStreamImpl):
>+        (foo.set get html):
>+        (foo.html.StylePropertyMap.prototype.set return):
>+        (foo.html._StreamPool.dart.generic):
>+        (foo.html.StylePropertyMap):
>+        (foo.html._CustomEventStreamProvider.dart.generic):
>+        (foo.html._Html5NodeValidator.prototype.allowsElement):
>+        (foo.html._Html5NodeValidator.prototype.allowsAttribute):
>+        (foo.html._Html5NodeValidator._standardAttributeValidator):
>+        (foo.html._Html5NodeValidator._uriAttributeValidator):
>+        (foo.html._Html5NodeValidator):
>+        (foo.get html.KeyCode.isCharacterKey):
>+        (foo.get html.KeyCode._convertKeyCodeToKeyName):
>+        (foo.get html.KeyCode):
>+        (foo.get html.KeyLocation):
>+        (foo.get html._KeyName):
>+        (foo.html._KeyboardEventHandler.prototype.forTarget):
>+        (foo.html._KeyboardEventHandler.prototype.get _capsLockOn):
>+        (foo.html._KeyboardEventHandler.prototype._determineKeyCodeForKeypress):
>+        (foo.html._KeyboardEventHandler.prototype._findCharCodeKeyDown):
>+        (foo.html._KeyboardEventHandler.prototype._firesKeyPressEvent):
>+        (foo.html._KeyboardEventHandler.prototype._normalizeKeyCodes):
>+        (foo.html._KeyboardEventHandler.prototype.processKeyDown):
>+        (foo.html._KeyboardEventHandler.prototype.processKeyPress):
>+        (foo.html._KeyboardEventHandler.prototype.processKeyUp):
>+        (foo.html._KeyboardEventHandler):
>+        (foo.get html.KeyboardEventStream.onKeyPress):
>+        (foo.get html.KeyboardEventStream.onKeyUp):
>+        (foo.get html.KeyboardEventStream.onKeyDown):
>+        (foo.get html.KeyboardEventStream):
>+        (foo.html.NodeValidatorBuilder.prototype.allowNavigation):
>+        (foo.html.NodeValidatorBuilder.prototype.allowImages):
>+        (foo.html.NodeValidatorBuilder.prototype.allowTextElements):
>+        (foo.html.NodeValidatorBuilder.prototype.allowInlineStyles):
>+        (foo.html.NodeValidatorBuilder.prototype.allowHtml5):
>+        (foo.html.NodeValidatorBuilder.prototype.allowSvg):
>+        (foo.html.NodeValidatorBuilder.prototype.allowCustomElement):
>+        (foo.html.NodeValidatorBuilder.prototype.allowTagExtension):
>+        (foo.html.NodeValidatorBuilder.prototype.allowElement):
>+        (foo.html.NodeValidatorBuilder.prototype.allowTemplating):
>+        (foo.html.NodeValidatorBuilder.prototype.add):
>+        (foo.html.NodeValidatorBuilder.prototype.allowsElement):
>+        (foo.html.NodeValidatorBuilder.prototype.allowsAttribute):
>+        (foo.html.NodeValidatorBuilder):
>+        (foo.html._SimpleNodeValidator.allowNavigation):
>+        (foo.html._SimpleNodeValidator.allowImages):
>+        (foo.html._SimpleNodeValidator.allowTextElements):
>+        (foo.html._SimpleNodeValidator.prototype.allowsElement):
>+        (foo.html._SimpleNodeValidator.prototype.allowsAttribute):
>+        (foo.html._SimpleNodeValidator):
>+        (foo.html._CustomElementNodeValidator.prototype.allowsElement):
>+        (foo.html._CustomElementNodeValidator.prototype.allowsAttribute):
>+        (foo.html._CustomElementNodeValidator):
>+        (foo.html._TemplatingNodeValidator.prototype.allowsAttribute):
>+        (foo.html._TemplatingNodeValidator):
>+        (foo.get html._SvgNodeValidator.prototype.allowsElement):
>+        (foo.get html._SvgNodeValidator.prototype.allowsAttribute):
>+        (foo.get html._SvgNodeValidator):
>+        (foo.html.ReadyState):
>+        (foo.html._WrappedList.dart.generic):
>+        (foo.html._WrappedIterator.dart.generic):
>+        (foo.html._HttpRequestUtils.get let):
>+        (foo.html._HttpRequestUtils.async request):
>+        (foo.html._HttpRequestUtils):
>+        (foo.html.FixedSizeListIterator.dart.generic):
>+        (foo.html._VariableSizeListIterator.dart.generic):
>+        (foo.html.Console.prototype.get _isConsoleDefined):
>+        (foo.html.Console.prototype.get memory):
>+        (foo.html.Console.prototype.assertCondition):
>+        (foo.html.Console.prototype.clear):
>+        (foo.html.Console.prototype.count):
>+        (foo.html.Console.prototype.debug):
>+        (foo.html.Console.prototype.dir):
>+        (foo.html.Console.prototype.dirxml):
>+        (foo.html.Console.prototype.error):
>+        (foo.html.Console.prototype.group):
>+        (foo.html.Console.prototype.groupCollapsed):
>+        (foo.html.Console.prototype.groupEnd):
>+        (foo.html.Console.prototype.info):
>+        (foo.html.Console.prototype.log):
>+        (foo.html.Console.prototype.markTimeline):
>+        (foo.html.Console.prototype.profile):
>+        (foo.html.Console.prototype.profileEnd):
>+        (foo.html.Console.prototype.table):
>+        (foo.html.Console.prototype.time):
>+        (foo.html.Console.prototype.timeEnd):
>+        (foo.html.Console.prototype.timeStamp):
>+        (foo.html.Console.prototype.trace):
>+        (foo.html.Console.prototype.warn):
>+        (foo.html.Console):
>+        (foo.get html._convertNativeToDart_Window):
>+        (foo.html._convertNativeToDart_EventTarget):
>+        (foo.html._convertDartToNative_EventTarget):
>+        (foo.html._convertNativeToDart_XHR_Response):
>+        (foo.html._callConstructor):
>+        (foo.html._callAttached):
>+        (foo.html._callDetached):
>+        (foo.html._callAttributeChanged):
>+        (foo.html._makeCallbackMethod):
>+        (foo.html._makeCallbackMethod3):
>+        (foo.html._checkExtendsNativeClassOrTemplate):
>+        (foo.html._JSElementUpgrader.prototype.upgrade):
>+        (foo.html._JSElementUpgrader):
>+        (foo.html._DOMWindowCrossFrame.prototype.get history):
>+        (foo.html._DOMWindowCrossFrame.prototype.get location):
>+        (foo.html._DOMWindowCrossFrame.prototype.get closed):
>+        (foo.html._DOMWindowCrossFrame.prototype.get opener):
>+        (foo.html._DOMWindowCrossFrame.prototype.get parent):
>+        (foo.html._DOMWindowCrossFrame.prototype.get top):
>+        (foo.html._DOMWindowCrossFrame.prototype.close):
>+        (foo.html._DOMWindowCrossFrame.prototype.postMessage):
>+        (foo.html._DOMWindowCrossFrame._createSafe):
>+        (foo.html._DOMWindowCrossFrame.prototype.get on):
>+        (foo.html._DOMWindowCrossFrame.prototype._addEventListener):
>+        (foo.html._DOMWindowCrossFrame.prototype.addEventListener):
>+        (foo.html._DOMWindowCrossFrame.prototype.dispatchEvent):
>+        (foo.html._DOMWindowCrossFrame.prototype._removeEventListener):
>+        (foo.html._DOMWindowCrossFrame.prototype.removeEventListener):
>+        (foo.html._DOMWindowCrossFrame):
>+        (foo.html._LocationCrossFrame.prototype.set href):
>+        (foo.html._LocationCrossFrame._setHref):
>+        (foo.html._LocationCrossFrame._createSafe):
>+        (foo.html._LocationCrossFrame):
>+        (foo.html._HistoryCrossFrame.prototype.back):
>+        (foo.html._HistoryCrossFrame.prototype.forward):
>+        (foo.html._HistoryCrossFrame.prototype.go):
>+        (foo.html._HistoryCrossFrame._createSafe):
>+        (foo.html._HistoryCrossFrame):
>+        (foo.html.Platform):
>+        (foo.html.querySelector):
>+        (foo.html.querySelectorAll):
>+        (foo.html.ElementUpgrader):
>+        (foo.html.NodeValidator.new):
>+        (foo.html.NodeValidator.throws):
>+        (foo.html.NodeValidator):
>+        (foo.html.NodeTreeSanitizer.new):
>+        (foo.html.NodeTreeSanitizer):
>+        (foo.get html._TrustedHtmlTreeSanitizer.prototype.sanitizeTree):
>+        (foo.get html._TrustedHtmlTreeSanitizer):
>+        (foo.html.UriPolicy.new):
>+        (foo.html.UriPolicy):
>+        (foo.html._SameOriginUriPolicy.prototype.allowsUri):
>+        (foo.html._SameOriginUriPolicy):
>+        (foo.html._ThrowsNodeValidator.prototype.allowsElement):
>+        (foo.html._ThrowsNodeValidator.prototype.allowsAttribute):
>+        (foo.html._ThrowsNodeValidator):
>+        (foo.html._ValidatingTreeSanitizer.prototype.sanitizeTree):
>+        (foo.html._ValidatingTreeSanitizer.prototype._removeNode):
>+        (foo.html._ValidatingTreeSanitizer.prototype._sanitizeUntrustedElement):
>+        (foo.html._ValidatingTreeSanitizer.prototype._sanitizeElement):
>+        (foo.html._ValidatingTreeSanitizer.prototype.sanitizeNode):
>+        (foo.html._ValidatingTreeSanitizer):
>+        (foo.html_common.convertDartToNative_SerializedScriptValue):
>+        (foo.html_common.convertNativeToDart_SerializedScriptValue):
>+        (foo.html_common._StructuredClone.prototype.findSlot):
>+        (foo.html_common._StructuredClone.prototype.readSlot):
>+        (foo.html_common._StructuredClone.prototype.writeSlot):
>+        (foo.html_common._StructuredClone.prototype.cleanupSlots):
>+        (foo.html_common._StructuredClone.prototype.walk):
>+        (foo.html_common._StructuredClone.prototype.copyList):
>+        (foo.html_common._StructuredClone.prototype.convertDartToNative_PrepareForStructuredClone):
>+        (foo.html_common._StructuredClone):
>+        (foo.html_common._AcceptStructuredClone.prototype.findSlot):
>+        (foo.html_common._AcceptStructuredClone.prototype.readSlot):
>+        (foo.html_common._AcceptStructuredClone.prototype.writeSlot):
>+        (foo.html_common._AcceptStructuredClone.prototype.walk):
>+        (foo.html_common._AcceptStructuredClone.prototype.convertNativeToDart_AcceptStructuredClone):
>+        (foo.html_common._AcceptStructuredClone):
>+        (foo.async return):
>+        (foo.html._wrapBinaryZone):
>+        (foo.html_common.ContextAttributes.prototype.get alpha):
>+        (foo.html_common.ContextAttributes.prototype.set alpha):
>+        (foo.html_common.ContextAttributes.prototype.get antialias):
>+        (foo.html_common.ContextAttributes.prototype.set antialias):
>+        (foo.html_common.ContextAttributes.prototype.get depth):
>+        (foo.html_common.ContextAttributes.prototype.set depth):
>+        (foo.html_common.ContextAttributes.prototype.get premultipliedAlpha):
>+        (foo.html_common.ContextAttributes.prototype.set premultipliedAlpha):
>+        (foo.html_common.ContextAttributes.prototype.get preserveDrawingBuffer):
>+        (foo.html_common.ContextAttributes.prototype.set preserveDrawingBuffer):
>+        (foo.html_common.ContextAttributes.prototype.get stencil):
>+        (foo.html_common.ContextAttributes.prototype.set stencil):
>+        (foo.html_common.ContextAttributes.prototype.get failIfMajorPerformanceCaveat):
>+        (foo.html_common.ContextAttributes.prototype.set failIfMajorPerformanceCaveat):
>+        (foo.html_common.ContextAttributes):
>+        (foo.html_common.convertNativeToDart_ContextAttributes):
>+        (foo.html_common._TypedImageData.prototype.get data):
>+        (foo.html_common._TypedImageData.prototype.set data):
>+        (foo.html_common._TypedImageData.prototype.get height):
>+        (foo.html_common._TypedImageData.prototype.set height):
>+        (foo.html_common._TypedImageData.prototype.get width):
>+        (foo.html_common._TypedImageData.prototype.set width):
>+        (foo.html_common._TypedImageData):
>+        (foo.html_common.convertNativeToDart_ImageData):
>+        (foo.html_common.convertDartToNative_ImageData):
>+        (foo.html_common.convertNativeToDart_Dictionary):
>+        (foo.html_common.convertDartToNative_Dictionary):
>+        (foo.html_common.convertDartToNative_StringArray):
>+        (foo.html_common.convertNativeToDart_DateTime):
>+        (foo.html_common.convertDartToNative_DateTime):
>+        (foo.html_common.convertDartToNative_PrepareForStructuredClone):
>+        (foo.html_common.convertNativeToDart_AcceptStructuredClone):
>+        (foo.html_common._StructuredCloneDart2Js.prototype.newJsMap):
>+        (foo.html_common._StructuredCloneDart2Js.prototype.putIntoMap):
>+        (foo.html_common._StructuredCloneDart2Js.prototype.newJsList):
>+        (foo.html_common._StructuredCloneDart2Js.prototype.cloneNotRequired):
>+        (foo.html_common._StructuredCloneDart2Js):
>+        (foo.html_common._AcceptStructuredCloneDart2Js.prototype.newJsList):
>+        (foo.html_common._AcceptStructuredCloneDart2Js.prototype.newDartList):
>+        (foo.html_common._AcceptStructuredCloneDart2Js.prototype.identicalInJs):
>+        (foo.html_common._AcceptStructuredCloneDart2Js.prototype.forEachJsField):
>+        (foo.html_common._AcceptStructuredCloneDart2Js):
>+        (foo.html_common.isJavaScriptDate):
>+        (foo.html_common.isJavaScriptRegExp):
>+        (foo.html_common.isJavaScriptArray):
>+        (foo.html_common.isJavaScriptSimpleObject):
>+        (foo.html_common.isImmutableJavaScriptArray):
>+        (foo.html_common.isJavaScriptPromise):
>+        (foo.html_common.convertNativePromiseToDartFuture):
>+        (foo.get html_common.Device.get userAgent):
>+        (foo.get html_common.Device.get isOpera):
>+        (foo.get html_common.Device.get isIE):
>+        (foo.get html_common.Device.get isFirefox):
>+        (foo.get html_common.Device.get isWebKit):
>+        (foo.get html_common.Device.get cssPrefix):
>+        (foo.get html_common.Device.get propertyPrefix):
>+        (foo.get html_common.Device.isEventTypeSupported):
>+        (foo.get html_common.Device):
>+        (foo.get html_common):
>+        (foo.html_common.FilteredElementList.prototype.get _iterable):
>+        (foo.html_common.FilteredElementList.prototype.get _filtered):
>+        (foo.html_common.FilteredElementList.prototype.forEach):
>+        (foo.html_common.FilteredElementList.prototype._set):
>+        (foo.html_common.FilteredElementList.prototype.set length):
>+        (foo.html_common.FilteredElementList.prototype.add):
>+        (foo.html_common.FilteredElementList.prototype.addAll):
>+        (foo.html_common.FilteredElementList.prototype.contains):
>+        (foo.html_common.FilteredElementList.prototype.get reversed):
>+        (foo.html_common.FilteredElementList.prototype.sort):
>+        (foo.html_common.FilteredElementList.prototype.setRange):
>+        (foo.html_common.FilteredElementList.prototype.fillRange):
>+        (foo.html_common.FilteredElementList.prototype.replaceRange):
>+        (foo.html_common.FilteredElementList.prototype.removeRange):
>+        (foo.html_common.FilteredElementList.prototype.clear):
>+        (foo.html_common.FilteredElementList.prototype.removeLast):
>+        (foo.html_common.FilteredElementList.prototype.insert):
>+        (foo.html_common.FilteredElementList.prototype.insertAll):
>+        (foo.html_common.FilteredElementList.prototype.removeAt):
>+        (foo.html_common.FilteredElementList.prototype.remove):
>+        (foo.html_common.FilteredElementList.prototype.get length):
>+        (foo.html_common.FilteredElementList.prototype._get):
>+        (foo.html_common.FilteredElementList.prototype.get iterator):
>+        (foo.html_common.FilteredElementList.prototype.get rawList):
>+        (foo.html_common.FilteredElementList):
>+        (foo.html_common.Lists.indexOf):
>+        (foo.html_common.Lists.lastIndexOf):
>+        (foo.html_common.Lists.getRange):
>+        (foo.html_common.Lists):
>+        (foo.html_common.NodeListWrapper):
>+        (foo.svg._SvgElementFactoryProvider.createSvgElement_tag):
>+        (foo.svg._SvgElementFactoryProvider):
>+        (foo.svg.SvgElement.tag):
>+        (foo.svg.SvgElement.svg):
>+        (foo.svg.SvgElement.prototype.get classes):
>+        (foo.svg.SvgElement.prototype.set classes):
>+        (foo.svg.SvgElement.prototype.get children):
>+        (foo.svg.SvgElement.prototype.set children):
>+        (foo.svg.SvgElement.prototype.get outerHtml):
>+        (foo.svg.SvgElement.prototype.get innerHtml):
>+        (foo.svg.SvgElement.prototype.set innerHtml):
>+        (foo.svg.SvgElement.prototype.createFragment):
>+        (foo.svg.SvgElement.prototype.insertAdjacentText):
>+        (foo.svg.SvgElement.prototype.insertAdjacentHtml):
>+        (foo.svg.SvgElement.prototype.insertAdjacentElement):
>+        (foo.svg.SvgElement.prototype.get _children):
>+        (foo.svg.SvgElement.prototype.get isContentEditable):
>+        (foo.svg.SvgElement.prototype.click):
>+        (foo.svg.SvgElement.isTagSupported):
>+        (foo.svg.SvgElement.prototype.get _svgClassName):
>+        (foo.svg.SvgElement.prototype.get ownerSvgElement):
>+        (foo.svg.SvgElement.prototype.get viewportElement):
>+        (foo.svg.SvgElement.prototype.blur):
>+        (foo.svg.SvgElement.prototype.focus):
>+        (foo.svg.SvgElement.prototype.get nonce):
>+        (foo.svg.SvgElement.prototype.set nonce):
>+        (foo.svg.SvgElement.prototype.get onAbort):
>+        (foo.svg.SvgElement.prototype.get onBlur):
>+        (foo.svg.SvgElement.prototype.get onCanPlay):
>+        (foo.svg.SvgElement.prototype.get onCanPlayThrough):
>+        (foo.svg.SvgElement.prototype.get onChange):
>+        (foo.svg.SvgElement.prototype.get onClick):
>+        (foo.svg.SvgElement.prototype.get onContextMenu):
>+        (foo.svg.SvgElement.prototype.get onDoubleClick):
>+        (foo.svg.SvgElement.prototype.get onDrag):
>+        (foo.svg.SvgElement.prototype.get onDragEnd):
>+        (foo.svg.SvgElement.prototype.get onDragEnter):
>+        (foo.svg.SvgElement.prototype.get onDragLeave):
>+        (foo.svg.SvgElement.prototype.get onDragOver):
>+        (foo.svg.SvgElement.prototype.get onDragStart):
>+        (foo.svg.SvgElement.prototype.get onDrop):
>+        (foo.svg.SvgElement.prototype.get onDurationChange):
>+        (foo.svg.SvgElement.prototype.get onEmptied):
>+        (foo.svg.SvgElement.prototype.get onEnded):
>+        (foo.svg.SvgElement.prototype.get onError):
>+        (foo.svg.SvgElement.prototype.get onFocus):
>+        (foo.svg.SvgElement.prototype.get onInput):
>+        (foo.svg.SvgElement.prototype.get onInvalid):
>+        (foo.svg.SvgElement.prototype.get onKeyDown):
>+        (foo.svg.SvgElement.prototype.get onKeyPress):
>+        (foo.svg.SvgElement.prototype.get onKeyUp):
>+        (foo.svg.SvgElement.prototype.get onLoad):
>+        (foo.svg.SvgElement.prototype.get onLoadedData):
>+        (foo.svg.SvgElement.prototype.get onLoadedMetadata):
>+        (foo.svg.SvgElement.prototype.get onMouseDown):
>+        (foo.svg.SvgElement.prototype.get onMouseEnter):
>+        (foo.svg.SvgElement.prototype.get onMouseLeave):
>+        (foo.svg.SvgElement.prototype.get onMouseMove):
>+        (foo.svg.SvgElement.prototype.get onMouseOut):
>+        (foo.svg.SvgElement.prototype.get onMouseOver):
>+        (foo.svg.SvgElement.prototype.get onMouseUp):
>+        (foo.svg.SvgElement.prototype.get onMouseWheel):
>+        (foo.svg.SvgElement.prototype.get onPause):
>+        (foo.svg.SvgElement.prototype.get onPlay):
>+        (foo.svg.SvgElement.prototype.get onPlaying):
>+        (foo.svg.SvgElement.prototype.get onRateChange):
>+        (foo.svg.SvgElement.prototype.get onReset):
>+        (foo.svg.SvgElement.prototype.get onResize):
>+        (foo.svg.SvgElement.prototype.get onScroll):
>+        (foo.svg.SvgElement.prototype.get onSeeked):
>+        (foo.svg.SvgElement.prototype.get onSeeking):
>+        (foo.svg.SvgElement.prototype.get onSelect):
>+        (foo.svg.SvgElement.prototype.get onStalled):
>+        (foo.svg.SvgElement.prototype.get onSubmit):
>+        (foo.svg.SvgElement.prototype.get onSuspend):
>+        (foo.svg.SvgElement.prototype.get onTimeUpdate):
>+        (foo.svg.SvgElement.prototype.get onTouchCancel):
>+        (foo.svg.SvgElement.prototype.get onTouchEnd):
>+        (foo.svg.SvgElement.prototype.get onTouchMove):
>+        (foo.svg.SvgElement.prototype.get onTouchStart):
>+        (foo.svg.SvgElement.prototype.get onVolumeChange):
>+        (foo.svg.SvgElement.prototype.get onWaiting):
>+        (foo.svg.SvgElement.prototype.get onWheel):
>+        (foo.svg.SvgElement):
>+        (foo.get html._wrapZone):
>+        (foo.svg.GraphicsElement.prototype.get farthestViewportElement):
>+        (foo.svg.GraphicsElement.prototype.get nearestViewportElement):
>+        (foo.svg.GraphicsElement.prototype.get transform):
>+        (foo.svg.GraphicsElement.prototype.getBBox):
>+        (foo.svg.GraphicsElement.prototype.getCtm):
>+        (foo.svg.GraphicsElement.prototype.getScreenCtm):
>+        (foo.svg.GraphicsElement.prototype.get requiredExtensions):
>+        (foo.svg.GraphicsElement.prototype.get systemLanguage):
>+        (foo.svg.GraphicsElement):
>+        (foo.svg.AElement.new):
>+        (foo.svg.AElement.prototype.get target):
>+        (foo.svg.AElement.prototype.get href):
>+        (foo.svg.AElement):
>+        (foo.svg.Angle.prototype.get unitType):
>+        (foo.svg.Angle.prototype.get value):
>+        (foo.svg.Angle.prototype.set value):
>+        (foo.svg.Angle.prototype.get valueAsString):
>+        (foo.svg.Angle.prototype.set valueAsString):
>+        (foo.svg.Angle.prototype.get valueInSpecifiedUnits):
>+        (foo.svg.Angle.prototype.set valueInSpecifiedUnits):
>+        (foo.svg.Angle.prototype.convertToSpecifiedUnits):
>+        (foo.svg.Angle.prototype.newValueSpecifiedUnits):
>+        (foo.svg.Angle):
>+        (foo.svg.AnimationElement.new):
>+        (foo.svg.AnimationElement.prototype.get targetElement):
>+        (foo.svg.AnimationElement.prototype.beginElement):
>+        (foo.svg.AnimationElement.prototype.beginElementAt):
>+        (foo.svg.AnimationElement.prototype.endElement):
>+        (foo.svg.AnimationElement.prototype.endElementAt):
>+        (foo.svg.AnimationElement.prototype.getCurrentTime):
>+        (foo.svg.AnimationElement.prototype.getSimpleDuration):
>+        (foo.svg.AnimationElement.prototype.getStartTime):
>+        (foo.svg.AnimationElement.prototype.get requiredExtensions):
>+        (foo.svg.AnimationElement.prototype.get systemLanguage):
>+        (foo.svg.AnimationElement):
>+        (foo.svg.AnimateElement.new):
>+        (foo.svg.AnimateElement.get supported):
>+        (foo.svg.AnimateElement):
>+        (foo.svg.AnimateMotionElement.new):
>+        (foo.svg.AnimateMotionElement.get supported):
>+        (foo.svg.AnimateMotionElement):
>+        (foo.svg.AnimateTransformElement.new):
>+        (foo.svg.AnimateTransformElement.get supported):
>+        (foo.svg.AnimateTransformElement):
>+        (foo.svg.AnimatedAngle.prototype.get animVal):
>+        (foo.svg.AnimatedAngle.prototype.get baseVal):
>+        (foo.svg.AnimatedAngle):
>+        (foo.svg.AnimatedBoolean.prototype.get animVal):
>+        (foo.svg.AnimatedBoolean.prototype.get baseVal):
>+        (foo.svg.AnimatedBoolean.prototype.set baseVal):
>+        (foo.svg.AnimatedBoolean):
>+        (foo.svg.AnimatedEnumeration.prototype.get animVal):
>+        (foo.svg.AnimatedEnumeration.prototype.get baseVal):
>+        (foo.svg.AnimatedEnumeration.prototype.set baseVal):
>+        (foo.svg.AnimatedEnumeration):
>+        (foo.svg.AnimatedInteger.prototype.get animVal):
>+        (foo.svg.AnimatedInteger.prototype.get baseVal):
>+        (foo.svg.AnimatedInteger.prototype.set baseVal):
>+        (foo.svg.AnimatedInteger):
>+        (foo.svg.AnimatedLength.prototype.get animVal):
>+        (foo.svg.AnimatedLength.prototype.get baseVal):
>+        (foo.svg.AnimatedLength):
>+        (foo.svg.AnimatedLengthList.prototype.get animVal):
>+        (foo.svg.AnimatedLengthList.prototype.get baseVal):
>+        (foo.svg.AnimatedLengthList):
>+        (foo.svg.AnimatedNumber.prototype.get animVal):
>+        (foo.svg.AnimatedNumber.prototype.get baseVal):
>+        (foo.svg.AnimatedNumber.prototype.set baseVal):
>+        (foo.svg.AnimatedNumber):
>+        (foo.svg.AnimatedNumberList.prototype.get animVal):
>+        (foo.svg.AnimatedNumberList.prototype.get baseVal):
>+        (foo.svg.AnimatedNumberList):
>+        (foo.svg.AnimatedPreserveAspectRatio.prototype.get animVal):
>+        (foo.svg.AnimatedPreserveAspectRatio.prototype.get baseVal):
>+        (foo.svg.AnimatedPreserveAspectRatio):
>+        (foo.svg.AnimatedRect.prototype.get animVal):
>+        (foo.svg.AnimatedRect.prototype.get baseVal):
>+        (foo.svg.AnimatedRect):
>+        (foo.svg.AnimatedString.prototype.get animVal):
>+        (foo.svg.AnimatedString.prototype.get baseVal):
>+        (foo.svg.AnimatedString.prototype.set baseVal):
>+        (foo.svg.AnimatedString):
>+        (foo.svg.AnimatedTransformList.prototype.get animVal):
>+        (foo.svg.AnimatedTransformList.prototype.get baseVal):
>+        (foo.svg.AnimatedTransformList):
>+        (foo.svg.GeometryElement.prototype.get pathLength):
>+        (foo.svg.GeometryElement.prototype.getPointAtLength):
>+        (foo.svg.GeometryElement.prototype.getTotalLength):
>+        (foo.svg.GeometryElement.prototype.isPointInFill):
>+        (foo.svg.GeometryElement.prototype.isPointInStroke):
>+        (foo.svg.GeometryElement):
>+        (foo.svg.CircleElement.new):
>+        (foo.svg.CircleElement.prototype.get cx):
>+        (foo.svg.CircleElement.prototype.get cy):
>+        (foo.svg.CircleElement.prototype.get r):
>+        (foo.svg.CircleElement):
>+        (foo.svg.ClipPathElement.new):
>+        (foo.svg.ClipPathElement.prototype.get clipPathUnits):
>+        (foo.svg.ClipPathElement):
>+        (foo.svg.DefsElement.new):
>+        (foo.svg.DefsElement):
>+        (foo.svg.DescElement.new):
>+        (foo.svg.DescElement):
>+        (foo.svg.DiscardElement):
>+        (foo.svg.EllipseElement.new):
>+        (foo.svg.EllipseElement.prototype.get cx):
>+        (foo.svg.EllipseElement.prototype.get cy):
>+        (foo.svg.EllipseElement.prototype.get rx):
>+        (foo.svg.EllipseElement.prototype.get ry):
>+        (foo.svg.EllipseElement):
>+        (foo.svg.FEBlendElement.new):
>+        (foo.svg.FEBlendElement.get supported):
>+        (foo.svg.FEBlendElement.prototype.get in1):
>+        (foo.svg.FEBlendElement.prototype.get in2):
>+        (foo.svg.FEBlendElement.prototype.get mode):
>+        (foo.svg.FEBlendElement.prototype.get height):
>+        (foo.svg.FEBlendElement.prototype.get result):
>+        (foo.svg.FEBlendElement.prototype.get width):
>+        (foo.svg.FEBlendElement.prototype.get x):
>+        (foo.svg.FEBlendElement.prototype.get y):
>+        (foo.svg.FEBlendElement):
>+        (foo.svg.FEColorMatrixElement.new):
>+        (foo.svg.FEColorMatrixElement.get supported):
>+        (foo.svg.FEColorMatrixElement.prototype.get in1):
>+        (foo.svg.FEColorMatrixElement.prototype.get type):
>+        (foo.svg.FEColorMatrixElement.prototype.get values):
>+        (foo.svg.FEColorMatrixElement.prototype.get height):
>+        (foo.svg.FEColorMatrixElement.prototype.get result):
>+        (foo.svg.FEColorMatrixElement.prototype.get width):
>+        (foo.svg.FEColorMatrixElement.prototype.get x):
>+        (foo.svg.FEColorMatrixElement.prototype.get y):
>+        (foo.svg.FEColorMatrixElement):
>+        (foo.svg.FEComponentTransferElement.new):
>+        (foo.svg.FEComponentTransferElement.get supported):
>+        (foo.svg.FEComponentTransferElement.prototype.get in1):
>+        (foo.svg.FEComponentTransferElement.prototype.get height):
>+        (foo.svg.FEComponentTransferElement.prototype.get result):
>+        (foo.svg.FEComponentTransferElement.prototype.get width):
>+        (foo.svg.FEComponentTransferElement.prototype.get x):
>+        (foo.svg.FEComponentTransferElement.prototype.get y):
>+        (foo.svg.FEComponentTransferElement):
>+        (foo.svg.FECompositeElement.prototype.get in1):
>+        (foo.svg.FECompositeElement.prototype.get in2):
>+        (foo.svg.FECompositeElement.prototype.get k1):
>+        (foo.svg.FECompositeElement.prototype.get k2):
>+        (foo.svg.FECompositeElement.prototype.get k3):
>+        (foo.svg.FECompositeElement.prototype.get k4):
>+        (foo.svg.FECompositeElement.prototype.get operator):
>+        (foo.svg.FECompositeElement.prototype.get height):
>+        (foo.svg.FECompositeElement.prototype.get result):
>+        (foo.svg.FECompositeElement.prototype.get width):
>+        (foo.svg.FECompositeElement.prototype.get x):
>+        (foo.svg.FECompositeElement.prototype.get y):
>+        (foo.svg.FECompositeElement):
>+        (foo.svg.FEConvolveMatrixElement.new):
>+        (foo.svg.FEConvolveMatrixElement.get supported):
>+        (foo.svg.FEConvolveMatrixElement.prototype.get bias):
>+        (foo.svg.FEConvolveMatrixElement.prototype.get divisor):
>+        (foo.svg.FEConvolveMatrixElement.prototype.get edgeMode):
>+        (foo.svg.FEConvolveMatrixElement.prototype.get in1):
>+        (foo.svg.FEConvolveMatrixElement.prototype.get kernelMatrix):
>+        (foo.svg.FEConvolveMatrixElement.prototype.get kernelUnitLengthX):
>+        (foo.svg.FEConvolveMatrixElement.prototype.get kernelUnitLengthY):
>+        (foo.svg.FEConvolveMatrixElement.prototype.get orderX):
>+        (foo.svg.FEConvolveMatrixElement.prototype.get orderY):
>+        (foo.svg.FEConvolveMatrixElement.prototype.get preserveAlpha):
>+        (foo.svg.FEConvolveMatrixElement.prototype.get targetX):
>+        (foo.svg.FEConvolveMatrixElement.prototype.get targetY):
>+        (foo.svg.FEConvolveMatrixElement.prototype.get height):
>+        (foo.svg.FEConvolveMatrixElement.prototype.get result):
>+        (foo.svg.FEConvolveMatrixElement.prototype.get width):
>+        (foo.svg.FEConvolveMatrixElement.prototype.get x):
>+        (foo.svg.FEConvolveMatrixElement.prototype.get y):
>+        (foo.svg.FEConvolveMatrixElement):
>+        (foo.svg.FEDiffuseLightingElement.new):
>+        (foo.svg.FEDiffuseLightingElement.get supported):
>+        (foo.svg.FEDiffuseLightingElement.prototype.get diffuseConstant):
>+        (foo.svg.FEDiffuseLightingElement.prototype.get in1):
>+        (foo.svg.FEDiffuseLightingElement.prototype.get kernelUnitLengthX):
>+        (foo.svg.FEDiffuseLightingElement.prototype.get kernelUnitLengthY):
>+        (foo.svg.FEDiffuseLightingElement.prototype.get surfaceScale):
>+        (foo.svg.FEDiffuseLightingElement.prototype.get height):
>+        (foo.svg.FEDiffuseLightingElement.prototype.get result):
>+        (foo.svg.FEDiffuseLightingElement.prototype.get width):
>+        (foo.svg.FEDiffuseLightingElement.prototype.get x):
>+        (foo.svg.FEDiffuseLightingElement.prototype.get y):
>+        (foo.svg.FEDiffuseLightingElement):
>+        (foo.svg.FEDisplacementMapElement.new):
>+        (foo.svg.FEDisplacementMapElement.get supported):
>+        (foo.svg.FEDisplacementMapElement.prototype.get in1):
>+        (foo.svg.FEDisplacementMapElement.prototype.get in2):
>+        (foo.svg.FEDisplacementMapElement.prototype.get scale):
>+        (foo.svg.FEDisplacementMapElement.prototype.get xChannelSelector):
>+        (foo.svg.FEDisplacementMapElement.prototype.get yChannelSelector):
>+        (foo.svg.FEDisplacementMapElement.prototype.get height):
>+        (foo.svg.FEDisplacementMapElement.prototype.get result):
>+        (foo.svg.FEDisplacementMapElement.prototype.get width):
>+        (foo.svg.FEDisplacementMapElement.prototype.get x):
>+        (foo.svg.FEDisplacementMapElement.prototype.get y):
>+        (foo.svg.FEDisplacementMapElement):
>+        (foo.svg.FEDistantLightElement.new):
>+        (foo.svg.FEDistantLightElement.get supported):
>+        (foo.svg.FEDistantLightElement.prototype.get azimuth):
>+        (foo.svg.FEDistantLightElement.prototype.get elevation):
>+        (foo.svg.FEDistantLightElement):
>+        (foo.svg.FEFloodElement.new):
>+        (foo.svg.FEFloodElement.get supported):
>+        (foo.svg.FEFloodElement.prototype.get height):
>+        (foo.svg.FEFloodElement.prototype.get result):
>+        (foo.svg.FEFloodElement.prototype.get width):
>+        (foo.svg.FEFloodElement.prototype.get x):
>+        (foo.svg.FEFloodElement.prototype.get y):
>+        (foo.svg.FEFloodElement):
>+        (foo.svg._SVGComponentTransferFunctionElement):
>+        (foo.svg.FEFuncAElement.new):
>+        (foo.svg.FEFuncAElement.get supported):
>+        (foo.svg.FEFuncAElement):
>+        (foo.svg.FEFuncBElement.new):
>+        (foo.svg.FEFuncBElement.get supported):
>+        (foo.svg.FEFuncBElement):
>+        (foo.svg.FEFuncGElement.new):
>+        (foo.svg.FEFuncGElement.get supported):
>+        (foo.svg.FEFuncGElement):
>+        (foo.svg.FEFuncRElement.new):
>+        (foo.svg.FEFuncRElement.get supported):
>+        (foo.svg.FEFuncRElement):
>+        (foo.svg.FEGaussianBlurElement.new):
>+        (foo.svg.FEGaussianBlurElement.get supported):
>+        (foo.svg.FEGaussianBlurElement.prototype.get in1):
>+        (foo.svg.FEGaussianBlurElement.prototype.get stdDeviationX):
>+        (foo.svg.FEGaussianBlurElement.prototype.get stdDeviationY):
>+        (foo.svg.FEGaussianBlurElement.prototype.setStdDeviation):
>+        (foo.svg.FEGaussianBlurElement.prototype.get height):
>+        (foo.svg.FEGaussianBlurElement.prototype.get result):
>+        (foo.svg.FEGaussianBlurElement.prototype.get width):
>+        (foo.svg.FEGaussianBlurElement.prototype.get x):
>+        (foo.svg.FEGaussianBlurElement.prototype.get y):
>+        (foo.svg.FEGaussianBlurElement):
>+        (foo.svg.FEImageElement.new):
>+        (foo.svg.FEImageElement.get supported):
>+        (foo.svg.FEImageElement.prototype.get preserveAspectRatio):
>+        (foo.svg.FEImageElement.prototype.get height):
>+        (foo.svg.FEImageElement.prototype.get result):
>+        (foo.svg.FEImageElement.prototype.get width):
>+        (foo.svg.FEImageElement.prototype.get x):
>+        (foo.svg.FEImageElement.prototype.get y):
>+        (foo.svg.FEImageElement.prototype.get href):
>+        (foo.svg.FEImageElement):
>+        (foo.svg.FEMergeElement.new):
>+        (foo.svg.FEMergeElement.get supported):
>+        (foo.svg.FEMergeElement.prototype.get height):
>+        (foo.svg.FEMergeElement.prototype.get result):
>+        (foo.svg.FEMergeElement.prototype.get width):
>+        (foo.svg.FEMergeElement.prototype.get x):
>+        (foo.svg.FEMergeElement.prototype.get y):
>+        (foo.svg.FEMergeElement):
>+        (foo.svg.FEMergeNodeElement.new):
>+        (foo.svg.FEMergeNodeElement.get supported):
>+        (foo.svg.FEMergeNodeElement.prototype.get in1):
>+        (foo.svg.FEMergeNodeElement):
>+        (foo.svg.FEMorphologyElement.prototype.get in1):
>+        (foo.svg.FEMorphologyElement.prototype.get operator):
>+        (foo.svg.FEMorphologyElement.prototype.get radiusX):
>+        (foo.svg.FEMorphologyElement.prototype.get radiusY):
>+        (foo.svg.FEMorphologyElement.prototype.get height):
>+        (foo.svg.FEMorphologyElement.prototype.get result):
>+        (foo.svg.FEMorphologyElement.prototype.get width):
>+        (foo.svg.FEMorphologyElement.prototype.get x):
>+        (foo.svg.FEMorphologyElement.prototype.get y):
>+        (foo.svg.FEMorphologyElement):
>+        (foo.svg.FEOffsetElement.new):
>+        (foo.svg.FEOffsetElement.get supported):
>+        (foo.svg.FEOffsetElement.prototype.get dx):
>+        (foo.svg.FEOffsetElement.prototype.get dy):
>+        (foo.svg.FEOffsetElement.prototype.get in1):
>+        (foo.svg.FEOffsetElement.prototype.get height):
>+        (foo.svg.FEOffsetElement.prototype.get result):
>+        (foo.svg.FEOffsetElement.prototype.get width):
>+        (foo.svg.FEOffsetElement.prototype.get x):
>+        (foo.svg.FEOffsetElement.prototype.get y):
>+        (foo.svg.FEOffsetElement):
>+        (foo.svg.FEPointLightElement.new):
>+        (foo.svg.FEPointLightElement.get supported):
>+        (foo.svg.FEPointLightElement.prototype.get x):
>+        (foo.svg.FEPointLightElement.prototype.get y):
>+        (foo.svg.FEPointLightElement.prototype.get z):
>+        (foo.svg.FEPointLightElement):
>+        (foo.svg.FESpecularLightingElement.new):
>+        (foo.svg.FESpecularLightingElement.get supported):
>+        (foo.svg.FESpecularLightingElement.prototype.get in1):
>+        (foo.svg.FESpecularLightingElement.prototype.get kernelUnitLengthX):
>+        (foo.svg.FESpecularLightingElement.prototype.get kernelUnitLengthY):
>+        (foo.svg.FESpecularLightingElement.prototype.get specularConstant):
>+        (foo.svg.FESpecularLightingElement.prototype.get specularExponent):
>+        (foo.svg.FESpecularLightingElement.prototype.get surfaceScale):
>+        (foo.svg.FESpecularLightingElement.prototype.get height):
>+        (foo.svg.FESpecularLightingElement.prototype.get result):
>+        (foo.svg.FESpecularLightingElement.prototype.get width):
>+        (foo.svg.FESpecularLightingElement.prototype.get x):
>+        (foo.svg.FESpecularLightingElement.prototype.get y):
>+        (foo.svg.FESpecularLightingElement):
>+        (foo.svg.FESpotLightElement.new):
>+        (foo.svg.FESpotLightElement.get supported):
>+        (foo.svg.FESpotLightElement.prototype.get limitingConeAngle):
>+        (foo.svg.FESpotLightElement.prototype.get pointsAtX):
>+        (foo.svg.FESpotLightElement.prototype.get pointsAtY):
>+        (foo.svg.FESpotLightElement.prototype.get pointsAtZ):
>+        (foo.svg.FESpotLightElement.prototype.get specularExponent):
>+        (foo.svg.FESpotLightElement.prototype.get x):
>+        (foo.svg.FESpotLightElement.prototype.get y):
>+        (foo.svg.FESpotLightElement.prototype.get z):
>+        (foo.svg.FESpotLightElement):
>+        (foo.svg.FETileElement.new):
>+        (foo.svg.FETileElement.get supported):
>+        (foo.svg.FETileElement.prototype.get in1):
>+        (foo.svg.FETileElement.prototype.get height):
>+        (foo.svg.FETileElement.prototype.get result):
>+        (foo.svg.FETileElement.prototype.get width):
>+        (foo.svg.FETileElement.prototype.get x):
>+        (foo.svg.FETileElement.prototype.get y):
>+        (foo.svg.FETileElement):
>+        (foo.svg.FETurbulenceElement.new):
>+        (foo.svg.FETurbulenceElement.get supported):
>+        (foo.svg.FETurbulenceElement.prototype.get baseFrequencyX):
>+        (foo.svg.FETurbulenceElement.prototype.get baseFrequencyY):
>+        (foo.svg.FETurbulenceElement.prototype.get numOctaves):
>+        (foo.svg.FETurbulenceElement.prototype.get seed):
>+        (foo.svg.FETurbulenceElement.prototype.get stitchTiles):
>+        (foo.svg.FETurbulenceElement.prototype.get type):
>+        (foo.svg.FETurbulenceElement.prototype.get height):
>+        (foo.svg.FETurbulenceElement.prototype.get result):
>+        (foo.svg.FETurbulenceElement.prototype.get width):
>+        (foo.svg.FETurbulenceElement.prototype.get x):
>+        (foo.svg.FETurbulenceElement.prototype.get y):
>+        (foo.svg.FETurbulenceElement):
>+        (foo.svg.FilterElement.new):
>+        (foo.svg.FilterElement.get supported):
>+        (foo.svg.FilterElement.prototype.get filterUnits):
>+        (foo.svg.FilterElement.prototype.get height):
>+        (foo.svg.FilterElement.prototype.get primitiveUnits):
>+        (foo.svg.FilterElement.prototype.get width):
>+        (foo.svg.FilterElement.prototype.get x):
>+        (foo.svg.FilterElement.prototype.get y):
>+        (foo.svg.FilterElement.prototype.get href):
>+        (foo.svg.FilterElement):
>+        (foo.svg.FilterPrimitiveStandardAttributes.prototype.get height):
>+        (foo.svg.FilterPrimitiveStandardAttributes.prototype.set height):
>+        (foo.svg.FilterPrimitiveStandardAttributes.prototype.get result):
>+        (foo.svg.FilterPrimitiveStandardAttributes.prototype.set result):
>+        (foo.svg.FilterPrimitiveStandardAttributes.prototype.get width):
>+        (foo.svg.FilterPrimitiveStandardAttributes.prototype.set width):
>+        (foo.svg.FilterPrimitiveStandardAttributes.prototype.get x):
>+        (foo.svg.FilterPrimitiveStandardAttributes.prototype.set x):
>+        (foo.svg.FilterPrimitiveStandardAttributes.prototype.get y):
>+        (foo.svg.FilterPrimitiveStandardAttributes.prototype.set y):
>+        (foo.svg.FilterPrimitiveStandardAttributes):
>+        (foo.svg.FitToViewBox.prototype.get preserveAspectRatio):
>+        (foo.svg.FitToViewBox.prototype.set preserveAspectRatio):
>+        (foo.svg.FitToViewBox.prototype.get viewBox):
>+        (foo.svg.FitToViewBox.prototype.set viewBox):
>+        (foo.svg.FitToViewBox):
>+        (foo.svg.ForeignObjectElement.new):
>+        (foo.svg.ForeignObjectElement.get supported):
>+        (foo.svg.ForeignObjectElement.prototype.get height):
>+        (foo.svg.ForeignObjectElement.prototype.get width):
>+        (foo.svg.ForeignObjectElement.prototype.get x):
>+        (foo.svg.ForeignObjectElement.prototype.get y):
>+        (foo.svg.ForeignObjectElement):
>+        (foo.svg.GElement.new):
>+        (foo.svg.GElement):
>+        (foo.svg.ImageElement.new):
>+        (foo.svg.ImageElement.get height):
>+        (foo.svg.ImageElement.get preserveAspectRatio):
>+        (foo.svg.ImageElement.get width):
>+        (foo.svg.ImageElement.get x):
>+        (foo.svg.ImageElement.get y):
>+        (foo.svg.ImageElement.get href):
>+        (foo.const.async 1):
>+        (foo.svg.Length.prototype.get unitType):
>+        (foo.svg.Length.prototype.get value):
>+        (foo.svg.Length.prototype.set value):
>+        (foo.svg.Length.prototype.get valueAsString):
>+        (foo.svg.Length.prototype.set valueAsString):
>+        (foo.svg.Length.prototype.get valueInSpecifiedUnits):
>+        (foo.svg.Length.prototype.set valueInSpecifiedUnits):
>+        (foo.svg.Length.prototype.convertToSpecifiedUnits):
>+        (foo.svg.Length.prototype.newValueSpecifiedUnits):
>+        (foo.svg.Length):
>+        (foo.const.Interceptor_ListMixin.13):
>+        (foo.const.Interceptor_ImmutableListMixin.13):
>+        (foo.svg.LengthList.prototype.get length):
>+        (foo.svg.LengthList.prototype.get numberOfItems):
>+        (foo.svg.LengthList.prototype._get):
>+        (foo.svg.LengthList.prototype._set):
>+        (foo.svg.LengthList.prototype.set length):
>+        (foo.svg.LengthList.prototype.get first):
>+        (foo.svg.LengthList.prototype.set first):
>+        (foo.svg.LengthList.prototype.get last):
>+        (foo.svg.LengthList.prototype.set last):
>+        (foo.svg.LengthList.prototype.get single):
>+        (foo.svg.LengthList.prototype.elementAt):
>+        (foo.svg.LengthList.prototype.__setter__):
>+        (foo.svg.LengthList.prototype.appendItem):
>+        (foo.svg.LengthList.prototype.clear):
>+        (foo.svg.LengthList.prototype.getItem):
>+        (foo.svg.LengthList.prototype.initialize):
>+        (foo.svg.LengthList.prototype.insertItemBefore):
>+        (foo.svg.LengthList.prototype.removeItem):
>+        (foo.svg.LengthList.prototype.replaceItem):
>+        (foo.svg.LengthList):
>+        (foo.svg.LineElement.new):
>+        (foo.svg.LineElement.prototype.get x1):
>+        (foo.svg.LineElement.prototype.get x2):
>+        (foo.svg.LineElement.prototype.get y1):
>+        (foo.svg.LineElement.prototype.get y2):
>+        (foo.svg.LineElement):
>+        (foo.svg._GradientElement.prototype.get gradientTransform):
>+        (foo.svg._GradientElement.prototype.get gradientUnits):
>+        (foo.svg._GradientElement.prototype.get spreadMethod):
>+        (foo.svg._GradientElement.prototype.get href):
>+        (foo.svg._GradientElement):
>+        (foo.svg.LinearGradientElement.new):
>+        (foo.svg.LinearGradientElement.prototype.get x1):
>+        (foo.svg.LinearGradientElement.prototype.get x2):
>+        (foo.svg.LinearGradientElement.prototype.get y1):
>+        (foo.svg.LinearGradientElement.prototype.get y2):
>+        (foo.svg.LinearGradientElement):
>+        (foo.svg.MarkerElement.new):
>+        (foo.svg.MarkerElement.prototype.get markerHeight):
>+        (foo.svg.MarkerElement.prototype.get markerUnits):
>+        (foo.svg.MarkerElement.prototype.get markerWidth):
>+        (foo.svg.MarkerElement.prototype.get orientAngle):
>+        (foo.svg.MarkerElement.prototype.get orientType):
>+        (foo.svg.MarkerElement.prototype.get refX):
>+        (foo.svg.MarkerElement.prototype.get refY):
>+        (foo.svg.MarkerElement.prototype.setOrientToAngle):
>+        (foo.svg.MarkerElement.prototype.setOrientToAuto):
>+        (foo.svg.MarkerElement.prototype.get preserveAspectRatio):
>+        (foo.svg.MarkerElement.prototype.get viewBox):
>+        (foo.svg.MarkerElement):
>+        (foo.svg.MaskElement.new):
>+        (foo.svg.MaskElement.prototype.get height):
>+        (foo.svg.MaskElement.prototype.get maskContentUnits):
>+        (foo.svg.MaskElement.prototype.get maskUnits):
>+        (foo.svg.MaskElement.prototype.get width):
>+        (foo.svg.MaskElement.prototype.get x):
>+        (foo.svg.MaskElement.prototype.get y):
>+        (foo.svg.MaskElement.prototype.get requiredExtensions):
>+        (foo.svg.MaskElement.prototype.get systemLanguage):
>+        (foo.svg.MaskElement):
>+        (foo.svg.Matrix.prototype.get a):
>+        (foo.svg.Matrix.prototype.set a):
>+        (foo.svg.Matrix.prototype.get b):
>+        (foo.svg.Matrix.prototype.set b):
>+        (foo.svg.Matrix.prototype.get c):
>+        (foo.svg.Matrix.prototype.set c):
>+        (foo.svg.Matrix.prototype.get d):
>+        (foo.svg.Matrix.prototype.set d):
>+        (foo.svg.Matrix.prototype.get e):
>+        (foo.svg.Matrix.prototype.set e):
>+        (foo.svg.Matrix.prototype.get f):
>+        (foo.svg.Matrix.prototype.set f):
>+        (foo.svg.Matrix.prototype.flipX):
>+        (foo.svg.Matrix.prototype.flipY):
>+        (foo.svg.Matrix.prototype.inverse):
>+        (foo.svg.Matrix.prototype.multiply):
>+        (foo.svg.Matrix.prototype.rotate):
>+        (foo.svg.Matrix.prototype.rotateFromVector):
>+        (foo.svg.Matrix.prototype.scale):
>+        (foo.svg.Matrix.prototype.scaleNonUniform):
>+        (foo.svg.Matrix.prototype.skewX):
>+        (foo.svg.Matrix.prototype.skewY):
>+        (foo.svg.Matrix.prototype.translate):
>+        (foo.svg.Matrix):
>+        (foo.svg.MetadataElement):
>+        (foo.svg.Number.prototype.get value):
>+        (foo.svg.Number.prototype.set value):
>+        (foo.svg.Number):
>+        (foo.const.Interceptor_ListMixin.14):
>+        (foo.const.Interceptor_ImmutableListMixin.14):
>+        (foo.svg.NumberList.prototype.get length):
>+        (foo.svg.NumberList.prototype.get numberOfItems):
>+        (foo.svg.NumberList.prototype._get):
>+        (foo.svg.NumberList.prototype._set):
>+        (foo.svg.NumberList.prototype.set length):
>+        (foo.svg.NumberList.prototype.get first):
>+        (foo.svg.NumberList.prototype.set first):
>+        (foo.svg.NumberList.prototype.get last):
>+        (foo.svg.NumberList.prototype.set last):
>+        (foo.svg.NumberList.prototype.get single):
>+        (foo.svg.NumberList.prototype.elementAt):
>+        (foo.svg.NumberList.prototype.__setter__):
>+        (foo.svg.NumberList.prototype.appendItem):
>+        (foo.svg.NumberList.prototype.clear):
>+        (foo.svg.NumberList.prototype.getItem):
>+        (foo.svg.NumberList.prototype.initialize):
>+        (foo.svg.NumberList.prototype.insertItemBefore):
>+        (foo.svg.NumberList.prototype.removeItem):
>+        (foo.svg.NumberList.prototype.replaceItem):
>+        (foo.svg.NumberList):
>+        (foo.svg.PathElement.new):
>+        (foo.svg.PathElement):
>+        (foo.svg.PatternElement.new):
>+        (foo.svg.PatternElement.prototype.get height):
>+        (foo.svg.PatternElement.prototype.get patternContentUnits):
>+        (foo.svg.PatternElement.prototype.get patternTransform):
>+        (foo.svg.PatternElement.prototype.get patternUnits):
>+        (foo.svg.PatternElement.prototype.get width):
>+        (foo.svg.PatternElement.prototype.get x):
>+        (foo.svg.PatternElement.prototype.get y):
>+        (foo.svg.PatternElement.prototype.get preserveAspectRatio):
>+        (foo.svg.PatternElement.prototype.get viewBox):
>+        (foo.svg.PatternElement.prototype.get requiredExtensions):
>+        (foo.svg.PatternElement.prototype.get systemLanguage):
>+        (foo.svg.PatternElement.prototype.get href):
>+        (foo.svg.PatternElement):
>+        (foo.svg.Point.prototype.get x):
>+        (foo.svg.Point.prototype.set x):
>+        (foo.svg.Point.prototype.get y):
>+        (foo.svg.Point.prototype.set y):
>+        (foo.svg.Point.prototype.matrixTransform):
>+        (foo.svg.Point):
>+        (foo.svg.PointList.prototype.get length):
>+        (foo.svg.PointList.prototype.get numberOfItems):
>+        (foo.svg.PointList.prototype.__setter__):
>+        (foo.svg.PointList.prototype.appendItem):
>+        (foo.svg.PointList.prototype.clear):
>+        (foo.svg.PointList.prototype.getItem):
>+        (foo.svg.PointList.prototype.initialize):
>+        (foo.svg.PointList.prototype.insertItemBefore):
>+        (foo.svg.PointList.prototype.removeItem):
>+        (foo.svg.PointList.prototype.replaceItem):
>+        (foo.svg.PointList):
>+        (foo.svg.PolygonElement.new):
>+        (foo.svg.PolygonElement.prototype.get animatedPoints):
>+        (foo.svg.PolygonElement.prototype.get points):
>+        (foo.svg.PolygonElement):
>+        (foo.svg.PolylineElement.new):
>+        (foo.svg.PolylineElement.prototype.get animatedPoints):
>+        (foo.svg.PolylineElement.prototype.get points):
>+        (foo.svg.PolylineElement):
>+        (foo.svg.PreserveAspectRatio.prototype.get align):
>+        (foo.svg.PreserveAspectRatio.prototype.set align):
>+        (foo.svg.PreserveAspectRatio.prototype.get meetOrSlice):
>+        (foo.svg.PreserveAspectRatio.prototype.set meetOrSlice):
>+        (foo.svg.PreserveAspectRatio):
>+        (foo.svg.RadialGradientElement.new):
>+        (foo.svg.RadialGradientElement.prototype.get cx):
>+        (foo.svg.RadialGradientElement.prototype.get cy):
>+        (foo.svg.RadialGradientElement.prototype.get fr):
>+        (foo.svg.RadialGradientElement.prototype.get fx):
>+        (foo.svg.RadialGradientElement.prototype.get fy):
>+        (foo.svg.RadialGradientElement.prototype.get r):
>+        (foo.svg.RadialGradientElement):
>+        (foo.svg.Rect.prototype.get height):
>+        (foo.svg.Rect.prototype.set height):
>+        (foo.svg.Rect.prototype.get width):
>+        (foo.svg.Rect.prototype.set width):
>+        (foo.svg.Rect.prototype.get x):
>+        (foo.svg.Rect.prototype.set x):
>+        (foo.svg.Rect.prototype.get y):
>+        (foo.svg.Rect.prototype.set y):
>+        (foo.svg.Rect):
>+        (foo.svg.RectElement.new):
>+        (foo.svg.RectElement.prototype.get height):
>+        (foo.svg.RectElement.prototype.get rx):
>+        (foo.svg.RectElement.prototype.get ry):
>+        (foo.svg.RectElement.prototype.get width):
>+        (foo.svg.RectElement.prototype.get x):
>+        (foo.svg.RectElement.prototype.get y):
>+        (foo.svg.RectElement):
>+        (foo.svg.ScriptElement.new):
>+        (foo.svg.ScriptElement.prototype.get type):
>+        (foo.svg.ScriptElement.prototype.set type):
>+        (foo.svg.ScriptElement.prototype.get href):
>+        (foo.svg.ScriptElement):
>+        (foo.svg.SetElement.new):
>+        (foo.svg.SetElement.get supported):
>+        (foo.svg.SetElement):
>+        (foo.svg.StopElement.new):
>+        (foo.svg.StopElement.prototype.get gradientOffset):
>+        (foo.svg.StopElement):
>+        (foo.const.Interceptor_ListMixin.15):
>+        (foo.const.Interceptor_ImmutableListMixin.15):
>+        (foo.svg.StringList.prototype.get length):
>+        (foo.svg.StringList.prototype.get numberOfItems):
>+        (foo.svg.StringList.prototype._get):
>+        (foo.svg.StringList.prototype._set):
>+        (foo.svg.StringList.prototype.set length):
>+        (foo.svg.StringList.prototype.get first):
>+        (foo.svg.StringList.prototype.set first):
>+        (foo.svg.StringList.prototype.get last):
>+        (foo.svg.StringList.prototype.set last):
>+        (foo.svg.StringList.prototype.get single):
>+        (foo.svg.StringList.prototype.elementAt):
>+        (foo.svg.StringList.prototype.__setter__):
>+        (foo.svg.StringList.prototype.appendItem):
>+        (foo.svg.StringList.prototype.clear):
>+        (foo.svg.StringList.prototype.getItem):
>+        (foo.svg.StringList.prototype.initialize):
>+        (foo.svg.StringList.prototype.insertItemBefore):
>+        (foo.svg.StringList.prototype.removeItem):
>+        (foo.svg.StringList.prototype.replaceItem):
>+        (foo.svg.StringList):
>+        (foo.svg.StyleElement.new):
>+        (foo.svg.StyleElement.prototype.get disabled):
>+        (foo.svg.StyleElement.prototype.set disabled):
>+        (foo.svg.StyleElement.prototype.get media):
>+        (foo.svg.StyleElement.prototype.set media):
>+        (foo.svg.StyleElement.prototype.get sheet):
>+        (foo.svg.StyleElement.prototype.get type):
>+        (foo.svg.StyleElement.prototype.set type):
>+        (foo.svg.StyleElement):
>+        (foo.svg.AttributeClassSet.prototype.readClasses):
>+        (foo.svg.AttributeClassSet.prototype.writeClasses):
>+        (foo.svg.AttributeClassSet):
>+        (foo.svg.SvgSvgElement.new):
>+        (foo.svg.SvgSvgElement.prototype.get currentScale):
>+        (foo.svg.SvgSvgElement.prototype.set currentScale):
>+        (foo.svg.SvgSvgElement.prototype.get currentTranslate):
>+        (foo.svg.SvgSvgElement.prototype.get height):
>+        (foo.svg.SvgSvgElement.prototype.get width):
>+        (foo.svg.SvgSvgElement.prototype.get x):
>+        (foo.svg.SvgSvgElement.prototype.get y):
>+        (foo.svg.SvgSvgElement.prototype.animationsPaused):
>+        (foo.svg.SvgSvgElement.prototype.checkEnclosure):
>+        (foo.svg.SvgSvgElement.prototype.checkIntersection):
>+        (foo.svg.SvgSvgElement.prototype.createSvgAngle):
>+        (foo.svg.SvgSvgElement.prototype.createSvgLength):
>+        (foo.svg.SvgSvgElement.prototype.createSvgMatrix):
>+        (foo.svg.SvgSvgElement.prototype.createSvgNumber):
>+        (foo.svg.SvgSvgElement.prototype.createSvgPoint):
>+        (foo.svg.SvgSvgElement.prototype.createSvgRect):
>+        (foo.svg.SvgSvgElement.prototype.createSvgTransform):
>+        (foo.svg.SvgSvgElement.prototype.createSvgTransformFromMatrix):
>+        (foo.svg.SvgSvgElement.prototype.deselectAll):
>+        (foo.svg.SvgSvgElement.prototype.forceRedraw):
>+        (foo.svg.SvgSvgElement.prototype.getCurrentTime):
>+        (foo.svg.SvgSvgElement.prototype.getElementById):
>+        (foo.svg.SvgSvgElement.prototype.getEnclosureList):
>+        (foo.svg.SvgSvgElement.prototype.getIntersectionList):
>+        (foo.svg.SvgSvgElement.prototype.pauseAnimations):
>+        (foo.svg.SvgSvgElement.prototype.setCurrentTime):
>+        (foo.svg.SvgSvgElement.prototype.suspendRedraw):
>+        (foo.svg.SvgSvgElement.prototype.unpauseAnimations):
>+        (foo.svg.SvgSvgElement.prototype.unsuspendRedraw):
>+        (foo.svg.SvgSvgElement.prototype.unsuspendRedrawAll):
>+        (foo.svg.SvgSvgElement.prototype.get preserveAspectRatio):
>+        (foo.svg.SvgSvgElement.prototype.get viewBox):
>+        (foo.svg.SvgSvgElement.prototype.get zoomAndPan):
>+        (foo.svg.SvgSvgElement.prototype.set zoomAndPan):
>+        (foo.svg.SvgSvgElement):
>+        (foo.svg.SwitchElement.new):
>+        (foo.svg.SwitchElement):
>+        (foo.svg.SymbolElement.new):
>+        (foo.svg.SymbolElement.prototype.get preserveAspectRatio):
>+        (foo.svg.SymbolElement.prototype.get viewBox):
>+        (foo.svg.SymbolElement):
>+        (foo.svg.TextContentElement.prototype.get lengthAdjust):
>+        (foo.svg.TextContentElement.prototype.get textLength):
>+        (foo.svg.TextContentElement.prototype.getCharNumAtPosition):
>+        (foo.svg.TextContentElement.prototype.getComputedTextLength):
>+        (foo.svg.TextContentElement.prototype.getEndPositionOfChar):
>+        (foo.svg.TextContentElement.prototype.getExtentOfChar):
>+        (foo.svg.TextContentElement.prototype.getNumberOfChars):
>+        (foo.svg.TextContentElement.prototype.getRotationOfChar):
>+        (foo.svg.TextContentElement.prototype.getStartPositionOfChar):
>+        (foo.svg.TextContentElement.prototype.getSubStringLength):
>+        (foo.svg.TextContentElement.prototype.selectSubString):
>+        (foo.svg.TextContentElement):
>+        (foo.svg.TextPositioningElement.prototype.get dx):
>+        (foo.svg.TextPositioningElement.prototype.get dy):
>+        (foo.svg.TextPositioningElement.prototype.get rotate):
>+        (foo.svg.TextPositioningElement.prototype.get x):
>+        (foo.svg.TextPositioningElement.prototype.get y):
>+        (foo.svg.TextPositioningElement):
>+        (foo.svg.TSpanElement.new):
>+        (foo.svg.TSpanElement):
>+        (foo.svg.Tests.prototype.get requiredExtensions):
>+        (foo.svg.Tests.prototype.set requiredExtensions):
>+        (foo.svg.Tests.prototype.get systemLanguage):
>+        (foo.svg.Tests.prototype.set systemLanguage):
>+        (foo.svg.Tests):
>+        (foo.svg.TextElement.new):
>+        (foo.svg.TextElement):
>+        (foo.svg.TextPathElement.prototype.get method):
>+        (foo.svg.TextPathElement.prototype.get spacing):
>+        (foo.svg.TextPathElement.prototype.get startOffset):
>+        (foo.svg.TextPathElement.prototype.get href):
>+        (foo.svg.TextPathElement):
>+        (foo.svg.TitleElement.new):
>+        (foo.svg.TitleElement):
>+        (foo.svg.Transform.prototype.get angle):
>+        (foo.svg.Transform.prototype.get matrix):
>+        (foo.svg.Transform.prototype.get type):
>+        (foo.svg.Transform.prototype.setMatrix):
>+        (foo.svg.Transform.prototype.setRotate):
>+        (foo.svg.Transform.prototype.setScale):
>+        (foo.svg.Transform.prototype.setSkewX):
>+        (foo.svg.Transform.prototype.setSkewY):
>+        (foo.svg.Transform.prototype.setTranslate):
>+        (foo.svg.Transform):
>+        (foo.const.Interceptor_ListMixin.16):
>+        (foo.const.Interceptor_ImmutableListMixin.16):
>+        (foo.svg.TransformList.prototype.get length):
>+        (foo.svg.TransformList.prototype.get numberOfItems):
>+        (foo.svg.TransformList.prototype._get):
>+        (foo.svg.TransformList.prototype._set):
>+        (foo.svg.TransformList.prototype.set length):
>+        (foo.svg.TransformList.prototype.get first):
>+        (foo.svg.TransformList.prototype.set first):
>+        (foo.svg.TransformList.prototype.get last):
>+        (foo.svg.TransformList.prototype.set last):
>+        (foo.svg.TransformList.prototype.get single):
>+        (foo.svg.TransformList.prototype.elementAt):
>+        (foo.svg.TransformList.prototype.__setter__):
>+        (foo.svg.TransformList.prototype.appendItem):
>+        (foo.svg.TransformList.prototype.clear):
>+        (foo.svg.TransformList.prototype.consolidate):
>+        (foo.svg.TransformList.prototype.createSvgTransformFromMatrix):
>+        (foo.svg.TransformList.prototype.getItem):
>+        (foo.svg.TransformList.prototype.initialize):
>+        (foo.svg.TransformList.prototype.insertItemBefore):
>+        (foo.svg.TransformList.prototype.removeItem):
>+        (foo.svg.TransformList.prototype.replaceItem):
>+        (foo.svg.TransformList):
>+        (foo.svg.UnitTypes):
>+        (foo.svg.UriReference.prototype.get href):
>+        (foo.svg.UriReference.prototype.set href):
>+        (foo.svg.UriReference):
>+        (foo.svg.UseElement.new):
>+        (foo.svg.UseElement.prototype.get height):
>+        (foo.svg.UseElement.prototype.get width):
>+        (foo.svg.UseElement.prototype.get x):
>+        (foo.svg.UseElement.prototype.get y):
>+        (foo.svg.UseElement.prototype.get href):
>+        (foo.svg.UseElement):
>+        (foo.svg.ViewElement.new):
>+        (foo.svg.ViewElement.prototype.get preserveAspectRatio):
>+        (foo.svg.ViewElement.prototype.get viewBox):
>+        (foo.svg.ViewElement.prototype.get zoomAndPan):
>+        (foo.svg.ViewElement.prototype.set zoomAndPan):
>+        (foo.svg.ViewElement):
>+        (foo.svg.ZoomAndPan.prototype.get zoomAndPan):
>+        (foo.svg.ZoomAndPan.prototype.set zoomAndPan):
>+        (foo.svg.ZoomAndPan):
>+        (foo.get svg._SVGFEDropShadowElement):
>+        (foo.svg._SVGMPathElement.new):
>+        (foo.svg._SVGMPathElement):
>+        (foo.web_audio.AudioNode.prototype.get channelCount):
>+        (foo.web_audio.AudioNode.prototype.set channelCount):
>+        (foo.web_audio.AudioNode.prototype.get channelCountMode):
>+        (foo.web_audio.AudioNode.prototype.set channelCountMode):
>+        (foo.web_audio.AudioNode.prototype.get channelInterpretation):
>+        (foo.web_audio.AudioNode.prototype.set channelInterpretation):
>+        (foo.web_audio.AudioNode.prototype.get context):
>+        (foo.web_audio.AudioNode.prototype.get numberOfInputs):
>+        (foo.web_audio.AudioNode.prototype.get numberOfOutputs):
>+        (foo.web_audio.AudioNode.prototype._connect):
>+        (foo.web_audio.AudioNode.prototype.disconnect):
>+        (foo.web_audio.AudioNode.prototype.connectNode):
>+        (foo.web_audio.AudioNode.prototype.connectParam):
>+        (foo.web_audio.AudioNode):
>+        (foo.get svg):
>+        (foo.web_audio.AnalyserNode.new):
>+        (foo.web_audio.AnalyserNode._create_1):
>+        (foo.web_audio.AnalyserNode._create_2):
>+        (foo.web_audio.AnalyserNode.prototype.get fftSize):
>+        (foo.web_audio.AnalyserNode.prototype.set fftSize):
>+        (foo.web_audio.AnalyserNode.prototype.get frequencyBinCount):
>+        (foo.web_audio.AnalyserNode.prototype.get maxDecibels):
>+        (foo.web_audio.AnalyserNode.prototype.set maxDecibels):
>+        (foo.web_audio.AnalyserNode.prototype.get minDecibels):
>+        (foo.web_audio.AnalyserNode.prototype.set minDecibels):
>+        (foo.web_audio.AnalyserNode.prototype.get smoothingTimeConstant):
>+        (foo.web_audio.AnalyserNode.prototype.set smoothingTimeConstant):
>+        (foo.web_audio.AnalyserNode.prototype.getByteFrequencyData):
>+        (foo.web_audio.AnalyserNode.prototype.getByteTimeDomainData):
>+        (foo.web_audio.AnalyserNode.prototype.getFloatFrequencyData):
>+        (foo.web_audio.AnalyserNode.prototype.getFloatTimeDomainData):
>+        (foo.web_audio.AnalyserNode):
>+        (foo.web_audio.AudioBuffer.new):
>+        (foo.web_audio.AudioBuffer._create_1):
>+        (foo.web_audio.AudioBuffer.prototype.get duration):
>+        (foo.web_audio.AudioBuffer.prototype.get length):
>+        (foo.web_audio.AudioBuffer.prototype.get numberOfChannels):
>+        (foo.web_audio.AudioBuffer.prototype.get sampleRate):
>+        (foo.web_audio.AudioBuffer.prototype.copyFromChannel):
>+        (foo.web_audio.AudioBuffer.prototype.copyToChannel):
>+        (foo.web_audio.AudioBuffer.prototype.getChannelData):
>+        (foo.web_audio.AudioBuffer):
>+        (foo.web_audio.AudioScheduledSourceNode.prototype.start2):
>+        (foo.web_audio.AudioScheduledSourceNode.prototype.stop):
>+        (foo.web_audio.AudioScheduledSourceNode.prototype.get onEnded):
>+        (foo.web_audio.AudioScheduledSourceNode):
>+        (foo.web_audio.AudioBufferSourceNode.new):
>+        (foo.web_audio.AudioBufferSourceNode._create_1):
>+        (foo.web_audio.AudioBufferSourceNode._create_2):
>+        (foo.web_audio.AudioBufferSourceNode.prototype.get buffer):
>+        (foo.web_audio.AudioBufferSourceNode.prototype.set buffer):
>+        (foo.web_audio.AudioBufferSourceNode.prototype.get detune):
>+        (foo.web_audio.AudioBufferSourceNode.prototype.get loop):
>+        (foo.web_audio.AudioBufferSourceNode.prototype.set loop):
>+        (foo.web_audio.AudioBufferSourceNode.prototype.get loopEnd):
>+        (foo.web_audio.AudioBufferSourceNode.prototype.set loopEnd):
>+        (foo.web_audio.AudioBufferSourceNode.prototype.get loopStart):
>+        (foo.web_audio.AudioBufferSourceNode.prototype.set loopStart):
>+        (foo.web_audio.AudioBufferSourceNode.prototype.get playbackRate):
>+        (foo.web_audio.AudioBufferSourceNode.prototype.start):
>+        (foo.web_audio.AudioBufferSourceNode):
>+        (foo.web_audio.BaseAudioContext.prototype.get currentTime):
>+        (foo.web_audio.BaseAudioContext.prototype.get destination):
>+        (foo.web_audio.BaseAudioContext.prototype.get listener):
>+        (foo.web_audio.BaseAudioContext.prototype.get sampleRate):
>+        (foo.web_audio.BaseAudioContext.prototype.get state):
>+        (foo.web_audio.BaseAudioContext.prototype.createAnalyser):
>+        (foo.web_audio.BaseAudioContext.prototype.createBiquadFilter):
>+        (foo.web_audio.BaseAudioContext.prototype.createBuffer):
>+        (foo.web_audio.BaseAudioContext.prototype.createBufferSource):
>+        (foo.web_audio.BaseAudioContext.prototype.createChannelMerger):
>+        (foo.web_audio.BaseAudioContext.prototype.createChannelSplitter):
>+        (foo.web_audio.BaseAudioContext.prototype.createConstantSource):
>+        (foo.web_audio.BaseAudioContext.prototype.createConvolver):
>+        (foo.web_audio.BaseAudioContext.prototype.createDelay):
>+        (foo.web_audio.BaseAudioContext.prototype.createDynamicsCompressor):
>+        (foo.web_audio.BaseAudioContext.prototype.createGain):
>+        (foo.web_audio.BaseAudioContext.prototype.createIirFilter):
>+        (foo.web_audio.BaseAudioContext.prototype.createMediaElementSource):
>+        (foo.web_audio.BaseAudioContext.prototype.createMediaStreamDestination):
>+        (foo.web_audio.BaseAudioContext.prototype.createMediaStreamSource):
>+        (foo.web_audio.BaseAudioContext.prototype.createOscillator):
>+        (foo.web_audio.BaseAudioContext.prototype.createPanner):
>+        (foo.web_audio.BaseAudioContext.prototype.createPeriodicWave):
>+        (foo.web_audio.BaseAudioContext.prototype._createPeriodicWave_1):
>+        (foo.web_audio.BaseAudioContext.prototype._createPeriodicWave_2):
>+        (foo.web_audio.BaseAudioContext.prototype.createScriptProcessor):
>+        (foo.web_audio.BaseAudioContext.prototype.createStereoPanner):
>+        (foo.web_audio.BaseAudioContext.prototype.createWaveShaper):
>+        (foo.web_audio.BaseAudioContext.prototype.decodeAudioData):
>+        (foo.web_audio.BaseAudioContext.prototype.resume):
>+        (foo.web_audio.BaseAudioContext):
>+        (foo.web_audio.AudioContext.get supported):
>+        (foo.web_audio.AudioContext.prototype.get baseLatency):
>+        (foo.web_audio.AudioContext.prototype.close):
>+        (foo.web_audio.AudioContext.prototype.getOutputTimestamp):
>+        (foo.web_audio.AudioContext.prototype._getOutputTimestamp_1):
>+        (foo.web_audio.AudioContext.prototype.suspend):
>+        (foo.web_audio.AudioContext.new):
>+        (foo.web_audio.AudioContext.prototype.createGain):
>+        (foo.web_audio.AudioContext.prototype.createScriptProcessor):
>+        (foo.web_audio.AudioContext.prototype._decodeAudioData):
>+        (foo.web_audio.AudioContext.prototype.decodeAudioData):
>+        (foo.web_audio.AudioContext):
>+        (foo.web_audio.AudioDestinationNode.prototype.get maxChannelCount):
>+        (foo.web_audio.AudioDestinationNode):
>+        (foo.web_audio.AudioListener.prototype.get forwardX):
>+        (foo.web_audio.AudioListener.prototype.get forwardY):
>+        (foo.web_audio.AudioListener.prototype.get forwardZ):
>+        (foo.web_audio.AudioListener.prototype.get positionX):
>+        (foo.web_audio.AudioListener.prototype.get positionY):
>+        (foo.web_audio.AudioListener.prototype.get positionZ):
>+        (foo.web_audio.AudioListener.prototype.get upX):
>+        (foo.web_audio.AudioListener.prototype.get upY):
>+        (foo.web_audio.AudioListener.prototype.get upZ):
>+        (foo.web_audio.AudioListener.prototype.setOrientation):
>+        (foo.web_audio.AudioListener.prototype.setPosition):
>+        (foo.web_audio.AudioListener):
>+        (foo.web_audio.AudioParam.prototype.get defaultValue):
>+        (foo.web_audio.AudioParam.prototype.get maxValue):
>+        (foo.web_audio.AudioParam.prototype.get minValue):
>+        (foo.web_audio.AudioParam.prototype.get value):
>+        (foo.web_audio.AudioParam.prototype.set value):
>+        (foo.web_audio.AudioParam.prototype.cancelAndHoldAtTime):
>+        (foo.web_audio.AudioParam.prototype.cancelScheduledValues):
>+        (foo.web_audio.AudioParam.prototype.exponentialRampToValueAtTime):
>+        (foo.web_audio.AudioParam.prototype.linearRampToValueAtTime):
>+        (foo.web_audio.AudioParam.prototype.setTargetAtTime):
>+        (foo.web_audio.AudioParam.prototype.setValueAtTime):
>+        (foo.web_audio.AudioParam.prototype.setValueCurveAtTime):
>+        (foo.web_audio.AudioParam):
>+        (foo.const.Interceptor_MapMixin.2):
>+        (foo.web_audio.AudioParamMap.prototype._getItem):
>+        (foo.web_audio.AudioParamMap.prototype.addAll):
>+        (foo.web_audio.AudioParamMap.prototype.containsValue):
>+        (foo.web_audio.AudioParamMap.prototype.containsKey):
>+        (foo.web_audio.AudioParamMap.prototype._get):
>+        (foo.web_audio.AudioParamMap.prototype.forEach):
>+        (foo.web_audio.AudioParamMap.prototype.get keys):
>+        (foo.web_audio.AudioParamMap.prototype.get values):
>+        (foo.web_audio.AudioParamMap.prototype.get length):
>+        (foo.web_audio.AudioParamMap.prototype.get isEmpty):
>+        (foo.web_audio.AudioParamMap.prototype.get isNotEmpty):
>+        (foo.web_audio.AudioParamMap.prototype._set):
>+        (foo.web_audio.AudioParamMap.prototype.putIfAbsent):
>+        (foo.web_audio.AudioParamMap.prototype.remove):
>+        (foo.web_audio.AudioParamMap.prototype.clear):
>+        (foo.web_audio.AudioParamMap):
>+        (foo.web_audio.AudioProcessingEvent.new):
>+        (foo.web_audio.AudioProcessingEvent._create_1):
>+        (foo.web_audio.AudioProcessingEvent.prototype.get inputBuffer):
>+        (foo.web_audio.AudioProcessingEvent.prototype.get outputBuffer):
>+        (foo.web_audio.AudioProcessingEvent.prototype.get playbackTime):
>+        (foo.web_audio.AudioProcessingEvent):
>+        (foo.web_audio.AudioTrack.prototype.get enabled):
>+        (foo.web_audio.AudioTrack.prototype.set enabled):
>+        (foo.web_audio.AudioTrack.prototype.get id):
>+        (foo.web_audio.AudioTrack.prototype.get kind):
>+        (foo.web_audio.AudioTrack.prototype.get label):
>+        (foo.web_audio.AudioTrack.prototype.get language):
>+        (foo.web_audio.AudioTrack.prototype.get sourceBuffer):
>+        (foo.web_audio.AudioTrack):
>+        (foo.web_audio.AudioTrackList.prototype.get length):
>+        (foo.web_audio.AudioTrackList.prototype.__getter__):
>+        (foo.web_audio.AudioTrackList.prototype.getTrackById):
>+        (foo.web_audio.AudioTrackList.prototype.get onChange):
>+        (foo.web_audio.AudioTrackList):
>+        (foo.web_audio.AudioWorkletGlobalScope.prototype.get currentTime):
>+        (foo.web_audio.AudioWorkletGlobalScope.prototype.get sampleRate):
>+        (foo.web_audio.AudioWorkletGlobalScope.prototype.registerProcessor):
>+        (foo.web_audio.AudioWorkletGlobalScope):
>+        (foo.web_audio.AudioWorkletNode.new):
>+        (foo.web_audio.AudioWorkletNode._create_1):
>+        (foo.web_audio.AudioWorkletNode._create_2):
>+        (foo.web_audio.AudioWorkletNode.prototype.get parameters):
>+        (foo.web_audio.AudioWorkletNode):
>+        (foo.web_audio.AudioWorkletProcessor):
>+        (foo.web_audio.BiquadFilterNode.new):
>+        (foo.web_audio.BiquadFilterNode._create_1):
>+        (foo.web_audio.BiquadFilterNode._create_2):
>+        (foo.web_audio.BiquadFilterNode.prototype.get Q):
>+        (foo.web_audio.BiquadFilterNode.prototype.get detune):
>+        (foo.web_audio.BiquadFilterNode.prototype.get frequency):
>+        (foo.web_audio.BiquadFilterNode.prototype.get gain):
>+        (foo.web_audio.BiquadFilterNode.prototype.get type):
>+        (foo.web_audio.BiquadFilterNode.prototype.set type):
>+        (foo.web_audio.BiquadFilterNode.prototype.getFrequencyResponse):
>+        (foo.web_audio.BiquadFilterNode):
>+        (foo.web_audio.ChannelMergerNode.new):
>+        (foo.web_audio.ChannelMergerNode._create_1):
>+        (foo.web_audio.ChannelMergerNode._create_2):
>+        (foo.web_audio.ChannelMergerNode):
>+        (foo.web_audio.ChannelSplitterNode.new):
>+        (foo.web_audio.ChannelSplitterNode._create_1):
>+        (foo.web_audio.ChannelSplitterNode._create_2):
>+        (foo.web_audio.ChannelSplitterNode):
>+        (foo.web_audio.ConstantSourceNode.new):
>+        (foo.web_audio.ConstantSourceNode._create_1):
>+        (foo.web_audio.ConstantSourceNode._create_2):
>+        (foo.web_audio.ConstantSourceNode.prototype.get offset):
>+        (foo.web_audio.ConstantSourceNode):
>+        (foo.web_audio.ConvolverNode.new):
>+        (foo.web_audio.ConvolverNode._create_1):
>+        (foo.web_audio.ConvolverNode._create_2):
>+        (foo.web_audio.ConvolverNode.prototype.get buffer):
>+        (foo.web_audio.ConvolverNode.prototype.set buffer):
>+        (foo.web_audio.ConvolverNode.prototype.get normalize):
>+        (foo.web_audio.ConvolverNode.prototype.set normalize):
>+        (foo.web_audio.ConvolverNode):
>+        (foo.web_audio.DelayNode.new):
>+        (foo.web_audio.DelayNode._create_1):
>+        (foo.web_audio.DelayNode._create_2):
>+        (foo.web_audio.DelayNode.prototype.get delayTime):
>+        (foo.web_audio.DelayNode):
>+        (foo.web_audio.DynamicsCompressorNode.new):
>+        (foo.web_audio.DynamicsCompressorNode._create_1):
>+        (foo.web_audio.DynamicsCompressorNode._create_2):
>+        (foo.web_audio.DynamicsCompressorNode.prototype.get attack):
>+        (foo.web_audio.DynamicsCompressorNode.prototype.get knee):
>+        (foo.web_audio.DynamicsCompressorNode.prototype.get ratio):
>+        (foo.web_audio.DynamicsCompressorNode.prototype.get reduction):
>+        (foo.web_audio.DynamicsCompressorNode.prototype.get release):
>+        (foo.web_audio.DynamicsCompressorNode.prototype.get threshold):
>+        (foo.web_audio.DynamicsCompressorNode):
>+        (foo.web_audio.GainNode.new):
>+        (foo.web_audio.GainNode._create_1):
>+        (foo.web_audio.GainNode._create_2):
>+        (foo.web_audio.GainNode.prototype.get gain):
>+        (foo.web_audio.GainNode):
>+        (foo.web_audio.IirFilterNode.new):
>+        (foo.web_audio.IirFilterNode._create_1):
>+        (foo.web_audio.IirFilterNode.prototype.getFrequencyResponse):
>+        (foo.web_audio.IirFilterNode):
>+        (foo.web_audio.MediaElementAudioSourceNode.new):
>+        (foo.web_audio.MediaElementAudioSourceNode._create_1):
>+        (foo.web_audio.MediaElementAudioSourceNode.prototype.get mediaElement):
>+        (foo.web_audio.MediaElementAudioSourceNode):
>+        (foo.web_audio.MediaStreamAudioDestinationNode.new):
>+        (foo.web_audio.MediaStreamAudioDestinationNode._create_1):
>+        (foo.web_audio.MediaStreamAudioDestinationNode._create_2):
>+        (foo.web_audio.MediaStreamAudioDestinationNode.prototype.get stream):
>+        (foo.web_audio.MediaStreamAudioDestinationNode):
>+        (foo.web_audio.MediaStreamAudioSourceNode.new):
>+        (foo.web_audio.MediaStreamAudioSourceNode._create_1):
>+        (foo.web_audio.MediaStreamAudioSourceNode.prototype.get mediaStream):
>+        (foo.web_audio.MediaStreamAudioSourceNode):
>+        (foo.web_audio.OfflineAudioCompletionEvent.new):
>+        (foo.web_audio.OfflineAudioCompletionEvent._create_1):
>+        (foo.web_audio.OfflineAudioCompletionEvent.prototype.get renderedBuffer):
>+        (foo.web_audio.OfflineAudioCompletionEvent):
>+        (foo.web_audio.OfflineAudioContext.new):
>+        (foo.web_audio.OfflineAudioContext._create_1):
>+        (foo.web_audio.OfflineAudioContext._create_2):
>+        (foo.web_audio.OfflineAudioContext.prototype.get length):
>+        (foo.web_audio.OfflineAudioContext.prototype.startRendering):
>+        (foo.web_audio.OfflineAudioContext.prototype.suspendFor):
>+        (foo.web_audio.OfflineAudioContext):
>+        (foo.web_audio.OscillatorNode.new):
>+        (foo.web_audio.OscillatorNode._create_1):
>+        (foo.web_audio.OscillatorNode._create_2):
>+        (foo.web_audio.OscillatorNode.prototype.get detune):
>+        (foo.web_audio.OscillatorNode.prototype.get frequency):
>+        (foo.web_audio.OscillatorNode.prototype.get type):
>+        (foo.web_audio.OscillatorNode.prototype.set type):
>+        (foo.web_audio.OscillatorNode.prototype.setPeriodicWave):
>+        (foo.web_audio.OscillatorNode):
>+        (foo.web_audio.PannerNode.new):
>+        (foo.web_audio.PannerNode._create_1):
>+        (foo.web_audio.PannerNode._create_2):
>+        (foo.web_audio.PannerNode.prototype.get coneInnerAngle):
>+        (foo.web_audio.PannerNode.prototype.set coneInnerAngle):
>+        (foo.web_audio.PannerNode.prototype.get coneOuterAngle):
>+        (foo.web_audio.PannerNode.prototype.set coneOuterAngle):
>+        (foo.web_audio.PannerNode.prototype.get coneOuterGain):
>+        (foo.web_audio.PannerNode.prototype.set coneOuterGain):
>+        (foo.web_audio.PannerNode.prototype.get distanceModel):
>+        (foo.web_audio.PannerNode.prototype.set distanceModel):
>+        (foo.web_audio.PannerNode.prototype.get maxDistance):
>+        (foo.web_audio.PannerNode.prototype.set maxDistance):
>+        (foo.web_audio.PannerNode.prototype.get orientationX):
>+        (foo.web_audio.PannerNode.prototype.get orientationY):
>+        (foo.web_audio.PannerNode.prototype.get orientationZ):
>+        (foo.web_audio.PannerNode.prototype.get panningModel):
>+        (foo.web_audio.PannerNode.prototype.set panningModel):
>+        (foo.web_audio.PannerNode.prototype.get positionX):
>+        (foo.web_audio.PannerNode.prototype.get positionY):
>+        (foo.web_audio.PannerNode.prototype.get positionZ):
>+        (foo.web_audio.PannerNode.prototype.get refDistance):
>+        (foo.web_audio.PannerNode.prototype.set refDistance):
>+        (foo.web_audio.PannerNode.prototype.get rolloffFactor):
>+        (foo.web_audio.PannerNode.prototype.set rolloffFactor):
>+        (foo.web_audio.PannerNode.prototype.setOrientation):
>+        (foo.web_audio.PannerNode.prototype.setPosition):
>+        (foo.web_audio.PannerNode):
>+        (foo.web_audio.PeriodicWave.new):
>+        (foo.web_audio.PeriodicWave._create_1):
>+        (foo.web_audio.PeriodicWave._create_2):
>+        (foo.web_audio.PeriodicWave):
>+        (foo.web_audio.ScriptProcessorNode.prototype.get bufferSize):
>+        (foo.web_audio.ScriptProcessorNode.prototype.setEventListener):
>+        (foo.web_audio.ScriptProcessorNode.prototype.get onAudioProcess):
>+        (foo.web_audio.ScriptProcessorNode):
>+        (foo.web_audio.StereoPannerNode.new):
>+        (foo.web_audio.StereoPannerNode._create_1):
>+        (foo.web_audio.StereoPannerNode._create_2):
>+        (foo.web_audio.StereoPannerNode.prototype.get pan):
>+        (foo.web_audio.StereoPannerNode):
>+        (foo.web_audio.WaveShaperNode.new):
>+        (foo.web_audio.WaveShaperNode._create_1):
>+        (foo.web_audio.WaveShaperNode._create_2):
>+        (foo.web_audio.WaveShaperNode.prototype.get curve):
>+        (foo.web_audio.WaveShaperNode.prototype.set curve):
>+        (foo.web_audio.WaveShaperNode.prototype.get oversample):
>+        (foo.web_audio.WaveShaperNode.prototype.set oversample):
>+        (foo.web_audio.WaveShaperNode):
>+        (foo.web_gl.ActiveInfo.prototype.get name):
>+        (foo.web_gl.ActiveInfo.prototype.get size):
>+        (foo.web_gl.ActiveInfo.prototype.get type):
>+        (foo.web_gl.ActiveInfo):
>+        (foo.web_gl.AngleInstancedArrays.prototype.drawArraysInstancedAngle):
>+        (foo.web_gl.AngleInstancedArrays.prototype.drawElementsInstancedAngle):
>+        (foo.web_gl.AngleInstancedArrays.prototype.vertexAttribDivisorAngle):
>+        (foo.web_gl.AngleInstancedArrays):
>+        (foo.web_gl.Buffer):
>+        (foo.web_gl.Canvas.prototype.get canvas):
>+        (foo.web_gl.Canvas.prototype.get offscreenCanvas):
>+        (foo.web_gl.Canvas):
>+        (foo.web_gl.ColorBufferFloat):
>+        (foo.web_gl.CompressedTextureAstc):
>+        (foo.web_gl.CompressedTextureAtc):
>+        (foo.web_gl.CompressedTextureETC1):
>+        (foo.web_gl.CompressedTextureEtc):
>+        (foo.web_gl.CompressedTexturePvrtc):
>+        (foo.web_gl.CompressedTextureS3TC):
>+        (foo.web_gl.CompressedTextureS3TCsRgb):
>+        (foo.web_gl.ContextEvent.new):
>+        (foo.web_gl.ContextEvent._create_1):
>+        (foo.web_gl.ContextEvent._create_2):
>+        (foo.web_gl.ContextEvent.prototype.get statusMessage):
>+        (foo.web_gl.ContextEvent):
>+        (foo.web_gl.DebugRendererInfo):
>+        (foo.web_gl.DebugShaders.prototype.getTranslatedShaderSource):
>+        (foo.web_gl.DebugShaders):
>+        (foo.web_gl.DepthTexture):
>+        (foo.web_gl.DrawBuffers.prototype.drawBuffersWebgl):
>+        (foo.web_gl.DrawBuffers):
>+        (foo.web_gl.EXTsRgb):
>+        (foo.web_gl.ExtBlendMinMax):
>+        (foo.web_gl.ExtColorBufferFloat):
>+        (foo.web_gl.ExtColorBufferHalfFloat):
>+        (foo.web_gl.ExtDisjointTimerQuery.prototype.beginQueryExt):
>+        (foo.web_gl.ExtDisjointTimerQuery.prototype.createQueryExt):
>+        (foo.web_gl.ExtDisjointTimerQuery.prototype.deleteQueryExt):
>+        (foo.web_gl.ExtDisjointTimerQuery.prototype.endQueryExt):
>+        (foo.web_gl.ExtDisjointTimerQuery.prototype.getQueryExt):
>+        (foo.web_gl.ExtDisjointTimerQuery.prototype.getQueryObjectExt):
>+        (foo.web_gl.ExtDisjointTimerQuery.prototype.isQueryExt):
>+        (foo.web_gl.ExtDisjointTimerQuery.prototype.queryCounterExt):
>+        (foo.web_gl.ExtDisjointTimerQuery):
>+        (foo.web_gl.ExtDisjointTimerQueryWebGL2.prototype.queryCounterExt):
>+        (foo.web_gl.ExtDisjointTimerQueryWebGL2):
>+        (foo.web_gl.ExtFragDepth):
>+        (foo.web_gl.ExtShaderTextureLod):
>+        (foo.web_gl.ExtTextureFilterAnisotropic):
>+        (foo.web_gl.Framebuffer):
>+        (foo.web_gl.GetBufferSubDataAsync.prototype.getBufferSubDataAsync):
>+        (foo.web_gl.GetBufferSubDataAsync):
>+        (foo.web_gl.LoseContext.prototype.loseContext):
>+        (foo.web_gl.LoseContext.prototype.restoreContext):
>+        (foo.web_gl.LoseContext):
>+        (foo.web_gl.OesElementIndexUint):
>+        (foo.web_gl.OesStandardDerivatives):
>+        (foo.web_gl.OesTextureFloat):
>+        (foo.web_gl.OesTextureFloatLinear):
>+        (foo.web_gl.OesTextureHalfFloat):
>+        (foo.web_gl.OesTextureHalfFloatLinear):
>+        (foo.web_gl.OesVertexArrayObject.prototype.bindVertexArray):
>+        (foo.web_gl.OesVertexArrayObject.prototype.createVertexArray):
>+        (foo.web_gl.OesVertexArrayObject.prototype.deleteVertexArray):
>+        (foo.web_gl.OesVertexArrayObject.prototype.isVertexArray):
>+        (foo.web_gl.OesVertexArrayObject):
>+        (foo.web_gl.Program):
>+        (foo.web_gl.Query):
>+        (foo.web_gl.Renderbuffer):
>+        (foo.web_gl.RenderingContext.get supported):
>+        (foo.web_gl.RenderingContext.prototype.get canvas):
>+        (foo.web_gl.RenderingContext.prototype.get drawingBufferHeight):
>+        (foo.web_gl.RenderingContext.prototype.get drawingBufferWidth):
>+        (foo.web_gl.RenderingContext.prototype.activeTexture):
>+        (foo.web_gl.RenderingContext.prototype.attachShader):
>+        (foo.web_gl.RenderingContext.prototype.bindAttribLocation):
>+        (foo.web_gl.RenderingContext.prototype.bindBuffer):
>+        (foo.web_gl.RenderingContext.prototype.bindFramebuffer):
>+        (foo.web_gl.RenderingContext.prototype.bindRenderbuffer):
>+        (foo.web_gl.RenderingContext.prototype.bindTexture):
>+        (foo.web_gl.RenderingContext.prototype.blendColor):
>+        (foo.web_gl.RenderingContext.prototype.blendEquation):
>+        (foo.web_gl.RenderingContext.prototype.blendEquationSeparate):
>+        (foo.web_gl.RenderingContext.prototype.blendFunc):
>+        (foo.web_gl.RenderingContext.prototype.blendFuncSeparate):
>+        (foo.web_gl.RenderingContext.prototype.bufferData):
>+        (foo.web_gl.RenderingContext.prototype.bufferSubData):
>+        (foo.web_gl.RenderingContext.prototype.checkFramebufferStatus):
>+        (foo.web_gl.RenderingContext.prototype.clear):
>+        (foo.web_gl.RenderingContext.prototype.clearColor):
>+        (foo.web_gl.RenderingContext.prototype.clearDepth):
>+        (foo.web_gl.RenderingContext.prototype.clearStencil):
>+        (foo.web_gl.RenderingContext.prototype.colorMask):
>+        (foo.web_gl.RenderingContext.prototype.commit):
>+        (foo.web_gl.RenderingContext.prototype.compileShader):
>+        (foo.web_gl.RenderingContext.prototype.compressedTexImage2D):
>+        (foo.web_gl.RenderingContext.prototype.compressedTexSubImage2D):
>+        (foo.web_gl.RenderingContext.prototype.copyTexImage2D):
>+        (foo.web_gl.RenderingContext.prototype.copyTexSubImage2D):
>+        (foo.web_gl.RenderingContext.prototype.createBuffer):
>+        (foo.web_gl.RenderingContext.prototype.createFramebuffer):
>+        (foo.web_gl.RenderingContext.prototype.createProgram):
>+        (foo.web_gl.RenderingContext.prototype.createRenderbuffer):
>+        (foo.web_gl.RenderingContext.prototype.createShader):
>+        (foo.web_gl.RenderingContext.prototype.createTexture):
>+        (foo.web_gl.RenderingContext.prototype.cullFace):
>+        (foo.web_gl.RenderingContext.prototype.deleteBuffer):
>+        (foo.web_gl.RenderingContext.prototype.deleteFramebuffer):
>+        (foo.web_gl.RenderingContext.prototype.deleteProgram):
>+        (foo.web_gl.RenderingContext.prototype.deleteRenderbuffer):
>+        (foo.web_gl.RenderingContext.prototype.deleteShader):
>+        (foo.web_gl.RenderingContext.prototype.deleteTexture):
>+        (foo.web_gl.RenderingContext.prototype.depthFunc):
>+        (foo.web_gl.RenderingContext.prototype.depthMask):
>+        (foo.web_gl.RenderingContext.prototype.depthRange):
>+        (foo.web_gl.RenderingContext.prototype.detachShader):
>+        (foo.web_gl.RenderingContext.prototype.disable):
>+        (foo.web_gl.RenderingContext.prototype.disableVertexAttribArray):
>+        (foo.web_gl.RenderingContext.prototype.drawArrays):
>+        (foo.web_gl.RenderingContext.prototype.drawElements):
>+        (foo.web_gl.RenderingContext.prototype.enable):
>+        (foo.web_gl.RenderingContext.prototype.enableVertexAttribArray):
>+        (foo.web_gl.RenderingContext.prototype.finish):
>+        (foo.web_gl.RenderingContext.prototype.flush):
>+        (foo.web_gl.RenderingContext.prototype.framebufferRenderbuffer):
>+        (foo.web_gl.RenderingContext.prototype.framebufferTexture2D):
>+        (foo.web_gl.RenderingContext.prototype.frontFace):
>+        (foo.web_gl.RenderingContext.prototype.generateMipmap):
>+        (foo.web_gl.RenderingContext.prototype.getActiveAttrib):
>+        (foo.web_gl.RenderingContext.prototype.getActiveUniform):
>+        (foo.web_gl.RenderingContext.prototype.getAttachedShaders):
>+        (foo.web_gl.RenderingContext.prototype.getAttribLocation):
>+        (foo.web_gl.RenderingContext.prototype.getBufferParameter):
>+        (foo.web_gl.RenderingContext.prototype.getContextAttributes):
>+        (foo.web_gl.RenderingContext.prototype._getContextAttributes_1):
>+        (foo.web_gl.RenderingContext.prototype.getError):
>+        (foo.web_gl.RenderingContext.prototype.getExtension):
>+        (foo.web_gl.RenderingContext.prototype.getFramebufferAttachmentParameter):
>+        (foo.web_gl.RenderingContext.prototype.getParameter):
>+        (foo.web_gl.RenderingContext.prototype.getProgramInfoLog):
>+        (foo.web_gl.RenderingContext.prototype.getProgramParameter):
>+        (foo.web_gl.RenderingContext.prototype.getRenderbufferParameter):
>+        (foo.web_gl.RenderingContext.prototype.getShaderInfoLog):
>+        (foo.web_gl.RenderingContext.prototype.getShaderParameter):
>+        (foo.web_gl.RenderingContext.prototype.getShaderPrecisionFormat):
>+        (foo.web_gl.RenderingContext.prototype.getShaderSource):
>+        (foo.web_gl.RenderingContext.prototype.getSupportedExtensions):
>+        (foo.web_gl.RenderingContext.prototype.getTexParameter):
>+        (foo.web_gl.RenderingContext.prototype.getUniform):
>+        (foo.web_gl.RenderingContext.prototype.getUniformLocation):
>+        (foo.web_gl.RenderingContext.prototype.getVertexAttrib):
>+        (foo.web_gl.RenderingContext.prototype.getVertexAttribOffset):
>+        (foo.web_gl.RenderingContext.prototype.hint):
>+        (foo.web_gl.RenderingContext.prototype.isBuffer):
>+        (foo.web_gl.RenderingContext.prototype.isContextLost):
>+        (foo.web_gl.RenderingContext.prototype.isEnabled):
>+        (foo.web_gl.RenderingContext.prototype.isFramebuffer):
>+        (foo.web_gl.RenderingContext.prototype.isProgram):
>+        (foo.web_gl.RenderingContext.prototype.isRenderbuffer):
>+        (foo.web_gl.RenderingContext.prototype.isShader):
>+        (foo.web_gl.RenderingContext.prototype.isTexture):
>+        (foo.web_gl.RenderingContext.prototype.lineWidth):
>+        (foo.web_gl.RenderingContext.prototype.linkProgram):
>+        (foo.web_gl.RenderingContext.prototype.pixelStorei):
>+        (foo.web_gl.RenderingContext.prototype.polygonOffset):
>+        (foo.web_gl.RenderingContext.prototype._readPixels):
>+        (foo.web_gl.RenderingContext.prototype.renderbufferStorage):
>+        (foo.web_gl.RenderingContext.prototype.sampleCoverage):
>+        (foo.web_gl.RenderingContext.prototype.scissor):
>+        (foo.web_gl.RenderingContext.prototype.shaderSource):
>+        (foo.web_gl.RenderingContext.prototype.stencilFunc):
>+        (foo.web_gl.RenderingContext.prototype.stencilFuncSeparate):
>+        (foo.web_gl.RenderingContext.prototype.stencilMask):
>+        (foo.web_gl.RenderingContext.prototype.stencilMaskSeparate):
>+        (foo.web_gl.RenderingContext.prototype.stencilOp):
>+        (foo.web_gl.RenderingContext.prototype.stencilOpSeparate):
>+        (foo.web_gl.RenderingContext.prototype.texImage2D):
>+        (foo.web_gl.RenderingContext.prototype._texImage2D_1):
>+        (foo.web_gl.RenderingContext.prototype._texImage2D_2):
>+        (foo.web_gl.RenderingContext.prototype._texImage2D_3):
>+        (foo.web_gl.RenderingContext.prototype._texImage2D_4):
>+        (foo.web_gl.RenderingContext.prototype._texImage2D_5):
>+        (foo.web_gl.RenderingContext.prototype._texImage2D_6):
>+        (foo.web_gl.RenderingContext.prototype.texParameterf):
>+        (foo.web_gl.RenderingContext.prototype.texParameteri):
>+        (foo.web_gl.RenderingContext.prototype.texSubImage2D):
>+        (foo.web_gl.RenderingContext.prototype._texSubImage2D_1):
>+        (foo.web_gl.RenderingContext.prototype._texSubImage2D_2):
>+        (foo.web_gl.RenderingContext.prototype._texSubImage2D_3):
>+        (foo.web_gl.RenderingContext.prototype._texSubImage2D_4):
>+        (foo.web_gl.RenderingContext.prototype._texSubImage2D_5):
>+        (foo.web_gl.RenderingContext.prototype._texSubImage2D_6):
>+        (foo.web_gl.RenderingContext.prototype.uniform1f):
>+        (foo.web_gl.RenderingContext.prototype.uniform1fv):
>+        (foo.web_gl.RenderingContext.prototype.uniform1i):
>+        (foo.web_gl.RenderingContext.prototype.uniform1iv):
>+        (foo.web_gl.RenderingContext.prototype.uniform2f):
>+        (foo.web_gl.RenderingContext.prototype.uniform2fv):
>+        (foo.web_gl.RenderingContext.prototype.uniform2i):
>+        (foo.web_gl.RenderingContext.prototype.uniform2iv):
>+        (foo.web_gl.RenderingContext.prototype.uniform3f):
>+        (foo.web_gl.RenderingContext.prototype.uniform3fv):
>+        (foo.web_gl.RenderingContext.prototype.uniform3i):
>+        (foo.web_gl.RenderingContext.prototype.uniform3iv):
>+        (foo.web_gl.RenderingContext.prototype.uniform4f):
>+        (foo.web_gl.RenderingContext.prototype.uniform4fv):
>+        (foo.web_gl.RenderingContext.prototype.uniform4i):
>+        (foo.web_gl.RenderingContext.prototype.uniform4iv):
>+        (foo.web_gl.RenderingContext.prototype.uniformMatrix2fv):
>+        (foo.web_gl.RenderingContext.prototype.uniformMatrix3fv):
>+        (foo.web_gl.RenderingContext.prototype.uniformMatrix4fv):
>+        (foo.web_gl.RenderingContext.prototype.useProgram):
>+        (foo.web_gl.RenderingContext.prototype.validateProgram):
>+        (foo.web_gl.RenderingContext.prototype.vertexAttrib1f):
>+        (foo.web_gl.RenderingContext.prototype.vertexAttrib1fv):
>+        (foo.web_gl.RenderingContext.prototype.vertexAttrib2f):
>+        (foo.web_gl.RenderingContext.prototype.vertexAttrib2fv):
>+        (foo.web_gl.RenderingContext.prototype.vertexAttrib3f):
>+        (foo.web_gl.RenderingContext.prototype.vertexAttrib3fv):
>+        (foo.web_gl.RenderingContext.prototype.vertexAttrib4f):
>+        (foo.web_gl.RenderingContext.prototype.vertexAttrib4fv):
>+        (foo.web_gl.RenderingContext.prototype.vertexAttribPointer):
>+        (foo.web_gl.RenderingContext.prototype.viewport):
>+        (foo.web_gl.RenderingContext.prototype.readPixels):
>+        (foo.web_gl.RenderingContext.prototype.texImage2DUntyped):
>+        (foo.web_gl.RenderingContext.prototype.texImage2DTyped):
>+        (foo.web_gl.RenderingContext.prototype.texSubImage2DUntyped):
>+        (foo.web_gl.RenderingContext.prototype.texSubImage2DTyped):
>+        (foo.web_gl.RenderingContext.prototype.bufferDataTyped):
>+        (foo.web_gl.RenderingContext.prototype.bufferSubDataTyped):
>+        (foo.web_gl.RenderingContext):
>+        (foo.web_gl.RenderingContext2.prototype.get canvas):
>+        (foo.web_gl.RenderingContext2.prototype.beginQuery):
>+        (foo.web_gl.RenderingContext2.prototype.beginTransformFeedback):
>+        (foo.web_gl.RenderingContext2.prototype.bindBufferBase):
>+        (foo.web_gl.RenderingContext2.prototype.bindBufferRange):
>+        (foo.web_gl.RenderingContext2.prototype.bindSampler):
>+        (foo.web_gl.RenderingContext2.prototype.bindTransformFeedback):
>+        (foo.web_gl.RenderingContext2.prototype.bindVertexArray):
>+        (foo.web_gl.RenderingContext2.prototype.blitFramebuffer):
>+        (foo.web_gl.RenderingContext2.prototype.bufferData2):
>+        (foo.web_gl.RenderingContext2.prototype.bufferSubData2):
>+        (foo.web_gl.RenderingContext2.prototype.clearBufferfi):
>+        (foo.web_gl.RenderingContext2.prototype.clearBufferfv):
>+        (foo.web_gl.RenderingContext2.prototype.clearBufferiv):
>+        (foo.web_gl.RenderingContext2.prototype.clearBufferuiv):
>+        (foo.web_gl.RenderingContext2.prototype.clientWaitSync):
>+        (foo.web_gl.RenderingContext2.prototype.compressedTexImage2D2):
>+        (foo.web_gl.RenderingContext2.prototype.compressedTexImage2D3):
>+        (foo.web_gl.RenderingContext2.prototype.compressedTexImage3D):
>+        (foo.web_gl.RenderingContext2.prototype.compressedTexImage3D2):
>+        (foo.web_gl.RenderingContext2.prototype.compressedTexSubImage2D2):
>+        (foo.web_gl.RenderingContext2.prototype.compressedTexSubImage2D3):
>+        (foo.web_gl.RenderingContext2.prototype.compressedTexSubImage3D):
>+        (foo.web_gl.RenderingContext2.prototype.compressedTexSubImage3D2):
>+        (foo.web_gl.RenderingContext2.prototype.copyBufferSubData):
>+        (foo.web_gl.RenderingContext2.prototype.copyTexSubImage3D):
>+        (foo.web_gl.RenderingContext2.prototype.createQuery):
>+        (foo.web_gl.RenderingContext2.prototype.createSampler):
>+        (foo.web_gl.RenderingContext2.prototype.createTransformFeedback):
>+        (foo.web_gl.RenderingContext2.prototype.createVertexArray):
>+        (foo.web_gl.RenderingContext2.prototype.deleteQuery):
>+        (foo.web_gl.RenderingContext2.prototype.deleteSampler):
>+        (foo.web_gl.RenderingContext2.prototype.deleteSync):
>+        (foo.web_gl.RenderingContext2.prototype.deleteTransformFeedback):
>+        (foo.web_gl.RenderingContext2.prototype.deleteVertexArray):
>+        (foo.web_gl.RenderingContext2.prototype.drawArraysInstanced):
>+        (foo.web_gl.RenderingContext2.prototype.drawBuffers):
>+        (foo.web_gl.RenderingContext2.prototype.drawElementsInstanced):
>+        (foo.web_gl.RenderingContext2.prototype.drawRangeElements):
>+        (foo.web_gl.RenderingContext2.prototype.endQuery):
>+        (foo.web_gl.RenderingContext2.prototype.endTransformFeedback):
>+        (foo.web_gl.RenderingContext2.prototype.fenceSync):
>+        (foo.web_gl.RenderingContext2.prototype.framebufferTextureLayer):
>+        (foo.web_gl.RenderingContext2.prototype.getActiveUniformBlockName):
>+        (foo.web_gl.RenderingContext2.prototype.getActiveUniformBlockParameter):
>+        (foo.web_gl.RenderingContext2.prototype.getActiveUniforms):
>+        (foo.web_gl.RenderingContext2.prototype.getBufferSubData):
>+        (foo.web_gl.RenderingContext2.prototype.getFragDataLocation):
>+        (foo.web_gl.RenderingContext2.prototype.getIndexedParameter):
>+        (foo.web_gl.RenderingContext2.prototype.getInternalformatParameter):
>+        (foo.web_gl.RenderingContext2.prototype.getQuery):
>+        (foo.web_gl.RenderingContext2.prototype.getQueryParameter):
>+        (foo.web_gl.RenderingContext2.prototype.getSamplerParameter):
>+        (foo.web_gl.RenderingContext2.prototype.getSyncParameter):
>+        (foo.web_gl.RenderingContext2.prototype.getTransformFeedbackVarying):
>+        (foo.web_gl.RenderingContext2.prototype.getUniformBlockIndex):
>+        (foo.web_gl.RenderingContext2.prototype.getUniformIndices):
>+        (foo.web_gl.RenderingContext2.prototype._getUniformIndices_1):
>+        (foo.web_gl.RenderingContext2.prototype.invalidateFramebuffer):
>+        (foo.web_gl.RenderingContext2.prototype.invalidateSubFramebuffer):
>+        (foo.web_gl.RenderingContext2.prototype.isQuery):
>+        (foo.web_gl.RenderingContext2.prototype.isSampler):
>+        (foo.web_gl.RenderingContext2.prototype.isSync):
>+        (foo.web_gl.RenderingContext2.prototype.isTransformFeedback):
>+        (foo.web_gl.RenderingContext2.prototype.isVertexArray):
>+        (foo.web_gl.RenderingContext2.prototype.pauseTransformFeedback):
>+        (foo.web_gl.RenderingContext2.prototype.readBuffer):
>+        (foo.web_gl.RenderingContext2.prototype.readPixels2):
>+        (foo.web_gl.RenderingContext2.prototype.renderbufferStorageMultisample):
>+        (foo.web_gl.RenderingContext2.prototype.resumeTransformFeedback):
>+        (foo.web_gl.RenderingContext2.prototype.samplerParameterf):
>+        (foo.web_gl.RenderingContext2.prototype.samplerParameteri):
>+        (foo.web_gl.RenderingContext2.prototype.texImage2D2):
>+        (foo.web_gl.RenderingContext2.prototype._texImage2D2_1):
>+        (foo.web_gl.RenderingContext2.prototype._texImage2D2_2):
>+        (foo.web_gl.RenderingContext2.prototype._texImage2D2_3):
>+        (foo.web_gl.RenderingContext2.prototype._texImage2D2_4):
>+        (foo.web_gl.RenderingContext2.prototype._texImage2D2_5):
>+        (foo.web_gl.RenderingContext2.prototype._texImage2D2_6):
>+        (foo.web_gl.RenderingContext2.prototype._texImage2D2_7):
>+        (foo.web_gl.RenderingContext2.prototype.texImage3D):
>+        (foo.web_gl.RenderingContext2.prototype._texImage3D_1):
>+        (foo.web_gl.RenderingContext2.prototype._texImage3D_2):
>+        (foo.web_gl.RenderingContext2.prototype._texImage3D_3):
>+        (foo.web_gl.RenderingContext2.prototype._texImage3D_4):
>+        (foo.web_gl.RenderingContext2.prototype._texImage3D_5):
>+        (foo.web_gl.RenderingContext2.prototype._texImage3D_6):
>+        (foo.web_gl.RenderingContext2.prototype._texImage3D_7):
>+        (foo.web_gl.RenderingContext2.prototype._texImage3D_8):
>+        (foo.web_gl.RenderingContext2.prototype.texStorage2D):
>+        (foo.web_gl.RenderingContext2.prototype.texStorage3D):
>+        (foo.web_gl.RenderingContext2.prototype.texSubImage2D2):
>+        (foo.web_gl.RenderingContext2.prototype._texSubImage2D2_1):
>+        (foo.web_gl.RenderingContext2.prototype._texSubImage2D2_2):
>+        (foo.web_gl.RenderingContext2.prototype._texSubImage2D2_3):
>+        (foo.web_gl.RenderingContext2.prototype._texSubImage2D2_4):
>+        (foo.web_gl.RenderingContext2.prototype._texSubImage2D2_5):
>+        (foo.web_gl.RenderingContext2.prototype._texSubImage2D2_6):
>+        (foo.web_gl.RenderingContext2.prototype._texSubImage2D2_7):
>+        (foo.web_gl.RenderingContext2.prototype.texSubImage3D):
>+        (foo.web_gl.RenderingContext2.prototype._texSubImage3D_1):
>+        (foo.web_gl.RenderingContext2.prototype._texSubImage3D_2):
>+        (foo.web_gl.RenderingContext2.prototype._texSubImage3D_3):
>+        (foo.web_gl.RenderingContext2.prototype._texSubImage3D_4):
>+        (foo.web_gl.RenderingContext2.prototype._texSubImage3D_5):
>+        (foo.web_gl.RenderingContext2.prototype._texSubImage3D_6):
>+        (foo.web_gl.RenderingContext2.prototype._texSubImage3D_7):
>+        (foo.web_gl.RenderingContext2.prototype._texSubImage3D_8):
>+        (foo.web_gl.RenderingContext2.prototype.transformFeedbackVaryings):
>+        (foo.web_gl.RenderingContext2.prototype._transformFeedbackVaryings_1):
>+        (foo.web_gl.RenderingContext2.prototype.uniform1fv2):
>+        (foo.web_gl.RenderingContext2.prototype.uniform1iv2):
>+        (foo.web_gl.RenderingContext2.prototype.uniform1ui):
>+        (foo.web_gl.RenderingContext2.prototype.uniform1uiv):
>+        (foo.web_gl.RenderingContext2.prototype.uniform2fv2):
>+        (foo.web_gl.RenderingContext2.prototype.uniform2iv2):
>+        (foo.web_gl.RenderingContext2.prototype.uniform2ui):
>+        (foo.web_gl.RenderingContext2.prototype.uniform2uiv):
>+        (foo.web_gl.RenderingContext2.prototype.uniform3fv2):
>+        (foo.web_gl.RenderingContext2.prototype.uniform3iv2):
>+        (foo.web_gl.RenderingContext2.prototype.uniform3ui):
>+        (foo.web_gl.RenderingContext2.prototype.uniform3uiv):
>+        (foo.web_gl.RenderingContext2.prototype.uniform4fv2):
>+        (foo.web_gl.RenderingContext2.prototype.uniform4iv2):
>+        (foo.web_gl.RenderingContext2.prototype.uniform4ui):
>+        (foo.web_gl.RenderingContext2.prototype.uniform4uiv):
>+        (foo.web_gl.RenderingContext2.prototype.uniformBlockBinding):
>+        (foo.web_gl.RenderingContext2.prototype.uniformMatrix2fv2):
>+        (foo.web_gl.RenderingContext2.prototype.uniformMatrix2x3fv):
>+        (foo.web_gl.RenderingContext2.prototype.uniformMatrix2x4fv):
>+        (foo.web_gl.RenderingContext2.prototype.uniformMatrix3fv2):
>+        (foo.web_gl.RenderingContext2.prototype.uniformMatrix3x2fv):
>+        (foo.web_gl.RenderingContext2.prototype.uniformMatrix3x4fv):
>+        (foo.web_gl.RenderingContext2.prototype.uniformMatrix4fv2):
>+        (foo.web_gl.RenderingContext2.prototype.uniformMatrix4x2fv):
>+        (foo.web_gl.RenderingContext2.prototype.uniformMatrix4x3fv):
>+        (foo.web_gl.RenderingContext2.prototype.vertexAttribDivisor):
>+        (foo.web_gl.RenderingContext2.prototype.vertexAttribI4i):
>+        (foo.web_gl.RenderingContext2.prototype.vertexAttribI4iv):
>+        (foo.web_gl.RenderingContext2.prototype.vertexAttribI4ui):
>+        (foo.web_gl.RenderingContext2.prototype.vertexAttribI4uiv):
>+        (foo.web_gl.RenderingContext2.prototype.vertexAttribIPointer):
>+        (foo.web_gl.RenderingContext2.prototype.waitSync):
>+        (foo.web_gl.RenderingContext2.prototype.get drawingBufferHeight):
>+        (foo.web_gl.RenderingContext2.prototype.get drawingBufferWidth):
>+        (foo.web_gl.RenderingContext2.prototype.activeTexture):
>+        (foo.web_gl.RenderingContext2.prototype.attachShader):
>+        (foo.web_gl.RenderingContext2.prototype.bindAttribLocation):
>+        (foo.web_gl.RenderingContext2.prototype.bindBuffer):
>+        (foo.web_gl.RenderingContext2.prototype.bindFramebuffer):
>+        (foo.web_gl.RenderingContext2.prototype.bindRenderbuffer):
>+        (foo.web_gl.RenderingContext2.prototype.bindTexture):
>+        (foo.web_gl.RenderingContext2.prototype.blendColor):
>+        (foo.web_gl.RenderingContext2.prototype.blendEquation):
>+        (foo.web_gl.RenderingContext2.prototype.blendEquationSeparate):
>+        (foo.web_gl.RenderingContext2.prototype.blendFunc):
>+        (foo.web_gl.RenderingContext2.prototype.blendFuncSeparate):
>+        (foo.web_gl.RenderingContext2.prototype.bufferData):
>+        (foo.web_gl.RenderingContext2.prototype.bufferSubData):
>+        (foo.web_gl.RenderingContext2.prototype.checkFramebufferStatus):
>+        (foo.web_gl.RenderingContext2.prototype.clear):
>+        (foo.web_gl.RenderingContext2.prototype.clearColor):
>+        (foo.web_gl.RenderingContext2.prototype.clearDepth):
>+        (foo.web_gl.RenderingContext2.prototype.clearStencil):
>+        (foo.web_gl.RenderingContext2.prototype.colorMask):
>+        (foo.web_gl.RenderingContext2.prototype.commit):
>+        (foo.web_gl.RenderingContext2.prototype.compileShader):
>+        (foo.web_gl.RenderingContext2.prototype.compressedTexImage2D):
>+        (foo.web_gl.RenderingContext2.prototype.compressedTexSubImage2D):
>+        (foo.web_gl.RenderingContext2.prototype.copyTexImage2D):
>+        (foo.web_gl.RenderingContext2.prototype.copyTexSubImage2D):
>+        (foo.web_gl.RenderingContext2.prototype.createBuffer):
>+        (foo.web_gl.RenderingContext2.prototype.createFramebuffer):
>+        (foo.web_gl.RenderingContext2.prototype.createProgram):
>+        (foo.web_gl.RenderingContext2.prototype.createRenderbuffer):
>+        (foo.web_gl.RenderingContext2.prototype.createShader):
>+        (foo.web_gl.RenderingContext2.prototype.createTexture):
>+        (foo.web_gl.RenderingContext2.prototype.cullFace):
>+        (foo.web_gl.RenderingContext2.prototype.deleteBuffer):
>+        (foo.web_gl.RenderingContext2.prototype.deleteFramebuffer):
>+        (foo.web_gl.RenderingContext2.prototype.deleteProgram):
>+        (foo.web_gl.RenderingContext2.prototype.deleteRenderbuffer):
>+        (foo.web_gl.RenderingContext2.prototype.deleteShader):
>+        (foo.web_gl.RenderingContext2.prototype.deleteTexture):
>+        (foo.web_gl.RenderingContext2.prototype.depthFunc):
>+        (foo.web_gl.RenderingContext2.prototype.depthMask):
>+        (foo.web_gl.RenderingContext2.prototype.depthRange):
>+        (foo.web_gl.RenderingContext2.prototype.detachShader):
>+        (foo.web_gl.RenderingContext2.prototype.disable):
>+        (foo.web_gl.RenderingContext2.prototype.disableVertexAttribArray):
>+        (foo.web_gl.RenderingContext2.prototype.drawArrays):
>+        (foo.web_gl.RenderingContext2.prototype.drawElements):
>+        (foo.web_gl.RenderingContext2.prototype.enable):
>+        (foo.web_gl.RenderingContext2.prototype.enableVertexAttribArray):
>+        (foo.web_gl.RenderingContext2.prototype.finish):
>+        (foo.web_gl.RenderingContext2.prototype.flush):
>+        (foo.web_gl.RenderingContext2.prototype.framebufferRenderbuffer):
>+        (foo.web_gl.RenderingContext2.prototype.framebufferTexture2D):
>+        (foo.web_gl.RenderingContext2.prototype.frontFace):
>+        (foo.web_gl.RenderingContext2.prototype.generateMipmap):
>+        (foo.web_gl.RenderingContext2.prototype.getActiveAttrib):
>+        (foo.web_gl.RenderingContext2.prototype.getActiveUniform):
>+        (foo.web_gl.RenderingContext2.prototype.getAttachedShaders):
>+        (foo.web_gl.RenderingContext2.prototype.getAttribLocation):
>+        (foo.web_gl.RenderingContext2.prototype.getBufferParameter):
>+        (foo.web_gl.RenderingContext2.prototype.getContextAttributes):
>+        (foo.web_gl.RenderingContext2.prototype._getContextAttributes_1):
>+        (foo.web_gl.RenderingContext2.prototype.getError):
>+        (foo.web_gl.RenderingContext2.prototype.getExtension):
>+        (foo.web_gl.RenderingContext2.prototype.getFramebufferAttachmentParameter):
>+        (foo.web_gl.RenderingContext2.prototype.getParameter):
>+        (foo.web_gl.RenderingContext2.prototype.getProgramInfoLog):
>+        (foo.web_gl.RenderingContext2.prototype.getProgramParameter):
>+        (foo.web_gl.RenderingContext2.prototype.getRenderbufferParameter):
>+        (foo.web_gl.RenderingContext2.prototype.getShaderInfoLog):
>+        (foo.web_gl.RenderingContext2.prototype.getShaderParameter):
>+        (foo.web_gl.RenderingContext2.prototype.getShaderPrecisionFormat):
>+        (foo.web_gl.RenderingContext2.prototype.getShaderSource):
>+        (foo.web_gl.RenderingContext2.prototype.getSupportedExtensions):
>+        (foo.web_gl.RenderingContext2.prototype.getTexParameter):
>+        (foo.web_gl.RenderingContext2.prototype.getUniform):
>+        (foo.web_gl.RenderingContext2.prototype.getUniformLocation):
>+        (foo.web_gl.RenderingContext2.prototype.getVertexAttrib):
>+        (foo.web_gl.RenderingContext2.prototype.getVertexAttribOffset):
>+        (foo.web_gl.RenderingContext2.prototype.hint):
>+        (foo.web_gl.RenderingContext2.prototype.isBuffer):
>+        (foo.web_gl.RenderingContext2.prototype.isContextLost):
>+        (foo.web_gl.RenderingContext2.prototype.isEnabled):
>+        (foo.web_gl.RenderingContext2.prototype.isFramebuffer):
>+        (foo.web_gl.RenderingContext2.prototype.isProgram):
>+        (foo.web_gl.RenderingContext2.prototype.isRenderbuffer):
>+        (foo.web_gl.RenderingContext2.prototype.isShader):
>+        (foo.web_gl.RenderingContext2.prototype.isTexture):
>+        (foo.web_gl.RenderingContext2.prototype.lineWidth):
>+        (foo.web_gl.RenderingContext2.prototype.linkProgram):
>+        (foo.web_gl.RenderingContext2.prototype.pixelStorei):
>+        (foo.web_gl.RenderingContext2.prototype.polygonOffset):
>+        (foo.web_gl.RenderingContext2.prototype._readPixels):
>+        (foo.web_gl.RenderingContext2.prototype.renderbufferStorage):
>+        (foo.web_gl.RenderingContext2.prototype.sampleCoverage):
>+        (foo.web_gl.RenderingContext2.prototype.scissor):
>+        (foo.web_gl.RenderingContext2.prototype.shaderSource):
>+        (foo.web_gl.RenderingContext2.prototype.stencilFunc):
>+        (foo.web_gl.RenderingContext2.prototype.stencilFuncSeparate):
>+        (foo.web_gl.RenderingContext2.prototype.stencilMask):
>+        (foo.web_gl.RenderingContext2.prototype.stencilMaskSeparate):
>+        (foo.web_gl.RenderingContext2.prototype.stencilOp):
>+        (foo.web_gl.RenderingContext2.prototype.stencilOpSeparate):
>+        (foo.web_gl.RenderingContext2.prototype.texImage2D):
>+        (foo.web_gl.RenderingContext2.prototype._texImage2D_1):
>+        (foo.web_gl.RenderingContext2.prototype._texImage2D_2):
>+        (foo.web_gl.RenderingContext2.prototype._texImage2D_3):
>+        (foo.web_gl.RenderingContext2.prototype._texImage2D_4):
>+        (foo.web_gl.RenderingContext2.prototype._texImage2D_5):
>+        (foo.web_gl.RenderingContext2.prototype._texImage2D_6):
>+        (foo.web_gl.RenderingContext2.prototype.texParameterf):
>+        (foo.web_gl.RenderingContext2.prototype.texParameteri):
>+        (foo.web_gl.RenderingContext2.prototype.texSubImage2D):
>+        (foo.web_gl.RenderingContext2.prototype._texSubImage2D_1):
>+        (foo.web_gl.RenderingContext2.prototype._texSubImage2D_2):
>+        (foo.web_gl.RenderingContext2.prototype._texSubImage2D_3):
>+        (foo.web_gl.RenderingContext2.prototype._texSubImage2D_4):
>+        (foo.web_gl.RenderingContext2.prototype._texSubImage2D_5):
>+        (foo.web_gl.RenderingContext2.prototype._texSubImage2D_6):
>+        (foo.web_gl.RenderingContext2.prototype.uniform1f):
>+        (foo.web_gl.RenderingContext2.prototype.uniform1fv):
>+        (foo.web_gl.RenderingContext2.prototype.uniform1i):
>+        (foo.web_gl.RenderingContext2.prototype.uniform1iv):
>+        (foo.web_gl.RenderingContext2.prototype.uniform2f):
>+        (foo.web_gl.RenderingContext2.prototype.uniform2fv):
>+        (foo.web_gl.RenderingContext2.prototype.uniform2i):
>+        (foo.web_gl.RenderingContext2.prototype.uniform2iv):
>+        (foo.web_gl.RenderingContext2.prototype.uniform3f):
>+        (foo.web_gl.RenderingContext2.prototype.uniform3fv):
>+        (foo.web_gl.RenderingContext2.prototype.uniform3i):
>+        (foo.web_gl.RenderingContext2.prototype.uniform3iv):
>+        (foo.web_gl.RenderingContext2.prototype.uniform4f):
>+        (foo.web_gl.RenderingContext2.prototype.uniform4fv):
>+        (foo.web_gl.RenderingContext2.prototype.uniform4i):
>+        (foo.web_gl.RenderingContext2.prototype.uniform4iv):
>+        (foo.web_gl.RenderingContext2.prototype.uniformMatrix2fv):
>+        (foo.web_gl.RenderingContext2.prototype.uniformMatrix3fv):
>+        (foo.web_gl.RenderingContext2.prototype.uniformMatrix4fv):
>+        (foo.web_gl.RenderingContext2.prototype.useProgram):
>+        (foo.web_gl.RenderingContext2.prototype.validateProgram):
>+        (foo.web_gl.RenderingContext2.prototype.vertexAttrib1f):
>+        (foo.web_gl.RenderingContext2.prototype.vertexAttrib1fv):
>+        (foo.web_gl.RenderingContext2.prototype.vertexAttrib2f):
>+        (foo.web_gl.RenderingContext2.prototype.vertexAttrib2fv):
>+        (foo.web_gl.RenderingContext2.prototype.vertexAttrib3f):
>+        (foo.web_gl.RenderingContext2.prototype.vertexAttrib3fv):
>+        (foo.web_gl.RenderingContext2.prototype.vertexAttrib4f):
>+        (foo.web_gl.RenderingContext2.prototype.vertexAttrib4fv):
>+        (foo.web_gl.RenderingContext2.prototype.vertexAttribPointer):
>+        (foo.web_gl.RenderingContext2.prototype.viewport):
>+        (foo.web_gl.RenderingContext2.prototype.readPixels):
>+        (foo.web_gl.RenderingContext2):
>+        (foo.web_gl.Sampler):
>+        (foo.web_gl.Shader):
>+        (foo.web_gl.ShaderPrecisionFormat.prototype.get precision):
>+        (foo.web_gl.ShaderPrecisionFormat.prototype.get rangeMax):
>+        (foo.web_gl.ShaderPrecisionFormat.prototype.get rangeMin):
>+        (foo.web_gl.ShaderPrecisionFormat):
>+        (foo.web_gl.Sync):
>+        (foo.web_gl.Texture.prototype.get lastUploadedVideoFrameWasSkipped):
>+        (foo.web_gl.Texture.prototype.get lastUploadedVideoHeight):
>+        (foo.web_gl.Texture.prototype.get lastUploadedVideoTimestamp):
>+        (foo.web_gl.Texture.prototype.get lastUploadedVideoWidth):
>+        (foo.web_gl.Texture):
>+        (foo.web_gl.TimerQueryExt):
>+        (foo.web_gl.TransformFeedback):
>+        (foo.web_gl.UniformLocation):
>+        (foo.web_gl.VertexArrayObject):
>+        (foo.web_gl.VertexArrayObjectOes):
>+        (foo.web_gl.WebGL):
>+        (foo.web_gl._WebGL2RenderingContextBase):
>+        (foo.web_gl._WebGLRenderingContextBase):
>+        (foo.web_sql.SqlDatabase.get supported):
>+        (foo.web_sql.SqlDatabase.prototype.get version):
>+        (foo.web_sql.SqlDatabase.prototype._changeVersion):
>+        (foo.web_sql.SqlDatabase.prototype.changeVersion):
>+        (foo.web_sql.SqlDatabase.prototype._readTransaction):
>+        (foo.web_sql.SqlDatabase.prototype.readTransaction):
>+        (foo.web_sql.SqlDatabase.prototype.transaction):
>+        (foo.web_sql.SqlDatabase.prototype.transaction_future):
>+        (foo.web_sql.SqlDatabase):
>+        (foo.web_sql.SqlError.prototype.get code):
>+        (foo.web_sql.SqlError.prototype.get message):
>+        (foo.web_sql.SqlError):
>+        (foo.web_sql.SqlResultSet.prototype.get insertId):
>+        (foo.web_sql.SqlResultSet.prototype.get rows):
>+        (foo.web_sql.SqlResultSet.prototype.get rowsAffected):
>+        (foo.web_sql.SqlResultSet):
>+        (foo.const.Interceptor_ListMixin.17):
>+        (foo.const.Interceptor_ImmutableListMixin.17):
>+        (foo.web_sql.SqlResultSetRowList.prototype.get length):
>+        (foo.web_sql.SqlResultSetRowList.prototype._get):
>+        (foo.web_sql.SqlResultSetRowList.prototype._set):
>+        (foo.web_sql.SqlResultSetRowList.prototype.set length):
>+        (foo.web_sql.SqlResultSetRowList.prototype.get first):
>+        (foo.web_sql.SqlResultSetRowList.prototype.set first):
>+        (foo.web_sql.SqlResultSetRowList.prototype.get last):
>+        (foo.web_sql.SqlResultSetRowList.prototype.set last):
>+        (foo.web_sql.SqlResultSetRowList.prototype.get single):
>+        (foo.web_sql.SqlResultSetRowList.prototype.elementAt):
>+        (foo.web_sql.SqlResultSetRowList.prototype.item):
>+        (foo.web_sql.SqlResultSetRowList.prototype._item_1):
>+        (foo.web_sql.SqlResultSetRowList):
>+        (foo.web_sql.SqlTransaction.prototype._executeSql):
>+        (foo.web_sql.SqlTransaction.prototype.executeSql):
>+        (foo.web_sql.SqlTransaction):
>+        (foo._http.HttpServer.bind):
>+        (foo._http.HttpServer.bindSecure):
>+        (foo._http.HttpServer.listenOn):
>+        (foo._http.HttpServer):
>+        (foo._http.HttpConnectionsInfo):
>+        (foo._http.HttpHeaders):
>+        (foo.get _http.HeaderValue.new):
>+        (foo.get _http.HeaderValue.parse):
>+        (foo.get _http.HeaderValue):
>+        (foo._http.HttpSession):
>+        (foo._http.ContentType.new):
>+        (foo._http.ContentType.parse):
>+        (foo._http.ContentType):
>+        (foo.get _http):
>+        (foo.get _http.Cookie.new):
>+        (foo.get _http.Cookie.fromSetCookieValue):
>+        (foo.get _http.Cookie):
>+        (foo._http.HttpRequest):
>+        (foo._http.HttpResponse):
>+        (foo._http.HttpClient.new):
>+        (foo._http.HttpClient.findProxyFromEnvironment):
>+        (foo._http.HttpClient):
>+        (foo.get _http.HttpClientRequest):
>+        (foo._http.HttpClientResponse):
>+        (foo._http.HttpClientResponseCompressionState.prototype.toString):
>+        (foo._http.HttpClientResponseCompressionState):
>+        (foo._http.HttpClientCredentials):
>+        (foo._http.HttpClientBasicCredentials.new):
>+        (foo._http.HttpClientBasicCredentials):
>+        (foo._http.HttpClientDigestCredentials.new):
>+        (foo._http.HttpClientDigestCredentials):
>+        (foo._http.HttpConnectionInfo):
>+        (foo._http.RedirectInfo):
>+        (foo._http.DetachedSocket):
>+        (foo._http.HttpException.prototype.toString):
>+        (foo._http.HttpException):
>+        (foo._http.RedirectException.prototype.toString):
>+        (foo._http.RedirectException.prototype.get uri):
>+        (foo._http.RedirectException):
>+        (foo._http._CryptoUtils.getRandomBytes):
>+        (foo._http._CryptoUtils.bytesToHex):
>+        (foo._http._CryptoUtils.bytesToBase64):
>+        (foo._http._CryptoUtils.base64StringToBytes):
>+        (foo._http._CryptoUtils):
>+        (foo._http._HashBase.prototype.add):
>+        (foo._http._HashBase.prototype.close):
>+        (foo._http._HashBase.prototype.get blockSize):
>+        (foo._http._HashBase.prototype._add32):
>+        (foo._http._HashBase.prototype._roundUp):
>+        (foo._http._HashBase.prototype._rotl32):
>+        (foo._http._HashBase.prototype._resultAsBytes):
>+        (foo._http._HashBase.prototype._bytesToChunk):
>+        (foo._http._HashBase.prototype._wordToBytes):
>+        (foo._http._HashBase.prototype._iterate):
>+        (foo._http._HashBase.prototype._finalizeData):
>+        (foo._http._HashBase):
>+        (foo._http._MD5.prototype.newInstance):
>+        (foo._http._MD5.prototype._updateHash):
>+        (foo._http._MD5):
>+        (foo._http._SHA1.prototype.newInstance):
>+        (foo._http._SHA1.prototype._updateHash):
>+        (foo._http._SHA1):
>+        (foo._http.HttpDate.format):
>+        (foo._http.HttpDate.parse.expect):
>+        (foo._http.HttpDate.parse.expectWeekday):
>+        (foo._http.HttpDate.parse.expectMonth):
>+        (foo._http.HttpDate.parse.expectNum):
>+        (foo._http.HttpDate.parse.expectEnd):
>+        (foo._http.HttpDate.parse):
>+        (foo._http.HttpDate._parseCookieDate.error):
>+        (foo._http.HttpDate._parseCookieDate.isEnd):
>+        (foo._http.HttpDate._parseCookieDate.isDelimiter):
>+        (foo._http.HttpDate._parseCookieDate.isNonDelimiter):
>+        (foo._http.HttpDate._parseCookieDate.isDigit):
>+        (foo._http.HttpDate._parseCookieDate.getMonth):
>+        (foo._http.HttpDate._parseCookieDate.toInt):
>+        (foo._http.HttpDate._parseCookieDate):
>+        (foo._http.HttpDate):
>+        (foo._http._HttpHeaders.prototype._get):
>+        (foo._http._HttpHeaders.prototype.value):
>+        (foo._http._HttpHeaders.prototype.add):
>+        (foo._http._HttpHeaders.prototype._addAll):
>+        (foo._http._HttpHeaders.prototype.set this):
>+        (foo._http._HttpHeaders.prototype.remove):
>+        (foo._http._HttpHeaders.prototype.removeAll):
>+        (foo._http._HttpHeaders.prototype.forEach):
>+        (foo._http._HttpHeaders.prototype.noFolding):
>+        (foo._http._HttpHeaders.prototype.get persistentConnection):
>+        (foo._http._HttpHeaders.prototype.set persistentConnection):
>+        (foo._http._HttpHeaders.prototype.get contentLength):
>+        (foo._http._HttpHeaders.prototype.set contentLength):
>+        (foo._http._HttpHeaders.prototype.get chunkedTransferEncoding):
>+        (foo._http._HttpHeaders.prototype.set chunkedTransferEncoding):
>+        (foo._http._HttpHeaders.prototype.get host):
>+        (foo._http._HttpHeaders.prototype.set host):
>+        (foo._http._HttpHeaders.prototype.get port):
>+        (foo._http._HttpHeaders.prototype.set port):
>+        (foo._http._HttpHeaders.prototype.get ifModifiedSince):
>+        (foo._http._HttpHeaders.prototype.set ifModifiedSince):
>+        (foo._http._HttpHeaders.prototype.get date):
>+        (foo._http._HttpHeaders.prototype.set date):
>+        (foo._http._HttpHeaders.prototype.get expires):
>+        (foo._http._HttpHeaders.prototype.set expires):
>+        (foo._http._HttpHeaders.prototype.get contentType):
>+        (foo._http._HttpHeaders.prototype.set contentType):
>+        (foo._http._HttpHeaders.prototype.clear):
>+        (foo._http._HttpHeaders.prototype._add.2):
>+        (foo._http._HttpHeaders.prototype._addContentLength):
>+        (foo._http._HttpHeaders.prototype._addTransferEncoding):
>+        (foo._http._HttpHeaders.prototype._addDate):
>+        (foo._http._HttpHeaders.prototype._addExpires):
>+        (foo._http._HttpHeaders.prototype._addIfModifiedSince):
>+        (foo._http._HttpHeaders.prototype._addHost):
>+        (foo._http._HttpHeaders.prototype._addConnection):
>+        (foo._http._HttpHeaders.prototype._addContentType):
>+        (foo._http._HttpHeaders.prototype._addValue):
>+        (foo._http._HttpHeaders.prototype._set):
>+        (foo._http._HttpHeaders.prototype._checkMutable):
>+        (foo._http._HttpHeaders.prototype._updateHostHeader):
>+        (foo._http._HttpHeaders.prototype._foldHeader):
>+        (foo._http._HttpHeaders.prototype._finalize):
>+        (foo._http._HttpHeaders.prototype._build):
>+        (foo._http._HttpHeaders.prototype.toString):
>+        (foo._http._HttpHeaders.prototype._parseCookies.parseCookieString.done):
>+        (foo._http._HttpHeaders.prototype._parseCookies.parseCookieString.skipWS):
>+        (foo._http._HttpHeaders.prototype._parseCookies.parseCookieString.parseName):
>+        (foo._http._HttpHeaders.prototype._parseCookies.parseCookieString.parseValue):
>+        (foo._http._HttpHeaders.prototype._parseCookies.parseCookieString.expect):
>+        (foo._http._HttpHeaders.prototype._parseCookies.parseCookieString):
>+        (foo._http._HttpHeaders.prototype._parseCookies):
>+        (foo._http._HttpHeaders._validateField):
>+        (foo._http._HttpHeaders._validateValue):
>+        (foo._http._HttpHeaders):
>+        (foo._http._HeaderValue.parse):
>+        (foo._http._HeaderValue.prototype.get value):
>+        (foo._http._HeaderValue.prototype._ensureParameters):
>+        (foo._http._HeaderValue.prototype.get parameters):
>+        (foo._http._HeaderValue.prototype.toString):
>+        (foo._http._HeaderValue.prototype._parse.done):
>+        (foo._http._HeaderValue.prototype._parse.skipWS):
>+        (foo._http._HeaderValue.prototype._parse.parseValue):
>+        (foo._http._HeaderValue.prototype._parse.expect):
>+        (foo._http._HeaderValue.prototype._parse.maybeExpect):
>+        (foo._http._HeaderValue.prototype._parse.const.parseParameters.parseParameterName):
>+        (foo._http._HeaderValue.prototype._parse.const.parseParameters.parseParameterValue):
>+        (foo._http._HeaderValue.prototype._parse):
>+        (foo._http._HeaderValue):
>+        (foo._http._ContentType.parse):
>+        (foo._http._ContentType.prototype.get mimeType):
>+        (foo._http._ContentType.prototype.get primaryType):
>+        (foo._http._ContentType.prototype.get subType):
>+        (foo._http._ContentType.prototype.get charset):
>+        (foo._http._ContentType):
>+        (foo._http._Cookie.prototype._parseSetCookieValue.done):
>+        (foo._http._Cookie.prototype._parseSetCookieValue.parseName):
>+        (foo._http._Cookie.prototype._parseSetCookieValue.parseValue):
>+        (foo._http._Cookie.prototype._parseSetCookieValue.expect):
>+        (foo._http._Cookie.prototype._parseSetCookieValue.const.parseAttributes):
>+        (foo._http._Cookie.prototype._parseSetCookieValue.const.parseAttributes.parseAttributeValue):
>+        (foo._http._Cookie.prototype._parseSetCookieValue):
>+        (foo._http._Cookie.prototype.toString):
>+        (foo._http._Cookie.prototype._validate):
>+        (foo._http._Cookie):
>+        (foo._http._ServiceObject.prototype.get _serviceId):
>+        (foo._http._ServiceObject.prototype.get _servicePath):
>+        (foo._http._ServiceObject.prototype._serviceType):
>+        (foo._http._ServiceObject):
>+        (foo._http._CopyingBytesBuilder.prototype.add):
>+        (foo._http._CopyingBytesBuilder.prototype.addByte):
>+        (foo._http._CopyingBytesBuilder.prototype._grow.0):
>+        (foo._http._CopyingBytesBuilder.prototype.takeBytes):
>+        (foo._http._CopyingBytesBuilder.prototype.toBytes):
>+        (foo._http._CopyingBytesBuilder.prototype.get length):
>+        (foo._http._CopyingBytesBuilder.prototype.get isEmpty):
>+        (foo._http._CopyingBytesBuilder.prototype.get isNotEmpty):
>+        (foo._http._CopyingBytesBuilder.prototype.clear):
>+        (foo._http._CopyingBytesBuilder._pow2roundup):
>+        (foo._http._CopyingBytesBuilder):
>+        (foo._http._HttpIncoming.prototype.get transferLength):
>+        (foo._http._HttpIncoming.prototype.listen):
>+        (foo._http._HttpIncoming.prototype.get dataDone):
>+        (foo._http._HttpIncoming.prototype.close):
>+        (foo._http._HttpIncoming):
>+        (foo._http._HttpInboundMessage.prototype.get cookies):
>+        (foo._http._HttpInboundMessage.prototype.get headers):
>+        (foo._http._HttpInboundMessage.prototype.get protocolVersion):
>+        (foo._http._HttpInboundMessage.prototype.get contentLength):
>+        (foo._http._HttpInboundMessage.prototype.get persistentConnection):
>+        (foo._http._HttpInboundMessage):
>+        (foo._http._HttpRequest.prototype.listen):
>+        (foo._http._HttpRequest.prototype.get uri):
>+        (foo._http._HttpRequest.prototype.get requestedUri):
>+        (foo._http._HttpRequest.prototype.get method):
>+        (foo._http._HttpRequest.prototype.get session):
>+        (foo._http._HttpRequest.prototype.get connectionInfo):
>+        (foo._http._HttpRequest.prototype.get certificate):
>+        (foo._http._HttpRequest):
>+        (foo._http._HttpClientResponse.prototype.get redirects):
>+        (foo._http._HttpClientResponse._getCompressionState):
>+        (foo._http._HttpClientResponse.prototype.get statusCode):
>+        (foo._http._HttpClientResponse.prototype.get reasonPhrase):
>+        (foo._http._HttpClientResponse.prototype.get certificate):
>+        (foo._http._HttpClientResponse.prototype.get cookies):
>+        (foo._http._HttpClientResponse.prototype.get isRedirect):
>+        (foo._http._HttpClientResponse.prototype.redirect):
>+        (foo._http._HttpClientResponse.prototype.listen):
>+        (foo._http._HttpClientResponse.prototype.detachSocket):
>+        (foo._http._HttpClientResponse.prototype.get connectionInfo):
>+        (foo._http._HttpClientResponse.prototype.get _shouldAuthenticateProxy):
>+        (foo._http._HttpClientResponse.prototype.get _shouldAuthenticate):
>+        (foo._http._HttpClientResponse.prototype._authenticate.else.return.async Future):
>+        (foo._http._HttpClientResponse.prototype._authenticate.return.async Future):
>+        (foo._http._HttpClientResponse.prototype._authenticate):
>+        (foo._http._StreamSinkImpl.dart.generic):
>+        (foo._http._HttpClientResponse):
>+        (foo._http._IOSinkImpl.prototype.get encoding):
>+        (foo._http._IOSinkImpl.prototype.set encoding):
>+        (foo._http._IOSinkImpl.prototype.write):
>+        (foo._http._IOSinkImpl.prototype.writeAll):
>+        (foo._http._IOSinkImpl.prototype.writeln):
>+        (foo._http._IOSinkImpl.prototype.writeCharCode):
>+        (foo._http._IOSinkImpl):
>+        (foo.svg.ImageElement.async set this):
>+        (foo.svg.ImageElement.prototype.async get return):
>+        (foo._http._HttpOutboundMessage.dart.generic):
>+        (foo.svg.ImageElement):
>+        (foo._http._HttpResponse.prototype.get _isConnectionClosed):
>+        (foo._http._HttpResponse.prototype.get cookies):
>+        (foo._http._HttpResponse.prototype.get statusCode):
>+        (foo._http._HttpResponse.prototype.set statusCode):
>+        (foo._http._HttpResponse.prototype.get reasonPhrase):
>+        (foo._http._HttpResponse.prototype.set reasonPhrase):
>+        (foo._http._HttpResponse.prototype.redirect):
>+        (foo._http._HttpResponse.prototype.detachSocket):
>+        (foo._http._HttpResponse.prototype.get connectionInfo):
>+        (foo._http._HttpResponse.prototype.get deadline):
>+        (foo._http._HttpResponse.set deadline.this._deadlineTimer.async Timer):
>+        (foo._http._HttpResponse.prototype.set deadline):
>+        (foo._http._HttpResponse.prototype._writeHeader):
>+        (foo._http._HttpResponse.prototype._findReasonPhrase):
>+        (foo._http._HttpResponse):
>+        (foo._http._HttpClientRequest.get maxRedirects):
>+        (foo._http._HttpClientRequest.set maxRedirects):
>+        (foo._http._HttpClientRequest.get followRedirects):
>+        (foo._http._HttpClientRequest.set followRedirects):
>+        (foo._http._HttpClientRequest.get connectionInfo):
>+        (foo._http._HttpClientRequest.get done.async return):
>+        (foo._http._HttpClientRequest.prototype.get done):
>+        (foo._http._HttpClientRequest.prototype._onError):
>+        (foo._http._HttpClientRequest.prototype._requestUri):
>+        (foo._http._HttpClientRequest.prototype._writeHeader):
>+        (foo._http._HttpClientRequest):
>+        (foo._http._HttpGZipSink.prototype.add):
>+        (foo._http._HttpGZipSink.prototype.addSlice):
>+        (foo._http._HttpGZipSink.prototype.close):
>+        (foo._http._HttpGZipSink):
>+        (foo._http._HttpOutgoing.prototype.writeHeaders):
>+        (foo._http._HttpOutgoing.prototype.addStream.return.async Future):
>+        (foo._http._HttpOutgoing.prototype.addStream):
>+        (foo._http._HttpOutgoing.prototype.close.else.return.this._closeFuture.async Future):
>+        (foo._http._HttpOutgoing.prototype.close.return.this._closeFuture.async Future):
>+        (foo._http._HttpOutgoing.prototype.close.return.async Future):
>+        (foo._http._HttpOutgoing.prototype.close):
>+        (foo._http._HttpOutgoing.prototype.get done):
>+        (foo._http._HttpOutgoing.prototype.setHeader):
>+        (foo._http._HttpOutgoing.prototype.set gzip):
>+        (foo._http._HttpOutgoing.prototype._ignoreError):
>+        (foo._http._HttpOutgoing.prototype._addGZipChunk):
>+        (foo._http._HttpOutgoing.prototype._addChunk):
>+        (foo._http._HttpOutgoing.prototype._chunkHeader):
>+        (foo._http._HttpOutgoing):
>+        (foo._http._HttpClientConnection.prototype.send):
>+        (foo._http._HttpClientConnection.prototype.detachSocket):
>+        (foo._http._HttpClientConnection.prototype.destroy):
>+        (foo._http._HttpClientConnection.prototype.close):
>+        (foo._http._HttpClientConnection.prototype.createProxyTunnel):
>+        (foo._http._HttpClientConnection.prototype.get connectionInfo):
>+        (foo._http._HttpClientConnection.makeKey):
>+        (foo._http._HttpClientConnection.prototype.stopTimer):
>+        (foo._http._HttpClientConnection.prototype.startTimer.this._idleTimer.async Timer):
>+        (foo._http._HttpClientConnection.prototype.startTimer):
>+        (foo._http._HttpClientConnection):
>+        (foo.async _http._ConnectionInfo):
>+        (foo.async _http):
>+        (foo._http._ConnectionTarget.prototype.get isEmpty):
>+        (foo._http._ConnectionTarget.prototype.get hasIdle):
>+        (foo._http._ConnectionTarget.prototype.get hasActive):
>+        (foo._http._ConnectionTarget.prototype.takeIdle):
>+        (foo._http._ConnectionTarget.prototype._checkPending):
>+        (foo._http._ConnectionTarget.prototype.addNewActive):
>+        (foo._http._ConnectionTarget.prototype.returnConnection):
>+        (foo._http._ConnectionTarget.prototype.connectionClosed):
>+        (foo._http._ConnectionTarget.prototype.close):
>+        (foo._http._ConnectionTarget.prototype.connect.callback):
>+        (foo._http._ConnectionTarget.prototype.connect):
>+        (foo._http._ConnectionTarget):
>+        (foo._http._HttpClient.prototype.get idleTimeout):
>+        (foo._http._HttpClient.prototype.set idleTimeout):
>+        (foo._http._HttpClient.prototype.set badCertificateCallback):
>+        (foo._http._HttpClient.prototype.open):
>+        (foo._http._HttpClient.prototype.openUrl):
>+        (foo._http._HttpClient.set authenticate):
>+        (foo._http._HttpClient.set authenticateProxy):
>+        (foo._http._HttpClient.set findProxy):
>+        (foo._http._HttpClient.prototype.get return):
>+        (foo._http._HttpClient.prototype.else):
>+        (foo._http._HttpClient.prototype.catch):
>+        (foo._http._HttpClient.):
>+        (foo._http._HttpClient.prototype._openUrlFromRequest):
>+        (foo._http._HttpClient.prototype._returnConnection):
>+        (foo._http._HttpClient.prototype._connectionClosed):
>+        (foo._http._HttpClient.prototype._connectionsChanged):
>+        (foo._http._HttpClient.prototype._closeConnections):
>+        (foo._http._HttpClient.prototype._getConnectionTarget):
>+        (foo._http._HttpClient.prototype._getConnection):
>+        (foo._http._HttpClient.prototype._findCredentials):
>+        (foo._http._HttpClient.prototype._findProxyCredentials):
>+        (foo._http._HttpClient.prototype._removeCredentials):
>+        (foo._http._HttpClient.prototype._removeProxyCredentials):
>+        (foo._http._HttpClient._findProxyFromEnvironment.checkNoProxy):
>+        (foo._http._HttpClient._findProxyFromEnvironment.checkProxy):
>+        (foo._http._HttpClient._findProxyFromEnvironment):
>+        (foo._http._HttpClient):
>+        (foo.const.LinkedListEntry__ServiceObject):
>+        (foo._http._HttpConnection.prototype.markIdle):
>+        (foo._http._HttpConnection.prototype.get isMarkedIdle):
>+        (foo._http._HttpConnection.prototype.destroy):
>+        (foo._http._HttpConnection.prototype.detachSocket):
>+        (foo._http._HttpConnection.prototype.get connectionInfo):
>+        (foo._http._HttpConnection.prototype.get _isActive):
>+        (foo._http._HttpConnection.prototype.get _isIdle):
>+        (foo._http._HttpConnection.prototype.get _isClosing):
>+        (foo._http._HttpConnection.prototype.get _isDetached):
>+        (foo._http._HttpConnection.prototype.get _serviceTypePath):
>+        (foo._http._HttpConnection.prototype.get _serviceTypeName):
>+        (foo._http._HttpConnection.prototype._toJSON):
>+        (foo._http._HttpConnection):
>+        (foo.const.Stream__ServiceObject):
>+        (foo._http._HttpServer.bind):
>+        (foo._http._HttpServer.bindSecure):
>+        (foo._http._HttpServer._initDefaultResponseHeaders):
>+        (foo._http._HttpServer.prototype.get idleTimeout):
>+        (foo._http._HttpServer.set idleTimeout.this._idleTimer.async Timer):
>+        (foo._http._HttpServer.prototype.set idleTimeout):
>+        (foo._http._HttpServer.prototype.listen):
>+        (foo._http._HttpServer.prototype.close.else.result.async Future):
>+        (foo._http._HttpServer.get port):
>+        (foo._http._HttpServer.get address):
>+        (foo._http._HttpServer.set sessionTimeout):
>+        (foo._http._HttpServer.get _sessionManager):
>+        (foo._http._HttpServer.prototype.close.result.async Future):
>+        (foo._http._HttpServer.prototype.close):
>+        (foo._http._HttpServer.prototype.get _serviceTypePath):
>+        (foo._http._HttpServer.prototype.get _serviceTypeName):
>+        (foo._http._HttpServer.prototype._toJSON):
>+        (foo._http._HttpServer):
>+        (foo._http._ProxyConfiguration):
>+        (foo.get _http._Proxy.prototype.get isAuthenticated):
>+        (foo.get _http._Proxy):
>+        (foo._http._HttpConnectionInfo.create):
>+        (foo._http._HttpConnectionInfo):
>+        (foo._http._DetachedSocket.prototype.listen):
>+        (foo._http._DetachedSocket.prototype.get encoding):
>+        (foo._http._DetachedSocket.prototype.set encoding):
>+        (foo._http._DetachedSocket.prototype.write):
>+        (foo._http._DetachedSocket.prototype.writeln):
>+        (foo._http._DetachedSocket.prototype.writeCharCode):
>+        (foo._http._DetachedSocket.prototype.writeAll):
>+        (foo._http._DetachedSocket.prototype.add):
>+        (foo._http._DetachedSocket.prototype.addError):
>+        (foo._http._DetachedSocket.prototype.addStream):
>+        (foo._http._DetachedSocket.prototype.destroy):
>+        (foo._http._DetachedSocket.prototype.flush):
>+        (foo._http._DetachedSocket.prototype.close):
>+        (foo._http._DetachedSocket.prototype.get done):
>+        (foo._http._DetachedSocket.prototype.get port):
>+        (foo._http._DetachedSocket.prototype.get address):
>+        (foo._http._DetachedSocket.prototype.get remoteAddress):
>+        (foo._http._DetachedSocket.prototype.get remotePort):
>+        (foo._http._DetachedSocket.prototype.setOption):
>+        (foo._http._DetachedSocket.prototype.getRawOption):
>+        (foo._http._DetachedSocket.prototype.setRawOption):
>+        (foo._http._DetachedSocket.prototype._toJSON):
>+        (foo._http._DetachedSocket):
>+        (foo._http._AuthenticationScheme.fromString):
>+        (foo._http._AuthenticationScheme.prototype.toString):
>+        (foo._http._AuthenticationScheme):
>+        (foo.get _http._Credentials.prototype.get scheme):
>+        (foo.get _http._Credentials):
>+        (foo._http._SiteCredentials.prototype.applies):
>+        (foo._http._SiteCredentials.prototype.authorize):
>+        (foo._http._SiteCredentials):
>+        (foo._http._ProxyCredentials.prototype.applies):
>+        (foo._http._ProxyCredentials.prototype.authorize):
>+        (foo._http._ProxyCredentials):
>+        (foo._http._HttpClientCredentials):
>+        (foo._http._HttpClientBasicCredentials.prototype.get scheme):
>+        (foo._http._HttpClientBasicCredentials.prototype.authorization):
>+        (foo._http._HttpClientBasicCredentials.prototype.authorize):
>+        (foo._http._HttpClientBasicCredentials.prototype.authorizeProxy):
>+        (foo._http._HttpClientBasicCredentials):
>+        (foo._http._HttpClientDigestCredentials.prototype.get scheme):
>+        (foo._http._HttpClientDigestCredentials.prototype.authorization):
>+        (foo._http._HttpClientDigestCredentials.prototype.authorize):
>+        (foo._http._HttpClientDigestCredentials.prototype.authorizeProxy):
>+        (foo._http._HttpClientDigestCredentials):
>+        (foo._http._RedirectInfo):
>+        (foo._http._getHttpVersion):
>+        (foo._http._Const):
>+        (foo.get _http._CharCode):
>+        (foo.get _http._State):
>+        (foo.get _http._HttpVersion):
>+        (foo.get _http._MessageType):
>+        (foo._http._HttpDetachedStreamSubscription.prototype.get isPaused):
>+        (foo._http._HttpDetachedStreamSubscription.prototype.asFuture.return.async Future):
>+        (foo._http._HttpDetachedStreamSubscription.prototype.asFuture):
>+        (foo._http._HttpDetachedStreamSubscription.prototype.resume):
>+        (foo._http._HttpDetachedStreamSubscription.prototype._maybeScheduleData.async scheduleMicrotask):
>+        (foo._http._HttpDetachedStreamSubscription.prototype._maybeScheduleData):
>+        (foo._http._HttpDetachedStreamSubscription):
>+        (foo._http._HttpDetachedIncoming.prototype.listen):
>+        (foo._http._HttpDetachedIncoming):
>+        (foo._http._HttpParser.requestParser):
>+        (foo._http._HttpParser.responseParser):
>+        (foo._http._HttpParser.prototype.listen):
>+        (foo._http._HttpParser.prototype.listenToStream):
>+        (foo._http._HttpParser.prototype._parse):
>+        (foo._http._HttpParser.prototype._headersEnd):
>+        (foo._http._HttpParser.prototype._doParse):
>+        (foo._http._HttpParser.prototype._onData.2):
>+        (foo._http._HttpParser.prototype._onDone):
>+        (foo._http._HttpParser.prototype.get version):
>+        (foo._http._HttpParser.prototype.get messageType):
>+        (foo._http._HttpParser.prototype.get transferLength):
>+        (foo._http._HttpParser.prototype.get upgrade):
>+        (foo._http._HttpParser.prototype.get persistentConnection):
>+        (foo._http._HttpParser.prototype.set isHead):
>+        (foo._http._HttpParser.prototype.detachIncoming):
>+        (foo._http._HttpParser.prototype.readUnparsedData):
>+        (foo._http._HttpParser.prototype._reset):
>+        (foo._http._HttpParser.prototype._releaseBuffer):
>+        (foo._http._HttpParser._isTokenChar):
>+        (foo._http._HttpParser._isValueChar):
>+        (foo._http._HttpParser._tokenizeFieldValue):
>+        (foo._http._HttpParser._toLowerCaseByte):
>+        (foo._http._HttpParser.prototype._caseInsensitiveCompare):
>+        (foo._http._HttpParser.prototype._expect):
>+        (foo._http._HttpParser.prototype._expectHexDigit):
>+        (foo._http._HttpParser.prototype._createIncoming):
>+        (foo._http._HttpParser.prototype._closeIncoming):
>+        (foo._http._HttpParser.prototype._pauseStateChanged):
>+        (foo._http._HttpParser.prototype._reportError):
>+        (foo._http._HttpParser):
>+        (foo._http._HttpSession.prototype.destroy):
>+        (foo._http._HttpSession.prototype._markSeen):
>+        (foo._http._HttpSession.prototype.get lastSeen):
>+        (foo._http._HttpSession.prototype.get isNew):
>+        (foo._http._HttpSession.prototype.set onTimeout):
>+        (foo._http._HttpSession.prototype.containsValue):
>+        (foo._http._HttpSession.prototype.containsKey):
>+        (foo._http._HttpSession.prototype._get):
>+        (foo._http._HttpSession.prototype._set):
>+        (foo._http._HttpSession.prototype.putIfAbsent):
>+        (foo._http._HttpSession.prototype.addAll):
>+        (foo._http._HttpSession.prototype.remove):
>+        (foo._http._HttpSession.prototype.clear):
>+        (foo._http._HttpSession.prototype.forEach):
>+        (foo._http._HttpSession.prototype.get entries):
>+        (foo._http._HttpSession.prototype.addEntries):
>+        (foo._http._HttpSession.prototype.map):
>+        (foo._http._HttpSession.prototype.removeWhere):
>+        (foo._http._HttpSession.prototype.cast):
>+        (foo._http._HttpSession.prototype.update):
>+        (foo._http._HttpSession.prototype.updateAll):
>+        (foo._http._HttpSession.prototype.get keys):
>+        (foo._http._HttpSession.prototype.get values):
>+        (foo._http._HttpSession.prototype.get length):
>+        (foo._http._HttpSession.prototype.get isEmpty):
>+        (foo._http._HttpSession.prototype.get isNotEmpty):
>+        (foo._http._HttpSession.prototype.toString):
>+        (foo._http._HttpSession):
>+        (foo._http._HttpSessionManager.prototype.createSessionId):
>+        (foo._http._HttpSessionManager.prototype.getSession):
>+        (foo._http._HttpSessionManager.prototype.createSession):
>+        (foo._http._HttpSessionManager.prototype.set sessionTimeout):
>+        (foo._http._HttpSessionManager.prototype.close):
>+        (foo._http._HttpSessionManager.prototype._bumpToEnd):
>+        (foo._http._HttpSessionManager.prototype._addToTimeoutQueue):
>+        (foo._http._HttpSessionManager.prototype._removeFromTimeoutQueue):
>+        (foo._http._HttpSessionManager.prototype._timerTimeout):
>+        (foo._http._HttpSessionManager.prototype._startTimer.this._timer.async Timer):
>+        (foo._http._HttpSessionManager.prototype._startTimer):
>+        (foo._http._HttpSessionManager.prototype._stopTimer):
>+        (foo._http._HttpSessionManager):
>+        (foo.async get _http.HttpOverrides.get current):
>+        (foo.async get _http.HttpOverrides.async set global):
>+        (foo.async get _http.HttpOverrides.runZoned):
>+        (foo.async get _http.HttpOverrides.runWithHttpOverrides):
>+        (foo.async get _http.HttpOverrides.prototype.createHttpClient):
>+        (foo.async get _http.HttpOverrides.prototype.findProxyFromEnvironment):
>+        (foo.async get _http.HttpOverrides):
>+        (foo.async get _http):
>+        (foo._http._HttpOverridesScope.prototype.createHttpClient):
>+        (foo._http._HttpOverridesScope.prototype.findProxyFromEnvironment):
>+        (foo._http._HttpOverridesScope):
>+        (foo._http.WebSocketStatus):
>+        (foo._http.CompressionOptions.prototype._createServerResponseHeader):
>+        (foo._http.CompressionOptions.prototype._createClientRequestHeader):
>+        (foo._http.CompressionOptions.prototype._createHeader):
>+        (foo._http.CompressionOptions):
>+        (foo.get _http.WebSocketTransformer.new):
>+        (foo.get _http.WebSocketTransformer.upgrade):
>+        (foo.get _http.WebSocketTransformer.isUpgradeRequest):
>+        (foo.get _http.WebSocketTransformer):
>+        (foo._http.WebSocket.connect):
>+        (foo._http.WebSocket.fromUpgradedSocket):
>+        (foo._http.WebSocket.get userAgent):
>+        (foo._http.WebSocket.set userAgent):
>+        (foo._http.WebSocket):
>+        (foo._http.WebSocket.dart.implements.async Stream):
>+        (foo.get _http.WebSocketException.prototype.toString):
>+        (foo.get _http.WebSocketException):
>+        (foo.get _http._WebSocketMessageType):
>+        (foo.get _http._WebSocketOpcode):
>+        (foo.get _http._EncodedString):
>+        (foo._http._CompressionMaxWindowBits.prototype.toString):
>+        (foo._http._CompressionMaxWindowBits):
>+        (foo._http._WebSocketProtocolTransformer.prototype.bind.return.async Stream):
>+        (foo._http._WebSocketProtocolTransformer.prototype.bind):
>+        (foo._http._WebSocketProtocolTransformer.prototype.addError):
>+        (foo._http._WebSocketProtocolTransformer.prototype.close):
>+        (foo._http._WebSocketProtocolTransformer.prototype.add):
>+        (foo._http._WebSocketProtocolTransformer.prototype._unmask):
>+        (foo._http._WebSocketProtocolTransformer.prototype._lengthDone):
>+        (foo._http._WebSocketProtocolTransformer.prototype._maskDone):
>+        (foo._http._WebSocketProtocolTransformer.prototype._startPayload):
>+        (foo._http._WebSocketProtocolTransformer.prototype._messageFrameEnd):
>+        (foo._http._WebSocketProtocolTransformer.prototype._controlFrameEnd):
>+        (foo._http._WebSocketProtocolTransformer.prototype._isControlFrame):
>+        (foo._http._WebSocketProtocolTransformer.prototype._prepareForNextFrame):
>+        (foo._http._WebSocketProtocolTransformer):
>+        (foo.get _http._WebSocketPing):
>+        (foo._http._WebSocketPong):
>+        (foo._http._WebSocketTransformerImpl.prototype.bind):
>+        (foo._http._WebSocketTransformerImpl._tokenizeFieldValue):
>+        (foo._http._WebSocketTransformerImpl._upgrade.upgrade):
>+        (foo._http._WebSocketTransformerImpl._upgrade):
>+        (foo._http._WebSocketTransformerImpl._negotiateCompression):
>+        (foo._http._WebSocketTransformerImpl._isUpgradeRequest):
>+        (foo._http._WebSocketTransformerImpl):
>+        (foo._http._WebSocketPerMessageDeflate.prototype._ensureDecoder):
>+        (foo._http._WebSocketPerMessageDeflate.prototype._ensureEncoder):
>+        (foo._http._WebSocketPerMessageDeflate.prototype.processIncomingMessage):
>+        (foo._http._WebSocketPerMessageDeflate.prototype.processOutgoingMessage):
>+        (foo._http._WebSocketPerMessageDeflate):
>+        (foo._http._WebSocketOutgoingTransformer.prototype.bind):
>+        (foo._http._WebSocketOutgoingTransformer.prototype.add):
>+        (foo._http._WebSocketOutgoingTransformer.prototype.addError):
>+        (foo._http._WebSocketOutgoingTransformer.prototype.close):
>+        (foo._http._WebSocketOutgoingTransformer.prototype.addFrame):
>+        (foo._http._WebSocketOutgoingTransformer.createFrame):
>+        (foo._http._WebSocketOutgoingTransformer):
>+        (foo._http._WebSocketOutgoingTransformer.dart.implements.async EventSink):
>+        (foo._http._WebSocketConsumer.prototype._onListen):
>+        (foo._http._WebSocketConsumer.prototype._onPause):
>+        (foo._http._WebSocketConsumer.prototype._onResume):
>+        (foo._http._WebSocketConsumer.prototype._cancel):
>+        (foo._http._WebSocketConsumer.prototype._ensureController.this._controller.1.async StreamController):
>+        (foo._http._WebSocketConsumer.prototype._ensureController):
>+        (foo._http._WebSocketConsumer.prototype._done):
>+        (foo._http._WebSocketConsumer.prototype.addStream.this._completer.async Completer):
>+        (foo._http._WebSocketConsumer.prototype.addStream.return.async Future):
>+        (foo._http._WebSocketConsumer.prototype.addStream):
>+        (foo._http._WebSocketConsumer.prototype.add):
>+        (foo._http._WebSocketConsumer.prototype.closeSocket):
>+        (foo._http._WebSocketConsumer):
>+        (foo._http._WebSocketConsumer.dart.implements.async StreamConsumer):
>+        (foo._http._WebSocketImpl.connect.):
>+        (foo._http._WebSocketImpl.connect):
>+        (foo._http._WebSocketImpl.negotiateClientCompression.getWindowBits):
>+        (foo._http._WebSocketImpl.negotiateClientCompression):
>+        (foo._http._WebSocketImpl.prototype.listen):
>+        (foo._http._WebSocketImpl.prototype.get pingInterval):
>+        (foo._http._WebSocketImpl.set pingInterval.this._pingTimer.async Timer):
>+        (foo._http._WebSocketImpl.prototype.set pingInterval):
>+        (foo._http._WebSocketImpl.prototype.async get readyState):
>+        (foo._http._WebSocketImpl.prototype.get extensions):
>+        (foo._http._WebSocketImpl.prototype.get closeCode):
>+        (foo._http._WebSocketImpl.prototype.get closeReason):
>+        (foo._http._WebSocketImpl.prototype.add):
>+        (foo._http._WebSocketImpl.prototype.addUtf8Text):
>+        (foo._http._WebSocketImpl.prototype.addError):
>+        (foo._http._WebSocketImpl.prototype.addStream):
>+        (foo._http._WebSocketImpl.prototype.get done):
>+        (foo._http._WebSocketImpl.prototype.close.this._closeTimer.async Timer):
>+        (foo._http._WebSocketImpl.prototype.close):
>+        (foo._http._WebSocketImpl.get userAgent):
>+        (foo._http._WebSocketImpl.set userAgent):
>+        (foo._http._WebSocketImpl.prototype._close.0):
>+        (foo._http._WebSocketImpl.prototype.get _serviceTypePath):
>+        (foo._http._WebSocketImpl.prototype.get _serviceTypeName):
>+        (foo._http._WebSocketImpl.prototype._toJSON):
>+        (foo._http._WebSocketImpl._isReservedStatusCode):
>+        (foo._http._WebSocketImpl):
>+
> 2020-10-21  Caitlin Potter  <caitp@igalia.com>
> 
>         [JSC] support op_get_private_name in DFG and FTL
>Index: JSTests/microbenchmarks/let-const-tdz-environment-parsing-and-hash-consing-speed.js
>===================================================================
>--- JSTests/microbenchmarks/let-const-tdz-environment-parsing-and-hash-consing-speed.js	(nonexistent)
>+++ JSTests/microbenchmarks/let-const-tdz-environment-parsing-and-hash-consing-speed.js	(working copy)
>@@ -0,0 +1,124744 @@
>+/*
>+ * Copyright jQuery Foundation and other contributors, https://jquery.org/
>+ *
>+ * This software consists of voluntary contributions made by many
>+ * individuals. For exact contribution history, see the revision history
>+ * available at https://github.com/requirejs/requirejs
>+ * 
>+ * The following license applies to all parts of this software except as
>+ * documented below:
>+ * 
>+ * ====
>+ * 
>+ * Permission is hereby granted, free of charge, to any person obtaining
>+ * a copy of this software and associated documentation files (the
>+ * "Software"), to deal in the Software without restriction, including
>+ * without limitation the rights to use, copy, modify, merge, publish,
>+ * distribute, sublicense, and/or sell copies of the Software, and to
>+ * permit persons to whom the Software is furnished to do so, subject to
>+ * the following conditions:
>+ * 
>+ * The above copyright notice and this permission notice shall be
>+ * included in all copies or substantial portions of the Software.
>+ * 
>+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
>+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
>+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
>+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
>+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
>+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
>+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
>+ * 
>+ * ====
>+ * 
>+ * Copyright and related rights for sample code are waived via CC0. Sample
>+ * code is defined as all source code displayed within the prose of the
>+ * documentation.
>+ * 
>+ * CC0: http://creativecommons.org/publicdomain/zero/1.0/
>+ * 
>+ * ====
>+ * 
>+ * Files located in the node_modules directory, and certain utilities used
>+ * to build or test the software in the test and dist directories, are
>+ * externally maintained libraries used by this software which have their own
>+ * licenses; we recommend you read them, as their terms may differ from the
>+ * terms above.
>+*/
>+
>+console = {
>+    log() { }
>+};
>+
>+function foo() {
>+const _library = Object.create(null);
>+const dart = Object.create(_library);
>+dart.library = _library;
>+const _debugger = Object.create(dart.library);
>+const _foreign_helper = Object.create(dart.library);
>+const _interceptors = Object.create(dart.library);
>+const _internal = Object.create(dart.library);
>+const _isolate_helper = Object.create(dart.library);
>+const _js_helper = Object.create(dart.library);
>+const _js_mirrors = Object.create(dart.library);
>+const _js_primitives = Object.create(dart.library);
>+const _metadata = Object.create(dart.library);
>+const _native_typed_data = Object.create(dart.library);
>+const async = Object.create(dart.library);
>+const collection = Object.create(dart.library);
>+const convert = Object.create(dart.library);
>+const core = Object.create(dart.library);
>+const developer = Object.create(dart.library);
>+const io = Object.create(dart.library);
>+const isolate = Object.create(dart.library);
>+const js = Object.create(dart.library);
>+const js_util = Object.create(dart.library);
>+const math = Object.create(dart.library);
>+const mirrors = Object.create(dart.library);
>+const typed_data = Object.create(dart.library);
>+const indexed_db = Object.create(dart.library);
>+const html$ = Object.create(dart.library);
>+const html_common = Object.create(dart.library);
>+const svg$ = Object.create(dart.library);
>+const web_audio = Object.create(dart.library);
>+const web_gl = Object.create(dart.library);
>+const web_sql = Object.create(dart.library);
>+const _http = Object.create(dart.library);
>+const dartx = Object.create(dart.library);
>+const _privateNames = Symbol("_privateNames");
>+dart.privateName = function(library, name) {
>+  let names = library[_privateNames];
>+  if (names == null) names = library[_privateNames] = new Map();
>+  let symbol = names.get(name);
>+  if (symbol == null) names.set(name, symbol = Symbol(name));
>+  return symbol;
>+};
>+const $clear = dartx.clear = Symbol("dartx.clear");
>+const $hashCode = dartx.hashCode = Symbol("dartx.hashCode");
>+const $cast = dartx.cast = Symbol("dartx.cast");
>+const $addAll = dartx.addAll = Symbol("dartx.addAll");
>+const $_set = dartx._set = Symbol("dartx._set");
>+const $_get = dartx._get = Symbol("dartx._get");
>+const $_equals = dartx._equals = Symbol("dartx._equals");
>+const $toString = dartx.toString = Symbol("dartx.toString");
>+const $noSuchMethod = dartx.noSuchMethod = Symbol("dartx.noSuchMethod");
>+const $runtimeType = dartx.runtimeType = Symbol("dartx.runtimeType");
>+const $length = dartx.length = Symbol("dartx.length");
>+const $containsKey = dartx.containsKey = Symbol("dartx.containsKey");
>+const $any = dartx.any = Symbol("dartx.any");
>+const $remove = dartx.remove = Symbol("dartx.remove");
>+const $keys = dartx.keys = Symbol("dartx.keys");
>+const $isNotEmpty = dartx.isNotEmpty = Symbol("dartx.isNotEmpty");
>+const $indexOf = dartx.indexOf = Symbol("dartx.indexOf");
>+const $toList = dartx.toList = Symbol("dartx.toList");
>+const $trim = dartx.trim = Symbol("dartx.trim");
>+const $map = dartx.map = Symbol("dartx.map");
>+const $split = dartx.split = Symbol("dartx.split");
>+const $substring = dartx.substring = Symbol("dartx.substring");
>+const $add = dartx.add = Symbol("dartx.add");
>+const $isEmpty = dartx.isEmpty = Symbol("dartx.isEmpty");
>+const $values = dartx.values = Symbol("dartx.values");
>+const $dartStack = dartx.dartStack = Symbol("dartx.dartStack");
>+const $startsWith = dartx.startsWith = Symbol("dartx.startsWith");
>+const $compareTo = dartx.compareTo = Symbol("dartx.compareTo");
>+const $sort = dartx.sort = Symbol("dartx.sort");
>+const $truncate = dartx.truncate = Symbol("dartx.truncate");
>+const $asMap = dartx.asMap = Symbol("dartx.asMap");
>+const $take = dartx.take = Symbol("dartx.take");
>+const $skip = dartx.skip = Symbol("dartx.skip");
>+const $forEach = dartx.forEach = Symbol("dartx.forEach");
>+const $elementAt = dartx.elementAt = Symbol("dartx.elementAt");
>+const $where = dartx.where = Symbol("dartx.where");
>+const $console = dartx.console = Symbol("dartx.console");
>+const $contains = dartx.contains = Symbol("dartx.contains");
>+const $last = dartx.last = Symbol("dartx.last");
>+const $join = dartx.join = Symbol("dartx.join");
>+const $firstWhere = dartx.firstWhere = Symbol("dartx.firstWhere");
>+const $replaceFirst = dartx.replaceFirst = Symbol("dartx.replaceFirst");
>+const $putIfAbsent = dartx.putIfAbsent = Symbol("dartx.putIfAbsent");
>+const $round = dartx.round = Symbol("dartx.round");
>+const $bitAnd = dartx['&'] = Symbol("dartx.&");
>+const $bitOr = dartx['|'] = Symbol("dartx.|");
>+const $bitXor = dartx['^'] = Symbol("dartx.^");
>+const $sublist = dartx.sublist = Symbol("dartx.sublist");
>+const $stackTrace = dartx.stackTrace = Symbol("dartx.stackTrace");
>+const $invalidValue = dartx.invalidValue = Symbol("dartx.invalidValue");
>+const $name = dartx.name = Symbol("dartx.name");
>+const $message = dartx.message = Symbol("dartx.message");
>+const $checkMutable = dartx.checkMutable = Symbol("dartx.checkMutable");
>+const $checkGrowable = dartx.checkGrowable = Symbol("dartx.checkGrowable");
>+const $removeAt = dartx.removeAt = Symbol("dartx.removeAt");
>+const $insert = dartx.insert = Symbol("dartx.insert");
>+const $setRange = dartx.setRange = Symbol("dartx.setRange");
>+const $insertAll = dartx.insertAll = Symbol("dartx.insertAll");
>+const $setAll = dartx.setAll = Symbol("dartx.setAll");
>+const $removeLast = dartx.removeLast = Symbol("dartx.removeLast");
>+const $removeWhere = dartx.removeWhere = Symbol("dartx.removeWhere");
>+const $retainWhere = dartx.retainWhere = Symbol("dartx.retainWhere");
>+const $expand = dartx.expand = Symbol("dartx.expand");
>+const $takeWhile = dartx.takeWhile = Symbol("dartx.takeWhile");
>+const $skipWhile = dartx.skipWhile = Symbol("dartx.skipWhile");
>+const $reduce = dartx.reduce = Symbol("dartx.reduce");
>+const $fold = dartx.fold = Symbol("dartx.fold");
>+const $lastWhere = dartx.lastWhere = Symbol("dartx.lastWhere");
>+const $singleWhere = dartx.singleWhere = Symbol("dartx.singleWhere");
>+const $getRange = dartx.getRange = Symbol("dartx.getRange");
>+const $first = dartx.first = Symbol("dartx.first");
>+const $single = dartx.single = Symbol("dartx.single");
>+const $removeRange = dartx.removeRange = Symbol("dartx.removeRange");
>+const $fillRange = dartx.fillRange = Symbol("dartx.fillRange");
>+const $replaceRange = dartx.replaceRange = Symbol("dartx.replaceRange");
>+const $every = dartx.every = Symbol("dartx.every");
>+const $reversed = dartx.reversed = Symbol("dartx.reversed");
>+const $shuffle = dartx.shuffle = Symbol("dartx.shuffle");
>+const $lastIndexOf = dartx.lastIndexOf = Symbol("dartx.lastIndexOf");
>+const $toSet = dartx.toSet = Symbol("dartx.toSet");
>+const $iterator = dartx.iterator = Symbol("dartx.iterator");
>+const $followedBy = dartx.followedBy = Symbol("dartx.followedBy");
>+const $whereType = dartx.whereType = Symbol("dartx.whereType");
>+const $plus = dartx['+'] = Symbol("dartx.+");
>+const $indexWhere = dartx.indexWhere = Symbol("dartx.indexWhere");
>+const $lastIndexWhere = dartx.lastIndexWhere = Symbol("dartx.lastIndexWhere");
>+const $isNegative = dartx.isNegative = Symbol("dartx.isNegative");
>+const $isNaN = dartx.isNaN = Symbol("dartx.isNaN");
>+const $isInfinite = dartx.isInfinite = Symbol("dartx.isInfinite");
>+const $isFinite = dartx.isFinite = Symbol("dartx.isFinite");
>+const $remainder = dartx.remainder = Symbol("dartx.remainder");
>+const $abs = dartx.abs = Symbol("dartx.abs");
>+const $sign = dartx.sign = Symbol("dartx.sign");
>+const $truncateToDouble = dartx.truncateToDouble = Symbol("dartx.truncateToDouble");
>+const $toInt = dartx.toInt = Symbol("dartx.toInt");
>+const $ceilToDouble = dartx.ceilToDouble = Symbol("dartx.ceilToDouble");
>+const $ceil = dartx.ceil = Symbol("dartx.ceil");
>+const $floorToDouble = dartx.floorToDouble = Symbol("dartx.floorToDouble");
>+const $floor = dartx.floor = Symbol("dartx.floor");
>+const $roundToDouble = dartx.roundToDouble = Symbol("dartx.roundToDouble");
>+const $clamp = dartx.clamp = Symbol("dartx.clamp");
>+const $toDouble = dartx.toDouble = Symbol("dartx.toDouble");
>+const $toStringAsFixed = dartx.toStringAsFixed = Symbol("dartx.toStringAsFixed");
>+const $toStringAsExponential = dartx.toStringAsExponential = Symbol("dartx.toStringAsExponential");
>+const $toStringAsPrecision = dartx.toStringAsPrecision = Symbol("dartx.toStringAsPrecision");
>+const $codeUnitAt = dartx.codeUnitAt = Symbol("dartx.codeUnitAt");
>+const $toRadixString = dartx.toRadixString = Symbol("dartx.toRadixString");
>+const $times = dartx['*'] = Symbol("dartx.*");
>+const $_negate = dartx._negate = Symbol("dartx._negate");
>+const $minus = dartx['-'] = Symbol("dartx.-");
>+const $divide = dartx['/'] = Symbol("dartx./");
>+const $modulo = dartx['%'] = Symbol("dartx.%");
>+const $floorDivide = dartx['~/'] = Symbol("dartx.~/");
>+const $leftShift = dartx['<<'] = Symbol("dartx.<<");
>+const $rightShift = dartx['>>'] = Symbol("dartx.>>");
>+const $lessThan = dartx['<'] = Symbol("dartx.<");
>+const $greaterThan = dartx['>'] = Symbol("dartx.>");
>+const $lessOrEquals = dartx['<='] = Symbol("dartx.<=");
>+const $greaterOrEquals = dartx['>='] = Symbol("dartx.>=");
>+const $isEven = dartx.isEven = Symbol("dartx.isEven");
>+const $isOdd = dartx.isOdd = Symbol("dartx.isOdd");
>+const $toUnsigned = dartx.toUnsigned = Symbol("dartx.toUnsigned");
>+const $toSigned = dartx.toSigned = Symbol("dartx.toSigned");
>+const $bitLength = dartx.bitLength = Symbol("dartx.bitLength");
>+const $modPow = dartx.modPow = Symbol("dartx.modPow");
>+const $modInverse = dartx.modInverse = Symbol("dartx.modInverse");
>+const $gcd = dartx.gcd = Symbol("dartx.gcd");
>+const $bitNot = dartx['~'] = Symbol("dartx.~");
>+const $allMatches = dartx.allMatches = Symbol("dartx.allMatches");
>+const $matchAsPrefix = dartx.matchAsPrefix = Symbol("dartx.matchAsPrefix");
>+const $endsWith = dartx.endsWith = Symbol("dartx.endsWith");
>+const $replaceAll = dartx.replaceAll = Symbol("dartx.replaceAll");
>+const $splitMapJoin = dartx.splitMapJoin = Symbol("dartx.splitMapJoin");
>+const $replaceAllMapped = dartx.replaceAllMapped = Symbol("dartx.replaceAllMapped");
>+const $replaceFirstMapped = dartx.replaceFirstMapped = Symbol("dartx.replaceFirstMapped");
>+const $toLowerCase = dartx.toLowerCase = Symbol("dartx.toLowerCase");
>+const $toUpperCase = dartx.toUpperCase = Symbol("dartx.toUpperCase");
>+const $trimLeft = dartx.trimLeft = Symbol("dartx.trimLeft");
>+const $trimRight = dartx.trimRight = Symbol("dartx.trimRight");
>+const $padLeft = dartx.padLeft = Symbol("dartx.padLeft");
>+const $padRight = dartx.padRight = Symbol("dartx.padRight");
>+const $codeUnits = dartx.codeUnits = Symbol("dartx.codeUnits");
>+const $runes = dartx.runes = Symbol("dartx.runes");
>+const $containsValue = dartx.containsValue = Symbol("dartx.containsValue");
>+const $update = dartx.update = Symbol("dartx.update");
>+const $updateAll = dartx.updateAll = Symbol("dartx.updateAll");
>+const $entries = dartx.entries = Symbol("dartx.entries");
>+const $addEntries = dartx.addEntries = Symbol("dartx.addEntries");
>+const $lengthInBytes = dartx.lengthInBytes = Symbol("dartx.lengthInBytes");
>+const $asUint8List = dartx.asUint8List = Symbol("dartx.asUint8List");
>+const $asInt8List = dartx.asInt8List = Symbol("dartx.asInt8List");
>+const $asUint8ClampedList = dartx.asUint8ClampedList = Symbol("dartx.asUint8ClampedList");
>+const $asUint16List = dartx.asUint16List = Symbol("dartx.asUint16List");
>+const $asInt16List = dartx.asInt16List = Symbol("dartx.asInt16List");
>+const $asUint32List = dartx.asUint32List = Symbol("dartx.asUint32List");
>+const $asInt32List = dartx.asInt32List = Symbol("dartx.asInt32List");
>+const $asUint64List = dartx.asUint64List = Symbol("dartx.asUint64List");
>+const $asInt64List = dartx.asInt64List = Symbol("dartx.asInt64List");
>+const $asInt32x4List = dartx.asInt32x4List = Symbol("dartx.asInt32x4List");
>+const $asFloat32List = dartx.asFloat32List = Symbol("dartx.asFloat32List");
>+const $asFloat64List = dartx.asFloat64List = Symbol("dartx.asFloat64List");
>+const $asFloat32x4List = dartx.asFloat32x4List = Symbol("dartx.asFloat32x4List");
>+const $asFloat64x2List = dartx.asFloat64x2List = Symbol("dartx.asFloat64x2List");
>+const $asByteData = dartx.asByteData = Symbol("dartx.asByteData");
>+const $offsetInBytes = dartx.offsetInBytes = Symbol("dartx.offsetInBytes");
>+const $buffer = dartx.buffer = Symbol("dartx.buffer");
>+const $elementSizeInBytes = dartx.elementSizeInBytes = Symbol("dartx.elementSizeInBytes");
>+const $getFloat32 = dartx.getFloat32 = Symbol("dartx.getFloat32");
>+const $getFloat64 = dartx.getFloat64 = Symbol("dartx.getFloat64");
>+const $getInt16 = dartx.getInt16 = Symbol("dartx.getInt16");
>+const $getInt32 = dartx.getInt32 = Symbol("dartx.getInt32");
>+const $getInt64 = dartx.getInt64 = Symbol("dartx.getInt64");
>+const $getInt8 = dartx.getInt8 = Symbol("dartx.getInt8");
>+const $getUint16 = dartx.getUint16 = Symbol("dartx.getUint16");
>+const $getUint32 = dartx.getUint32 = Symbol("dartx.getUint32");
>+const $getUint64 = dartx.getUint64 = Symbol("dartx.getUint64");
>+const $getUint8 = dartx.getUint8 = Symbol("dartx.getUint8");
>+const $setFloat32 = dartx.setFloat32 = Symbol("dartx.setFloat32");
>+const $setFloat64 = dartx.setFloat64 = Symbol("dartx.setFloat64");
>+const $setInt16 = dartx.setInt16 = Symbol("dartx.setInt16");
>+const $setInt32 = dartx.setInt32 = Symbol("dartx.setInt32");
>+const $setInt64 = dartx.setInt64 = Symbol("dartx.setInt64");
>+const $setInt8 = dartx.setInt8 = Symbol("dartx.setInt8");
>+const $setUint16 = dartx.setUint16 = Symbol("dartx.setUint16");
>+const $setUint32 = dartx.setUint32 = Symbol("dartx.setUint32");
>+const $setUint64 = dartx.setUint64 = Symbol("dartx.setUint64");
>+const $setUint8 = dartx.setUint8 = Symbol("dartx.setUint8");
>+const $left = dartx.left = Symbol("dartx.left");
>+const $width = dartx.width = Symbol("dartx.width");
>+const $top = dartx.top = Symbol("dartx.top");
>+const $height = dartx.height = Symbol("dartx.height");
>+const $right = dartx.right = Symbol("dartx.right");
>+const $bottom = dartx.bottom = Symbol("dartx.bottom");
>+const $intersection = dartx.intersection = Symbol("dartx.intersection");
>+const $intersects = dartx.intersects = Symbol("dartx.intersects");
>+const $boundingBox = dartx.boundingBox = Symbol("dartx.boundingBox");
>+const $containsRectangle = dartx.containsRectangle = Symbol("dartx.containsRectangle");
>+const $containsPoint = dartx.containsPoint = Symbol("dartx.containsPoint");
>+const $topLeft = dartx.topLeft = Symbol("dartx.topLeft");
>+const $topRight = dartx.topRight = Symbol("dartx.topRight");
>+const $bottomRight = dartx.bottomRight = Symbol("dartx.bottomRight");
>+const $bottomLeft = dartx.bottomLeft = Symbol("dartx.bottomLeft");
>+const $delete = dartx.delete = Symbol("dartx.delete");
>+const $next = dartx.next = Symbol("dartx.next");
>+const $direction = dartx.direction = Symbol("dartx.direction");
>+const $key = dartx.key = Symbol("dartx.key");
>+const $primaryKey = dartx.primaryKey = Symbol("dartx.primaryKey");
>+const $source = dartx.source = Symbol("dartx.source");
>+const $advance = dartx.advance = Symbol("dartx.advance");
>+const $continuePrimaryKey = dartx.continuePrimaryKey = Symbol("dartx.continuePrimaryKey");
>+const $value = dartx.value = Symbol("dartx.value");
>+const $createObjectStore = dartx.createObjectStore = Symbol("dartx.createObjectStore");
>+const $transaction = dartx.transaction = Symbol("dartx.transaction");
>+const $transactionStore = dartx.transactionStore = Symbol("dartx.transactionStore");
>+const $transactionList = dartx.transactionList = Symbol("dartx.transactionList");
>+const $transactionStores = dartx.transactionStores = Symbol("dartx.transactionStores");
>+const $objectStoreNames = dartx.objectStoreNames = Symbol("dartx.objectStoreNames");
>+const $version = dartx.version = Symbol("dartx.version");
>+const $close = dartx.close = Symbol("dartx.close");
>+const $deleteObjectStore = dartx.deleteObjectStore = Symbol("dartx.deleteObjectStore");
>+const $onAbort = dartx.onAbort = Symbol("dartx.onAbort");
>+const $onClose = dartx.onClose = Symbol("dartx.onClose");
>+const $onError = dartx.onError = Symbol("dartx.onError");
>+const $onVersionChange = dartx.onVersionChange = Symbol("dartx.onVersionChange");
>+const $on = dartx.on = Symbol("dartx.on");
>+const $addEventListener = dartx.addEventListener = Symbol("dartx.addEventListener");
>+const $removeEventListener = dartx.removeEventListener = Symbol("dartx.removeEventListener");
>+const $dispatchEvent = dartx.dispatchEvent = Symbol("dartx.dispatchEvent");
>+const $open = dartx.open = Symbol("dartx.open");
>+const $onBlocked = dartx.onBlocked = Symbol("dartx.onBlocked");
>+const $onSuccess = dartx.onSuccess = Symbol("dartx.onSuccess");
>+const $deleteDatabase = dartx.deleteDatabase = Symbol("dartx.deleteDatabase");
>+const $supportsDatabaseNames = dartx.supportsDatabaseNames = Symbol("dartx.supportsDatabaseNames");
>+const $cmp = dartx.cmp = Symbol("dartx.cmp");
>+const $result = dartx.result = Symbol("dartx.result");
>+const $count = dartx.count = Symbol("dartx.count");
>+const $get = dartx.get = Symbol("dartx.get");
>+const $getKey = dartx.getKey = Symbol("dartx.getKey");
>+const $openCursor = dartx.openCursor = Symbol("dartx.openCursor");
>+const $openKeyCursor = dartx.openKeyCursor = Symbol("dartx.openKeyCursor");
>+const $keyPath = dartx.keyPath = Symbol("dartx.keyPath");
>+const $multiEntry = dartx.multiEntry = Symbol("dartx.multiEntry");
>+const $objectStore = dartx.objectStore = Symbol("dartx.objectStore");
>+const $unique = dartx.unique = Symbol("dartx.unique");
>+const $getAll = dartx.getAll = Symbol("dartx.getAll");
>+const $getAllKeys = dartx.getAllKeys = Symbol("dartx.getAllKeys");
>+const $lower = dartx.lower = Symbol("dartx.lower");
>+const $lowerOpen = dartx.lowerOpen = Symbol("dartx.lowerOpen");
>+const $upper = dartx.upper = Symbol("dartx.upper");
>+const $upperOpen = dartx.upperOpen = Symbol("dartx.upperOpen");
>+const $includes = dartx.includes = Symbol("dartx.includes");
>+const $put = dartx.put = Symbol("dartx.put");
>+const $getObject = dartx.getObject = Symbol("dartx.getObject");
>+const $createIndex = dartx.createIndex = Symbol("dartx.createIndex");
>+const $autoIncrement = dartx.autoIncrement = Symbol("dartx.autoIncrement");
>+const $indexNames = dartx.indexNames = Symbol("dartx.indexNames");
>+const $deleteIndex = dartx.deleteIndex = Symbol("dartx.deleteIndex");
>+const $index = dartx.index = Symbol("dartx.index");
>+const $type = dartx.type = Symbol("dartx.type");
>+const $observe = dartx.observe = Symbol("dartx.observe");
>+const $unobserve = dartx.unobserve = Symbol("dartx.unobserve");
>+const $database = dartx.database = Symbol("dartx.database");
>+const $records = dartx.records = Symbol("dartx.records");
>+const $onUpgradeNeeded = dartx.onUpgradeNeeded = Symbol("dartx.onUpgradeNeeded");
>+const $error = dartx.error = Symbol("dartx.error");
>+const $readyState = dartx.readyState = Symbol("dartx.readyState");
>+const $onComplete = dartx.onComplete = Symbol("dartx.onComplete");
>+const $completed = dartx.completed = Symbol("dartx.completed");
>+const $db = dartx.db = Symbol("dartx.db");
>+const $mode = dartx.mode = Symbol("dartx.mode");
>+const $abort = dartx.abort = Symbol("dartx.abort");
>+const $dataLoss = dartx.dataLoss = Symbol("dartx.dataLoss");
>+const $dataLossMessage = dartx.dataLossMessage = Symbol("dartx.dataLossMessage");
>+const $newVersion = dartx.newVersion = Symbol("dartx.newVersion");
>+const $oldVersion = dartx.oldVersion = Symbol("dartx.oldVersion");
>+const $target = dartx.target = Symbol("dartx.target");
>+const $currentTarget = dartx.currentTarget = Symbol("dartx.currentTarget");
>+const $matches = dartx.matches = Symbol("dartx.matches");
>+const $parent = dartx.parent = Symbol("dartx.parent");
>+const $matchingTarget = dartx.matchingTarget = Symbol("dartx.matchingTarget");
>+const $path = dartx.path = Symbol("dartx.path");
>+const $bubbles = dartx.bubbles = Symbol("dartx.bubbles");
>+const $cancelable = dartx.cancelable = Symbol("dartx.cancelable");
>+const $composed = dartx.composed = Symbol("dartx.composed");
>+const $defaultPrevented = dartx.defaultPrevented = Symbol("dartx.defaultPrevented");
>+const $eventPhase = dartx.eventPhase = Symbol("dartx.eventPhase");
>+const $isTrusted = dartx.isTrusted = Symbol("dartx.isTrusted");
>+const $timeStamp = dartx.timeStamp = Symbol("dartx.timeStamp");
>+const $composedPath = dartx.composedPath = Symbol("dartx.composedPath");
>+const $preventDefault = dartx.preventDefault = Symbol("dartx.preventDefault");
>+const $stopImmediatePropagation = dartx.stopImmediatePropagation = Symbol("dartx.stopImmediatePropagation");
>+const $stopPropagation = dartx.stopPropagation = Symbol("dartx.stopPropagation");
>+const $nonce = dartx.nonce = Symbol("dartx.nonce");
>+const $createFragment = dartx.createFragment = Symbol("dartx.createFragment");
>+const $nodes = dartx.nodes = Symbol("dartx.nodes");
>+const $attributes = dartx.attributes = Symbol("dartx.attributes");
>+const $getAttribute = dartx.getAttribute = Symbol("dartx.getAttribute");
>+const $getAttributeNS = dartx.getAttributeNS = Symbol("dartx.getAttributeNS");
>+const $hasAttribute = dartx.hasAttribute = Symbol("dartx.hasAttribute");
>+const $hasAttributeNS = dartx.hasAttributeNS = Symbol("dartx.hasAttributeNS");
>+const $removeAttribute = dartx.removeAttribute = Symbol("dartx.removeAttribute");
>+const $removeAttributeNS = dartx.removeAttributeNS = Symbol("dartx.removeAttributeNS");
>+const $setAttribute = dartx.setAttribute = Symbol("dartx.setAttribute");
>+const $setAttributeNS = dartx.setAttributeNS = Symbol("dartx.setAttributeNS");
>+const $children = dartx.children = Symbol("dartx.children");
>+const $querySelectorAll = dartx.querySelectorAll = Symbol("dartx.querySelectorAll");
>+const $setApplyScroll = dartx.setApplyScroll = Symbol("dartx.setApplyScroll");
>+const $setDistributeScroll = dartx.setDistributeScroll = Symbol("dartx.setDistributeScroll");
>+const $classes = dartx.classes = Symbol("dartx.classes");
>+const $dataset = dartx.dataset = Symbol("dartx.dataset");
>+const $getNamespacedAttributes = dartx.getNamespacedAttributes = Symbol("dartx.getNamespacedAttributes");
>+const $getComputedStyle = dartx.getComputedStyle = Symbol("dartx.getComputedStyle");
>+const $client = dartx.client = Symbol("dartx.client");
>+const $offsetLeft = dartx.offsetLeft = Symbol("dartx.offsetLeft");
>+const $offsetTop = dartx.offsetTop = Symbol("dartx.offsetTop");
>+const $offsetWidth = dartx.offsetWidth = Symbol("dartx.offsetWidth");
>+const $offsetHeight = dartx.offsetHeight = Symbol("dartx.offsetHeight");
>+const $offset = dartx.offset = Symbol("dartx.offset");
>+const $append = dartx.append = Symbol("dartx.append");
>+const $appendText = dartx.appendText = Symbol("dartx.appendText");
>+const $insertAdjacentHtml = dartx.insertAdjacentHtml = Symbol("dartx.insertAdjacentHtml");
>+const $appendHtml = dartx.appendHtml = Symbol("dartx.appendHtml");
>+const $enteredView = dartx.enteredView = Symbol("dartx.enteredView");
>+const $attached = dartx.attached = Symbol("dartx.attached");
>+const $leftView = dartx.leftView = Symbol("dartx.leftView");
>+const $detached = dartx.detached = Symbol("dartx.detached");
>+const $getClientRects = dartx.getClientRects = Symbol("dartx.getClientRects");
>+const $animate = dartx.animate = Symbol("dartx.animate");
>+const $attributeChanged = dartx.attributeChanged = Symbol("dartx.attributeChanged");
>+const $localName = dartx.localName = Symbol("dartx.localName");
>+const $namespaceUri = dartx.namespaceUri = Symbol("dartx.namespaceUri");
>+const $scrollIntoView = dartx.scrollIntoView = Symbol("dartx.scrollIntoView");
>+const $insertAdjacentText = dartx.insertAdjacentText = Symbol("dartx.insertAdjacentText");
>+const $insertAdjacentElement = dartx.insertAdjacentElement = Symbol("dartx.insertAdjacentElement");
>+const $nextNode = dartx.nextNode = Symbol("dartx.nextNode");
>+const $matchesWithAncestors = dartx.matchesWithAncestors = Symbol("dartx.matchesWithAncestors");
>+const $createShadowRoot = dartx.createShadowRoot = Symbol("dartx.createShadowRoot");
>+const $shadowRoot = dartx.shadowRoot = Symbol("dartx.shadowRoot");
>+const $contentEdge = dartx.contentEdge = Symbol("dartx.contentEdge");
>+const $paddingEdge = dartx.paddingEdge = Symbol("dartx.paddingEdge");
>+const $borderEdge = dartx.borderEdge = Symbol("dartx.borderEdge");
>+const $marginEdge = dartx.marginEdge = Symbol("dartx.marginEdge");
>+const $offsetTo = dartx.offsetTo = Symbol("dartx.offsetTo");
>+const $documentOffset = dartx.documentOffset = Symbol("dartx.documentOffset");
>+const $createHtmlDocument = dartx.createHtmlDocument = Symbol("dartx.createHtmlDocument");
>+const $createElement = dartx.createElement = Symbol("dartx.createElement");
>+const $baseUri = dartx.baseUri = Symbol("dartx.baseUri");
>+const $head = dartx.head = Symbol("dartx.head");
>+const $setInnerHtml = dartx.setInnerHtml = Symbol("dartx.setInnerHtml");
>+const $innerHtml = dartx.innerHtml = Symbol("dartx.innerHtml");
>+const $text = dartx.text = Symbol("dartx.text");
>+const $offsetParent = dartx.offsetParent = Symbol("dartx.offsetParent");
>+const $scrollHeight = dartx.scrollHeight = Symbol("dartx.scrollHeight");
>+const $scrollLeft = dartx.scrollLeft = Symbol("dartx.scrollLeft");
>+const $scrollTop = dartx.scrollTop = Symbol("dartx.scrollTop");
>+const $scrollWidth = dartx.scrollWidth = Symbol("dartx.scrollWidth");
>+const $contentEditable = dartx.contentEditable = Symbol("dartx.contentEditable");
>+const $dir = dartx.dir = Symbol("dartx.dir");
>+const $draggable = dartx.draggable = Symbol("dartx.draggable");
>+const $hidden = dartx.hidden = Symbol("dartx.hidden");
>+const $inert = dartx.inert = Symbol("dartx.inert");
>+const $inputMode = dartx.inputMode = Symbol("dartx.inputMode");
>+const $isContentEditable = dartx.isContentEditable = Symbol("dartx.isContentEditable");
>+const $lang = dartx.lang = Symbol("dartx.lang");
>+const $spellcheck = dartx.spellcheck = Symbol("dartx.spellcheck");
>+const $style = dartx.style = Symbol("dartx.style");
>+const $tabIndex = dartx.tabIndex = Symbol("dartx.tabIndex");
>+const $title = dartx.title = Symbol("dartx.title");
>+const $translate = dartx.translate = Symbol("dartx.translate");
>+const $blur = dartx.blur = Symbol("dartx.blur");
>+const $click = dartx.click = Symbol("dartx.click");
>+const $focus = dartx.focus = Symbol("dartx.focus");
>+const $accessibleNode = dartx.accessibleNode = Symbol("dartx.accessibleNode");
>+const $assignedSlot = dartx.assignedSlot = Symbol("dartx.assignedSlot");
>+const $className = dartx.className = Symbol("dartx.className");
>+const $clientHeight = dartx.clientHeight = Symbol("dartx.clientHeight");
>+const $clientLeft = dartx.clientLeft = Symbol("dartx.clientLeft");
>+const $clientTop = dartx.clientTop = Symbol("dartx.clientTop");
>+const $clientWidth = dartx.clientWidth = Symbol("dartx.clientWidth");
>+const $computedName = dartx.computedName = Symbol("dartx.computedName");
>+const $computedRole = dartx.computedRole = Symbol("dartx.computedRole");
>+const $id = dartx.id = Symbol("dartx.id");
>+const $innerText = dartx.innerText = Symbol("dartx.innerText");
>+const $outerHtml = dartx.outerHtml = Symbol("dartx.outerHtml");
>+const $slot = dartx.slot = Symbol("dartx.slot");
>+const $styleMap = dartx.styleMap = Symbol("dartx.styleMap");
>+const $tagName = dartx.tagName = Symbol("dartx.tagName");
>+const $attachShadow = dartx.attachShadow = Symbol("dartx.attachShadow");
>+const $closest = dartx.closest = Symbol("dartx.closest");
>+const $getAnimations = dartx.getAnimations = Symbol("dartx.getAnimations");
>+const $getAttributeNames = dartx.getAttributeNames = Symbol("dartx.getAttributeNames");
>+const $getBoundingClientRect = dartx.getBoundingClientRect = Symbol("dartx.getBoundingClientRect");
>+const $getDestinationInsertionPoints = dartx.getDestinationInsertionPoints = Symbol("dartx.getDestinationInsertionPoints");
>+const $getElementsByClassName = dartx.getElementsByClassName = Symbol("dartx.getElementsByClassName");
>+const $hasPointerCapture = dartx.hasPointerCapture = Symbol("dartx.hasPointerCapture");
>+const $releasePointerCapture = dartx.releasePointerCapture = Symbol("dartx.releasePointerCapture");
>+const $requestPointerLock = dartx.requestPointerLock = Symbol("dartx.requestPointerLock");
>+const $scroll = dartx.scroll = Symbol("dartx.scroll");
>+const $scrollBy = dartx.scrollBy = Symbol("dartx.scrollBy");
>+const $scrollTo = dartx.scrollTo = Symbol("dartx.scrollTo");
>+const $setPointerCapture = dartx.setPointerCapture = Symbol("dartx.setPointerCapture");
>+const $requestFullscreen = dartx.requestFullscreen = Symbol("dartx.requestFullscreen");
>+const $after = dartx.after = Symbol("dartx.after");
>+const $before = dartx.before = Symbol("dartx.before");
>+const $nextElementSibling = dartx.nextElementSibling = Symbol("dartx.nextElementSibling");
>+const $previousElementSibling = dartx.previousElementSibling = Symbol("dartx.previousElementSibling");
>+const $querySelector = dartx.querySelector = Symbol("dartx.querySelector");
>+const $onBeforeCopy = dartx.onBeforeCopy = Symbol("dartx.onBeforeCopy");
>+const $onBeforeCut = dartx.onBeforeCut = Symbol("dartx.onBeforeCut");
>+const $onBeforePaste = dartx.onBeforePaste = Symbol("dartx.onBeforePaste");
>+const $onBlur = dartx.onBlur = Symbol("dartx.onBlur");
>+const $onCanPlay = dartx.onCanPlay = Symbol("dartx.onCanPlay");
>+const $onCanPlayThrough = dartx.onCanPlayThrough = Symbol("dartx.onCanPlayThrough");
>+const $onChange = dartx.onChange = Symbol("dartx.onChange");
>+const $onClick = dartx.onClick = Symbol("dartx.onClick");
>+const $onContextMenu = dartx.onContextMenu = Symbol("dartx.onContextMenu");
>+const $onCopy = dartx.onCopy = Symbol("dartx.onCopy");
>+const $onCut = dartx.onCut = Symbol("dartx.onCut");
>+const $onDoubleClick = dartx.onDoubleClick = Symbol("dartx.onDoubleClick");
>+const $onDrag = dartx.onDrag = Symbol("dartx.onDrag");
>+const $onDragEnd = dartx.onDragEnd = Symbol("dartx.onDragEnd");
>+const $onDragEnter = dartx.onDragEnter = Symbol("dartx.onDragEnter");
>+const $onDragLeave = dartx.onDragLeave = Symbol("dartx.onDragLeave");
>+const $onDragOver = dartx.onDragOver = Symbol("dartx.onDragOver");
>+const $onDragStart = dartx.onDragStart = Symbol("dartx.onDragStart");
>+const $onDrop = dartx.onDrop = Symbol("dartx.onDrop");
>+const $onDurationChange = dartx.onDurationChange = Symbol("dartx.onDurationChange");
>+const $onEmptied = dartx.onEmptied = Symbol("dartx.onEmptied");
>+const $onEnded = dartx.onEnded = Symbol("dartx.onEnded");
>+const $onFocus = dartx.onFocus = Symbol("dartx.onFocus");
>+const $onInput = dartx.onInput = Symbol("dartx.onInput");
>+const $onInvalid = dartx.onInvalid = Symbol("dartx.onInvalid");
>+const $onKeyDown = dartx.onKeyDown = Symbol("dartx.onKeyDown");
>+const $onKeyPress = dartx.onKeyPress = Symbol("dartx.onKeyPress");
>+const $onKeyUp = dartx.onKeyUp = Symbol("dartx.onKeyUp");
>+const $onLoad = dartx.onLoad = Symbol("dartx.onLoad");
>+const $onLoadedData = dartx.onLoadedData = Symbol("dartx.onLoadedData");
>+const $onLoadedMetadata = dartx.onLoadedMetadata = Symbol("dartx.onLoadedMetadata");
>+const $onMouseDown = dartx.onMouseDown = Symbol("dartx.onMouseDown");
>+const $onMouseEnter = dartx.onMouseEnter = Symbol("dartx.onMouseEnter");
>+const $onMouseLeave = dartx.onMouseLeave = Symbol("dartx.onMouseLeave");
>+const $onMouseMove = dartx.onMouseMove = Symbol("dartx.onMouseMove");
>+const $onMouseOut = dartx.onMouseOut = Symbol("dartx.onMouseOut");
>+const $onMouseOver = dartx.onMouseOver = Symbol("dartx.onMouseOver");
>+const $onMouseUp = dartx.onMouseUp = Symbol("dartx.onMouseUp");
>+const $onMouseWheel = dartx.onMouseWheel = Symbol("dartx.onMouseWheel");
>+const $onPaste = dartx.onPaste = Symbol("dartx.onPaste");
>+const $onPause = dartx.onPause = Symbol("dartx.onPause");
>+const $onPlay = dartx.onPlay = Symbol("dartx.onPlay");
>+const $onPlaying = dartx.onPlaying = Symbol("dartx.onPlaying");
>+const $onRateChange = dartx.onRateChange = Symbol("dartx.onRateChange");
>+const $onReset = dartx.onReset = Symbol("dartx.onReset");
>+const $onResize = dartx.onResize = Symbol("dartx.onResize");
>+const $onScroll = dartx.onScroll = Symbol("dartx.onScroll");
>+const $onSearch = dartx.onSearch = Symbol("dartx.onSearch");
>+const $onSeeked = dartx.onSeeked = Symbol("dartx.onSeeked");
>+const $onSeeking = dartx.onSeeking = Symbol("dartx.onSeeking");
>+const $onSelect = dartx.onSelect = Symbol("dartx.onSelect");
>+const $onSelectStart = dartx.onSelectStart = Symbol("dartx.onSelectStart");
>+const $onStalled = dartx.onStalled = Symbol("dartx.onStalled");
>+const $onSubmit = dartx.onSubmit = Symbol("dartx.onSubmit");
>+const $onSuspend = dartx.onSuspend = Symbol("dartx.onSuspend");
>+const $onTimeUpdate = dartx.onTimeUpdate = Symbol("dartx.onTimeUpdate");
>+const $onTouchCancel = dartx.onTouchCancel = Symbol("dartx.onTouchCancel");
>+const $onTouchEnd = dartx.onTouchEnd = Symbol("dartx.onTouchEnd");
>+const $onTouchEnter = dartx.onTouchEnter = Symbol("dartx.onTouchEnter");
>+const $onTouchLeave = dartx.onTouchLeave = Symbol("dartx.onTouchLeave");
>+const $onTouchMove = dartx.onTouchMove = Symbol("dartx.onTouchMove");
>+const $onTouchStart = dartx.onTouchStart = Symbol("dartx.onTouchStart");
>+const $onTransitionEnd = dartx.onTransitionEnd = Symbol("dartx.onTransitionEnd");
>+const $onVolumeChange = dartx.onVolumeChange = Symbol("dartx.onVolumeChange");
>+const $onWaiting = dartx.onWaiting = Symbol("dartx.onWaiting");
>+const $onFullscreenChange = dartx.onFullscreenChange = Symbol("dartx.onFullscreenChange");
>+const $onFullscreenError = dartx.onFullscreenError = Symbol("dartx.onFullscreenError");
>+const $onWheel = dartx.onWheel = Symbol("dartx.onWheel");
>+const $replaceWith = dartx.replaceWith = Symbol("dartx.replaceWith");
>+const $insertAllBefore = dartx.insertAllBefore = Symbol("dartx.insertAllBefore");
>+const $childNodes = dartx.childNodes = Symbol("dartx.childNodes");
>+const $firstChild = dartx.firstChild = Symbol("dartx.firstChild");
>+const $isConnected = dartx.isConnected = Symbol("dartx.isConnected");
>+const $lastChild = dartx.lastChild = Symbol("dartx.lastChild");
>+const $nodeName = dartx.nodeName = Symbol("dartx.nodeName");
>+const $nodeType = dartx.nodeType = Symbol("dartx.nodeType");
>+const $nodeValue = dartx.nodeValue = Symbol("dartx.nodeValue");
>+const $ownerDocument = dartx.ownerDocument = Symbol("dartx.ownerDocument");
>+const $parentNode = dartx.parentNode = Symbol("dartx.parentNode");
>+const $previousNode = dartx.previousNode = Symbol("dartx.previousNode");
>+const $clone = dartx.clone = Symbol("dartx.clone");
>+const $getRootNode = dartx.getRootNode = Symbol("dartx.getRootNode");
>+const $hasChildNodes = dartx.hasChildNodes = Symbol("dartx.hasChildNodes");
>+const $insertBefore = dartx.insertBefore = Symbol("dartx.insertBefore");
>+const $respondWith = dartx.respondWith = Symbol("dartx.respondWith");
>+const $waitUntil = dartx.waitUntil = Symbol("dartx.waitUntil");
>+const $quaternion = dartx.quaternion = Symbol("dartx.quaternion");
>+const $populateMatrix = dartx.populateMatrix = Symbol("dartx.populateMatrix");
>+const $activated = dartx.activated = Symbol("dartx.activated");
>+const $hasReading = dartx.hasReading = Symbol("dartx.hasReading");
>+const $timestamp = dartx.timestamp = Symbol("dartx.timestamp");
>+const $start = dartx.start = Symbol("dartx.start");
>+const $stop = dartx.stop = Symbol("dartx.stop");
>+const $x = dartx.x = Symbol("dartx.x");
>+const $y = dartx.y = Symbol("dartx.y");
>+const $z = dartx.z = Symbol("dartx.z");
>+const $activeDescendant = dartx.activeDescendant = Symbol("dartx.activeDescendant");
>+const $atomic = dartx.atomic = Symbol("dartx.atomic");
>+const $autocomplete = dartx.autocomplete = Symbol("dartx.autocomplete");
>+const $busy = dartx.busy = Symbol("dartx.busy");
>+const $checked = dartx.checked = Symbol("dartx.checked");
>+const $colCount = dartx.colCount = Symbol("dartx.colCount");
>+const $colIndex = dartx.colIndex = Symbol("dartx.colIndex");
>+const $colSpan = dartx.colSpan = Symbol("dartx.colSpan");
>+const $controls = dartx.controls = Symbol("dartx.controls");
>+const $current = dartx.current = Symbol("dartx.current");
>+const $describedBy = dartx.describedBy = Symbol("dartx.describedBy");
>+const $details = dartx.details = Symbol("dartx.details");
>+const $disabled = dartx.disabled = Symbol("dartx.disabled");
>+const $errorMessage = dartx.errorMessage = Symbol("dartx.errorMessage");
>+const $expanded = dartx.expanded = Symbol("dartx.expanded");
>+const $flowTo = dartx.flowTo = Symbol("dartx.flowTo");
>+const $hasPopUp = dartx.hasPopUp = Symbol("dartx.hasPopUp");
>+const $invalid = dartx.invalid = Symbol("dartx.invalid");
>+const $keyShortcuts = dartx.keyShortcuts = Symbol("dartx.keyShortcuts");
>+const $label = dartx.label = Symbol("dartx.label");
>+const $labeledBy = dartx.labeledBy = Symbol("dartx.labeledBy");
>+const $level = dartx.level = Symbol("dartx.level");
>+const $live = dartx.live = Symbol("dartx.live");
>+const $modal = dartx.modal = Symbol("dartx.modal");
>+const $multiline = dartx.multiline = Symbol("dartx.multiline");
>+const $multiselectable = dartx.multiselectable = Symbol("dartx.multiselectable");
>+const $orientation = dartx.orientation = Symbol("dartx.orientation");
>+const $owns = dartx.owns = Symbol("dartx.owns");
>+const $placeholder = dartx.placeholder = Symbol("dartx.placeholder");
>+const $posInSet = dartx.posInSet = Symbol("dartx.posInSet");
>+const $pressed = dartx.pressed = Symbol("dartx.pressed");
>+const $readOnly = dartx.readOnly = Symbol("dartx.readOnly");
>+const $relevant = dartx.relevant = Symbol("dartx.relevant");
>+const $required = dartx.required = Symbol("dartx.required");
>+const $role = dartx.role = Symbol("dartx.role");
>+const $roleDescription = dartx.roleDescription = Symbol("dartx.roleDescription");
>+const $rowCount = dartx.rowCount = Symbol("dartx.rowCount");
>+const $rowIndex = dartx.rowIndex = Symbol("dartx.rowIndex");
>+const $rowSpan = dartx.rowSpan = Symbol("dartx.rowSpan");
>+const $selected = dartx.selected = Symbol("dartx.selected");
>+const $setSize = dartx.setSize = Symbol("dartx.setSize");
>+const $valueMax = dartx.valueMax = Symbol("dartx.valueMax");
>+const $valueMin = dartx.valueMin = Symbol("dartx.valueMin");
>+const $valueNow = dartx.valueNow = Symbol("dartx.valueNow");
>+const $valueText = dartx.valueText = Symbol("dartx.valueText");
>+const $appendChild = dartx.appendChild = Symbol("dartx.appendChild");
>+const $onAccessibleClick = dartx.onAccessibleClick = Symbol("dartx.onAccessibleClick");
>+const $onAccessibleContextMenu = dartx.onAccessibleContextMenu = Symbol("dartx.onAccessibleContextMenu");
>+const $onAccessibleDecrement = dartx.onAccessibleDecrement = Symbol("dartx.onAccessibleDecrement");
>+const $onAccessibleFocus = dartx.onAccessibleFocus = Symbol("dartx.onAccessibleFocus");
>+const $onAccessibleIncrement = dartx.onAccessibleIncrement = Symbol("dartx.onAccessibleIncrement");
>+const $onAccessibleScrollIntoView = dartx.onAccessibleScrollIntoView = Symbol("dartx.onAccessibleScrollIntoView");
>+const $item = dartx.item = Symbol("dartx.item");
>+const $illuminance = dartx.illuminance = Symbol("dartx.illuminance");
>+const $download = dartx.download = Symbol("dartx.download");
>+const $hreflang = dartx.hreflang = Symbol("dartx.hreflang");
>+const $referrerPolicy = dartx.referrerPolicy = Symbol("dartx.referrerPolicy");
>+const $rel = dartx.rel = Symbol("dartx.rel");
>+const $hash = dartx.hash = Symbol("dartx.hash");
>+const $host = dartx.host = Symbol("dartx.host");
>+const $hostname = dartx.hostname = Symbol("dartx.hostname");
>+const $href = dartx.href = Symbol("dartx.href");
>+const $origin = dartx.origin = Symbol("dartx.origin");
>+const $password = dartx.password = Symbol("dartx.password");
>+const $pathname = dartx.pathname = Symbol("dartx.pathname");
>+const $port = dartx.port = Symbol("dartx.port");
>+const $protocol = dartx.protocol = Symbol("dartx.protocol");
>+const $search = dartx.search = Symbol("dartx.search");
>+const $username = dartx.username = Symbol("dartx.username");
>+const $currentTime = dartx.currentTime = Symbol("dartx.currentTime");
>+const $effect = dartx.effect = Symbol("dartx.effect");
>+const $finished = dartx.finished = Symbol("dartx.finished");
>+const $playState = dartx.playState = Symbol("dartx.playState");
>+const $playbackRate = dartx.playbackRate = Symbol("dartx.playbackRate");
>+const $ready = dartx.ready = Symbol("dartx.ready");
>+const $startTime = dartx.startTime = Symbol("dartx.startTime");
>+const $timeline = dartx.timeline = Symbol("dartx.timeline");
>+const $cancel = dartx.cancel = Symbol("dartx.cancel");
>+const $finish = dartx.finish = Symbol("dartx.finish");
>+const $pause = dartx.pause = Symbol("dartx.pause");
>+const $play = dartx.play = Symbol("dartx.play");
>+const $reverse = dartx.reverse = Symbol("dartx.reverse");
>+const $onCancel = dartx.onCancel = Symbol("dartx.onCancel");
>+const $onFinish = dartx.onFinish = Symbol("dartx.onFinish");
>+const $timing = dartx.timing = Symbol("dartx.timing");
>+const $getComputedTiming = dartx.getComputedTiming = Symbol("dartx.getComputedTiming");
>+const $delay = dartx.delay = Symbol("dartx.delay");
>+const $duration = dartx.duration = Symbol("dartx.duration");
>+const $easing = dartx.easing = Symbol("dartx.easing");
>+const $endDelay = dartx.endDelay = Symbol("dartx.endDelay");
>+const $fill = dartx.fill = Symbol("dartx.fill");
>+const $iterationStart = dartx.iterationStart = Symbol("dartx.iterationStart");
>+const $iterations = dartx.iterations = Symbol("dartx.iterations");
>+const $animationName = dartx.animationName = Symbol("dartx.animationName");
>+const $elapsedTime = dartx.elapsedTime = Symbol("dartx.elapsedTime");
>+const $timelineTime = dartx.timelineTime = Symbol("dartx.timelineTime");
>+const $registerAnimator = dartx.registerAnimator = Symbol("dartx.registerAnimator");
>+const $status = dartx.status = Symbol("dartx.status");
>+const $swapCache = dartx.swapCache = Symbol("dartx.swapCache");
>+const $onCached = dartx.onCached = Symbol("dartx.onCached");
>+const $onChecking = dartx.onChecking = Symbol("dartx.onChecking");
>+const $onDownloading = dartx.onDownloading = Symbol("dartx.onDownloading");
>+const $onNoUpdate = dartx.onNoUpdate = Symbol("dartx.onNoUpdate");
>+const $onObsolete = dartx.onObsolete = Symbol("dartx.onObsolete");
>+const $onProgress = dartx.onProgress = Symbol("dartx.onProgress");
>+const $onUpdateReady = dartx.onUpdateReady = Symbol("dartx.onUpdateReady");
>+const $reason = dartx.reason = Symbol("dartx.reason");
>+const $url = dartx.url = Symbol("dartx.url");
>+const $alt = dartx.alt = Symbol("dartx.alt");
>+const $coords = dartx.coords = Symbol("dartx.coords");
>+const $shape = dartx.shape = Symbol("dartx.shape");
>+const $audioTracks = dartx.audioTracks = Symbol("dartx.audioTracks");
>+const $autoplay = dartx.autoplay = Symbol("dartx.autoplay");
>+const $buffered = dartx.buffered = Symbol("dartx.buffered");
>+const $controlsList = dartx.controlsList = Symbol("dartx.controlsList");
>+const $crossOrigin = dartx.crossOrigin = Symbol("dartx.crossOrigin");
>+const $currentSrc = dartx.currentSrc = Symbol("dartx.currentSrc");
>+const $defaultMuted = dartx.defaultMuted = Symbol("dartx.defaultMuted");
>+const $defaultPlaybackRate = dartx.defaultPlaybackRate = Symbol("dartx.defaultPlaybackRate");
>+const $disableRemotePlayback = dartx.disableRemotePlayback = Symbol("dartx.disableRemotePlayback");
>+const $ended = dartx.ended = Symbol("dartx.ended");
>+const $loop = dartx.loop = Symbol("dartx.loop");
>+const $mediaKeys = dartx.mediaKeys = Symbol("dartx.mediaKeys");
>+const $muted = dartx.muted = Symbol("dartx.muted");
>+const $networkState = dartx.networkState = Symbol("dartx.networkState");
>+const $paused = dartx.paused = Symbol("dartx.paused");
>+const $played = dartx.played = Symbol("dartx.played");
>+const $preload = dartx.preload = Symbol("dartx.preload");
>+const $remote = dartx.remote = Symbol("dartx.remote");
>+const $seekable = dartx.seekable = Symbol("dartx.seekable");
>+const $seeking = dartx.seeking = Symbol("dartx.seeking");
>+const $sinkId = dartx.sinkId = Symbol("dartx.sinkId");
>+const $src = dartx.src = Symbol("dartx.src");
>+const $srcObject = dartx.srcObject = Symbol("dartx.srcObject");
>+const $textTracks = dartx.textTracks = Symbol("dartx.textTracks");
>+const $videoTracks = dartx.videoTracks = Symbol("dartx.videoTracks");
>+const $volume = dartx.volume = Symbol("dartx.volume");
>+const $audioDecodedByteCount = dartx.audioDecodedByteCount = Symbol("dartx.audioDecodedByteCount");
>+const $videoDecodedByteCount = dartx.videoDecodedByteCount = Symbol("dartx.videoDecodedByteCount");
>+const $addTextTrack = dartx.addTextTrack = Symbol("dartx.addTextTrack");
>+const $canPlayType = dartx.canPlayType = Symbol("dartx.canPlayType");
>+const $captureStream = dartx.captureStream = Symbol("dartx.captureStream");
>+const $load = dartx.load = Symbol("dartx.load");
>+const $setMediaKeys = dartx.setMediaKeys = Symbol("dartx.setMediaKeys");
>+const $setSinkId = dartx.setSinkId = Symbol("dartx.setSinkId");
>+const $authenticatorData = dartx.authenticatorData = Symbol("dartx.authenticatorData");
>+const $signature = dartx.signature = Symbol("dartx.signature");
>+const $clientDataJson = dartx.clientDataJson = Symbol("dartx.clientDataJson");
>+const $attestationObject = dartx.attestationObject = Symbol("dartx.attestationObject");
>+const $state = dartx.state = Symbol("dartx.state");
>+const $fetches = dartx.fetches = Symbol("dartx.fetches");
>+const $request = dartx.request = Symbol("dartx.request");
>+const $fetch = dartx.fetch = Symbol("dartx.fetch");
>+const $getIds = dartx.getIds = Symbol("dartx.getIds");
>+const $downloadTotal = dartx.downloadTotal = Symbol("dartx.downloadTotal");
>+const $downloaded = dartx.downloaded = Symbol("dartx.downloaded");
>+const $totalDownloadSize = dartx.totalDownloadSize = Symbol("dartx.totalDownloadSize");
>+const $uploadTotal = dartx.uploadTotal = Symbol("dartx.uploadTotal");
>+const $uploaded = dartx.uploaded = Symbol("dartx.uploaded");
>+const $response = dartx.response = Symbol("dartx.response");
>+const $updateUI = dartx.updateUI = Symbol("dartx.updateUI");
>+const $visible = dartx.visible = Symbol("dartx.visible");
>+const $detect = dartx.detect = Symbol("dartx.detect");
>+const $charging = dartx.charging = Symbol("dartx.charging");
>+const $chargingTime = dartx.chargingTime = Symbol("dartx.chargingTime");
>+const $dischargingTime = dartx.dischargingTime = Symbol("dartx.dischargingTime");
>+const $platforms = dartx.platforms = Symbol("dartx.platforms");
>+const $userChoice = dartx.userChoice = Symbol("dartx.userChoice");
>+const $prompt = dartx.prompt = Symbol("dartx.prompt");
>+const $returnValue = dartx.returnValue = Symbol("dartx.returnValue");
>+const $size = dartx.size = Symbol("dartx.size");
>+const $slice = dartx.slice = Symbol("dartx.slice");
>+const $data = dartx.data = Symbol("dartx.data");
>+const $timecode = dartx.timecode = Symbol("dartx.timecode");
>+const $characteristic = dartx.characteristic = Symbol("dartx.characteristic");
>+const $uuid = dartx.uuid = Symbol("dartx.uuid");
>+const $readValue = dartx.readValue = Symbol("dartx.readValue");
>+const $writeValue = dartx.writeValue = Symbol("dartx.writeValue");
>+const $bodyUsed = dartx.bodyUsed = Symbol("dartx.bodyUsed");
>+const $arrayBuffer = dartx.arrayBuffer = Symbol("dartx.arrayBuffer");
>+const $blob = dartx.blob = Symbol("dartx.blob");
>+const $formData = dartx.formData = Symbol("dartx.formData");
>+const $json = dartx.json = Symbol("dartx.json");
>+const $onHashChange = dartx.onHashChange = Symbol("dartx.onHashChange");
>+const $onMessage = dartx.onMessage = Symbol("dartx.onMessage");
>+const $onOffline = dartx.onOffline = Symbol("dartx.onOffline");
>+const $onOnline = dartx.onOnline = Symbol("dartx.onOnline");
>+const $onPopState = dartx.onPopState = Symbol("dartx.onPopState");
>+const $onStorage = dartx.onStorage = Symbol("dartx.onStorage");
>+const $onUnload = dartx.onUnload = Symbol("dartx.onUnload");
>+const $postMessage = dartx.postMessage = Symbol("dartx.postMessage");
>+const $budgetAt = dartx.budgetAt = Symbol("dartx.budgetAt");
>+const $time = dartx.time = Symbol("dartx.time");
>+const $autofocus = dartx.autofocus = Symbol("dartx.autofocus");
>+const $form = dartx.form = Symbol("dartx.form");
>+const $formAction = dartx.formAction = Symbol("dartx.formAction");
>+const $formEnctype = dartx.formEnctype = Symbol("dartx.formEnctype");
>+const $formMethod = dartx.formMethod = Symbol("dartx.formMethod");
>+const $formNoValidate = dartx.formNoValidate = Symbol("dartx.formNoValidate");
>+const $formTarget = dartx.formTarget = Symbol("dartx.formTarget");
>+const $labels = dartx.labels = Symbol("dartx.labels");
>+const $validationMessage = dartx.validationMessage = Symbol("dartx.validationMessage");
>+const $validity = dartx.validity = Symbol("dartx.validity");
>+const $willValidate = dartx.willValidate = Symbol("dartx.willValidate");
>+const $checkValidity = dartx.checkValidity = Symbol("dartx.checkValidity");
>+const $reportValidity = dartx.reportValidity = Symbol("dartx.reportValidity");
>+const $setCustomValidity = dartx.setCustomValidity = Symbol("dartx.setCustomValidity");
>+const $wholeText = dartx.wholeText = Symbol("dartx.wholeText");
>+const $splitText = dartx.splitText = Symbol("dartx.splitText");
>+const $appendData = dartx.appendData = Symbol("dartx.appendData");
>+const $deleteData = dartx.deleteData = Symbol("dartx.deleteData");
>+const $insertData = dartx.insertData = Symbol("dartx.insertData");
>+const $replaceData = dartx.replaceData = Symbol("dartx.replaceData");
>+const $substringData = dartx.substringData = Symbol("dartx.substringData");
>+const $has = dartx.has = Symbol("dartx.has");
>+const $match = dartx.match = Symbol("dartx.match");
>+const $methodData = dartx.methodData = Symbol("dartx.methodData");
>+const $modifiers = dartx.modifiers = Symbol("dartx.modifiers");
>+const $paymentRequestOrigin = dartx.paymentRequestOrigin = Symbol("dartx.paymentRequestOrigin");
>+const $topLevelOrigin = dartx.topLevelOrigin = Symbol("dartx.topLevelOrigin");
>+const $canvas = dartx.canvas = Symbol("dartx.canvas");
>+const $requestFrame = dartx.requestFrame = Symbol("dartx.requestFrame");
>+const $contentHint = dartx.contentHint = Symbol("dartx.contentHint");
>+const $enabled = dartx.enabled = Symbol("dartx.enabled");
>+const $kind = dartx.kind = Symbol("dartx.kind");
>+const $applyConstraints = dartx.applyConstraints = Symbol("dartx.applyConstraints");
>+const $getCapabilities = dartx.getCapabilities = Symbol("dartx.getCapabilities");
>+const $getConstraints = dartx.getConstraints = Symbol("dartx.getConstraints");
>+const $getSettings = dartx.getSettings = Symbol("dartx.getSettings");
>+const $onMute = dartx.onMute = Symbol("dartx.onMute");
>+const $onUnmute = dartx.onUnmute = Symbol("dartx.onUnmute");
>+const $getContext = dartx.getContext = Symbol("dartx.getContext");
>+const $transferControlToOffscreen = dartx.transferControlToOffscreen = Symbol("dartx.transferControlToOffscreen");
>+const $onWebGlContextLost = dartx.onWebGlContextLost = Symbol("dartx.onWebGlContextLost");
>+const $onWebGlContextRestored = dartx.onWebGlContextRestored = Symbol("dartx.onWebGlContextRestored");
>+const $context2D = dartx.context2D = Symbol("dartx.context2D");
>+const $getContext3d = dartx.getContext3d = Symbol("dartx.getContext3d");
>+const $toDataUrl = dartx.toDataUrl = Symbol("dartx.toDataUrl");
>+const $toBlob = dartx.toBlob = Symbol("dartx.toBlob");
>+const $addColorStop = dartx.addColorStop = Symbol("dartx.addColorStop");
>+const $setTransform = dartx.setTransform = Symbol("dartx.setTransform");
>+const $currentTransform = dartx.currentTransform = Symbol("dartx.currentTransform");
>+const $fillStyle = dartx.fillStyle = Symbol("dartx.fillStyle");
>+const $filter = dartx.filter = Symbol("dartx.filter");
>+const $font = dartx.font = Symbol("dartx.font");
>+const $globalAlpha = dartx.globalAlpha = Symbol("dartx.globalAlpha");
>+const $globalCompositeOperation = dartx.globalCompositeOperation = Symbol("dartx.globalCompositeOperation");
>+const $imageSmoothingEnabled = dartx.imageSmoothingEnabled = Symbol("dartx.imageSmoothingEnabled");
>+const $imageSmoothingQuality = dartx.imageSmoothingQuality = Symbol("dartx.imageSmoothingQuality");
>+const $lineCap = dartx.lineCap = Symbol("dartx.lineCap");
>+const $lineJoin = dartx.lineJoin = Symbol("dartx.lineJoin");
>+const $lineWidth = dartx.lineWidth = Symbol("dartx.lineWidth");
>+const $miterLimit = dartx.miterLimit = Symbol("dartx.miterLimit");
>+const $shadowBlur = dartx.shadowBlur = Symbol("dartx.shadowBlur");
>+const $shadowColor = dartx.shadowColor = Symbol("dartx.shadowColor");
>+const $shadowOffsetX = dartx.shadowOffsetX = Symbol("dartx.shadowOffsetX");
>+const $shadowOffsetY = dartx.shadowOffsetY = Symbol("dartx.shadowOffsetY");
>+const $strokeStyle = dartx.strokeStyle = Symbol("dartx.strokeStyle");
>+const $textAlign = dartx.textAlign = Symbol("dartx.textAlign");
>+const $textBaseline = dartx.textBaseline = Symbol("dartx.textBaseline");
>+const $addHitRegion = dartx.addHitRegion = Symbol("dartx.addHitRegion");
>+const $beginPath = dartx.beginPath = Symbol("dartx.beginPath");
>+const $clearHitRegions = dartx.clearHitRegions = Symbol("dartx.clearHitRegions");
>+const $clearRect = dartx.clearRect = Symbol("dartx.clearRect");
>+const $clip = dartx.clip = Symbol("dartx.clip");
>+const $createImageData = dartx.createImageData = Symbol("dartx.createImageData");
>+const $createLinearGradient = dartx.createLinearGradient = Symbol("dartx.createLinearGradient");
>+const $createPattern = dartx.createPattern = Symbol("dartx.createPattern");
>+const $createRadialGradient = dartx.createRadialGradient = Symbol("dartx.createRadialGradient");
>+const $drawFocusIfNeeded = dartx.drawFocusIfNeeded = Symbol("dartx.drawFocusIfNeeded");
>+const $fillRect = dartx.fillRect = Symbol("dartx.fillRect");
>+const $getContextAttributes = dartx.getContextAttributes = Symbol("dartx.getContextAttributes");
>+const $getImageData = dartx.getImageData = Symbol("dartx.getImageData");
>+const $isContextLost = dartx.isContextLost = Symbol("dartx.isContextLost");
>+const $isPointInPath = dartx.isPointInPath = Symbol("dartx.isPointInPath");
>+const $isPointInStroke = dartx.isPointInStroke = Symbol("dartx.isPointInStroke");
>+const $measureText = dartx.measureText = Symbol("dartx.measureText");
>+const $putImageData = dartx.putImageData = Symbol("dartx.putImageData");
>+const $removeHitRegion = dartx.removeHitRegion = Symbol("dartx.removeHitRegion");
>+const $resetTransform = dartx.resetTransform = Symbol("dartx.resetTransform");
>+const $restore = dartx.restore = Symbol("dartx.restore");
>+const $rotate = dartx.rotate = Symbol("dartx.rotate");
>+const $save = dartx.save = Symbol("dartx.save");
>+const $scale = dartx.scale = Symbol("dartx.scale");
>+const $scrollPathIntoView = dartx.scrollPathIntoView = Symbol("dartx.scrollPathIntoView");
>+const $stroke = dartx.stroke = Symbol("dartx.stroke");
>+const $strokeRect = dartx.strokeRect = Symbol("dartx.strokeRect");
>+const $strokeText = dartx.strokeText = Symbol("dartx.strokeText");
>+const $transform = dartx.transform = Symbol("dartx.transform");
>+const $arcTo = dartx.arcTo = Symbol("dartx.arcTo");
>+const $bezierCurveTo = dartx.bezierCurveTo = Symbol("dartx.bezierCurveTo");
>+const $closePath = dartx.closePath = Symbol("dartx.closePath");
>+const $ellipse = dartx.ellipse = Symbol("dartx.ellipse");
>+const $lineTo = dartx.lineTo = Symbol("dartx.lineTo");
>+const $moveTo = dartx.moveTo = Symbol("dartx.moveTo");
>+const $quadraticCurveTo = dartx.quadraticCurveTo = Symbol("dartx.quadraticCurveTo");
>+const $rect = dartx.rect = Symbol("dartx.rect");
>+const $createImageDataFromImageData = dartx.createImageDataFromImageData = Symbol("dartx.createImageDataFromImageData");
>+const $setFillColorRgb = dartx.setFillColorRgb = Symbol("dartx.setFillColorRgb");
>+const $setFillColorHsl = dartx.setFillColorHsl = Symbol("dartx.setFillColorHsl");
>+const $setStrokeColorRgb = dartx.setStrokeColorRgb = Symbol("dartx.setStrokeColorRgb");
>+const $setStrokeColorHsl = dartx.setStrokeColorHsl = Symbol("dartx.setStrokeColorHsl");
>+const $arc = dartx.arc = Symbol("dartx.arc");
>+const $createPatternFromImage = dartx.createPatternFromImage = Symbol("dartx.createPatternFromImage");
>+const $drawImageScaled = dartx.drawImageScaled = Symbol("dartx.drawImageScaled");
>+const $drawImageScaledFromSource = dartx.drawImageScaledFromSource = Symbol("dartx.drawImageScaledFromSource");
>+const $drawImageToRect = dartx.drawImageToRect = Symbol("dartx.drawImageToRect");
>+const $drawImage = dartx.drawImage = Symbol("dartx.drawImage");
>+const $lineDashOffset = dartx.lineDashOffset = Symbol("dartx.lineDashOffset");
>+const $getLineDash = dartx.getLineDash = Symbol("dartx.getLineDash");
>+const $setLineDash = dartx.setLineDash = Symbol("dartx.setLineDash");
>+const $fillText = dartx.fillText = Symbol("dartx.fillText");
>+const $backingStorePixelRatio = dartx.backingStorePixelRatio = Symbol("dartx.backingStorePixelRatio");
>+const $frameType = dartx.frameType = Symbol("dartx.frameType");
>+const $claim = dartx.claim = Symbol("dartx.claim");
>+const $matchAll = dartx.matchAll = Symbol("dartx.matchAll");
>+const $openWindow = dartx.openWindow = Symbol("dartx.openWindow");
>+const $clipboardData = dartx.clipboardData = Symbol("dartx.clipboardData");
>+const $code = dartx.code = Symbol("dartx.code");
>+const $wasClean = dartx.wasClean = Symbol("dartx.wasClean");
>+const $detail = dartx.detail = Symbol("dartx.detail");
>+const $sourceCapabilities = dartx.sourceCapabilities = Symbol("dartx.sourceCapabilities");
>+const $view = dartx.view = Symbol("dartx.view");
>+const $select = dartx.select = Symbol("dartx.select");
>+const $getDistributedNodes = dartx.getDistributedNodes = Symbol("dartx.getDistributedNodes");
>+const $set = dartx.set = Symbol("dartx.set");
>+const $accuracy = dartx.accuracy = Symbol("dartx.accuracy");
>+const $altitude = dartx.altitude = Symbol("dartx.altitude");
>+const $altitudeAccuracy = dartx.altitudeAccuracy = Symbol("dartx.altitudeAccuracy");
>+const $heading = dartx.heading = Symbol("dartx.heading");
>+const $latitude = dartx.latitude = Symbol("dartx.latitude");
>+const $longitude = dartx.longitude = Symbol("dartx.longitude");
>+const $speed = dartx.speed = Symbol("dartx.speed");
>+const $iconUrl = dartx.iconUrl = Symbol("dartx.iconUrl");
>+const $create = dartx.create = Symbol("dartx.create");
>+const $preventSilentAccess = dartx.preventSilentAccess = Symbol("dartx.preventSilentAccess");
>+const $requireUserMediation = dartx.requireUserMediation = Symbol("dartx.requireUserMediation");
>+const $store = dartx.store = Symbol("dartx.store");
>+const $getRandomValues = dartx.getRandomValues = Symbol("dartx.getRandomValues");
>+const $subtle = dartx.subtle = Symbol("dartx.subtle");
>+const $algorithm = dartx.algorithm = Symbol("dartx.algorithm");
>+const $extractable = dartx.extractable = Symbol("dartx.extractable");
>+const $usages = dartx.usages = Symbol("dartx.usages");
>+const $encoding = dartx.encoding = Symbol("dartx.encoding");
>+const $cssText = dartx.cssText = Symbol("dartx.cssText");
>+const $parentRule = dartx.parentRule = Symbol("dartx.parentRule");
>+const $parentStyleSheet = dartx.parentStyleSheet = Symbol("dartx.parentStyleSheet");
>+const $conditionText = dartx.conditionText = Symbol("dartx.conditionText");
>+const $cssRules = dartx.cssRules = Symbol("dartx.cssRules");
>+const $deleteRule = dartx.deleteRule = Symbol("dartx.deleteRule");
>+const $insertRule = dartx.insertRule = Symbol("dartx.insertRule");
>+const $intrinsicHeight = dartx.intrinsicHeight = Symbol("dartx.intrinsicHeight");
>+const $intrinsicRatio = dartx.intrinsicRatio = Symbol("dartx.intrinsicRatio");
>+const $intrinsicWidth = dartx.intrinsicWidth = Symbol("dartx.intrinsicWidth");
>+const $media = dartx.media = Symbol("dartx.media");
>+const $styleSheet = dartx.styleSheet = Symbol("dartx.styleSheet");
>+const $keyText = dartx.keyText = Symbol("dartx.keyText");
>+const $appendRule = dartx.appendRule = Symbol("dartx.appendRule");
>+const $findRule = dartx.findRule = Symbol("dartx.findRule");
>+const $matrix = dartx.matrix = Symbol("dartx.matrix");
>+const $is2D = dartx.is2D = Symbol("dartx.is2D");
>+const $prefix = dartx.prefix = Symbol("dartx.prefix");
>+const $div = dartx.div = Symbol("dartx.div");
>+const $mul = dartx.mul = Symbol("dartx.mul");
>+const $sub = dartx.sub = Symbol("dartx.sub");
>+const $to = dartx.to = Symbol("dartx.to");
>+const $selectorText = dartx.selectorText = Symbol("dartx.selectorText");
>+const $angle = dartx.angle = Symbol("dartx.angle");
>+const $ax = dartx.ax = Symbol("dartx.ax");
>+const $ay = dartx.ay = Symbol("dartx.ay");
>+const $getPropertyValue = dartx.getPropertyValue = Symbol("dartx.getPropertyValue");
>+const $supportsProperty = dartx.supportsProperty = Symbol("dartx.supportsProperty");
>+const $setProperty = dartx.setProperty = Symbol("dartx.setProperty");
>+const $cssFloat = dartx.cssFloat = Symbol("dartx.cssFloat");
>+const $getPropertyPriority = dartx.getPropertyPriority = Symbol("dartx.getPropertyPriority");
>+const $removeProperty = dartx.removeProperty = Symbol("dartx.removeProperty");
>+const $background = dartx.background = Symbol("dartx.background");
>+const $backgroundAttachment = dartx.backgroundAttachment = Symbol("dartx.backgroundAttachment");
>+const $backgroundColor = dartx.backgroundColor = Symbol("dartx.backgroundColor");
>+const $backgroundImage = dartx.backgroundImage = Symbol("dartx.backgroundImage");
>+const $backgroundPosition = dartx.backgroundPosition = Symbol("dartx.backgroundPosition");
>+const $backgroundRepeat = dartx.backgroundRepeat = Symbol("dartx.backgroundRepeat");
>+const $border = dartx.border = Symbol("dartx.border");
>+const $borderBottom = dartx.borderBottom = Symbol("dartx.borderBottom");
>+const $borderBottomColor = dartx.borderBottomColor = Symbol("dartx.borderBottomColor");
>+const $borderBottomStyle = dartx.borderBottomStyle = Symbol("dartx.borderBottomStyle");
>+const $borderBottomWidth = dartx.borderBottomWidth = Symbol("dartx.borderBottomWidth");
>+const $borderCollapse = dartx.borderCollapse = Symbol("dartx.borderCollapse");
>+const $borderColor = dartx.borderColor = Symbol("dartx.borderColor");
>+const $borderLeft = dartx.borderLeft = Symbol("dartx.borderLeft");
>+const $borderLeftColor = dartx.borderLeftColor = Symbol("dartx.borderLeftColor");
>+const $borderLeftStyle = dartx.borderLeftStyle = Symbol("dartx.borderLeftStyle");
>+const $borderLeftWidth = dartx.borderLeftWidth = Symbol("dartx.borderLeftWidth");
>+const $borderRight = dartx.borderRight = Symbol("dartx.borderRight");
>+const $borderRightColor = dartx.borderRightColor = Symbol("dartx.borderRightColor");
>+const $borderRightStyle = dartx.borderRightStyle = Symbol("dartx.borderRightStyle");
>+const $borderRightWidth = dartx.borderRightWidth = Symbol("dartx.borderRightWidth");
>+const $borderSpacing = dartx.borderSpacing = Symbol("dartx.borderSpacing");
>+const $borderStyle = dartx.borderStyle = Symbol("dartx.borderStyle");
>+const $borderTop = dartx.borderTop = Symbol("dartx.borderTop");
>+const $borderTopColor = dartx.borderTopColor = Symbol("dartx.borderTopColor");
>+const $borderTopStyle = dartx.borderTopStyle = Symbol("dartx.borderTopStyle");
>+const $borderTopWidth = dartx.borderTopWidth = Symbol("dartx.borderTopWidth");
>+const $borderWidth = dartx.borderWidth = Symbol("dartx.borderWidth");
>+const $captionSide = dartx.captionSide = Symbol("dartx.captionSide");
>+const $color = dartx.color = Symbol("dartx.color");
>+const $content = dartx.content = Symbol("dartx.content");
>+const $cursor = dartx.cursor = Symbol("dartx.cursor");
>+const $display = dartx.display = Symbol("dartx.display");
>+const $emptyCells = dartx.emptyCells = Symbol("dartx.emptyCells");
>+const $fontFamily = dartx.fontFamily = Symbol("dartx.fontFamily");
>+const $fontSize = dartx.fontSize = Symbol("dartx.fontSize");
>+const $fontStyle = dartx.fontStyle = Symbol("dartx.fontStyle");
>+const $fontVariant = dartx.fontVariant = Symbol("dartx.fontVariant");
>+const $fontWeight = dartx.fontWeight = Symbol("dartx.fontWeight");
>+const $letterSpacing = dartx.letterSpacing = Symbol("dartx.letterSpacing");
>+const $lineHeight = dartx.lineHeight = Symbol("dartx.lineHeight");
>+const $listStyle = dartx.listStyle = Symbol("dartx.listStyle");
>+const $listStyleImage = dartx.listStyleImage = Symbol("dartx.listStyleImage");
>+const $listStylePosition = dartx.listStylePosition = Symbol("dartx.listStylePosition");
>+const $listStyleType = dartx.listStyleType = Symbol("dartx.listStyleType");
>+const $margin = dartx.margin = Symbol("dartx.margin");
>+const $marginBottom = dartx.marginBottom = Symbol("dartx.marginBottom");
>+const $marginLeft = dartx.marginLeft = Symbol("dartx.marginLeft");
>+const $marginRight = dartx.marginRight = Symbol("dartx.marginRight");
>+const $marginTop = dartx.marginTop = Symbol("dartx.marginTop");
>+const $maxHeight = dartx.maxHeight = Symbol("dartx.maxHeight");
>+const $maxWidth = dartx.maxWidth = Symbol("dartx.maxWidth");
>+const $minHeight = dartx.minHeight = Symbol("dartx.minHeight");
>+const $minWidth = dartx.minWidth = Symbol("dartx.minWidth");
>+const $outline = dartx.outline = Symbol("dartx.outline");
>+const $outlineColor = dartx.outlineColor = Symbol("dartx.outlineColor");
>+const $outlineStyle = dartx.outlineStyle = Symbol("dartx.outlineStyle");
>+const $outlineWidth = dartx.outlineWidth = Symbol("dartx.outlineWidth");
>+const $overflow = dartx.overflow = Symbol("dartx.overflow");
>+const $padding = dartx.padding = Symbol("dartx.padding");
>+const $paddingBottom = dartx.paddingBottom = Symbol("dartx.paddingBottom");
>+const $paddingLeft = dartx.paddingLeft = Symbol("dartx.paddingLeft");
>+const $paddingRight = dartx.paddingRight = Symbol("dartx.paddingRight");
>+const $paddingTop = dartx.paddingTop = Symbol("dartx.paddingTop");
>+const $pageBreakAfter = dartx.pageBreakAfter = Symbol("dartx.pageBreakAfter");
>+const $pageBreakBefore = dartx.pageBreakBefore = Symbol("dartx.pageBreakBefore");
>+const $pageBreakInside = dartx.pageBreakInside = Symbol("dartx.pageBreakInside");
>+const $position = dartx.position = Symbol("dartx.position");
>+const $quotes = dartx.quotes = Symbol("dartx.quotes");
>+const $tableLayout = dartx.tableLayout = Symbol("dartx.tableLayout");
>+const $textDecoration = dartx.textDecoration = Symbol("dartx.textDecoration");
>+const $textIndent = dartx.textIndent = Symbol("dartx.textIndent");
>+const $textTransform = dartx.textTransform = Symbol("dartx.textTransform");
>+const $unicodeBidi = dartx.unicodeBidi = Symbol("dartx.unicodeBidi");
>+const $verticalAlign = dartx.verticalAlign = Symbol("dartx.verticalAlign");
>+const $visibility = dartx.visibility = Symbol("dartx.visibility");
>+const $whiteSpace = dartx.whiteSpace = Symbol("dartx.whiteSpace");
>+const $wordSpacing = dartx.wordSpacing = Symbol("dartx.wordSpacing");
>+const $zIndex = dartx.zIndex = Symbol("dartx.zIndex");
>+const $alignContent = dartx.alignContent = Symbol("dartx.alignContent");
>+const $alignItems = dartx.alignItems = Symbol("dartx.alignItems");
>+const $alignSelf = dartx.alignSelf = Symbol("dartx.alignSelf");
>+const $animation = dartx.animation = Symbol("dartx.animation");
>+const $animationDelay = dartx.animationDelay = Symbol("dartx.animationDelay");
>+const $animationDirection = dartx.animationDirection = Symbol("dartx.animationDirection");
>+const $animationDuration = dartx.animationDuration = Symbol("dartx.animationDuration");
>+const $animationFillMode = dartx.animationFillMode = Symbol("dartx.animationFillMode");
>+const $animationIterationCount = dartx.animationIterationCount = Symbol("dartx.animationIterationCount");
>+const $animationPlayState = dartx.animationPlayState = Symbol("dartx.animationPlayState");
>+const $animationTimingFunction = dartx.animationTimingFunction = Symbol("dartx.animationTimingFunction");
>+const $appRegion = dartx.appRegion = Symbol("dartx.appRegion");
>+const $appearance = dartx.appearance = Symbol("dartx.appearance");
>+const $aspectRatio = dartx.aspectRatio = Symbol("dartx.aspectRatio");
>+const $backfaceVisibility = dartx.backfaceVisibility = Symbol("dartx.backfaceVisibility");
>+const $backgroundBlendMode = dartx.backgroundBlendMode = Symbol("dartx.backgroundBlendMode");
>+const $backgroundClip = dartx.backgroundClip = Symbol("dartx.backgroundClip");
>+const $backgroundComposite = dartx.backgroundComposite = Symbol("dartx.backgroundComposite");
>+const $backgroundOrigin = dartx.backgroundOrigin = Symbol("dartx.backgroundOrigin");
>+const $backgroundPositionX = dartx.backgroundPositionX = Symbol("dartx.backgroundPositionX");
>+const $backgroundPositionY = dartx.backgroundPositionY = Symbol("dartx.backgroundPositionY");
>+const $backgroundRepeatX = dartx.backgroundRepeatX = Symbol("dartx.backgroundRepeatX");
>+const $backgroundRepeatY = dartx.backgroundRepeatY = Symbol("dartx.backgroundRepeatY");
>+const $backgroundSize = dartx.backgroundSize = Symbol("dartx.backgroundSize");
>+const $borderAfter = dartx.borderAfter = Symbol("dartx.borderAfter");
>+const $borderAfterColor = dartx.borderAfterColor = Symbol("dartx.borderAfterColor");
>+const $borderAfterStyle = dartx.borderAfterStyle = Symbol("dartx.borderAfterStyle");
>+const $borderAfterWidth = dartx.borderAfterWidth = Symbol("dartx.borderAfterWidth");
>+const $borderBefore = dartx.borderBefore = Symbol("dartx.borderBefore");
>+const $borderBeforeColor = dartx.borderBeforeColor = Symbol("dartx.borderBeforeColor");
>+const $borderBeforeStyle = dartx.borderBeforeStyle = Symbol("dartx.borderBeforeStyle");
>+const $borderBeforeWidth = dartx.borderBeforeWidth = Symbol("dartx.borderBeforeWidth");
>+const $borderBottomLeftRadius = dartx.borderBottomLeftRadius = Symbol("dartx.borderBottomLeftRadius");
>+const $borderBottomRightRadius = dartx.borderBottomRightRadius = Symbol("dartx.borderBottomRightRadius");
>+const $borderEnd = dartx.borderEnd = Symbol("dartx.borderEnd");
>+const $borderEndColor = dartx.borderEndColor = Symbol("dartx.borderEndColor");
>+const $borderEndStyle = dartx.borderEndStyle = Symbol("dartx.borderEndStyle");
>+const $borderEndWidth = dartx.borderEndWidth = Symbol("dartx.borderEndWidth");
>+const $borderFit = dartx.borderFit = Symbol("dartx.borderFit");
>+const $borderHorizontalSpacing = dartx.borderHorizontalSpacing = Symbol("dartx.borderHorizontalSpacing");
>+const $borderImage = dartx.borderImage = Symbol("dartx.borderImage");
>+const $borderImageOutset = dartx.borderImageOutset = Symbol("dartx.borderImageOutset");
>+const $borderImageRepeat = dartx.borderImageRepeat = Symbol("dartx.borderImageRepeat");
>+const $borderImageSlice = dartx.borderImageSlice = Symbol("dartx.borderImageSlice");
>+const $borderImageSource = dartx.borderImageSource = Symbol("dartx.borderImageSource");
>+const $borderImageWidth = dartx.borderImageWidth = Symbol("dartx.borderImageWidth");
>+const $borderRadius = dartx.borderRadius = Symbol("dartx.borderRadius");
>+const $borderStart = dartx.borderStart = Symbol("dartx.borderStart");
>+const $borderStartColor = dartx.borderStartColor = Symbol("dartx.borderStartColor");
>+const $borderStartStyle = dartx.borderStartStyle = Symbol("dartx.borderStartStyle");
>+const $borderStartWidth = dartx.borderStartWidth = Symbol("dartx.borderStartWidth");
>+const $borderTopLeftRadius = dartx.borderTopLeftRadius = Symbol("dartx.borderTopLeftRadius");
>+const $borderTopRightRadius = dartx.borderTopRightRadius = Symbol("dartx.borderTopRightRadius");
>+const $borderVerticalSpacing = dartx.borderVerticalSpacing = Symbol("dartx.borderVerticalSpacing");
>+const $boxAlign = dartx.boxAlign = Symbol("dartx.boxAlign");
>+const $boxDecorationBreak = dartx.boxDecorationBreak = Symbol("dartx.boxDecorationBreak");
>+const $boxDirection = dartx.boxDirection = Symbol("dartx.boxDirection");
>+const $boxFlex = dartx.boxFlex = Symbol("dartx.boxFlex");
>+const $boxFlexGroup = dartx.boxFlexGroup = Symbol("dartx.boxFlexGroup");
>+const $boxLines = dartx.boxLines = Symbol("dartx.boxLines");
>+const $boxOrdinalGroup = dartx.boxOrdinalGroup = Symbol("dartx.boxOrdinalGroup");
>+const $boxOrient = dartx.boxOrient = Symbol("dartx.boxOrient");
>+const $boxPack = dartx.boxPack = Symbol("dartx.boxPack");
>+const $boxReflect = dartx.boxReflect = Symbol("dartx.boxReflect");
>+const $boxShadow = dartx.boxShadow = Symbol("dartx.boxShadow");
>+const $boxSizing = dartx.boxSizing = Symbol("dartx.boxSizing");
>+const $clipPath = dartx.clipPath = Symbol("dartx.clipPath");
>+const $columnBreakAfter = dartx.columnBreakAfter = Symbol("dartx.columnBreakAfter");
>+const $columnBreakBefore = dartx.columnBreakBefore = Symbol("dartx.columnBreakBefore");
>+const $columnBreakInside = dartx.columnBreakInside = Symbol("dartx.columnBreakInside");
>+const $columnCount = dartx.columnCount = Symbol("dartx.columnCount");
>+const $columnFill = dartx.columnFill = Symbol("dartx.columnFill");
>+const $columnGap = dartx.columnGap = Symbol("dartx.columnGap");
>+const $columnRule = dartx.columnRule = Symbol("dartx.columnRule");
>+const $columnRuleColor = dartx.columnRuleColor = Symbol("dartx.columnRuleColor");
>+const $columnRuleStyle = dartx.columnRuleStyle = Symbol("dartx.columnRuleStyle");
>+const $columnRuleWidth = dartx.columnRuleWidth = Symbol("dartx.columnRuleWidth");
>+const $columnSpan = dartx.columnSpan = Symbol("dartx.columnSpan");
>+const $columnWidth = dartx.columnWidth = Symbol("dartx.columnWidth");
>+const $columns = dartx.columns = Symbol("dartx.columns");
>+const $counterIncrement = dartx.counterIncrement = Symbol("dartx.counterIncrement");
>+const $counterReset = dartx.counterReset = Symbol("dartx.counterReset");
>+const $flex = dartx.flex = Symbol("dartx.flex");
>+const $flexBasis = dartx.flexBasis = Symbol("dartx.flexBasis");
>+const $flexDirection = dartx.flexDirection = Symbol("dartx.flexDirection");
>+const $flexFlow = dartx.flexFlow = Symbol("dartx.flexFlow");
>+const $flexGrow = dartx.flexGrow = Symbol("dartx.flexGrow");
>+const $flexShrink = dartx.flexShrink = Symbol("dartx.flexShrink");
>+const $flexWrap = dartx.flexWrap = Symbol("dartx.flexWrap");
>+const $float = dartx.float = Symbol("dartx.float");
>+const $fontFeatureSettings = dartx.fontFeatureSettings = Symbol("dartx.fontFeatureSettings");
>+const $fontKerning = dartx.fontKerning = Symbol("dartx.fontKerning");
>+const $fontSizeDelta = dartx.fontSizeDelta = Symbol("dartx.fontSizeDelta");
>+const $fontSmoothing = dartx.fontSmoothing = Symbol("dartx.fontSmoothing");
>+const $fontStretch = dartx.fontStretch = Symbol("dartx.fontStretch");
>+const $fontVariantLigatures = dartx.fontVariantLigatures = Symbol("dartx.fontVariantLigatures");
>+const $grid = dartx.grid = Symbol("dartx.grid");
>+const $gridArea = dartx.gridArea = Symbol("dartx.gridArea");
>+const $gridAutoColumns = dartx.gridAutoColumns = Symbol("dartx.gridAutoColumns");
>+const $gridAutoFlow = dartx.gridAutoFlow = Symbol("dartx.gridAutoFlow");
>+const $gridAutoRows = dartx.gridAutoRows = Symbol("dartx.gridAutoRows");
>+const $gridColumn = dartx.gridColumn = Symbol("dartx.gridColumn");
>+const $gridColumnEnd = dartx.gridColumnEnd = Symbol("dartx.gridColumnEnd");
>+const $gridColumnStart = dartx.gridColumnStart = Symbol("dartx.gridColumnStart");
>+const $gridRow = dartx.gridRow = Symbol("dartx.gridRow");
>+const $gridRowEnd = dartx.gridRowEnd = Symbol("dartx.gridRowEnd");
>+const $gridRowStart = dartx.gridRowStart = Symbol("dartx.gridRowStart");
>+const $gridTemplate = dartx.gridTemplate = Symbol("dartx.gridTemplate");
>+const $gridTemplateAreas = dartx.gridTemplateAreas = Symbol("dartx.gridTemplateAreas");
>+const $gridTemplateColumns = dartx.gridTemplateColumns = Symbol("dartx.gridTemplateColumns");
>+const $gridTemplateRows = dartx.gridTemplateRows = Symbol("dartx.gridTemplateRows");
>+const $highlight = dartx.highlight = Symbol("dartx.highlight");
>+const $hyphenateCharacter = dartx.hyphenateCharacter = Symbol("dartx.hyphenateCharacter");
>+const $imageRendering = dartx.imageRendering = Symbol("dartx.imageRendering");
>+const $isolation = dartx.isolation = Symbol("dartx.isolation");
>+const $justifyContent = dartx.justifyContent = Symbol("dartx.justifyContent");
>+const $justifySelf = dartx.justifySelf = Symbol("dartx.justifySelf");
>+const $lineBoxContain = dartx.lineBoxContain = Symbol("dartx.lineBoxContain");
>+const $lineBreak = dartx.lineBreak = Symbol("dartx.lineBreak");
>+const $lineClamp = dartx.lineClamp = Symbol("dartx.lineClamp");
>+const $locale = dartx.locale = Symbol("dartx.locale");
>+const $logicalHeight = dartx.logicalHeight = Symbol("dartx.logicalHeight");
>+const $logicalWidth = dartx.logicalWidth = Symbol("dartx.logicalWidth");
>+const $marginAfter = dartx.marginAfter = Symbol("dartx.marginAfter");
>+const $marginAfterCollapse = dartx.marginAfterCollapse = Symbol("dartx.marginAfterCollapse");
>+const $marginBefore = dartx.marginBefore = Symbol("dartx.marginBefore");
>+const $marginBeforeCollapse = dartx.marginBeforeCollapse = Symbol("dartx.marginBeforeCollapse");
>+const $marginBottomCollapse = dartx.marginBottomCollapse = Symbol("dartx.marginBottomCollapse");
>+const $marginCollapse = dartx.marginCollapse = Symbol("dartx.marginCollapse");
>+const $marginEnd = dartx.marginEnd = Symbol("dartx.marginEnd");
>+const $marginStart = dartx.marginStart = Symbol("dartx.marginStart");
>+const $marginTopCollapse = dartx.marginTopCollapse = Symbol("dartx.marginTopCollapse");
>+const $mask = dartx.mask = Symbol("dartx.mask");
>+const $maskBoxImage = dartx.maskBoxImage = Symbol("dartx.maskBoxImage");
>+const $maskBoxImageOutset = dartx.maskBoxImageOutset = Symbol("dartx.maskBoxImageOutset");
>+const $maskBoxImageRepeat = dartx.maskBoxImageRepeat = Symbol("dartx.maskBoxImageRepeat");
>+const $maskBoxImageSlice = dartx.maskBoxImageSlice = Symbol("dartx.maskBoxImageSlice");
>+const $maskBoxImageSource = dartx.maskBoxImageSource = Symbol("dartx.maskBoxImageSource");
>+const $maskBoxImageWidth = dartx.maskBoxImageWidth = Symbol("dartx.maskBoxImageWidth");
>+const $maskClip = dartx.maskClip = Symbol("dartx.maskClip");
>+const $maskComposite = dartx.maskComposite = Symbol("dartx.maskComposite");
>+const $maskImage = dartx.maskImage = Symbol("dartx.maskImage");
>+const $maskOrigin = dartx.maskOrigin = Symbol("dartx.maskOrigin");
>+const $maskPosition = dartx.maskPosition = Symbol("dartx.maskPosition");
>+const $maskPositionX = dartx.maskPositionX = Symbol("dartx.maskPositionX");
>+const $maskPositionY = dartx.maskPositionY = Symbol("dartx.maskPositionY");
>+const $maskRepeat = dartx.maskRepeat = Symbol("dartx.maskRepeat");
>+const $maskRepeatX = dartx.maskRepeatX = Symbol("dartx.maskRepeatX");
>+const $maskRepeatY = dartx.maskRepeatY = Symbol("dartx.maskRepeatY");
>+const $maskSize = dartx.maskSize = Symbol("dartx.maskSize");
>+const $maskSourceType = dartx.maskSourceType = Symbol("dartx.maskSourceType");
>+const $maxLogicalHeight = dartx.maxLogicalHeight = Symbol("dartx.maxLogicalHeight");
>+const $maxLogicalWidth = dartx.maxLogicalWidth = Symbol("dartx.maxLogicalWidth");
>+const $maxZoom = dartx.maxZoom = Symbol("dartx.maxZoom");
>+const $minLogicalHeight = dartx.minLogicalHeight = Symbol("dartx.minLogicalHeight");
>+const $minLogicalWidth = dartx.minLogicalWidth = Symbol("dartx.minLogicalWidth");
>+const $minZoom = dartx.minZoom = Symbol("dartx.minZoom");
>+const $mixBlendMode = dartx.mixBlendMode = Symbol("dartx.mixBlendMode");
>+const $objectFit = dartx.objectFit = Symbol("dartx.objectFit");
>+const $objectPosition = dartx.objectPosition = Symbol("dartx.objectPosition");
>+const $opacity = dartx.opacity = Symbol("dartx.opacity");
>+const $order = dartx.order = Symbol("dartx.order");
>+const $orphans = dartx.orphans = Symbol("dartx.orphans");
>+const $outlineOffset = dartx.outlineOffset = Symbol("dartx.outlineOffset");
>+const $overflowWrap = dartx.overflowWrap = Symbol("dartx.overflowWrap");
>+const $overflowX = dartx.overflowX = Symbol("dartx.overflowX");
>+const $overflowY = dartx.overflowY = Symbol("dartx.overflowY");
>+const $paddingAfter = dartx.paddingAfter = Symbol("dartx.paddingAfter");
>+const $paddingBefore = dartx.paddingBefore = Symbol("dartx.paddingBefore");
>+const $paddingEnd = dartx.paddingEnd = Symbol("dartx.paddingEnd");
>+const $paddingStart = dartx.paddingStart = Symbol("dartx.paddingStart");
>+const $page = dartx.page = Symbol("dartx.page");
>+const $perspective = dartx.perspective = Symbol("dartx.perspective");
>+const $perspectiveOrigin = dartx.perspectiveOrigin = Symbol("dartx.perspectiveOrigin");
>+const $perspectiveOriginX = dartx.perspectiveOriginX = Symbol("dartx.perspectiveOriginX");
>+const $perspectiveOriginY = dartx.perspectiveOriginY = Symbol("dartx.perspectiveOriginY");
>+const $pointerEvents = dartx.pointerEvents = Symbol("dartx.pointerEvents");
>+const $printColorAdjust = dartx.printColorAdjust = Symbol("dartx.printColorAdjust");
>+const $resize = dartx.resize = Symbol("dartx.resize");
>+const $rtlOrdering = dartx.rtlOrdering = Symbol("dartx.rtlOrdering");
>+const $rubyPosition = dartx.rubyPosition = Symbol("dartx.rubyPosition");
>+const $scrollBehavior = dartx.scrollBehavior = Symbol("dartx.scrollBehavior");
>+const $shapeImageThreshold = dartx.shapeImageThreshold = Symbol("dartx.shapeImageThreshold");
>+const $shapeMargin = dartx.shapeMargin = Symbol("dartx.shapeMargin");
>+const $shapeOutside = dartx.shapeOutside = Symbol("dartx.shapeOutside");
>+const $speak = dartx.speak = Symbol("dartx.speak");
>+const $tabSize = dartx.tabSize = Symbol("dartx.tabSize");
>+const $tapHighlightColor = dartx.tapHighlightColor = Symbol("dartx.tapHighlightColor");
>+const $textAlignLast = dartx.textAlignLast = Symbol("dartx.textAlignLast");
>+const $textCombine = dartx.textCombine = Symbol("dartx.textCombine");
>+const $textDecorationColor = dartx.textDecorationColor = Symbol("dartx.textDecorationColor");
>+const $textDecorationLine = dartx.textDecorationLine = Symbol("dartx.textDecorationLine");
>+const $textDecorationStyle = dartx.textDecorationStyle = Symbol("dartx.textDecorationStyle");
>+const $textDecorationsInEffect = dartx.textDecorationsInEffect = Symbol("dartx.textDecorationsInEffect");
>+const $textEmphasis = dartx.textEmphasis = Symbol("dartx.textEmphasis");
>+const $textEmphasisColor = dartx.textEmphasisColor = Symbol("dartx.textEmphasisColor");
>+const $textEmphasisPosition = dartx.textEmphasisPosition = Symbol("dartx.textEmphasisPosition");
>+const $textEmphasisStyle = dartx.textEmphasisStyle = Symbol("dartx.textEmphasisStyle");
>+const $textFillColor = dartx.textFillColor = Symbol("dartx.textFillColor");
>+const $textJustify = dartx.textJustify = Symbol("dartx.textJustify");
>+const $textLineThroughColor = dartx.textLineThroughColor = Symbol("dartx.textLineThroughColor");
>+const $textLineThroughMode = dartx.textLineThroughMode = Symbol("dartx.textLineThroughMode");
>+const $textLineThroughStyle = dartx.textLineThroughStyle = Symbol("dartx.textLineThroughStyle");
>+const $textLineThroughWidth = dartx.textLineThroughWidth = Symbol("dartx.textLineThroughWidth");
>+const $textOrientation = dartx.textOrientation = Symbol("dartx.textOrientation");
>+const $textOverflow = dartx.textOverflow = Symbol("dartx.textOverflow");
>+const $textOverlineColor = dartx.textOverlineColor = Symbol("dartx.textOverlineColor");
>+const $textOverlineMode = dartx.textOverlineMode = Symbol("dartx.textOverlineMode");
>+const $textOverlineStyle = dartx.textOverlineStyle = Symbol("dartx.textOverlineStyle");
>+const $textOverlineWidth = dartx.textOverlineWidth = Symbol("dartx.textOverlineWidth");
>+const $textRendering = dartx.textRendering = Symbol("dartx.textRendering");
>+const $textSecurity = dartx.textSecurity = Symbol("dartx.textSecurity");
>+const $textShadow = dartx.textShadow = Symbol("dartx.textShadow");
>+const $textStroke = dartx.textStroke = Symbol("dartx.textStroke");
>+const $textStrokeColor = dartx.textStrokeColor = Symbol("dartx.textStrokeColor");
>+const $textStrokeWidth = dartx.textStrokeWidth = Symbol("dartx.textStrokeWidth");
>+const $textUnderlineColor = dartx.textUnderlineColor = Symbol("dartx.textUnderlineColor");
>+const $textUnderlineMode = dartx.textUnderlineMode = Symbol("dartx.textUnderlineMode");
>+const $textUnderlinePosition = dartx.textUnderlinePosition = Symbol("dartx.textUnderlinePosition");
>+const $textUnderlineStyle = dartx.textUnderlineStyle = Symbol("dartx.textUnderlineStyle");
>+const $textUnderlineWidth = dartx.textUnderlineWidth = Symbol("dartx.textUnderlineWidth");
>+const $touchAction = dartx.touchAction = Symbol("dartx.touchAction");
>+const $touchActionDelay = dartx.touchActionDelay = Symbol("dartx.touchActionDelay");
>+const $transformOrigin = dartx.transformOrigin = Symbol("dartx.transformOrigin");
>+const $transformOriginX = dartx.transformOriginX = Symbol("dartx.transformOriginX");
>+const $transformOriginY = dartx.transformOriginY = Symbol("dartx.transformOriginY");
>+const $transformOriginZ = dartx.transformOriginZ = Symbol("dartx.transformOriginZ");
>+const $transformStyle = dartx.transformStyle = Symbol("dartx.transformStyle");
>+const $transition = dartx.transition = Symbol("dartx.transition");
>+const $transitionDelay = dartx.transitionDelay = Symbol("dartx.transitionDelay");
>+const $transitionDuration = dartx.transitionDuration = Symbol("dartx.transitionDuration");
>+const $transitionProperty = dartx.transitionProperty = Symbol("dartx.transitionProperty");
>+const $transitionTimingFunction = dartx.transitionTimingFunction = Symbol("dartx.transitionTimingFunction");
>+const $unicodeRange = dartx.unicodeRange = Symbol("dartx.unicodeRange");
>+const $userDrag = dartx.userDrag = Symbol("dartx.userDrag");
>+const $userModify = dartx.userModify = Symbol("dartx.userModify");
>+const $userSelect = dartx.userSelect = Symbol("dartx.userSelect");
>+const $userZoom = dartx.userZoom = Symbol("dartx.userZoom");
>+const $widows = dartx.widows = Symbol("dartx.widows");
>+const $willChange = dartx.willChange = Symbol("dartx.willChange");
>+const $wordBreak = dartx.wordBreak = Symbol("dartx.wordBreak");
>+const $wordWrap = dartx.wordWrap = Symbol("dartx.wordWrap");
>+const $wrapFlow = dartx.wrapFlow = Symbol("dartx.wrapFlow");
>+const $wrapThrough = dartx.wrapThrough = Symbol("dartx.wrapThrough");
>+const $writingMode = dartx.writingMode = Symbol("dartx.writingMode");
>+const $zoom = dartx.zoom = Symbol("dartx.zoom");
>+const $ownerRule = dartx.ownerRule = Symbol("dartx.ownerRule");
>+const $rules = dartx.rules = Symbol("dartx.rules");
>+const $addRule = dartx.addRule = Symbol("dartx.addRule");
>+const $removeRule = dartx.removeRule = Symbol("dartx.removeRule");
>+const $ownerNode = dartx.ownerNode = Symbol("dartx.ownerNode");
>+const $componentAtIndex = dartx.componentAtIndex = Symbol("dartx.componentAtIndex");
>+const $toMatrix = dartx.toMatrix = Symbol("dartx.toMatrix");
>+const $unit = dartx.unit = Symbol("dartx.unit");
>+const $fragmentAtIndex = dartx.fragmentAtIndex = Symbol("dartx.fragmentAtIndex");
>+const $fallback = dartx.fallback = Symbol("dartx.fallback");
>+const $variable = dartx.variable = Symbol("dartx.variable");
>+const $define = dartx.define = Symbol("dartx.define");
>+const $whenDefined = dartx.whenDefined = Symbol("dartx.whenDefined");
>+const $options = dartx.options = Symbol("dartx.options");
>+const $dropEffect = dartx.dropEffect = Symbol("dartx.dropEffect");
>+const $effectAllowed = dartx.effectAllowed = Symbol("dartx.effectAllowed");
>+const $files = dartx.files = Symbol("dartx.files");
>+const $items = dartx.items = Symbol("dartx.items");
>+const $types = dartx.types = Symbol("dartx.types");
>+const $clearData = dartx.clearData = Symbol("dartx.clearData");
>+const $getData = dartx.getData = Symbol("dartx.getData");
>+const $setData = dartx.setData = Symbol("dartx.setData");
>+const $setDragImage = dartx.setDragImage = Symbol("dartx.setDragImage");
>+const $getAsEntry = dartx.getAsEntry = Symbol("dartx.getAsEntry");
>+const $getAsFile = dartx.getAsFile = Symbol("dartx.getAsFile");
>+const $addData = dartx.addData = Symbol("dartx.addData");
>+const $addFile = dartx.addFile = Symbol("dartx.addFile");
>+const $requestFileSystemSync = dartx.requestFileSystemSync = Symbol("dartx.requestFileSystemSync");
>+const $resolveLocalFileSystemSyncUrl = dartx.resolveLocalFileSystemSyncUrl = Symbol("dartx.resolveLocalFileSystemSyncUrl");
>+const $addressSpace = dartx.addressSpace = Symbol("dartx.addressSpace");
>+const $caches = dartx.caches = Symbol("dartx.caches");
>+const $crypto = dartx.crypto = Symbol("dartx.crypto");
>+const $indexedDB = dartx.indexedDB = Symbol("dartx.indexedDB");
>+const $isSecureContext = dartx.isSecureContext = Symbol("dartx.isSecureContext");
>+const $location = dartx.location = Symbol("dartx.location");
>+const $navigator = dartx.navigator = Symbol("dartx.navigator");
>+const $performance = dartx.performance = Symbol("dartx.performance");
>+const $self = dartx.self = Symbol("dartx.self");
>+const $importScripts = dartx.importScripts = Symbol("dartx.importScripts");
>+const $atob = dartx.atob = Symbol("dartx.atob");
>+const $btoa = dartx.btoa = Symbol("dartx.btoa");
>+const $queryUsageAndQuota = dartx.queryUsageAndQuota = Symbol("dartx.queryUsageAndQuota");
>+const $requestQuota = dartx.requestQuota = Symbol("dartx.requestQuota");
>+const $lineNumber = dartx.lineNumber = Symbol("dartx.lineNumber");
>+const $sourceFile = dartx.sourceFile = Symbol("dartx.sourceFile");
>+const $cornerPoints = dartx.cornerPoints = Symbol("dartx.cornerPoints");
>+const $rawValue = dartx.rawValue = Symbol("dartx.rawValue");
>+const $landmarks = dartx.landmarks = Symbol("dartx.landmarks");
>+const $acceleration = dartx.acceleration = Symbol("dartx.acceleration");
>+const $accelerationIncludingGravity = dartx.accelerationIncludingGravity = Symbol("dartx.accelerationIncludingGravity");
>+const $interval = dartx.interval = Symbol("dartx.interval");
>+const $rotationRate = dartx.rotationRate = Symbol("dartx.rotationRate");
>+const $absolute = dartx.absolute = Symbol("dartx.absolute");
>+const $alpha = dartx.alpha = Symbol("dartx.alpha");
>+const $beta = dartx.beta = Symbol("dartx.beta");
>+const $gamma = dartx.gamma = Symbol("dartx.gamma");
>+const $show = dartx.show = Symbol("dartx.show");
>+const $showModal = dartx.showModal = Symbol("dartx.showModal");
>+const $createDirectory = dartx.createDirectory = Symbol("dartx.createDirectory");
>+const $createReader = dartx.createReader = Symbol("dartx.createReader");
>+const $getDirectory = dartx.getDirectory = Symbol("dartx.getDirectory");
>+const $createFile = dartx.createFile = Symbol("dartx.createFile");
>+const $getFile = dartx.getFile = Symbol("dartx.getFile");
>+const $removeRecursively = dartx.removeRecursively = Symbol("dartx.removeRecursively");
>+const $filesystem = dartx.filesystem = Symbol("dartx.filesystem");
>+const $fullPath = dartx.fullPath = Symbol("dartx.fullPath");
>+const $isDirectory = dartx.isDirectory = Symbol("dartx.isDirectory");
>+const $isFile = dartx.isFile = Symbol("dartx.isFile");
>+const $copyTo = dartx.copyTo = Symbol("dartx.copyTo");
>+const $getMetadata = dartx.getMetadata = Symbol("dartx.getMetadata");
>+const $getParent = dartx.getParent = Symbol("dartx.getParent");
>+const $toUrl = dartx.toUrl = Symbol("dartx.toUrl");
>+const $readEntries = dartx.readEntries = Symbol("dartx.readEntries");
>+const $contentType = dartx.contentType = Symbol("dartx.contentType");
>+const $cookie = dartx.cookie = Symbol("dartx.cookie");
>+const $currentScript = dartx.currentScript = Symbol("dartx.currentScript");
>+const $window = dartx.window = Symbol("dartx.window");
>+const $documentElement = dartx.documentElement = Symbol("dartx.documentElement");
>+const $domain = dartx.domain = Symbol("dartx.domain");
>+const $fullscreenEnabled = dartx.fullscreenEnabled = Symbol("dartx.fullscreenEnabled");
>+const $implementation = dartx.implementation = Symbol("dartx.implementation");
>+const $rootElement = dartx.rootElement = Symbol("dartx.rootElement");
>+const $rootScroller = dartx.rootScroller = Symbol("dartx.rootScroller");
>+const $scrollingElement = dartx.scrollingElement = Symbol("dartx.scrollingElement");
>+const $suborigin = dartx.suborigin = Symbol("dartx.suborigin");
>+const $adoptNode = dartx.adoptNode = Symbol("dartx.adoptNode");
>+const $createDocumentFragment = dartx.createDocumentFragment = Symbol("dartx.createDocumentFragment");
>+const $createRange = dartx.createRange = Symbol("dartx.createRange");
>+const $execCommand = dartx.execCommand = Symbol("dartx.execCommand");
>+const $exitFullscreen = dartx.exitFullscreen = Symbol("dartx.exitFullscreen");
>+const $exitPointerLock = dartx.exitPointerLock = Symbol("dartx.exitPointerLock");
>+const $getElementsByName = dartx.getElementsByName = Symbol("dartx.getElementsByName");
>+const $getElementsByTagName = dartx.getElementsByTagName = Symbol("dartx.getElementsByTagName");
>+const $importNode = dartx.importNode = Symbol("dartx.importNode");
>+const $queryCommandEnabled = dartx.queryCommandEnabled = Symbol("dartx.queryCommandEnabled");
>+const $queryCommandIndeterm = dartx.queryCommandIndeterm = Symbol("dartx.queryCommandIndeterm");
>+const $queryCommandState = dartx.queryCommandState = Symbol("dartx.queryCommandState");
>+const $queryCommandSupported = dartx.queryCommandSupported = Symbol("dartx.queryCommandSupported");
>+const $queryCommandValue = dartx.queryCommandValue = Symbol("dartx.queryCommandValue");
>+const $registerElement2 = dartx.registerElement2 = Symbol("dartx.registerElement2");
>+const $getElementById = dartx.getElementById = Symbol("dartx.getElementById");
>+const $activeElement = dartx.activeElement = Symbol("dartx.activeElement");
>+const $fullscreenElement = dartx.fullscreenElement = Symbol("dartx.fullscreenElement");
>+const $pointerLockElement = dartx.pointerLockElement = Symbol("dartx.pointerLockElement");
>+const $elementsFromPoint = dartx.elementsFromPoint = Symbol("dartx.elementsFromPoint");
>+const $fonts = dartx.fonts = Symbol("dartx.fonts");
>+const $onPointerLockChange = dartx.onPointerLockChange = Symbol("dartx.onPointerLockChange");
>+const $onPointerLockError = dartx.onPointerLockError = Symbol("dartx.onPointerLockError");
>+const $onReadyStateChange = dartx.onReadyStateChange = Symbol("dartx.onReadyStateChange");
>+const $onSecurityPolicyViolation = dartx.onSecurityPolicyViolation = Symbol("dartx.onSecurityPolicyViolation");
>+const $onSelectionChange = dartx.onSelectionChange = Symbol("dartx.onSelectionChange");
>+const $supportsRegisterElement = dartx.supportsRegisterElement = Symbol("dartx.supportsRegisterElement");
>+const $supportsRegister = dartx.supportsRegister = Symbol("dartx.supportsRegister");
>+const $registerElement = dartx.registerElement = Symbol("dartx.registerElement");
>+const $createElementNS = dartx.createElementNS = Symbol("dartx.createElementNS");
>+const $visibilityState = dartx.visibilityState = Symbol("dartx.visibilityState");
>+const $styleSheets = dartx.styleSheets = Symbol("dartx.styleSheets");
>+const $elementFromPoint = dartx.elementFromPoint = Symbol("dartx.elementFromPoint");
>+const $getSelection = dartx.getSelection = Symbol("dartx.getSelection");
>+const $createDocument = dartx.createDocument = Symbol("dartx.createDocument");
>+const $createDocumentType = dartx.createDocumentType = Symbol("dartx.createDocumentType");
>+const $hasFeature = dartx.hasFeature = Symbol("dartx.hasFeature");
>+const $a = dartx.a = Symbol("dartx.a");
>+const $b = dartx.b = Symbol("dartx.b");
>+const $c = dartx.c = Symbol("dartx.c");
>+const $d = dartx.d = Symbol("dartx.d");
>+const $e = dartx.e = Symbol("dartx.e");
>+const $f = dartx.f = Symbol("dartx.f");
>+const $m11 = dartx.m11 = Symbol("dartx.m11");
>+const $m12 = dartx.m12 = Symbol("dartx.m12");
>+const $m13 = dartx.m13 = Symbol("dartx.m13");
>+const $m14 = dartx.m14 = Symbol("dartx.m14");
>+const $m21 = dartx.m21 = Symbol("dartx.m21");
>+const $m22 = dartx.m22 = Symbol("dartx.m22");
>+const $m23 = dartx.m23 = Symbol("dartx.m23");
>+const $m24 = dartx.m24 = Symbol("dartx.m24");
>+const $m31 = dartx.m31 = Symbol("dartx.m31");
>+const $m32 = dartx.m32 = Symbol("dartx.m32");
>+const $m33 = dartx.m33 = Symbol("dartx.m33");
>+const $m34 = dartx.m34 = Symbol("dartx.m34");
>+const $m41 = dartx.m41 = Symbol("dartx.m41");
>+const $m42 = dartx.m42 = Symbol("dartx.m42");
>+const $m43 = dartx.m43 = Symbol("dartx.m43");
>+const $m44 = dartx.m44 = Symbol("dartx.m44");
>+const $invertSelf = dartx.invertSelf = Symbol("dartx.invertSelf");
>+const $multiplySelf = dartx.multiplySelf = Symbol("dartx.multiplySelf");
>+const $preMultiplySelf = dartx.preMultiplySelf = Symbol("dartx.preMultiplySelf");
>+const $rotateAxisAngleSelf = dartx.rotateAxisAngleSelf = Symbol("dartx.rotateAxisAngleSelf");
>+const $rotateFromVectorSelf = dartx.rotateFromVectorSelf = Symbol("dartx.rotateFromVectorSelf");
>+const $rotateSelf = dartx.rotateSelf = Symbol("dartx.rotateSelf");
>+const $scale3dSelf = dartx.scale3dSelf = Symbol("dartx.scale3dSelf");
>+const $scaleSelf = dartx.scaleSelf = Symbol("dartx.scaleSelf");
>+const $setMatrixValue = dartx.setMatrixValue = Symbol("dartx.setMatrixValue");
>+const $skewXSelf = dartx.skewXSelf = Symbol("dartx.skewXSelf");
>+const $skewYSelf = dartx.skewYSelf = Symbol("dartx.skewYSelf");
>+const $translateSelf = dartx.translateSelf = Symbol("dartx.translateSelf");
>+const $isIdentity = dartx.isIdentity = Symbol("dartx.isIdentity");
>+const $flipX = dartx.flipX = Symbol("dartx.flipX");
>+const $flipY = dartx.flipY = Symbol("dartx.flipY");
>+const $inverse = dartx.inverse = Symbol("dartx.inverse");
>+const $multiply = dartx.multiply = Symbol("dartx.multiply");
>+const $rotateAxisAngle = dartx.rotateAxisAngle = Symbol("dartx.rotateAxisAngle");
>+const $rotateFromVector = dartx.rotateFromVector = Symbol("dartx.rotateFromVector");
>+const $scale3d = dartx.scale3d = Symbol("dartx.scale3d");
>+const $skewX = dartx.skewX = Symbol("dartx.skewX");
>+const $skewY = dartx.skewY = Symbol("dartx.skewY");
>+const $toFloat32Array = dartx.toFloat32Array = Symbol("dartx.toFloat32Array");
>+const $toFloat64Array = dartx.toFloat64Array = Symbol("dartx.toFloat64Array");
>+const $transformPoint = dartx.transformPoint = Symbol("dartx.transformPoint");
>+const $parseFromString = dartx.parseFromString = Symbol("dartx.parseFromString");
>+const $w = dartx.w = Symbol("dartx.w");
>+const $matrixTransform = dartx.matrixTransform = Symbol("dartx.matrixTransform");
>+const $p1 = dartx.p1 = Symbol("dartx.p1");
>+const $p2 = dartx.p2 = Symbol("dartx.p2");
>+const $p3 = dartx.p3 = Symbol("dartx.p3");
>+const $p4 = dartx.p4 = Symbol("dartx.p4");
>+const $getBounds = dartx.getBounds = Symbol("dartx.getBounds");
>+const $replace = dartx.replace = Symbol("dartx.replace");
>+const $supports = dartx.supports = Symbol("dartx.supports");
>+const $toggle = dartx.toggle = Symbol("dartx.toggle");
>+const $colno = dartx.colno = Symbol("dartx.colno");
>+const $filename = dartx.filename = Symbol("dartx.filename");
>+const $lineno = dartx.lineno = Symbol("dartx.lineno");
>+const $withCredentials = dartx.withCredentials = Symbol("dartx.withCredentials");
>+const $onOpen = dartx.onOpen = Symbol("dartx.onOpen");
>+const $lastEventId = dartx.lastEventId = Symbol("dartx.lastEventId");
>+const $ports = dartx.ports = Symbol("dartx.ports");
>+const $AddSearchProvider = dartx.AddSearchProvider = Symbol("dartx.AddSearchProvider");
>+const $IsSearchProviderInstalled = dartx.IsSearchProviderInstalled = Symbol("dartx.IsSearchProviderInstalled");
>+const $provider = dartx.provider = Symbol("dartx.provider");
>+const $clientId = dartx.clientId = Symbol("dartx.clientId");
>+const $isReload = dartx.isReload = Symbol("dartx.isReload");
>+const $preloadResponse = dartx.preloadResponse = Symbol("dartx.preloadResponse");
>+const $elements = dartx.elements = Symbol("dartx.elements");
>+const $lastModified = dartx.lastModified = Symbol("dartx.lastModified");
>+const $lastModifiedDate = dartx.lastModifiedDate = Symbol("dartx.lastModifiedDate");
>+const $relativePath = dartx.relativePath = Symbol("dartx.relativePath");
>+const $createWriter = dartx.createWriter = Symbol("dartx.createWriter");
>+const $file = dartx.file = Symbol("dartx.file");
>+const $readAsArrayBuffer = dartx.readAsArrayBuffer = Symbol("dartx.readAsArrayBuffer");
>+const $readAsDataUrl = dartx.readAsDataUrl = Symbol("dartx.readAsDataUrl");
>+const $readAsText = dartx.readAsText = Symbol("dartx.readAsText");
>+const $onLoadEnd = dartx.onLoadEnd = Symbol("dartx.onLoadEnd");
>+const $onLoadStart = dartx.onLoadStart = Symbol("dartx.onLoadStart");
>+const $root = dartx.root = Symbol("dartx.root");
>+const $seek = dartx.seek = Symbol("dartx.seek");
>+const $write = dartx.write = Symbol("dartx.write");
>+const $onWrite = dartx.onWrite = Symbol("dartx.onWrite");
>+const $onWriteEnd = dartx.onWriteEnd = Symbol("dartx.onWriteEnd");
>+const $onWriteStart = dartx.onWriteStart = Symbol("dartx.onWriteStart");
>+const $relatedTarget = dartx.relatedTarget = Symbol("dartx.relatedTarget");
>+const $family = dartx.family = Symbol("dartx.family");
>+const $featureSettings = dartx.featureSettings = Symbol("dartx.featureSettings");
>+const $loaded = dartx.loaded = Symbol("dartx.loaded");
>+const $stretch = dartx.stretch = Symbol("dartx.stretch");
>+const $variant = dartx.variant = Symbol("dartx.variant");
>+const $weight = dartx.weight = Symbol("dartx.weight");
>+const $check = dartx.check = Symbol("dartx.check");
>+const $onLoading = dartx.onLoading = Symbol("dartx.onLoading");
>+const $onLoadingDone = dartx.onLoadingDone = Symbol("dartx.onLoadingDone");
>+const $onLoadingError = dartx.onLoadingError = Symbol("dartx.onLoadingError");
>+const $fontfaces = dartx.fontfaces = Symbol("dartx.fontfaces");
>+const $appendBlob = dartx.appendBlob = Symbol("dartx.appendBlob");
>+const $acceptCharset = dartx.acceptCharset = Symbol("dartx.acceptCharset");
>+const $action = dartx.action = Symbol("dartx.action");
>+const $enctype = dartx.enctype = Symbol("dartx.enctype");
>+const $method = dartx.method = Symbol("dartx.method");
>+const $noValidate = dartx.noValidate = Symbol("dartx.noValidate");
>+const $requestAutocomplete = dartx.requestAutocomplete = Symbol("dartx.requestAutocomplete");
>+const $reset = dartx.reset = Symbol("dartx.reset");
>+const $submit = dartx.submit = Symbol("dartx.submit");
>+const $axes = dartx.axes = Symbol("dartx.axes");
>+const $buttons = dartx.buttons = Symbol("dartx.buttons");
>+const $connected = dartx.connected = Symbol("dartx.connected");
>+const $displayId = dartx.displayId = Symbol("dartx.displayId");
>+const $hand = dartx.hand = Symbol("dartx.hand");
>+const $mapping = dartx.mapping = Symbol("dartx.mapping");
>+const $pose = dartx.pose = Symbol("dartx.pose");
>+const $touched = dartx.touched = Symbol("dartx.touched");
>+const $gamepad = dartx.gamepad = Symbol("dartx.gamepad");
>+const $angularAcceleration = dartx.angularAcceleration = Symbol("dartx.angularAcceleration");
>+const $angularVelocity = dartx.angularVelocity = Symbol("dartx.angularVelocity");
>+const $hasOrientation = dartx.hasOrientation = Symbol("dartx.hasOrientation");
>+const $hasPosition = dartx.hasPosition = Symbol("dartx.hasPosition");
>+const $linearAcceleration = dartx.linearAcceleration = Symbol("dartx.linearAcceleration");
>+const $linearVelocity = dartx.linearVelocity = Symbol("dartx.linearVelocity");
>+const $getCurrentPosition = dartx.getCurrentPosition = Symbol("dartx.getCurrentPosition");
>+const $watchPosition = dartx.watchPosition = Symbol("dartx.watchPosition");
>+const $newUrl = dartx.newUrl = Symbol("dartx.newUrl");
>+const $oldUrl = dartx.oldUrl = Symbol("dartx.oldUrl");
>+const $scrollRestoration = dartx.scrollRestoration = Symbol("dartx.scrollRestoration");
>+const $back = dartx.back = Symbol("dartx.back");
>+const $forward = dartx.forward = Symbol("dartx.forward");
>+const $go = dartx.go = Symbol("dartx.go");
>+const $pushState = dartx.pushState = Symbol("dartx.pushState");
>+const $replaceState = dartx.replaceState = Symbol("dartx.replaceState");
>+const $namedItem = dartx.namedItem = Symbol("dartx.namedItem");
>+const $body = dartx.body = Symbol("dartx.body");
>+const $caretRangeFromPoint = dartx.caretRangeFromPoint = Symbol("dartx.caretRangeFromPoint");
>+const $preferredStylesheetSet = dartx.preferredStylesheetSet = Symbol("dartx.preferredStylesheetSet");
>+const $referrer = dartx.referrer = Symbol("dartx.referrer");
>+const $selectedStylesheetSet = dartx.selectedStylesheetSet = Symbol("dartx.selectedStylesheetSet");
>+const $register = dartx.register = Symbol("dartx.register");
>+const $onVisibilityChange = dartx.onVisibilityChange = Symbol("dartx.onVisibilityChange");
>+const $createElementUpgrader = dartx.createElementUpgrader = Symbol("dartx.createElementUpgrader");
>+const $responseHeaders = dartx.responseHeaders = Symbol("dartx.responseHeaders");
>+const $responseText = dartx.responseText = Symbol("dartx.responseText");
>+const $responseType = dartx.responseType = Symbol("dartx.responseType");
>+const $responseUrl = dartx.responseUrl = Symbol("dartx.responseUrl");
>+const $responseXml = dartx.responseXml = Symbol("dartx.responseXml");
>+const $statusText = dartx.statusText = Symbol("dartx.statusText");
>+const $timeout = dartx.timeout = Symbol("dartx.timeout");
>+const $upload = dartx.upload = Symbol("dartx.upload");
>+const $getAllResponseHeaders = dartx.getAllResponseHeaders = Symbol("dartx.getAllResponseHeaders");
>+const $getResponseHeader = dartx.getResponseHeader = Symbol("dartx.getResponseHeader");
>+const $overrideMimeType = dartx.overrideMimeType = Symbol("dartx.overrideMimeType");
>+const $send = dartx.send = Symbol("dartx.send");
>+const $setRequestHeader = dartx.setRequestHeader = Symbol("dartx.setRequestHeader");
>+const $onTimeout = dartx.onTimeout = Symbol("dartx.onTimeout");
>+const $allow = dartx.allow = Symbol("dartx.allow");
>+const $allowFullscreen = dartx.allowFullscreen = Symbol("dartx.allowFullscreen");
>+const $allowPaymentRequest = dartx.allowPaymentRequest = Symbol("dartx.allowPaymentRequest");
>+const $contentWindow = dartx.contentWindow = Symbol("dartx.contentWindow");
>+const $csp = dartx.csp = Symbol("dartx.csp");
>+const $sandbox = dartx.sandbox = Symbol("dartx.sandbox");
>+const $srcdoc = dartx.srcdoc = Symbol("dartx.srcdoc");
>+const $didTimeout = dartx.didTimeout = Symbol("dartx.didTimeout");
>+const $timeRemaining = dartx.timeRemaining = Symbol("dartx.timeRemaining");
>+const $transferFromImageBitmap = dartx.transferFromImageBitmap = Symbol("dartx.transferFromImageBitmap");
>+const $track = dartx.track = Symbol("dartx.track");
>+const $getPhotoCapabilities = dartx.getPhotoCapabilities = Symbol("dartx.getPhotoCapabilities");
>+const $getPhotoSettings = dartx.getPhotoSettings = Symbol("dartx.getPhotoSettings");
>+const $grabFrame = dartx.grabFrame = Symbol("dartx.grabFrame");
>+const $setOptions = dartx.setOptions = Symbol("dartx.setOptions");
>+const $takePhoto = dartx.takePhoto = Symbol("dartx.takePhoto");
>+const $async = dartx.async = Symbol("dartx.async");
>+const $complete = dartx.complete = Symbol("dartx.complete");
>+const $isMap = dartx.isMap = Symbol("dartx.isMap");
>+const $naturalHeight = dartx.naturalHeight = Symbol("dartx.naturalHeight");
>+const $naturalWidth = dartx.naturalWidth = Symbol("dartx.naturalWidth");
>+const $sizes = dartx.sizes = Symbol("dartx.sizes");
>+const $srcset = dartx.srcset = Symbol("dartx.srcset");
>+const $useMap = dartx.useMap = Symbol("dartx.useMap");
>+const $decode = dartx.decode = Symbol("dartx.decode");
>+const $firesTouchEvents = dartx.firesTouchEvents = Symbol("dartx.firesTouchEvents");
>+const $accept = dartx.accept = Symbol("dartx.accept");
>+const $autocapitalize = dartx.autocapitalize = Symbol("dartx.autocapitalize");
>+const $capture = dartx.capture = Symbol("dartx.capture");
>+const $defaultChecked = dartx.defaultChecked = Symbol("dartx.defaultChecked");
>+const $defaultValue = dartx.defaultValue = Symbol("dartx.defaultValue");
>+const $dirName = dartx.dirName = Symbol("dartx.dirName");
>+const $incremental = dartx.incremental = Symbol("dartx.incremental");
>+const $indeterminate = dartx.indeterminate = Symbol("dartx.indeterminate");
>+const $list = dartx.list = Symbol("dartx.list");
>+const $max = dartx.max = Symbol("dartx.max");
>+const $maxLength = dartx.maxLength = Symbol("dartx.maxLength");
>+const $min = dartx.min = Symbol("dartx.min");
>+const $minLength = dartx.minLength = Symbol("dartx.minLength");
>+const $multiple = dartx.multiple = Symbol("dartx.multiple");
>+const $pattern = dartx.pattern = Symbol("dartx.pattern");
>+const $selectionDirection = dartx.selectionDirection = Symbol("dartx.selectionDirection");
>+const $selectionEnd = dartx.selectionEnd = Symbol("dartx.selectionEnd");
>+const $selectionStart = dartx.selectionStart = Symbol("dartx.selectionStart");
>+const $step = dartx.step = Symbol("dartx.step");
>+const $valueAsDate = dartx.valueAsDate = Symbol("dartx.valueAsDate");
>+const $valueAsNumber = dartx.valueAsNumber = Symbol("dartx.valueAsNumber");
>+const $directory = dartx.directory = Symbol("dartx.directory");
>+const $setRangeText = dartx.setRangeText = Symbol("dartx.setRangeText");
>+const $setSelectionRange = dartx.setSelectionRange = Symbol("dartx.setSelectionRange");
>+const $stepDown = dartx.stepDown = Symbol("dartx.stepDown");
>+const $stepUp = dartx.stepUp = Symbol("dartx.stepUp");
>+const $registerForeignFetch = dartx.registerForeignFetch = Symbol("dartx.registerForeignFetch");
>+const $rootMargin = dartx.rootMargin = Symbol("dartx.rootMargin");
>+const $thresholds = dartx.thresholds = Symbol("dartx.thresholds");
>+const $disconnect = dartx.disconnect = Symbol("dartx.disconnect");
>+const $takeRecords = dartx.takeRecords = Symbol("dartx.takeRecords");
>+const $boundingClientRect = dartx.boundingClientRect = Symbol("dartx.boundingClientRect");
>+const $intersectionRatio = dartx.intersectionRatio = Symbol("dartx.intersectionRatio");
>+const $intersectionRect = dartx.intersectionRect = Symbol("dartx.intersectionRect");
>+const $isIntersecting = dartx.isIntersecting = Symbol("dartx.isIntersecting");
>+const $rootBounds = dartx.rootBounds = Symbol("dartx.rootBounds");
>+const $keyCode = dartx.keyCode = Symbol("dartx.keyCode");
>+const $charCode = dartx.charCode = Symbol("dartx.charCode");
>+const $which = dartx.which = Symbol("dartx.which");
>+const $altKey = dartx.altKey = Symbol("dartx.altKey");
>+const $ctrlKey = dartx.ctrlKey = Symbol("dartx.ctrlKey");
>+const $isComposing = dartx.isComposing = Symbol("dartx.isComposing");
>+const $metaKey = dartx.metaKey = Symbol("dartx.metaKey");
>+const $repeat = dartx.repeat = Symbol("dartx.repeat");
>+const $shiftKey = dartx.shiftKey = Symbol("dartx.shiftKey");
>+const $getModifierState = dartx.getModifierState = Symbol("dartx.getModifierState");
>+const $control = dartx.control = Symbol("dartx.control");
>+const $htmlFor = dartx.htmlFor = Symbol("dartx.htmlFor");
>+const $as = dartx.as = Symbol("dartx.as");
>+const $import = dartx.import = Symbol("dartx.import");
>+const $integrity = dartx.integrity = Symbol("dartx.integrity");
>+const $relList = dartx.relList = Symbol("dartx.relList");
>+const $scope = dartx.scope = Symbol("dartx.scope");
>+const $sheet = dartx.sheet = Symbol("dartx.sheet");
>+const $supportsImport = dartx.supportsImport = Symbol("dartx.supportsImport");
>+const $ancestorOrigins = dartx.ancestorOrigins = Symbol("dartx.ancestorOrigins");
>+const $trustedHref = dartx.trustedHref = Symbol("dartx.trustedHref");
>+const $assign = dartx.assign = Symbol("dartx.assign");
>+const $reload = dartx.reload = Symbol("dartx.reload");
>+const $areas = dartx.areas = Symbol("dartx.areas");
>+const $decodingInfo = dartx.decodingInfo = Symbol("dartx.decodingInfo");
>+const $encodingInfo = dartx.encodingInfo = Symbol("dartx.encodingInfo");
>+const $powerEfficient = dartx.powerEfficient = Symbol("dartx.powerEfficient");
>+const $smooth = dartx.smooth = Symbol("dartx.smooth");
>+const $supported = dartx.supported = Symbol("dartx.supported");
>+const $deviceId = dartx.deviceId = Symbol("dartx.deviceId");
>+const $groupId = dartx.groupId = Symbol("dartx.groupId");
>+const $enumerateDevices = dartx.enumerateDevices = Symbol("dartx.enumerateDevices");
>+const $getSupportedConstraints = dartx.getSupportedConstraints = Symbol("dartx.getSupportedConstraints");
>+const $initData = dartx.initData = Symbol("dartx.initData");
>+const $initDataType = dartx.initDataType = Symbol("dartx.initDataType");
>+const $messageType = dartx.messageType = Symbol("dartx.messageType");
>+const $closed = dartx.closed = Symbol("dartx.closed");
>+const $expiration = dartx.expiration = Symbol("dartx.expiration");
>+const $keyStatuses = dartx.keyStatuses = Symbol("dartx.keyStatuses");
>+const $sessionId = dartx.sessionId = Symbol("dartx.sessionId");
>+const $generateRequest = dartx.generateRequest = Symbol("dartx.generateRequest");
>+const $keySystem = dartx.keySystem = Symbol("dartx.keySystem");
>+const $createMediaKeys = dartx.createMediaKeys = Symbol("dartx.createMediaKeys");
>+const $getConfiguration = dartx.getConfiguration = Symbol("dartx.getConfiguration");
>+const $getStatusForPolicy = dartx.getStatusForPolicy = Symbol("dartx.getStatusForPolicy");
>+const $setServerCertificate = dartx.setServerCertificate = Symbol("dartx.setServerCertificate");
>+const $minHdcpVersion = dartx.minHdcpVersion = Symbol("dartx.minHdcpVersion");
>+const $mediaText = dartx.mediaText = Symbol("dartx.mediaText");
>+const $appendMedium = dartx.appendMedium = Symbol("dartx.appendMedium");
>+const $deleteMedium = dartx.deleteMedium = Symbol("dartx.deleteMedium");
>+const $album = dartx.album = Symbol("dartx.album");
>+const $artist = dartx.artist = Symbol("dartx.artist");
>+const $artwork = dartx.artwork = Symbol("dartx.artwork");
>+const $addListener = dartx.addListener = Symbol("dartx.addListener");
>+const $removeListener = dartx.removeListener = Symbol("dartx.removeListener");
>+const $audioBitsPerSecond = dartx.audioBitsPerSecond = Symbol("dartx.audioBitsPerSecond");
>+const $mimeType = dartx.mimeType = Symbol("dartx.mimeType");
>+const $stream = dartx.stream = Symbol("dartx.stream");
>+const $videoBitsPerSecond = dartx.videoBitsPerSecond = Symbol("dartx.videoBitsPerSecond");
>+const $requestData = dartx.requestData = Symbol("dartx.requestData");
>+const $resume = dartx.resume = Symbol("dartx.resume");
>+const $metadata = dartx.metadata = Symbol("dartx.metadata");
>+const $playbackState = dartx.playbackState = Symbol("dartx.playbackState");
>+const $setActionHandler = dartx.setActionHandler = Symbol("dartx.setActionHandler");
>+const $activeSourceBuffers = dartx.activeSourceBuffers = Symbol("dartx.activeSourceBuffers");
>+const $sourceBuffers = dartx.sourceBuffers = Symbol("dartx.sourceBuffers");
>+const $addSourceBuffer = dartx.addSourceBuffer = Symbol("dartx.addSourceBuffer");
>+const $clearLiveSeekableRange = dartx.clearLiveSeekableRange = Symbol("dartx.clearLiveSeekableRange");
>+const $endOfStream = dartx.endOfStream = Symbol("dartx.endOfStream");
>+const $removeSourceBuffer = dartx.removeSourceBuffer = Symbol("dartx.removeSourceBuffer");
>+const $setLiveSeekableRange = dartx.setLiveSeekableRange = Symbol("dartx.setLiveSeekableRange");
>+const $active = dartx.active = Symbol("dartx.active");
>+const $addTrack = dartx.addTrack = Symbol("dartx.addTrack");
>+const $getAudioTracks = dartx.getAudioTracks = Symbol("dartx.getAudioTracks");
>+const $getTrackById = dartx.getTrackById = Symbol("dartx.getTrackById");
>+const $getTracks = dartx.getTracks = Symbol("dartx.getTracks");
>+const $getVideoTracks = dartx.getVideoTracks = Symbol("dartx.getVideoTracks");
>+const $removeTrack = dartx.removeTrack = Symbol("dartx.removeTrack");
>+const $onAddTrack = dartx.onAddTrack = Symbol("dartx.onAddTrack");
>+const $onRemoveTrack = dartx.onRemoveTrack = Symbol("dartx.onRemoveTrack");
>+const $jsHeapSizeLimit = dartx.jsHeapSizeLimit = Symbol("dartx.jsHeapSizeLimit");
>+const $totalJSHeapSize = dartx.totalJSHeapSize = Symbol("dartx.totalJSHeapSize");
>+const $usedJSHeapSize = dartx.usedJSHeapSize = Symbol("dartx.usedJSHeapSize");
>+const $port1 = dartx.port1 = Symbol("dartx.port1");
>+const $port2 = dartx.port2 = Symbol("dartx.port2");
>+const $httpEquiv = dartx.httpEquiv = Symbol("dartx.httpEquiv");
>+const $modificationTime = dartx.modificationTime = Symbol("dartx.modificationTime");
>+const $high = dartx.high = Symbol("dartx.high");
>+const $low = dartx.low = Symbol("dartx.low");
>+const $optimum = dartx.optimum = Symbol("dartx.optimum");
>+const $inputs = dartx.inputs = Symbol("dartx.inputs");
>+const $outputs = dartx.outputs = Symbol("dartx.outputs");
>+const $sysexEnabled = dartx.sysexEnabled = Symbol("dartx.sysexEnabled");
>+const $onMidiMessage = dartx.onMidiMessage = Symbol("dartx.onMidiMessage");
>+const $connection = dartx.connection = Symbol("dartx.connection");
>+const $manufacturer = dartx.manufacturer = Symbol("dartx.manufacturer");
>+const $description = dartx.description = Symbol("dartx.description");
>+const $enabledPlugin = dartx.enabledPlugin = Symbol("dartx.enabledPlugin");
>+const $suffixes = dartx.suffixes = Symbol("dartx.suffixes");
>+const $cite = dartx.cite = Symbol("dartx.cite");
>+const $dateTime = dartx.dateTime = Symbol("dartx.dateTime");
>+const $button = dartx.button = Symbol("dartx.button");
>+const $fromElement = dartx.fromElement = Symbol("dartx.fromElement");
>+const $region = dartx.region = Symbol("dartx.region");
>+const $toElement = dartx.toElement = Symbol("dartx.toElement");
>+const $movement = dartx.movement = Symbol("dartx.movement");
>+const $screen = dartx.screen = Symbol("dartx.screen");
>+const $layer = dartx.layer = Symbol("dartx.layer");
>+const $dataTransfer = dartx.dataTransfer = Symbol("dartx.dataTransfer");
>+const $attrChange = dartx.attrChange = Symbol("dartx.attrChange");
>+const $attrName = dartx.attrName = Symbol("dartx.attrName");
>+const $newValue = dartx.newValue = Symbol("dartx.newValue");
>+const $prevValue = dartx.prevValue = Symbol("dartx.prevValue");
>+const $relatedNode = dartx.relatedNode = Symbol("dartx.relatedNode");
>+const $initMutationEvent = dartx.initMutationEvent = Symbol("dartx.initMutationEvent");
>+const $addedNodes = dartx.addedNodes = Symbol("dartx.addedNodes");
>+const $attributeName = dartx.attributeName = Symbol("dartx.attributeName");
>+const $attributeNamespace = dartx.attributeNamespace = Symbol("dartx.attributeNamespace");
>+const $nextSibling = dartx.nextSibling = Symbol("dartx.nextSibling");
>+const $oldValue = dartx.oldValue = Symbol("dartx.oldValue");
>+const $previousSibling = dartx.previousSibling = Symbol("dartx.previousSibling");
>+const $removedNodes = dartx.removedNodes = Symbol("dartx.removedNodes");
>+const $disable = dartx.disable = Symbol("dartx.disable");
>+const $enable = dartx.enable = Symbol("dartx.enable");
>+const $getState = dartx.getState = Symbol("dartx.getState");
>+const $getGamepads = dartx.getGamepads = Symbol("dartx.getGamepads");
>+const $language = dartx.language = Symbol("dartx.language");
>+const $getUserMedia = dartx.getUserMedia = Symbol("dartx.getUserMedia");
>+const $budget = dartx.budget = Symbol("dartx.budget");
>+const $clipboard = dartx.clipboard = Symbol("dartx.clipboard");
>+const $credentials = dartx.credentials = Symbol("dartx.credentials");
>+const $deviceMemory = dartx.deviceMemory = Symbol("dartx.deviceMemory");
>+const $doNotTrack = dartx.doNotTrack = Symbol("dartx.doNotTrack");
>+const $geolocation = dartx.geolocation = Symbol("dartx.geolocation");
>+const $maxTouchPoints = dartx.maxTouchPoints = Symbol("dartx.maxTouchPoints");
>+const $mediaCapabilities = dartx.mediaCapabilities = Symbol("dartx.mediaCapabilities");
>+const $mediaDevices = dartx.mediaDevices = Symbol("dartx.mediaDevices");
>+const $mediaSession = dartx.mediaSession = Symbol("dartx.mediaSession");
>+const $mimeTypes = dartx.mimeTypes = Symbol("dartx.mimeTypes");
>+const $nfc = dartx.nfc = Symbol("dartx.nfc");
>+const $permissions = dartx.permissions = Symbol("dartx.permissions");
>+const $presentation = dartx.presentation = Symbol("dartx.presentation");
>+const $productSub = dartx.productSub = Symbol("dartx.productSub");
>+const $serviceWorker = dartx.serviceWorker = Symbol("dartx.serviceWorker");
>+const $storage = dartx.storage = Symbol("dartx.storage");
>+const $vendor = dartx.vendor = Symbol("dartx.vendor");
>+const $vendorSub = dartx.vendorSub = Symbol("dartx.vendorSub");
>+const $vr = dartx.vr = Symbol("dartx.vr");
>+const $persistentStorage = dartx.persistentStorage = Symbol("dartx.persistentStorage");
>+const $temporaryStorage = dartx.temporaryStorage = Symbol("dartx.temporaryStorage");
>+const $cancelKeyboardLock = dartx.cancelKeyboardLock = Symbol("dartx.cancelKeyboardLock");
>+const $getBattery = dartx.getBattery = Symbol("dartx.getBattery");
>+const $getInstalledRelatedApps = dartx.getInstalledRelatedApps = Symbol("dartx.getInstalledRelatedApps");
>+const $getVRDisplays = dartx.getVRDisplays = Symbol("dartx.getVRDisplays");
>+const $registerProtocolHandler = dartx.registerProtocolHandler = Symbol("dartx.registerProtocolHandler");
>+const $requestKeyboardLock = dartx.requestKeyboardLock = Symbol("dartx.requestKeyboardLock");
>+const $requestMidiAccess = dartx.requestMidiAccess = Symbol("dartx.requestMidiAccess");
>+const $requestMediaKeySystemAccess = dartx.requestMediaKeySystemAccess = Symbol("dartx.requestMediaKeySystemAccess");
>+const $sendBeacon = dartx.sendBeacon = Symbol("dartx.sendBeacon");
>+const $share = dartx.share = Symbol("dartx.share");
>+const $webdriver = dartx.webdriver = Symbol("dartx.webdriver");
>+const $cookieEnabled = dartx.cookieEnabled = Symbol("dartx.cookieEnabled");
>+const $appCodeName = dartx.appCodeName = Symbol("dartx.appCodeName");
>+const $appName = dartx.appName = Symbol("dartx.appName");
>+const $appVersion = dartx.appVersion = Symbol("dartx.appVersion");
>+const $dartEnabled = dartx.dartEnabled = Symbol("dartx.dartEnabled");
>+const $platform = dartx.platform = Symbol("dartx.platform");
>+const $product = dartx.product = Symbol("dartx.product");
>+const $userAgent = dartx.userAgent = Symbol("dartx.userAgent");
>+const $languages = dartx.languages = Symbol("dartx.languages");
>+const $onLine = dartx.onLine = Symbol("dartx.onLine");
>+const $hardwareConcurrency = dartx.hardwareConcurrency = Symbol("dartx.hardwareConcurrency");
>+const $constraintName = dartx.constraintName = Symbol("dartx.constraintName");
>+const $downlink = dartx.downlink = Symbol("dartx.downlink");
>+const $downlinkMax = dartx.downlinkMax = Symbol("dartx.downlinkMax");
>+const $effectiveType = dartx.effectiveType = Symbol("dartx.effectiveType");
>+const $rtt = dartx.rtt = Symbol("dartx.rtt");
>+const $pointerBeforeReferenceNode = dartx.pointerBeforeReferenceNode = Symbol("dartx.pointerBeforeReferenceNode");
>+const $referenceNode = dartx.referenceNode = Symbol("dartx.referenceNode");
>+const $whatToShow = dartx.whatToShow = Symbol("dartx.whatToShow");
>+const $detach = dartx.detach = Symbol("dartx.detach");
>+const $actions = dartx.actions = Symbol("dartx.actions");
>+const $badge = dartx.badge = Symbol("dartx.badge");
>+const $icon = dartx.icon = Symbol("dartx.icon");
>+const $image = dartx.image = Symbol("dartx.image");
>+const $renotify = dartx.renotify = Symbol("dartx.renotify");
>+const $requireInteraction = dartx.requireInteraction = Symbol("dartx.requireInteraction");
>+const $silent = dartx.silent = Symbol("dartx.silent");
>+const $tag = dartx.tag = Symbol("dartx.tag");
>+const $vibrate = dartx.vibrate = Symbol("dartx.vibrate");
>+const $onShow = dartx.onShow = Symbol("dartx.onShow");
>+const $notification = dartx.notification = Symbol("dartx.notification");
>+const $reply = dartx.reply = Symbol("dartx.reply");
>+const $convertToBlob = dartx.convertToBlob = Symbol("dartx.convertToBlob");
>+const $transferToImageBitmap = dartx.transferToImageBitmap = Symbol("dartx.transferToImageBitmap");
>+const $commit = dartx.commit = Symbol("dartx.commit");
>+const $defaultSelected = dartx.defaultSelected = Symbol("dartx.defaultSelected");
>+const $constraint = dartx.constraint = Symbol("dartx.constraint");
>+const $persisted = dartx.persisted = Symbol("dartx.persisted");
>+const $devicePixelRatio = dartx.devicePixelRatio = Symbol("dartx.devicePixelRatio");
>+const $registerPaint = dartx.registerPaint = Symbol("dartx.registerPaint");
>+const $additionalData = dartx.additionalData = Symbol("dartx.additionalData");
>+const $idName = dartx.idName = Symbol("dartx.idName");
>+const $passwordName = dartx.passwordName = Symbol("dartx.passwordName");
>+const $addPath = dartx.addPath = Symbol("dartx.addPath");
>+const $addressLine = dartx.addressLine = Symbol("dartx.addressLine");
>+const $city = dartx.city = Symbol("dartx.city");
>+const $country = dartx.country = Symbol("dartx.country");
>+const $dependentLocality = dartx.dependentLocality = Symbol("dartx.dependentLocality");
>+const $languageCode = dartx.languageCode = Symbol("dartx.languageCode");
>+const $organization = dartx.organization = Symbol("dartx.organization");
>+const $phone = dartx.phone = Symbol("dartx.phone");
>+const $postalCode = dartx.postalCode = Symbol("dartx.postalCode");
>+const $recipient = dartx.recipient = Symbol("dartx.recipient");
>+const $sortingCode = dartx.sortingCode = Symbol("dartx.sortingCode");
>+const $instruments = dartx.instruments = Symbol("dartx.instruments");
>+const $userHint = dartx.userHint = Symbol("dartx.userHint");
>+const $shippingAddress = dartx.shippingAddress = Symbol("dartx.shippingAddress");
>+const $shippingOption = dartx.shippingOption = Symbol("dartx.shippingOption");
>+const $shippingType = dartx.shippingType = Symbol("dartx.shippingType");
>+const $canMakePayment = dartx.canMakePayment = Symbol("dartx.canMakePayment");
>+const $instrumentKey = dartx.instrumentKey = Symbol("dartx.instrumentKey");
>+const $paymentRequestId = dartx.paymentRequestId = Symbol("dartx.paymentRequestId");
>+const $total = dartx.total = Symbol("dartx.total");
>+const $updateWith = dartx.updateWith = Symbol("dartx.updateWith");
>+const $methodName = dartx.methodName = Symbol("dartx.methodName");
>+const $payerEmail = dartx.payerEmail = Symbol("dartx.payerEmail");
>+const $payerName = dartx.payerName = Symbol("dartx.payerName");
>+const $payerPhone = dartx.payerPhone = Symbol("dartx.payerPhone");
>+const $requestId = dartx.requestId = Symbol("dartx.requestId");
>+const $memory = dartx.memory = Symbol("dartx.memory");
>+const $navigation = dartx.navigation = Symbol("dartx.navigation");
>+const $timeOrigin = dartx.timeOrigin = Symbol("dartx.timeOrigin");
>+const $clearMarks = dartx.clearMarks = Symbol("dartx.clearMarks");
>+const $clearMeasures = dartx.clearMeasures = Symbol("dartx.clearMeasures");
>+const $clearResourceTimings = dartx.clearResourceTimings = Symbol("dartx.clearResourceTimings");
>+const $getEntries = dartx.getEntries = Symbol("dartx.getEntries");
>+const $getEntriesByName = dartx.getEntriesByName = Symbol("dartx.getEntriesByName");
>+const $getEntriesByType = dartx.getEntriesByType = Symbol("dartx.getEntriesByType");
>+const $mark = dartx.mark = Symbol("dartx.mark");
>+const $measure = dartx.measure = Symbol("dartx.measure");
>+const $now = dartx.now = Symbol("dartx.now");
>+const $setResourceTimingBufferSize = dartx.setResourceTimingBufferSize = Symbol("dartx.setResourceTimingBufferSize");
>+const $entryType = dartx.entryType = Symbol("dartx.entryType");
>+const $attribution = dartx.attribution = Symbol("dartx.attribution");
>+const $redirectCount = dartx.redirectCount = Symbol("dartx.redirectCount");
>+const $domComplete = dartx.domComplete = Symbol("dartx.domComplete");
>+const $domContentLoadedEventEnd = dartx.domContentLoadedEventEnd = Symbol("dartx.domContentLoadedEventEnd");
>+const $domContentLoadedEventStart = dartx.domContentLoadedEventStart = Symbol("dartx.domContentLoadedEventStart");
>+const $domInteractive = dartx.domInteractive = Symbol("dartx.domInteractive");
>+const $loadEventEnd = dartx.loadEventEnd = Symbol("dartx.loadEventEnd");
>+const $loadEventStart = dartx.loadEventStart = Symbol("dartx.loadEventStart");
>+const $unloadEventEnd = dartx.unloadEventEnd = Symbol("dartx.unloadEventEnd");
>+const $unloadEventStart = dartx.unloadEventStart = Symbol("dartx.unloadEventStart");
>+const $connectEnd = dartx.connectEnd = Symbol("dartx.connectEnd");
>+const $connectStart = dartx.connectStart = Symbol("dartx.connectStart");
>+const $decodedBodySize = dartx.decodedBodySize = Symbol("dartx.decodedBodySize");
>+const $domainLookupEnd = dartx.domainLookupEnd = Symbol("dartx.domainLookupEnd");
>+const $domainLookupStart = dartx.domainLookupStart = Symbol("dartx.domainLookupStart");
>+const $encodedBodySize = dartx.encodedBodySize = Symbol("dartx.encodedBodySize");
>+const $fetchStart = dartx.fetchStart = Symbol("dartx.fetchStart");
>+const $initiatorType = dartx.initiatorType = Symbol("dartx.initiatorType");
>+const $nextHopProtocol = dartx.nextHopProtocol = Symbol("dartx.nextHopProtocol");
>+const $redirectEnd = dartx.redirectEnd = Symbol("dartx.redirectEnd");
>+const $redirectStart = dartx.redirectStart = Symbol("dartx.redirectStart");
>+const $requestStart = dartx.requestStart = Symbol("dartx.requestStart");
>+const $responseEnd = dartx.responseEnd = Symbol("dartx.responseEnd");
>+const $responseStart = dartx.responseStart = Symbol("dartx.responseStart");
>+const $secureConnectionStart = dartx.secureConnectionStart = Symbol("dartx.secureConnectionStart");
>+const $serverTiming = dartx.serverTiming = Symbol("dartx.serverTiming");
>+const $transferSize = dartx.transferSize = Symbol("dartx.transferSize");
>+const $workerStart = dartx.workerStart = Symbol("dartx.workerStart");
>+const $domLoading = dartx.domLoading = Symbol("dartx.domLoading");
>+const $navigationStart = dartx.navigationStart = Symbol("dartx.navigationStart");
>+const $query = dartx.query = Symbol("dartx.query");
>+const $requestAll = dartx.requestAll = Symbol("dartx.requestAll");
>+const $revoke = dartx.revoke = Symbol("dartx.revoke");
>+const $fillLightMode = dartx.fillLightMode = Symbol("dartx.fillLightMode");
>+const $imageHeight = dartx.imageHeight = Symbol("dartx.imageHeight");
>+const $imageWidth = dartx.imageWidth = Symbol("dartx.imageWidth");
>+const $redEyeReduction = dartx.redEyeReduction = Symbol("dartx.redEyeReduction");
>+const $refresh = dartx.refresh = Symbol("dartx.refresh");
>+const $isPrimary = dartx.isPrimary = Symbol("dartx.isPrimary");
>+const $pointerId = dartx.pointerId = Symbol("dartx.pointerId");
>+const $pointerType = dartx.pointerType = Symbol("dartx.pointerType");
>+const $pressure = dartx.pressure = Symbol("dartx.pressure");
>+const $tangentialPressure = dartx.tangentialPressure = Symbol("dartx.tangentialPressure");
>+const $tiltX = dartx.tiltX = Symbol("dartx.tiltX");
>+const $tiltY = dartx.tiltY = Symbol("dartx.tiltY");
>+const $twist = dartx.twist = Symbol("dartx.twist");
>+const $getCoalescedEvents = dartx.getCoalescedEvents = Symbol("dartx.getCoalescedEvents");
>+const $defaultRequest = dartx.defaultRequest = Symbol("dartx.defaultRequest");
>+const $receiver = dartx.receiver = Symbol("dartx.receiver");
>+const $binaryType = dartx.binaryType = Symbol("dartx.binaryType");
>+const $terminate = dartx.terminate = Symbol("dartx.terminate");
>+const $connections = dartx.connections = Symbol("dartx.connections");
>+const $connectionList = dartx.connectionList = Symbol("dartx.connectionList");
>+const $getAvailability = dartx.getAvailability = Symbol("dartx.getAvailability");
>+const $reconnect = dartx.reconnect = Symbol("dartx.reconnect");
>+const $lengthComputable = dartx.lengthComputable = Symbol("dartx.lengthComputable");
>+const $promise = dartx.promise = Symbol("dartx.promise");
>+const $rawId = dartx.rawId = Symbol("dartx.rawId");
>+const $getSubscription = dartx.getSubscription = Symbol("dartx.getSubscription");
>+const $permissionState = dartx.permissionState = Symbol("dartx.permissionState");
>+const $subscribe = dartx.subscribe = Symbol("dartx.subscribe");
>+const $endpoint = dartx.endpoint = Symbol("dartx.endpoint");
>+const $expirationTime = dartx.expirationTime = Symbol("dartx.expirationTime");
>+const $unsubscribe = dartx.unsubscribe = Symbol("dartx.unsubscribe");
>+const $applicationServerKey = dartx.applicationServerKey = Symbol("dartx.applicationServerKey");
>+const $userVisibleOnly = dartx.userVisibleOnly = Symbol("dartx.userVisibleOnly");
>+const $collapsed = dartx.collapsed = Symbol("dartx.collapsed");
>+const $commonAncestorContainer = dartx.commonAncestorContainer = Symbol("dartx.commonAncestorContainer");
>+const $endContainer = dartx.endContainer = Symbol("dartx.endContainer");
>+const $endOffset = dartx.endOffset = Symbol("dartx.endOffset");
>+const $startContainer = dartx.startContainer = Symbol("dartx.startContainer");
>+const $startOffset = dartx.startOffset = Symbol("dartx.startOffset");
>+const $cloneContents = dartx.cloneContents = Symbol("dartx.cloneContents");
>+const $cloneRange = dartx.cloneRange = Symbol("dartx.cloneRange");
>+const $collapse = dartx.collapse = Symbol("dartx.collapse");
>+const $compareBoundaryPoints = dartx.compareBoundaryPoints = Symbol("dartx.compareBoundaryPoints");
>+const $comparePoint = dartx.comparePoint = Symbol("dartx.comparePoint");
>+const $createContextualFragment = dartx.createContextualFragment = Symbol("dartx.createContextualFragment");
>+const $deleteContents = dartx.deleteContents = Symbol("dartx.deleteContents");
>+const $extractContents = dartx.extractContents = Symbol("dartx.extractContents");
>+const $insertNode = dartx.insertNode = Symbol("dartx.insertNode");
>+const $isPointInRange = dartx.isPointInRange = Symbol("dartx.isPointInRange");
>+const $selectNode = dartx.selectNode = Symbol("dartx.selectNode");
>+const $selectNodeContents = dartx.selectNodeContents = Symbol("dartx.selectNodeContents");
>+const $setEnd = dartx.setEnd = Symbol("dartx.setEnd");
>+const $setEndAfter = dartx.setEndAfter = Symbol("dartx.setEndAfter");
>+const $setEndBefore = dartx.setEndBefore = Symbol("dartx.setEndBefore");
>+const $setStart = dartx.setStart = Symbol("dartx.setStart");
>+const $setStartAfter = dartx.setStartAfter = Symbol("dartx.setStartAfter");
>+const $setStartBefore = dartx.setStartBefore = Symbol("dartx.setStartBefore");
>+const $surroundContents = dartx.surroundContents = Symbol("dartx.surroundContents");
>+const $cancelWatchAvailability = dartx.cancelWatchAvailability = Symbol("dartx.cancelWatchAvailability");
>+const $watchAvailability = dartx.watchAvailability = Symbol("dartx.watchAvailability");
>+const $contentRect = dartx.contentRect = Symbol("dartx.contentRect");
>+const $expires = dartx.expires = Symbol("dartx.expires");
>+const $getFingerprints = dartx.getFingerprints = Symbol("dartx.getFingerprints");
>+const $bufferedAmount = dartx.bufferedAmount = Symbol("dartx.bufferedAmount");
>+const $bufferedAmountLowThreshold = dartx.bufferedAmountLowThreshold = Symbol("dartx.bufferedAmountLowThreshold");
>+const $maxRetransmitTime = dartx.maxRetransmitTime = Symbol("dartx.maxRetransmitTime");
>+const $maxRetransmits = dartx.maxRetransmits = Symbol("dartx.maxRetransmits");
>+const $negotiated = dartx.negotiated = Symbol("dartx.negotiated");
>+const $ordered = dartx.ordered = Symbol("dartx.ordered");
>+const $reliable = dartx.reliable = Symbol("dartx.reliable");
>+const $sendBlob = dartx.sendBlob = Symbol("dartx.sendBlob");
>+const $sendByteBuffer = dartx.sendByteBuffer = Symbol("dartx.sendByteBuffer");
>+const $sendString = dartx.sendString = Symbol("dartx.sendString");
>+const $sendTypedData = dartx.sendTypedData = Symbol("dartx.sendTypedData");
>+const $channel = dartx.channel = Symbol("dartx.channel");
>+const $canInsertDtmf = dartx.canInsertDtmf = Symbol("dartx.canInsertDtmf");
>+const $interToneGap = dartx.interToneGap = Symbol("dartx.interToneGap");
>+const $toneBuffer = dartx.toneBuffer = Symbol("dartx.toneBuffer");
>+const $insertDtmf = dartx.insertDtmf = Symbol("dartx.insertDtmf");
>+const $onToneChange = dartx.onToneChange = Symbol("dartx.onToneChange");
>+const $tone = dartx.tone = Symbol("dartx.tone");
>+const $candidate = dartx.candidate = Symbol("dartx.candidate");
>+const $sdpMLineIndex = dartx.sdpMLineIndex = Symbol("dartx.sdpMLineIndex");
>+const $sdpMid = dartx.sdpMid = Symbol("dartx.sdpMid");
>+const $names = dartx.names = Symbol("dartx.names");
>+const $stat = dartx.stat = Symbol("dartx.stat");
>+const $getLegacyStats = dartx.getLegacyStats = Symbol("dartx.getLegacyStats");
>+const $iceConnectionState = dartx.iceConnectionState = Symbol("dartx.iceConnectionState");
>+const $iceGatheringState = dartx.iceGatheringState = Symbol("dartx.iceGatheringState");
>+const $localDescription = dartx.localDescription = Symbol("dartx.localDescription");
>+const $remoteDescription = dartx.remoteDescription = Symbol("dartx.remoteDescription");
>+const $signalingState = dartx.signalingState = Symbol("dartx.signalingState");
>+const $addIceCandidate = dartx.addIceCandidate = Symbol("dartx.addIceCandidate");
>+const $addStream = dartx.addStream = Symbol("dartx.addStream");
>+const $createAnswer = dartx.createAnswer = Symbol("dartx.createAnswer");
>+const $createDtmfSender = dartx.createDtmfSender = Symbol("dartx.createDtmfSender");
>+const $createDataChannel = dartx.createDataChannel = Symbol("dartx.createDataChannel");
>+const $createOffer = dartx.createOffer = Symbol("dartx.createOffer");
>+const $getLocalStreams = dartx.getLocalStreams = Symbol("dartx.getLocalStreams");
>+const $getReceivers = dartx.getReceivers = Symbol("dartx.getReceivers");
>+const $getRemoteStreams = dartx.getRemoteStreams = Symbol("dartx.getRemoteStreams");
>+const $getSenders = dartx.getSenders = Symbol("dartx.getSenders");
>+const $getStats = dartx.getStats = Symbol("dartx.getStats");
>+const $removeStream = dartx.removeStream = Symbol("dartx.removeStream");
>+const $setConfiguration = dartx.setConfiguration = Symbol("dartx.setConfiguration");
>+const $setLocalDescription = dartx.setLocalDescription = Symbol("dartx.setLocalDescription");
>+const $setRemoteDescription = dartx.setRemoteDescription = Symbol("dartx.setRemoteDescription");
>+const $onAddStream = dartx.onAddStream = Symbol("dartx.onAddStream");
>+const $onDataChannel = dartx.onDataChannel = Symbol("dartx.onDataChannel");
>+const $onIceCandidate = dartx.onIceCandidate = Symbol("dartx.onIceCandidate");
>+const $onIceConnectionStateChange = dartx.onIceConnectionStateChange = Symbol("dartx.onIceConnectionStateChange");
>+const $onNegotiationNeeded = dartx.onNegotiationNeeded = Symbol("dartx.onNegotiationNeeded");
>+const $onRemoveStream = dartx.onRemoveStream = Symbol("dartx.onRemoveStream");
>+const $onSignalingStateChange = dartx.onSignalingStateChange = Symbol("dartx.onSignalingStateChange");
>+const $getContributingSources = dartx.getContributingSources = Symbol("dartx.getContributingSources");
>+const $sdp = dartx.sdp = Symbol("dartx.sdp");
>+const $streams = dartx.streams = Symbol("dartx.streams");
>+const $available = dartx.available = Symbol("dartx.available");
>+const $colorDepth = dartx.colorDepth = Symbol("dartx.colorDepth");
>+const $keepAwake = dartx.keepAwake = Symbol("dartx.keepAwake");
>+const $pixelDepth = dartx.pixelDepth = Symbol("dartx.pixelDepth");
>+const $lock = dartx.lock = Symbol("dartx.lock");
>+const $unlock = dartx.unlock = Symbol("dartx.unlock");
>+const $charset = dartx.charset = Symbol("dartx.charset");
>+const $defer = dartx.defer = Symbol("dartx.defer");
>+const $noModule = dartx.noModule = Symbol("dartx.noModule");
>+const $deltaGranularity = dartx.deltaGranularity = Symbol("dartx.deltaGranularity");
>+const $deltaX = dartx.deltaX = Symbol("dartx.deltaX");
>+const $deltaY = dartx.deltaY = Symbol("dartx.deltaY");
>+const $fromUserInput = dartx.fromUserInput = Symbol("dartx.fromUserInput");
>+const $inInertialPhase = dartx.inInertialPhase = Symbol("dartx.inInertialPhase");
>+const $isBeginning = dartx.isBeginning = Symbol("dartx.isBeginning");
>+const $isDirectManipulation = dartx.isDirectManipulation = Symbol("dartx.isDirectManipulation");
>+const $isEnding = dartx.isEnding = Symbol("dartx.isEnding");
>+const $positionX = dartx.positionX = Symbol("dartx.positionX");
>+const $positionY = dartx.positionY = Symbol("dartx.positionY");
>+const $velocityX = dartx.velocityX = Symbol("dartx.velocityX");
>+const $velocityY = dartx.velocityY = Symbol("dartx.velocityY");
>+const $consumeDelta = dartx.consumeDelta = Symbol("dartx.consumeDelta");
>+const $distributeToScrollChainDescendant = dartx.distributeToScrollChainDescendant = Symbol("dartx.distributeToScrollChainDescendant");
>+const $scrollSource = dartx.scrollSource = Symbol("dartx.scrollSource");
>+const $timeRange = dartx.timeRange = Symbol("dartx.timeRange");
>+const $blockedUri = dartx.blockedUri = Symbol("dartx.blockedUri");
>+const $columnNumber = dartx.columnNumber = Symbol("dartx.columnNumber");
>+const $disposition = dartx.disposition = Symbol("dartx.disposition");
>+const $documentUri = dartx.documentUri = Symbol("dartx.documentUri");
>+const $effectiveDirective = dartx.effectiveDirective = Symbol("dartx.effectiveDirective");
>+const $originalPolicy = dartx.originalPolicy = Symbol("dartx.originalPolicy");
>+const $sample = dartx.sample = Symbol("dartx.sample");
>+const $statusCode = dartx.statusCode = Symbol("dartx.statusCode");
>+const $violatedDirective = dartx.violatedDirective = Symbol("dartx.violatedDirective");
>+const $selectedIndex = dartx.selectedIndex = Symbol("dartx.selectedIndex");
>+const $selectedOptions = dartx.selectedOptions = Symbol("dartx.selectedOptions");
>+const $anchorNode = dartx.anchorNode = Symbol("dartx.anchorNode");
>+const $anchorOffset = dartx.anchorOffset = Symbol("dartx.anchorOffset");
>+const $baseNode = dartx.baseNode = Symbol("dartx.baseNode");
>+const $baseOffset = dartx.baseOffset = Symbol("dartx.baseOffset");
>+const $extentNode = dartx.extentNode = Symbol("dartx.extentNode");
>+const $extentOffset = dartx.extentOffset = Symbol("dartx.extentOffset");
>+const $focusNode = dartx.focusNode = Symbol("dartx.focusNode");
>+const $focusOffset = dartx.focusOffset = Symbol("dartx.focusOffset");
>+const $isCollapsed = dartx.isCollapsed = Symbol("dartx.isCollapsed");
>+const $rangeCount = dartx.rangeCount = Symbol("dartx.rangeCount");
>+const $addRange = dartx.addRange = Symbol("dartx.addRange");
>+const $collapseToEnd = dartx.collapseToEnd = Symbol("dartx.collapseToEnd");
>+const $collapseToStart = dartx.collapseToStart = Symbol("dartx.collapseToStart");
>+const $containsNode = dartx.containsNode = Symbol("dartx.containsNode");
>+const $deleteFromDocument = dartx.deleteFromDocument = Symbol("dartx.deleteFromDocument");
>+const $empty = dartx.empty = Symbol("dartx.empty");
>+const $extend = dartx.extend = Symbol("dartx.extend");
>+const $getRangeAt = dartx.getRangeAt = Symbol("dartx.getRangeAt");
>+const $modify = dartx.modify = Symbol("dartx.modify");
>+const $removeAllRanges = dartx.removeAllRanges = Symbol("dartx.removeAllRanges");
>+const $selectAllChildren = dartx.selectAllChildren = Symbol("dartx.selectAllChildren");
>+const $setBaseAndExtent = dartx.setBaseAndExtent = Symbol("dartx.setBaseAndExtent");
>+const $setPosition = dartx.setPosition = Symbol("dartx.setPosition");
>+const $scriptUrl = dartx.scriptUrl = Symbol("dartx.scriptUrl");
>+const $controller = dartx.controller = Symbol("dartx.controller");
>+const $getRegistration = dartx.getRegistration = Symbol("dartx.getRegistration");
>+const $getRegistrations = dartx.getRegistrations = Symbol("dartx.getRegistrations");
>+const $clients = dartx.clients = Symbol("dartx.clients");
>+const $registration = dartx.registration = Symbol("dartx.registration");
>+const $skipWaiting = dartx.skipWaiting = Symbol("dartx.skipWaiting");
>+const $onActivate = dartx.onActivate = Symbol("dartx.onActivate");
>+const $onFetch = dartx.onFetch = Symbol("dartx.onFetch");
>+const $onForeignfetch = dartx.onForeignfetch = Symbol("dartx.onForeignfetch");
>+const $onInstall = dartx.onInstall = Symbol("dartx.onInstall");
>+const $backgroundFetch = dartx.backgroundFetch = Symbol("dartx.backgroundFetch");
>+const $installing = dartx.installing = Symbol("dartx.installing");
>+const $navigationPreload = dartx.navigationPreload = Symbol("dartx.navigationPreload");
>+const $paymentManager = dartx.paymentManager = Symbol("dartx.paymentManager");
>+const $pushManager = dartx.pushManager = Symbol("dartx.pushManager");
>+const $sync = dartx.sync = Symbol("dartx.sync");
>+const $waiting = dartx.waiting = Symbol("dartx.waiting");
>+const $getNotifications = dartx.getNotifications = Symbol("dartx.getNotifications");
>+const $showNotification = dartx.showNotification = Symbol("dartx.showNotification");
>+const $unregister = dartx.unregister = Symbol("dartx.unregister");
>+const $delegatesFocus = dartx.delegatesFocus = Symbol("dartx.delegatesFocus");
>+const $olderShadowRoot = dartx.olderShadowRoot = Symbol("dartx.olderShadowRoot");
>+const $resetStyleInheritance = dartx.resetStyleInheritance = Symbol("dartx.resetStyleInheritance");
>+const $applyAuthorStyles = dartx.applyAuthorStyles = Symbol("dartx.applyAuthorStyles");
>+const $byteLength = dartx.byteLength = Symbol("dartx.byteLength");
>+const $onConnect = dartx.onConnect = Symbol("dartx.onConnect");
>+const $assignedNodes = dartx.assignedNodes = Symbol("dartx.assignedNodes");
>+const $appendWindowEnd = dartx.appendWindowEnd = Symbol("dartx.appendWindowEnd");
>+const $appendWindowStart = dartx.appendWindowStart = Symbol("dartx.appendWindowStart");
>+const $timestampOffset = dartx.timestampOffset = Symbol("dartx.timestampOffset");
>+const $trackDefaults = dartx.trackDefaults = Symbol("dartx.trackDefaults");
>+const $updating = dartx.updating = Symbol("dartx.updating");
>+const $appendBuffer = dartx.appendBuffer = Symbol("dartx.appendBuffer");
>+const $appendTypedData = dartx.appendTypedData = Symbol("dartx.appendTypedData");
>+const $addFromString = dartx.addFromString = Symbol("dartx.addFromString");
>+const $addFromUri = dartx.addFromUri = Symbol("dartx.addFromUri");
>+const $audioTrack = dartx.audioTrack = Symbol("dartx.audioTrack");
>+const $continuous = dartx.continuous = Symbol("dartx.continuous");
>+const $grammars = dartx.grammars = Symbol("dartx.grammars");
>+const $interimResults = dartx.interimResults = Symbol("dartx.interimResults");
>+const $maxAlternatives = dartx.maxAlternatives = Symbol("dartx.maxAlternatives");
>+const $onAudioEnd = dartx.onAudioEnd = Symbol("dartx.onAudioEnd");
>+const $onAudioStart = dartx.onAudioStart = Symbol("dartx.onAudioStart");
>+const $onEnd = dartx.onEnd = Symbol("dartx.onEnd");
>+const $onNoMatch = dartx.onNoMatch = Symbol("dartx.onNoMatch");
>+const $onResult = dartx.onResult = Symbol("dartx.onResult");
>+const $onSoundEnd = dartx.onSoundEnd = Symbol("dartx.onSoundEnd");
>+const $onSoundStart = dartx.onSoundStart = Symbol("dartx.onSoundStart");
>+const $onSpeechEnd = dartx.onSpeechEnd = Symbol("dartx.onSpeechEnd");
>+const $onSpeechStart = dartx.onSpeechStart = Symbol("dartx.onSpeechStart");
>+const $onStart = dartx.onStart = Symbol("dartx.onStart");
>+const $confidence = dartx.confidence = Symbol("dartx.confidence");
>+const $transcript = dartx.transcript = Symbol("dartx.transcript");
>+const $emma = dartx.emma = Symbol("dartx.emma");
>+const $interpretation = dartx.interpretation = Symbol("dartx.interpretation");
>+const $resultIndex = dartx.resultIndex = Symbol("dartx.resultIndex");
>+const $results = dartx.results = Symbol("dartx.results");
>+const $isFinal = dartx.isFinal = Symbol("dartx.isFinal");
>+const $getVoices = dartx.getVoices = Symbol("dartx.getVoices");
>+const $pending = dartx.pending = Symbol("dartx.pending");
>+const $speaking = dartx.speaking = Symbol("dartx.speaking");
>+const $charIndex = dartx.charIndex = Symbol("dartx.charIndex");
>+const $utterance = dartx.utterance = Symbol("dartx.utterance");
>+const $pitch = dartx.pitch = Symbol("dartx.pitch");
>+const $rate = dartx.rate = Symbol("dartx.rate");
>+const $voice = dartx.voice = Symbol("dartx.voice");
>+const $onBoundary = dartx.onBoundary = Symbol("dartx.onBoundary");
>+const $onMark = dartx.onMark = Symbol("dartx.onMark");
>+const $onResume = dartx.onResume = Symbol("dartx.onResume");
>+const $localService = dartx.localService = Symbol("dartx.localService");
>+const $voiceUri = dartx.voiceUri = Symbol("dartx.voiceUri");
>+const $storageArea = dartx.storageArea = Symbol("dartx.storageArea");
>+const $estimate = dartx.estimate = Symbol("dartx.estimate");
>+const $persist = dartx.persist = Symbol("dartx.persist");
>+const $matchMedium = dartx.matchMedium = Symbol("dartx.matchMedium");
>+const $getProperties = dartx.getProperties = Symbol("dartx.getProperties");
>+const $lastChance = dartx.lastChance = Symbol("dartx.lastChance");
>+const $getTags = dartx.getTags = Symbol("dartx.getTags");
>+const $cellIndex = dartx.cellIndex = Symbol("dartx.cellIndex");
>+const $headers = dartx.headers = Symbol("dartx.headers");
>+const $span = dartx.span = Symbol("dartx.span");
>+const $tBodies = dartx.tBodies = Symbol("dartx.tBodies");
>+const $rows = dartx.rows = Symbol("dartx.rows");
>+const $insertRow = dartx.insertRow = Symbol("dartx.insertRow");
>+const $addRow = dartx.addRow = Symbol("dartx.addRow");
>+const $createCaption = dartx.createCaption = Symbol("dartx.createCaption");
>+const $createTBody = dartx.createTBody = Symbol("dartx.createTBody");
>+const $createTFoot = dartx.createTFoot = Symbol("dartx.createTFoot");
>+const $createTHead = dartx.createTHead = Symbol("dartx.createTHead");
>+const $caption = dartx.caption = Symbol("dartx.caption");
>+const $tFoot = dartx.tFoot = Symbol("dartx.tFoot");
>+const $tHead = dartx.tHead = Symbol("dartx.tHead");
>+const $deleteCaption = dartx.deleteCaption = Symbol("dartx.deleteCaption");
>+const $deleteRow = dartx.deleteRow = Symbol("dartx.deleteRow");
>+const $deleteTFoot = dartx.deleteTFoot = Symbol("dartx.deleteTFoot");
>+const $deleteTHead = dartx.deleteTHead = Symbol("dartx.deleteTHead");
>+const $cells = dartx.cells = Symbol("dartx.cells");
>+const $insertCell = dartx.insertCell = Symbol("dartx.insertCell");
>+const $addCell = dartx.addCell = Symbol("dartx.addCell");
>+const $sectionRowIndex = dartx.sectionRowIndex = Symbol("dartx.sectionRowIndex");
>+const $deleteCell = dartx.deleteCell = Symbol("dartx.deleteCell");
>+const $containerId = dartx.containerId = Symbol("dartx.containerId");
>+const $containerName = dartx.containerName = Symbol("dartx.containerName");
>+const $containerSrc = dartx.containerSrc = Symbol("dartx.containerSrc");
>+const $containerType = dartx.containerType = Symbol("dartx.containerType");
>+const $cols = dartx.cols = Symbol("dartx.cols");
>+const $textLength = dartx.textLength = Symbol("dartx.textLength");
>+const $wrap = dartx.wrap = Symbol("dartx.wrap");
>+const $actualBoundingBoxAscent = dartx.actualBoundingBoxAscent = Symbol("dartx.actualBoundingBoxAscent");
>+const $actualBoundingBoxDescent = dartx.actualBoundingBoxDescent = Symbol("dartx.actualBoundingBoxDescent");
>+const $actualBoundingBoxLeft = dartx.actualBoundingBoxLeft = Symbol("dartx.actualBoundingBoxLeft");
>+const $actualBoundingBoxRight = dartx.actualBoundingBoxRight = Symbol("dartx.actualBoundingBoxRight");
>+const $alphabeticBaseline = dartx.alphabeticBaseline = Symbol("dartx.alphabeticBaseline");
>+const $emHeightAscent = dartx.emHeightAscent = Symbol("dartx.emHeightAscent");
>+const $emHeightDescent = dartx.emHeightDescent = Symbol("dartx.emHeightDescent");
>+const $fontBoundingBoxAscent = dartx.fontBoundingBoxAscent = Symbol("dartx.fontBoundingBoxAscent");
>+const $fontBoundingBoxDescent = dartx.fontBoundingBoxDescent = Symbol("dartx.fontBoundingBoxDescent");
>+const $hangingBaseline = dartx.hangingBaseline = Symbol("dartx.hangingBaseline");
>+const $ideographicBaseline = dartx.ideographicBaseline = Symbol("dartx.ideographicBaseline");
>+const $activeCues = dartx.activeCues = Symbol("dartx.activeCues");
>+const $cues = dartx.cues = Symbol("dartx.cues");
>+const $addCue = dartx.addCue = Symbol("dartx.addCue");
>+const $removeCue = dartx.removeCue = Symbol("dartx.removeCue");
>+const $onCueChange = dartx.onCueChange = Symbol("dartx.onCueChange");
>+const $endTime = dartx.endTime = Symbol("dartx.endTime");
>+const $pauseOnExit = dartx.pauseOnExit = Symbol("dartx.pauseOnExit");
>+const $onEnter = dartx.onEnter = Symbol("dartx.onEnter");
>+const $onExit = dartx.onExit = Symbol("dartx.onExit");
>+const $getCueById = dartx.getCueById = Symbol("dartx.getCueById");
>+const $end = dartx.end = Symbol("dartx.end");
>+const $force = dartx.force = Symbol("dartx.force");
>+const $identifier = dartx.identifier = Symbol("dartx.identifier");
>+const $rotationAngle = dartx.rotationAngle = Symbol("dartx.rotationAngle");
>+const $radiusX = dartx.radiusX = Symbol("dartx.radiusX");
>+const $radiusY = dartx.radiusY = Symbol("dartx.radiusY");
>+const $changedTouches = dartx.changedTouches = Symbol("dartx.changedTouches");
>+const $targetTouches = dartx.targetTouches = Symbol("dartx.targetTouches");
>+const $touches = dartx.touches = Symbol("dartx.touches");
>+const $byteStreamTrackID = dartx.byteStreamTrackID = Symbol("dartx.byteStreamTrackID");
>+const $kinds = dartx.kinds = Symbol("dartx.kinds");
>+const $srclang = dartx.srclang = Symbol("dartx.srclang");
>+const $propertyName = dartx.propertyName = Symbol("dartx.propertyName");
>+const $pseudoElement = dartx.pseudoElement = Symbol("dartx.pseudoElement");
>+const $currentNode = dartx.currentNode = Symbol("dartx.currentNode");
>+const $notifyLockAcquired = dartx.notifyLockAcquired = Symbol("dartx.notifyLockAcquired");
>+const $notifyLockReleased = dartx.notifyLockReleased = Symbol("dartx.notifyLockReleased");
>+const $pull = dartx.pull = Symbol("dartx.pull");
>+const $searchParams = dartx.searchParams = Symbol("dartx.searchParams");
>+const $getDevices = dartx.getDevices = Symbol("dartx.getDevices");
>+const $getTransformTo = dartx.getTransformTo = Symbol("dartx.getTransformTo");
>+const $deviceName = dartx.deviceName = Symbol("dartx.deviceName");
>+const $isExternal = dartx.isExternal = Symbol("dartx.isExternal");
>+const $requestSession = dartx.requestSession = Symbol("dartx.requestSession");
>+const $supportsSession = dartx.supportsSession = Symbol("dartx.supportsSession");
>+const $device = dartx.device = Symbol("dartx.device");
>+const $capabilities = dartx.capabilities = Symbol("dartx.capabilities");
>+const $depthFar = dartx.depthFar = Symbol("dartx.depthFar");
>+const $depthNear = dartx.depthNear = Symbol("dartx.depthNear");
>+const $displayName = dartx.displayName = Symbol("dartx.displayName");
>+const $isPresenting = dartx.isPresenting = Symbol("dartx.isPresenting");
>+const $stageParameters = dartx.stageParameters = Symbol("dartx.stageParameters");
>+const $cancelAnimationFrame = dartx.cancelAnimationFrame = Symbol("dartx.cancelAnimationFrame");
>+const $exitPresent = dartx.exitPresent = Symbol("dartx.exitPresent");
>+const $getEyeParameters = dartx.getEyeParameters = Symbol("dartx.getEyeParameters");
>+const $getFrameData = dartx.getFrameData = Symbol("dartx.getFrameData");
>+const $getLayers = dartx.getLayers = Symbol("dartx.getLayers");
>+const $requestAnimationFrame = dartx.requestAnimationFrame = Symbol("dartx.requestAnimationFrame");
>+const $requestPresent = dartx.requestPresent = Symbol("dartx.requestPresent");
>+const $submitFrame = dartx.submitFrame = Symbol("dartx.submitFrame");
>+const $canPresent = dartx.canPresent = Symbol("dartx.canPresent");
>+const $hasExternalDisplay = dartx.hasExternalDisplay = Symbol("dartx.hasExternalDisplay");
>+const $maxLayers = dartx.maxLayers = Symbol("dartx.maxLayers");
>+const $renderHeight = dartx.renderHeight = Symbol("dartx.renderHeight");
>+const $renderWidth = dartx.renderWidth = Symbol("dartx.renderWidth");
>+const $leftProjectionMatrix = dartx.leftProjectionMatrix = Symbol("dartx.leftProjectionMatrix");
>+const $leftViewMatrix = dartx.leftViewMatrix = Symbol("dartx.leftViewMatrix");
>+const $rightProjectionMatrix = dartx.rightProjectionMatrix = Symbol("dartx.rightProjectionMatrix");
>+const $rightViewMatrix = dartx.rightViewMatrix = Symbol("dartx.rightViewMatrix");
>+const $bounds = dartx.bounds = Symbol("dartx.bounds");
>+const $emulatedHeight = dartx.emulatedHeight = Symbol("dartx.emulatedHeight");
>+const $exclusive = dartx.exclusive = Symbol("dartx.exclusive");
>+const $requestFrameOfReference = dartx.requestFrameOfReference = Symbol("dartx.requestFrameOfReference");
>+const $session = dartx.session = Symbol("dartx.session");
>+const $geometry = dartx.geometry = Symbol("dartx.geometry");
>+const $sittingToStandingTransform = dartx.sittingToStandingTransform = Symbol("dartx.sittingToStandingTransform");
>+const $sizeX = dartx.sizeX = Symbol("dartx.sizeX");
>+const $sizeZ = dartx.sizeZ = Symbol("dartx.sizeZ");
>+const $badInput = dartx.badInput = Symbol("dartx.badInput");
>+const $customError = dartx.customError = Symbol("dartx.customError");
>+const $patternMismatch = dartx.patternMismatch = Symbol("dartx.patternMismatch");
>+const $rangeOverflow = dartx.rangeOverflow = Symbol("dartx.rangeOverflow");
>+const $rangeUnderflow = dartx.rangeUnderflow = Symbol("dartx.rangeUnderflow");
>+const $stepMismatch = dartx.stepMismatch = Symbol("dartx.stepMismatch");
>+const $tooLong = dartx.tooLong = Symbol("dartx.tooLong");
>+const $tooShort = dartx.tooShort = Symbol("dartx.tooShort");
>+const $typeMismatch = dartx.typeMismatch = Symbol("dartx.typeMismatch");
>+const $valid = dartx.valid = Symbol("dartx.valid");
>+const $valueMissing = dartx.valueMissing = Symbol("dartx.valueMissing");
>+const $poster = dartx.poster = Symbol("dartx.poster");
>+const $videoHeight = dartx.videoHeight = Symbol("dartx.videoHeight");
>+const $videoWidth = dartx.videoWidth = Symbol("dartx.videoWidth");
>+const $decodedFrameCount = dartx.decodedFrameCount = Symbol("dartx.decodedFrameCount");
>+const $droppedFrameCount = dartx.droppedFrameCount = Symbol("dartx.droppedFrameCount");
>+const $getVideoPlaybackQuality = dartx.getVideoPlaybackQuality = Symbol("dartx.getVideoPlaybackQuality");
>+const $enterFullscreen = dartx.enterFullscreen = Symbol("dartx.enterFullscreen");
>+const $corruptedVideoFrames = dartx.corruptedVideoFrames = Symbol("dartx.corruptedVideoFrames");
>+const $creationTime = dartx.creationTime = Symbol("dartx.creationTime");
>+const $droppedVideoFrames = dartx.droppedVideoFrames = Symbol("dartx.droppedVideoFrames");
>+const $totalVideoFrames = dartx.totalVideoFrames = Symbol("dartx.totalVideoFrames");
>+const $sourceBuffer = dartx.sourceBuffer = Symbol("dartx.sourceBuffer");
>+const $pageLeft = dartx.pageLeft = Symbol("dartx.pageLeft");
>+const $pageTop = dartx.pageTop = Symbol("dartx.pageTop");
>+const $align = dartx.align = Symbol("dartx.align");
>+const $line = dartx.line = Symbol("dartx.line");
>+const $snapToLines = dartx.snapToLines = Symbol("dartx.snapToLines");
>+const $vertical = dartx.vertical = Symbol("dartx.vertical");
>+const $getCueAsHtml = dartx.getCueAsHtml = Symbol("dartx.getCueAsHtml");
>+const $lines = dartx.lines = Symbol("dartx.lines");
>+const $regionAnchorX = dartx.regionAnchorX = Symbol("dartx.regionAnchorX");
>+const $regionAnchorY = dartx.regionAnchorY = Symbol("dartx.regionAnchorY");
>+const $viewportAnchorX = dartx.viewportAnchorX = Symbol("dartx.viewportAnchorX");
>+const $viewportAnchorY = dartx.viewportAnchorY = Symbol("dartx.viewportAnchorY");
>+const $extensions = dartx.extensions = Symbol("dartx.extensions");
>+const $deltaZ = dartx.deltaZ = Symbol("dartx.deltaZ");
>+const $deltaMode = dartx.deltaMode = Symbol("dartx.deltaMode");
>+const $animationFrame = dartx.animationFrame = Symbol("dartx.animationFrame");
>+const $document = dartx.document = Symbol("dartx.document");
>+const $requestFileSystem = dartx.requestFileSystem = Symbol("dartx.requestFileSystem");
>+const $animationWorklet = dartx.animationWorklet = Symbol("dartx.animationWorklet");
>+const $applicationCache = dartx.applicationCache = Symbol("dartx.applicationCache");
>+const $audioWorklet = dartx.audioWorklet = Symbol("dartx.audioWorklet");
>+const $cookieStore = dartx.cookieStore = Symbol("dartx.cookieStore");
>+const $customElements = dartx.customElements = Symbol("dartx.customElements");
>+const $defaultStatus = dartx.defaultStatus = Symbol("dartx.defaultStatus");
>+const $defaultstatus = dartx.defaultstatus = Symbol("dartx.defaultstatus");
>+const $external = dartx.external = Symbol("dartx.external");
>+const $history = dartx.history = Symbol("dartx.history");
>+const $innerHeight = dartx.innerHeight = Symbol("dartx.innerHeight");
>+const $innerWidth = dartx.innerWidth = Symbol("dartx.innerWidth");
>+const $localStorage = dartx.localStorage = Symbol("dartx.localStorage");
>+const $locationbar = dartx.locationbar = Symbol("dartx.locationbar");
>+const $menubar = dartx.menubar = Symbol("dartx.menubar");
>+const $offscreenBuffering = dartx.offscreenBuffering = Symbol("dartx.offscreenBuffering");
>+const $opener = dartx.opener = Symbol("dartx.opener");
>+const $outerHeight = dartx.outerHeight = Symbol("dartx.outerHeight");
>+const $outerWidth = dartx.outerWidth = Symbol("dartx.outerWidth");
>+const $screenLeft = dartx.screenLeft = Symbol("dartx.screenLeft");
>+const $screenTop = dartx.screenTop = Symbol("dartx.screenTop");
>+const $screenX = dartx.screenX = Symbol("dartx.screenX");
>+const $screenY = dartx.screenY = Symbol("dartx.screenY");
>+const $scrollbars = dartx.scrollbars = Symbol("dartx.scrollbars");
>+const $sessionStorage = dartx.sessionStorage = Symbol("dartx.sessionStorage");
>+const $speechSynthesis = dartx.speechSynthesis = Symbol("dartx.speechSynthesis");
>+const $statusbar = dartx.statusbar = Symbol("dartx.statusbar");
>+const $styleMedia = dartx.styleMedia = Symbol("dartx.styleMedia");
>+const $toolbar = dartx.toolbar = Symbol("dartx.toolbar");
>+const $visualViewport = dartx.visualViewport = Symbol("dartx.visualViewport");
>+const $alert = dartx.alert = Symbol("dartx.alert");
>+const $cancelIdleCallback = dartx.cancelIdleCallback = Symbol("dartx.cancelIdleCallback");
>+const $confirm = dartx.confirm = Symbol("dartx.confirm");
>+const $find = dartx.find = Symbol("dartx.find");
>+const $getComputedStyleMap = dartx.getComputedStyleMap = Symbol("dartx.getComputedStyleMap");
>+const $getMatchedCssRules = dartx.getMatchedCssRules = Symbol("dartx.getMatchedCssRules");
>+const $matchMedia = dartx.matchMedia = Symbol("dartx.matchMedia");
>+const $moveBy = dartx.moveBy = Symbol("dartx.moveBy");
>+const $print = dartx.print = Symbol("dartx.print");
>+const $requestIdleCallback = dartx.requestIdleCallback = Symbol("dartx.requestIdleCallback");
>+const $resizeBy = dartx.resizeBy = Symbol("dartx.resizeBy");
>+const $resizeTo = dartx.resizeTo = Symbol("dartx.resizeTo");
>+const $resolveLocalFileSystemUrl = dartx.resolveLocalFileSystemUrl = Symbol("dartx.resolveLocalFileSystemUrl");
>+const $onContentLoaded = dartx.onContentLoaded = Symbol("dartx.onContentLoaded");
>+const $onDeviceMotion = dartx.onDeviceMotion = Symbol("dartx.onDeviceMotion");
>+const $onDeviceOrientation = dartx.onDeviceOrientation = Symbol("dartx.onDeviceOrientation");
>+const $onPageHide = dartx.onPageHide = Symbol("dartx.onPageHide");
>+const $onPageShow = dartx.onPageShow = Symbol("dartx.onPageShow");
>+const $onAnimationEnd = dartx.onAnimationEnd = Symbol("dartx.onAnimationEnd");
>+const $onAnimationIteration = dartx.onAnimationIteration = Symbol("dartx.onAnimationIteration");
>+const $onAnimationStart = dartx.onAnimationStart = Symbol("dartx.onAnimationStart");
>+const $onBeforeUnload = dartx.onBeforeUnload = Symbol("dartx.onBeforeUnload");
>+const $openDatabase = dartx.openDatabase = Symbol("dartx.openDatabase");
>+const $pageXOffset = dartx.pageXOffset = Symbol("dartx.pageXOffset");
>+const $pageYOffset = dartx.pageYOffset = Symbol("dartx.pageYOffset");
>+const $scrollX = dartx.scrollX = Symbol("dartx.scrollX");
>+const $scrollY = dartx.scrollY = Symbol("dartx.scrollY");
>+const $focused = dartx.focused = Symbol("dartx.focused");
>+const $navigate = dartx.navigate = Symbol("dartx.navigate");
>+const $createExpression = dartx.createExpression = Symbol("dartx.createExpression");
>+const $createNSResolver = dartx.createNSResolver = Symbol("dartx.createNSResolver");
>+const $evaluate = dartx.evaluate = Symbol("dartx.evaluate");
>+const $lookupNamespaceUri = dartx.lookupNamespaceUri = Symbol("dartx.lookupNamespaceUri");
>+const $booleanValue = dartx.booleanValue = Symbol("dartx.booleanValue");
>+const $invalidIteratorState = dartx.invalidIteratorState = Symbol("dartx.invalidIteratorState");
>+const $numberValue = dartx.numberValue = Symbol("dartx.numberValue");
>+const $resultType = dartx.resultType = Symbol("dartx.resultType");
>+const $singleNodeValue = dartx.singleNodeValue = Symbol("dartx.singleNodeValue");
>+const $snapshotLength = dartx.snapshotLength = Symbol("dartx.snapshotLength");
>+const $stringValue = dartx.stringValue = Symbol("dartx.stringValue");
>+const $iterateNext = dartx.iterateNext = Symbol("dartx.iterateNext");
>+const $snapshotItem = dartx.snapshotItem = Symbol("dartx.snapshotItem");
>+const $serializeToString = dartx.serializeToString = Symbol("dartx.serializeToString");
>+const $clearParameters = dartx.clearParameters = Symbol("dartx.clearParameters");
>+const $getParameter = dartx.getParameter = Symbol("dartx.getParameter");
>+const $importStylesheet = dartx.importStylesheet = Symbol("dartx.importStylesheet");
>+const $removeParameter = dartx.removeParameter = Symbol("dartx.removeParameter");
>+const $setParameter = dartx.setParameter = Symbol("dartx.setParameter");
>+const $transformToDocument = dartx.transformToDocument = Symbol("dartx.transformToDocument");
>+const $transformToFragment = dartx.transformToFragment = Symbol("dartx.transformToFragment");
>+const $getBudget = dartx.getBudget = Symbol("dartx.getBudget");
>+const $getCost = dartx.getCost = Symbol("dartx.getCost");
>+const $reserve = dartx.reserve = Symbol("dartx.reserve");
>+const $read = dartx.read = Symbol("dartx.read");
>+const $readText = dartx.readText = Symbol("dartx.readText");
>+const $writeText = dartx.writeText = Symbol("dartx.writeText");
>+const $getNamedItem = dartx.getNamedItem = Symbol("dartx.getNamedItem");
>+const $getNamedItemNS = dartx.getNamedItemNS = Symbol("dartx.getNamedItemNS");
>+const $removeNamedItem = dartx.removeNamedItem = Symbol("dartx.removeNamedItem");
>+const $removeNamedItemNS = dartx.removeNamedItemNS = Symbol("dartx.removeNamedItemNS");
>+const $setNamedItem = dartx.setNamedItem = Symbol("dartx.setNamedItem");
>+const $setNamedItemNS = dartx.setNamedItemNS = Symbol("dartx.setNamedItemNS");
>+const $cache = dartx.cache = Symbol("dartx.cache");
>+const $redirect = dartx.redirect = Symbol("dartx.redirect");
>+const $farthestViewportElement = dartx.farthestViewportElement = Symbol("dartx.farthestViewportElement");
>+const $nearestViewportElement = dartx.nearestViewportElement = Symbol("dartx.nearestViewportElement");
>+const $getBBox = dartx.getBBox = Symbol("dartx.getBBox");
>+const $getCtm = dartx.getCtm = Symbol("dartx.getCtm");
>+const $getScreenCtm = dartx.getScreenCtm = Symbol("dartx.getScreenCtm");
>+const $requiredExtensions = dartx.requiredExtensions = Symbol("dartx.requiredExtensions");
>+const $systemLanguage = dartx.systemLanguage = Symbol("dartx.systemLanguage");
>+const $ownerSvgElement = dartx.ownerSvgElement = Symbol("dartx.ownerSvgElement");
>+const $viewportElement = dartx.viewportElement = Symbol("dartx.viewportElement");
>+const $unitType = dartx.unitType = Symbol("dartx.unitType");
>+const $valueAsString = dartx.valueAsString = Symbol("dartx.valueAsString");
>+const $valueInSpecifiedUnits = dartx.valueInSpecifiedUnits = Symbol("dartx.valueInSpecifiedUnits");
>+const $convertToSpecifiedUnits = dartx.convertToSpecifiedUnits = Symbol("dartx.convertToSpecifiedUnits");
>+const $newValueSpecifiedUnits = dartx.newValueSpecifiedUnits = Symbol("dartx.newValueSpecifiedUnits");
>+const $targetElement = dartx.targetElement = Symbol("dartx.targetElement");
>+const $beginElement = dartx.beginElement = Symbol("dartx.beginElement");
>+const $beginElementAt = dartx.beginElementAt = Symbol("dartx.beginElementAt");
>+const $endElement = dartx.endElement = Symbol("dartx.endElement");
>+const $endElementAt = dartx.endElementAt = Symbol("dartx.endElementAt");
>+const $getCurrentTime = dartx.getCurrentTime = Symbol("dartx.getCurrentTime");
>+const $getSimpleDuration = dartx.getSimpleDuration = Symbol("dartx.getSimpleDuration");
>+const $getStartTime = dartx.getStartTime = Symbol("dartx.getStartTime");
>+const $animVal = dartx.animVal = Symbol("dartx.animVal");
>+const $baseVal = dartx.baseVal = Symbol("dartx.baseVal");
>+const $cx = dartx.cx = Symbol("dartx.cx");
>+const $cy = dartx.cy = Symbol("dartx.cy");
>+const $r = dartx.r = Symbol("dartx.r");
>+const $pathLength = dartx.pathLength = Symbol("dartx.pathLength");
>+const $getPointAtLength = dartx.getPointAtLength = Symbol("dartx.getPointAtLength");
>+const $getTotalLength = dartx.getTotalLength = Symbol("dartx.getTotalLength");
>+const $isPointInFill = dartx.isPointInFill = Symbol("dartx.isPointInFill");
>+const $clipPathUnits = dartx.clipPathUnits = Symbol("dartx.clipPathUnits");
>+const $rx = dartx.rx = Symbol("dartx.rx");
>+const $ry = dartx.ry = Symbol("dartx.ry");
>+const $in1 = dartx.in1 = Symbol("dartx.in1");
>+const $in2 = dartx.in2 = Symbol("dartx.in2");
>+const $k1 = dartx.k1 = Symbol("dartx.k1");
>+const $k2 = dartx.k2 = Symbol("dartx.k2");
>+const $k3 = dartx.k3 = Symbol("dartx.k3");
>+const $k4 = dartx.k4 = Symbol("dartx.k4");
>+const $operator = dartx.operator = Symbol("dartx.operator");
>+const $bias = dartx.bias = Symbol("dartx.bias");
>+const $divisor = dartx.divisor = Symbol("dartx.divisor");
>+const $edgeMode = dartx.edgeMode = Symbol("dartx.edgeMode");
>+const $kernelMatrix = dartx.kernelMatrix = Symbol("dartx.kernelMatrix");
>+const $kernelUnitLengthX = dartx.kernelUnitLengthX = Symbol("dartx.kernelUnitLengthX");
>+const $kernelUnitLengthY = dartx.kernelUnitLengthY = Symbol("dartx.kernelUnitLengthY");
>+const $orderX = dartx.orderX = Symbol("dartx.orderX");
>+const $orderY = dartx.orderY = Symbol("dartx.orderY");
>+const $preserveAlpha = dartx.preserveAlpha = Symbol("dartx.preserveAlpha");
>+const $targetX = dartx.targetX = Symbol("dartx.targetX");
>+const $targetY = dartx.targetY = Symbol("dartx.targetY");
>+const $diffuseConstant = dartx.diffuseConstant = Symbol("dartx.diffuseConstant");
>+const $surfaceScale = dartx.surfaceScale = Symbol("dartx.surfaceScale");
>+const $xChannelSelector = dartx.xChannelSelector = Symbol("dartx.xChannelSelector");
>+const $yChannelSelector = dartx.yChannelSelector = Symbol("dartx.yChannelSelector");
>+const $azimuth = dartx.azimuth = Symbol("dartx.azimuth");
>+const $elevation = dartx.elevation = Symbol("dartx.elevation");
>+const $stdDeviationX = dartx.stdDeviationX = Symbol("dartx.stdDeviationX");
>+const $stdDeviationY = dartx.stdDeviationY = Symbol("dartx.stdDeviationY");
>+const $setStdDeviation = dartx.setStdDeviation = Symbol("dartx.setStdDeviation");
>+const $preserveAspectRatio = dartx.preserveAspectRatio = Symbol("dartx.preserveAspectRatio");
>+const $dx = dartx.dx = Symbol("dartx.dx");
>+const $dy = dartx.dy = Symbol("dartx.dy");
>+const $specularConstant = dartx.specularConstant = Symbol("dartx.specularConstant");
>+const $specularExponent = dartx.specularExponent = Symbol("dartx.specularExponent");
>+const $limitingConeAngle = dartx.limitingConeAngle = Symbol("dartx.limitingConeAngle");
>+const $pointsAtX = dartx.pointsAtX = Symbol("dartx.pointsAtX");
>+const $pointsAtY = dartx.pointsAtY = Symbol("dartx.pointsAtY");
>+const $pointsAtZ = dartx.pointsAtZ = Symbol("dartx.pointsAtZ");
>+const $baseFrequencyX = dartx.baseFrequencyX = Symbol("dartx.baseFrequencyX");
>+const $baseFrequencyY = dartx.baseFrequencyY = Symbol("dartx.baseFrequencyY");
>+const $numOctaves = dartx.numOctaves = Symbol("dartx.numOctaves");
>+const $seed = dartx.seed = Symbol("dartx.seed");
>+const $stitchTiles = dartx.stitchTiles = Symbol("dartx.stitchTiles");
>+const $filterUnits = dartx.filterUnits = Symbol("dartx.filterUnits");
>+const $primitiveUnits = dartx.primitiveUnits = Symbol("dartx.primitiveUnits");
>+const $viewBox = dartx.viewBox = Symbol("dartx.viewBox");
>+const $numberOfItems = dartx.numberOfItems = Symbol("dartx.numberOfItems");
>+const $appendItem = dartx.appendItem = Symbol("dartx.appendItem");
>+const $getItem = dartx.getItem = Symbol("dartx.getItem");
>+const $initialize = dartx.initialize = Symbol("dartx.initialize");
>+const $insertItemBefore = dartx.insertItemBefore = Symbol("dartx.insertItemBefore");
>+const $removeItem = dartx.removeItem = Symbol("dartx.removeItem");
>+const $replaceItem = dartx.replaceItem = Symbol("dartx.replaceItem");
>+const $x1 = dartx.x1 = Symbol("dartx.x1");
>+const $x2 = dartx.x2 = Symbol("dartx.x2");
>+const $y1 = dartx.y1 = Symbol("dartx.y1");
>+const $y2 = dartx.y2 = Symbol("dartx.y2");
>+const $gradientTransform = dartx.gradientTransform = Symbol("dartx.gradientTransform");
>+const $gradientUnits = dartx.gradientUnits = Symbol("dartx.gradientUnits");
>+const $spreadMethod = dartx.spreadMethod = Symbol("dartx.spreadMethod");
>+const $markerHeight = dartx.markerHeight = Symbol("dartx.markerHeight");
>+const $markerUnits = dartx.markerUnits = Symbol("dartx.markerUnits");
>+const $markerWidth = dartx.markerWidth = Symbol("dartx.markerWidth");
>+const $orientAngle = dartx.orientAngle = Symbol("dartx.orientAngle");
>+const $orientType = dartx.orientType = Symbol("dartx.orientType");
>+const $refX = dartx.refX = Symbol("dartx.refX");
>+const $refY = dartx.refY = Symbol("dartx.refY");
>+const $setOrientToAngle = dartx.setOrientToAngle = Symbol("dartx.setOrientToAngle");
>+const $setOrientToAuto = dartx.setOrientToAuto = Symbol("dartx.setOrientToAuto");
>+const $maskContentUnits = dartx.maskContentUnits = Symbol("dartx.maskContentUnits");
>+const $maskUnits = dartx.maskUnits = Symbol("dartx.maskUnits");
>+const $scaleNonUniform = dartx.scaleNonUniform = Symbol("dartx.scaleNonUniform");
>+const $patternContentUnits = dartx.patternContentUnits = Symbol("dartx.patternContentUnits");
>+const $patternTransform = dartx.patternTransform = Symbol("dartx.patternTransform");
>+const $patternUnits = dartx.patternUnits = Symbol("dartx.patternUnits");
>+const $animatedPoints = dartx.animatedPoints = Symbol("dartx.animatedPoints");
>+const $points = dartx.points = Symbol("dartx.points");
>+const $meetOrSlice = dartx.meetOrSlice = Symbol("dartx.meetOrSlice");
>+const $fr = dartx.fr = Symbol("dartx.fr");
>+const $fx = dartx.fx = Symbol("dartx.fx");
>+const $fy = dartx.fy = Symbol("dartx.fy");
>+const $gradientOffset = dartx.gradientOffset = Symbol("dartx.gradientOffset");
>+const $currentScale = dartx.currentScale = Symbol("dartx.currentScale");
>+const $currentTranslate = dartx.currentTranslate = Symbol("dartx.currentTranslate");
>+const $animationsPaused = dartx.animationsPaused = Symbol("dartx.animationsPaused");
>+const $checkEnclosure = dartx.checkEnclosure = Symbol("dartx.checkEnclosure");
>+const $checkIntersection = dartx.checkIntersection = Symbol("dartx.checkIntersection");
>+const $createSvgAngle = dartx.createSvgAngle = Symbol("dartx.createSvgAngle");
>+const $createSvgLength = dartx.createSvgLength = Symbol("dartx.createSvgLength");
>+const $createSvgMatrix = dartx.createSvgMatrix = Symbol("dartx.createSvgMatrix");
>+const $createSvgNumber = dartx.createSvgNumber = Symbol("dartx.createSvgNumber");
>+const $createSvgPoint = dartx.createSvgPoint = Symbol("dartx.createSvgPoint");
>+const $createSvgRect = dartx.createSvgRect = Symbol("dartx.createSvgRect");
>+const $createSvgTransform = dartx.createSvgTransform = Symbol("dartx.createSvgTransform");
>+const $createSvgTransformFromMatrix = dartx.createSvgTransformFromMatrix = Symbol("dartx.createSvgTransformFromMatrix");
>+const $deselectAll = dartx.deselectAll = Symbol("dartx.deselectAll");
>+const $forceRedraw = dartx.forceRedraw = Symbol("dartx.forceRedraw");
>+const $getEnclosureList = dartx.getEnclosureList = Symbol("dartx.getEnclosureList");
>+const $getIntersectionList = dartx.getIntersectionList = Symbol("dartx.getIntersectionList");
>+const $pauseAnimations = dartx.pauseAnimations = Symbol("dartx.pauseAnimations");
>+const $setCurrentTime = dartx.setCurrentTime = Symbol("dartx.setCurrentTime");
>+const $suspendRedraw = dartx.suspendRedraw = Symbol("dartx.suspendRedraw");
>+const $unpauseAnimations = dartx.unpauseAnimations = Symbol("dartx.unpauseAnimations");
>+const $unsuspendRedraw = dartx.unsuspendRedraw = Symbol("dartx.unsuspendRedraw");
>+const $unsuspendRedrawAll = dartx.unsuspendRedrawAll = Symbol("dartx.unsuspendRedrawAll");
>+const $zoomAndPan = dartx.zoomAndPan = Symbol("dartx.zoomAndPan");
>+const $lengthAdjust = dartx.lengthAdjust = Symbol("dartx.lengthAdjust");
>+const $getCharNumAtPosition = dartx.getCharNumAtPosition = Symbol("dartx.getCharNumAtPosition");
>+const $getComputedTextLength = dartx.getComputedTextLength = Symbol("dartx.getComputedTextLength");
>+const $getEndPositionOfChar = dartx.getEndPositionOfChar = Symbol("dartx.getEndPositionOfChar");
>+const $getExtentOfChar = dartx.getExtentOfChar = Symbol("dartx.getExtentOfChar");
>+const $getNumberOfChars = dartx.getNumberOfChars = Symbol("dartx.getNumberOfChars");
>+const $getRotationOfChar = dartx.getRotationOfChar = Symbol("dartx.getRotationOfChar");
>+const $getStartPositionOfChar = dartx.getStartPositionOfChar = Symbol("dartx.getStartPositionOfChar");
>+const $getSubStringLength = dartx.getSubStringLength = Symbol("dartx.getSubStringLength");
>+const $selectSubString = dartx.selectSubString = Symbol("dartx.selectSubString");
>+const $spacing = dartx.spacing = Symbol("dartx.spacing");
>+const $setMatrix = dartx.setMatrix = Symbol("dartx.setMatrix");
>+const $setRotate = dartx.setRotate = Symbol("dartx.setRotate");
>+const $setScale = dartx.setScale = Symbol("dartx.setScale");
>+const $setSkewX = dartx.setSkewX = Symbol("dartx.setSkewX");
>+const $setSkewY = dartx.setSkewY = Symbol("dartx.setSkewY");
>+const $setTranslate = dartx.setTranslate = Symbol("dartx.setTranslate");
>+const $consolidate = dartx.consolidate = Symbol("dartx.consolidate");
>+const $fftSize = dartx.fftSize = Symbol("dartx.fftSize");
>+const $frequencyBinCount = dartx.frequencyBinCount = Symbol("dartx.frequencyBinCount");
>+const $maxDecibels = dartx.maxDecibels = Symbol("dartx.maxDecibels");
>+const $minDecibels = dartx.minDecibels = Symbol("dartx.minDecibels");
>+const $smoothingTimeConstant = dartx.smoothingTimeConstant = Symbol("dartx.smoothingTimeConstant");
>+const $getByteFrequencyData = dartx.getByteFrequencyData = Symbol("dartx.getByteFrequencyData");
>+const $getByteTimeDomainData = dartx.getByteTimeDomainData = Symbol("dartx.getByteTimeDomainData");
>+const $getFloatFrequencyData = dartx.getFloatFrequencyData = Symbol("dartx.getFloatFrequencyData");
>+const $getFloatTimeDomainData = dartx.getFloatTimeDomainData = Symbol("dartx.getFloatTimeDomainData");
>+const $channelCount = dartx.channelCount = Symbol("dartx.channelCount");
>+const $channelCountMode = dartx.channelCountMode = Symbol("dartx.channelCountMode");
>+const $channelInterpretation = dartx.channelInterpretation = Symbol("dartx.channelInterpretation");
>+const $context = dartx.context = Symbol("dartx.context");
>+const $numberOfInputs = dartx.numberOfInputs = Symbol("dartx.numberOfInputs");
>+const $numberOfOutputs = dartx.numberOfOutputs = Symbol("dartx.numberOfOutputs");
>+const $connectNode = dartx.connectNode = Symbol("dartx.connectNode");
>+const $connectParam = dartx.connectParam = Symbol("dartx.connectParam");
>+const $numberOfChannels = dartx.numberOfChannels = Symbol("dartx.numberOfChannels");
>+const $sampleRate = dartx.sampleRate = Symbol("dartx.sampleRate");
>+const $copyFromChannel = dartx.copyFromChannel = Symbol("dartx.copyFromChannel");
>+const $copyToChannel = dartx.copyToChannel = Symbol("dartx.copyToChannel");
>+const $getChannelData = dartx.getChannelData = Symbol("dartx.getChannelData");
>+const $detune = dartx.detune = Symbol("dartx.detune");
>+const $loopEnd = dartx.loopEnd = Symbol("dartx.loopEnd");
>+const $loopStart = dartx.loopStart = Symbol("dartx.loopStart");
>+const $start2 = dartx.start2 = Symbol("dartx.start2");
>+const $baseLatency = dartx.baseLatency = Symbol("dartx.baseLatency");
>+const $getOutputTimestamp = dartx.getOutputTimestamp = Symbol("dartx.getOutputTimestamp");
>+const $suspend = dartx.suspend = Symbol("dartx.suspend");
>+const $createGain = dartx.createGain = Symbol("dartx.createGain");
>+const $createScriptProcessor = dartx.createScriptProcessor = Symbol("dartx.createScriptProcessor");
>+const $decodeAudioData = dartx.decodeAudioData = Symbol("dartx.decodeAudioData");
>+const $destination = dartx.destination = Symbol("dartx.destination");
>+const $listener = dartx.listener = Symbol("dartx.listener");
>+const $createAnalyser = dartx.createAnalyser = Symbol("dartx.createAnalyser");
>+const $createBiquadFilter = dartx.createBiquadFilter = Symbol("dartx.createBiquadFilter");
>+const $createBuffer = dartx.createBuffer = Symbol("dartx.createBuffer");
>+const $createBufferSource = dartx.createBufferSource = Symbol("dartx.createBufferSource");
>+const $createChannelMerger = dartx.createChannelMerger = Symbol("dartx.createChannelMerger");
>+const $createChannelSplitter = dartx.createChannelSplitter = Symbol("dartx.createChannelSplitter");
>+const $createConstantSource = dartx.createConstantSource = Symbol("dartx.createConstantSource");
>+const $createConvolver = dartx.createConvolver = Symbol("dartx.createConvolver");
>+const $createDelay = dartx.createDelay = Symbol("dartx.createDelay");
>+const $createDynamicsCompressor = dartx.createDynamicsCompressor = Symbol("dartx.createDynamicsCompressor");
>+const $createIirFilter = dartx.createIirFilter = Symbol("dartx.createIirFilter");
>+const $createMediaElementSource = dartx.createMediaElementSource = Symbol("dartx.createMediaElementSource");
>+const $createMediaStreamDestination = dartx.createMediaStreamDestination = Symbol("dartx.createMediaStreamDestination");
>+const $createMediaStreamSource = dartx.createMediaStreamSource = Symbol("dartx.createMediaStreamSource");
>+const $createOscillator = dartx.createOscillator = Symbol("dartx.createOscillator");
>+const $createPanner = dartx.createPanner = Symbol("dartx.createPanner");
>+const $createPeriodicWave = dartx.createPeriodicWave = Symbol("dartx.createPeriodicWave");
>+const $createStereoPanner = dartx.createStereoPanner = Symbol("dartx.createStereoPanner");
>+const $createWaveShaper = dartx.createWaveShaper = Symbol("dartx.createWaveShaper");
>+const $maxChannelCount = dartx.maxChannelCount = Symbol("dartx.maxChannelCount");
>+const $forwardX = dartx.forwardX = Symbol("dartx.forwardX");
>+const $forwardY = dartx.forwardY = Symbol("dartx.forwardY");
>+const $forwardZ = dartx.forwardZ = Symbol("dartx.forwardZ");
>+const $positionZ = dartx.positionZ = Symbol("dartx.positionZ");
>+const $upX = dartx.upX = Symbol("dartx.upX");
>+const $upY = dartx.upY = Symbol("dartx.upY");
>+const $upZ = dartx.upZ = Symbol("dartx.upZ");
>+const $setOrientation = dartx.setOrientation = Symbol("dartx.setOrientation");
>+const $maxValue = dartx.maxValue = Symbol("dartx.maxValue");
>+const $minValue = dartx.minValue = Symbol("dartx.minValue");
>+const $cancelAndHoldAtTime = dartx.cancelAndHoldAtTime = Symbol("dartx.cancelAndHoldAtTime");
>+const $cancelScheduledValues = dartx.cancelScheduledValues = Symbol("dartx.cancelScheduledValues");
>+const $exponentialRampToValueAtTime = dartx.exponentialRampToValueAtTime = Symbol("dartx.exponentialRampToValueAtTime");
>+const $linearRampToValueAtTime = dartx.linearRampToValueAtTime = Symbol("dartx.linearRampToValueAtTime");
>+const $setTargetAtTime = dartx.setTargetAtTime = Symbol("dartx.setTargetAtTime");
>+const $setValueAtTime = dartx.setValueAtTime = Symbol("dartx.setValueAtTime");
>+const $setValueCurveAtTime = dartx.setValueCurveAtTime = Symbol("dartx.setValueCurveAtTime");
>+const $inputBuffer = dartx.inputBuffer = Symbol("dartx.inputBuffer");
>+const $outputBuffer = dartx.outputBuffer = Symbol("dartx.outputBuffer");
>+const $playbackTime = dartx.playbackTime = Symbol("dartx.playbackTime");
>+const $registerProcessor = dartx.registerProcessor = Symbol("dartx.registerProcessor");
>+const $parameters = dartx.parameters = Symbol("dartx.parameters");
>+const $Q = dartx.Q = Symbol("dartx.Q");
>+const $frequency = dartx.frequency = Symbol("dartx.frequency");
>+const $gain = dartx.gain = Symbol("dartx.gain");
>+const $getFrequencyResponse = dartx.getFrequencyResponse = Symbol("dartx.getFrequencyResponse");
>+const $normalize = dartx.normalize = Symbol("dartx.normalize");
>+const $delayTime = dartx.delayTime = Symbol("dartx.delayTime");
>+const $attack = dartx.attack = Symbol("dartx.attack");
>+const $knee = dartx.knee = Symbol("dartx.knee");
>+const $ratio = dartx.ratio = Symbol("dartx.ratio");
>+const $reduction = dartx.reduction = Symbol("dartx.reduction");
>+const $release = dartx.release = Symbol("dartx.release");
>+const $threshold = dartx.threshold = Symbol("dartx.threshold");
>+const $mediaElement = dartx.mediaElement = Symbol("dartx.mediaElement");
>+const $mediaStream = dartx.mediaStream = Symbol("dartx.mediaStream");
>+const $renderedBuffer = dartx.renderedBuffer = Symbol("dartx.renderedBuffer");
>+const $startRendering = dartx.startRendering = Symbol("dartx.startRendering");
>+const $suspendFor = dartx.suspendFor = Symbol("dartx.suspendFor");
>+const $setPeriodicWave = dartx.setPeriodicWave = Symbol("dartx.setPeriodicWave");
>+const $coneInnerAngle = dartx.coneInnerAngle = Symbol("dartx.coneInnerAngle");
>+const $coneOuterAngle = dartx.coneOuterAngle = Symbol("dartx.coneOuterAngle");
>+const $coneOuterGain = dartx.coneOuterGain = Symbol("dartx.coneOuterGain");
>+const $distanceModel = dartx.distanceModel = Symbol("dartx.distanceModel");
>+const $maxDistance = dartx.maxDistance = Symbol("dartx.maxDistance");
>+const $orientationX = dartx.orientationX = Symbol("dartx.orientationX");
>+const $orientationY = dartx.orientationY = Symbol("dartx.orientationY");
>+const $orientationZ = dartx.orientationZ = Symbol("dartx.orientationZ");
>+const $panningModel = dartx.panningModel = Symbol("dartx.panningModel");
>+const $refDistance = dartx.refDistance = Symbol("dartx.refDistance");
>+const $rolloffFactor = dartx.rolloffFactor = Symbol("dartx.rolloffFactor");
>+const $bufferSize = dartx.bufferSize = Symbol("dartx.bufferSize");
>+const $setEventListener = dartx.setEventListener = Symbol("dartx.setEventListener");
>+const $onAudioProcess = dartx.onAudioProcess = Symbol("dartx.onAudioProcess");
>+const $pan = dartx.pan = Symbol("dartx.pan");
>+const $curve = dartx.curve = Symbol("dartx.curve");
>+const $oversample = dartx.oversample = Symbol("dartx.oversample");
>+const $drawArraysInstancedAngle = dartx.drawArraysInstancedAngle = Symbol("dartx.drawArraysInstancedAngle");
>+const $drawElementsInstancedAngle = dartx.drawElementsInstancedAngle = Symbol("dartx.drawElementsInstancedAngle");
>+const $vertexAttribDivisorAngle = dartx.vertexAttribDivisorAngle = Symbol("dartx.vertexAttribDivisorAngle");
>+const $offscreenCanvas = dartx.offscreenCanvas = Symbol("dartx.offscreenCanvas");
>+const $statusMessage = dartx.statusMessage = Symbol("dartx.statusMessage");
>+const $getTranslatedShaderSource = dartx.getTranslatedShaderSource = Symbol("dartx.getTranslatedShaderSource");
>+const $drawBuffersWebgl = dartx.drawBuffersWebgl = Symbol("dartx.drawBuffersWebgl");
>+const $beginQueryExt = dartx.beginQueryExt = Symbol("dartx.beginQueryExt");
>+const $createQueryExt = dartx.createQueryExt = Symbol("dartx.createQueryExt");
>+const $deleteQueryExt = dartx.deleteQueryExt = Symbol("dartx.deleteQueryExt");
>+const $endQueryExt = dartx.endQueryExt = Symbol("dartx.endQueryExt");
>+const $getQueryExt = dartx.getQueryExt = Symbol("dartx.getQueryExt");
>+const $getQueryObjectExt = dartx.getQueryObjectExt = Symbol("dartx.getQueryObjectExt");
>+const $isQueryExt = dartx.isQueryExt = Symbol("dartx.isQueryExt");
>+const $queryCounterExt = dartx.queryCounterExt = Symbol("dartx.queryCounterExt");
>+const $getBufferSubDataAsync = dartx.getBufferSubDataAsync = Symbol("dartx.getBufferSubDataAsync");
>+const $loseContext = dartx.loseContext = Symbol("dartx.loseContext");
>+const $restoreContext = dartx.restoreContext = Symbol("dartx.restoreContext");
>+const $bindVertexArray = dartx.bindVertexArray = Symbol("dartx.bindVertexArray");
>+const $createVertexArray = dartx.createVertexArray = Symbol("dartx.createVertexArray");
>+const $deleteVertexArray = dartx.deleteVertexArray = Symbol("dartx.deleteVertexArray");
>+const $isVertexArray = dartx.isVertexArray = Symbol("dartx.isVertexArray");
>+const $drawingBufferHeight = dartx.drawingBufferHeight = Symbol("dartx.drawingBufferHeight");
>+const $drawingBufferWidth = dartx.drawingBufferWidth = Symbol("dartx.drawingBufferWidth");
>+const $activeTexture = dartx.activeTexture = Symbol("dartx.activeTexture");
>+const $attachShader = dartx.attachShader = Symbol("dartx.attachShader");
>+const $bindAttribLocation = dartx.bindAttribLocation = Symbol("dartx.bindAttribLocation");
>+const $bindBuffer = dartx.bindBuffer = Symbol("dartx.bindBuffer");
>+const $bindFramebuffer = dartx.bindFramebuffer = Symbol("dartx.bindFramebuffer");
>+const $bindRenderbuffer = dartx.bindRenderbuffer = Symbol("dartx.bindRenderbuffer");
>+const $bindTexture = dartx.bindTexture = Symbol("dartx.bindTexture");
>+const $blendColor = dartx.blendColor = Symbol("dartx.blendColor");
>+const $blendEquation = dartx.blendEquation = Symbol("dartx.blendEquation");
>+const $blendEquationSeparate = dartx.blendEquationSeparate = Symbol("dartx.blendEquationSeparate");
>+const $blendFunc = dartx.blendFunc = Symbol("dartx.blendFunc");
>+const $blendFuncSeparate = dartx.blendFuncSeparate = Symbol("dartx.blendFuncSeparate");
>+const $bufferData = dartx.bufferData = Symbol("dartx.bufferData");
>+const $bufferSubData = dartx.bufferSubData = Symbol("dartx.bufferSubData");
>+const $checkFramebufferStatus = dartx.checkFramebufferStatus = Symbol("dartx.checkFramebufferStatus");
>+const $clearColor = dartx.clearColor = Symbol("dartx.clearColor");
>+const $clearDepth = dartx.clearDepth = Symbol("dartx.clearDepth");
>+const $clearStencil = dartx.clearStencil = Symbol("dartx.clearStencil");
>+const $colorMask = dartx.colorMask = Symbol("dartx.colorMask");
>+const $compileShader = dartx.compileShader = Symbol("dartx.compileShader");
>+const $compressedTexImage2D = dartx.compressedTexImage2D = Symbol("dartx.compressedTexImage2D");
>+const $compressedTexSubImage2D = dartx.compressedTexSubImage2D = Symbol("dartx.compressedTexSubImage2D");
>+const $copyTexImage2D = dartx.copyTexImage2D = Symbol("dartx.copyTexImage2D");
>+const $copyTexSubImage2D = dartx.copyTexSubImage2D = Symbol("dartx.copyTexSubImage2D");
>+const $createFramebuffer = dartx.createFramebuffer = Symbol("dartx.createFramebuffer");
>+const $createProgram = dartx.createProgram = Symbol("dartx.createProgram");
>+const $createRenderbuffer = dartx.createRenderbuffer = Symbol("dartx.createRenderbuffer");
>+const $createShader = dartx.createShader = Symbol("dartx.createShader");
>+const $createTexture = dartx.createTexture = Symbol("dartx.createTexture");
>+const $cullFace = dartx.cullFace = Symbol("dartx.cullFace");
>+const $deleteBuffer = dartx.deleteBuffer = Symbol("dartx.deleteBuffer");
>+const $deleteFramebuffer = dartx.deleteFramebuffer = Symbol("dartx.deleteFramebuffer");
>+const $deleteProgram = dartx.deleteProgram = Symbol("dartx.deleteProgram");
>+const $deleteRenderbuffer = dartx.deleteRenderbuffer = Symbol("dartx.deleteRenderbuffer");
>+const $deleteShader = dartx.deleteShader = Symbol("dartx.deleteShader");
>+const $deleteTexture = dartx.deleteTexture = Symbol("dartx.deleteTexture");
>+const $depthFunc = dartx.depthFunc = Symbol("dartx.depthFunc");
>+const $depthMask = dartx.depthMask = Symbol("dartx.depthMask");
>+const $depthRange = dartx.depthRange = Symbol("dartx.depthRange");
>+const $detachShader = dartx.detachShader = Symbol("dartx.detachShader");
>+const $disableVertexAttribArray = dartx.disableVertexAttribArray = Symbol("dartx.disableVertexAttribArray");
>+const $drawArrays = dartx.drawArrays = Symbol("dartx.drawArrays");
>+const $drawElements = dartx.drawElements = Symbol("dartx.drawElements");
>+const $enableVertexAttribArray = dartx.enableVertexAttribArray = Symbol("dartx.enableVertexAttribArray");
>+const $flush = dartx.flush = Symbol("dartx.flush");
>+const $framebufferRenderbuffer = dartx.framebufferRenderbuffer = Symbol("dartx.framebufferRenderbuffer");
>+const $framebufferTexture2D = dartx.framebufferTexture2D = Symbol("dartx.framebufferTexture2D");
>+const $frontFace = dartx.frontFace = Symbol("dartx.frontFace");
>+const $generateMipmap = dartx.generateMipmap = Symbol("dartx.generateMipmap");
>+const $getActiveAttrib = dartx.getActiveAttrib = Symbol("dartx.getActiveAttrib");
>+const $getActiveUniform = dartx.getActiveUniform = Symbol("dartx.getActiveUniform");
>+const $getAttachedShaders = dartx.getAttachedShaders = Symbol("dartx.getAttachedShaders");
>+const $getAttribLocation = dartx.getAttribLocation = Symbol("dartx.getAttribLocation");
>+const $getBufferParameter = dartx.getBufferParameter = Symbol("dartx.getBufferParameter");
>+const $getError = dartx.getError = Symbol("dartx.getError");
>+const $getExtension = dartx.getExtension = Symbol("dartx.getExtension");
>+const $getFramebufferAttachmentParameter = dartx.getFramebufferAttachmentParameter = Symbol("dartx.getFramebufferAttachmentParameter");
>+const $getProgramInfoLog = dartx.getProgramInfoLog = Symbol("dartx.getProgramInfoLog");
>+const $getProgramParameter = dartx.getProgramParameter = Symbol("dartx.getProgramParameter");
>+const $getRenderbufferParameter = dartx.getRenderbufferParameter = Symbol("dartx.getRenderbufferParameter");
>+const $getShaderInfoLog = dartx.getShaderInfoLog = Symbol("dartx.getShaderInfoLog");
>+const $getShaderParameter = dartx.getShaderParameter = Symbol("dartx.getShaderParameter");
>+const $getShaderPrecisionFormat = dartx.getShaderPrecisionFormat = Symbol("dartx.getShaderPrecisionFormat");
>+const $getShaderSource = dartx.getShaderSource = Symbol("dartx.getShaderSource");
>+const $getSupportedExtensions = dartx.getSupportedExtensions = Symbol("dartx.getSupportedExtensions");
>+const $getTexParameter = dartx.getTexParameter = Symbol("dartx.getTexParameter");
>+const $getUniform = dartx.getUniform = Symbol("dartx.getUniform");
>+const $getUniformLocation = dartx.getUniformLocation = Symbol("dartx.getUniformLocation");
>+const $getVertexAttrib = dartx.getVertexAttrib = Symbol("dartx.getVertexAttrib");
>+const $getVertexAttribOffset = dartx.getVertexAttribOffset = Symbol("dartx.getVertexAttribOffset");
>+const $hint = dartx.hint = Symbol("dartx.hint");
>+const $isBuffer = dartx.isBuffer = Symbol("dartx.isBuffer");
>+const $isEnabled = dartx.isEnabled = Symbol("dartx.isEnabled");
>+const $isFramebuffer = dartx.isFramebuffer = Symbol("dartx.isFramebuffer");
>+const $isProgram = dartx.isProgram = Symbol("dartx.isProgram");
>+const $isRenderbuffer = dartx.isRenderbuffer = Symbol("dartx.isRenderbuffer");
>+const $isShader = dartx.isShader = Symbol("dartx.isShader");
>+const $isTexture = dartx.isTexture = Symbol("dartx.isTexture");
>+const $linkProgram = dartx.linkProgram = Symbol("dartx.linkProgram");
>+const $pixelStorei = dartx.pixelStorei = Symbol("dartx.pixelStorei");
>+const $polygonOffset = dartx.polygonOffset = Symbol("dartx.polygonOffset");
>+const $renderbufferStorage = dartx.renderbufferStorage = Symbol("dartx.renderbufferStorage");
>+const $sampleCoverage = dartx.sampleCoverage = Symbol("dartx.sampleCoverage");
>+const $scissor = dartx.scissor = Symbol("dartx.scissor");
>+const $shaderSource = dartx.shaderSource = Symbol("dartx.shaderSource");
>+const $stencilFunc = dartx.stencilFunc = Symbol("dartx.stencilFunc");
>+const $stencilFuncSeparate = dartx.stencilFuncSeparate = Symbol("dartx.stencilFuncSeparate");
>+const $stencilMask = dartx.stencilMask = Symbol("dartx.stencilMask");
>+const $stencilMaskSeparate = dartx.stencilMaskSeparate = Symbol("dartx.stencilMaskSeparate");
>+const $stencilOp = dartx.stencilOp = Symbol("dartx.stencilOp");
>+const $stencilOpSeparate = dartx.stencilOpSeparate = Symbol("dartx.stencilOpSeparate");
>+const $texImage2D = dartx.texImage2D = Symbol("dartx.texImage2D");
>+const $texParameterf = dartx.texParameterf = Symbol("dartx.texParameterf");
>+const $texParameteri = dartx.texParameteri = Symbol("dartx.texParameteri");
>+const $texSubImage2D = dartx.texSubImage2D = Symbol("dartx.texSubImage2D");
>+const $uniform1f = dartx.uniform1f = Symbol("dartx.uniform1f");
>+const $uniform1fv = dartx.uniform1fv = Symbol("dartx.uniform1fv");
>+const $uniform1i = dartx.uniform1i = Symbol("dartx.uniform1i");
>+const $uniform1iv = dartx.uniform1iv = Symbol("dartx.uniform1iv");
>+const $uniform2f = dartx.uniform2f = Symbol("dartx.uniform2f");
>+const $uniform2fv = dartx.uniform2fv = Symbol("dartx.uniform2fv");
>+const $uniform2i = dartx.uniform2i = Symbol("dartx.uniform2i");
>+const $uniform2iv = dartx.uniform2iv = Symbol("dartx.uniform2iv");
>+const $uniform3f = dartx.uniform3f = Symbol("dartx.uniform3f");
>+const $uniform3fv = dartx.uniform3fv = Symbol("dartx.uniform3fv");
>+const $uniform3i = dartx.uniform3i = Symbol("dartx.uniform3i");
>+const $uniform3iv = dartx.uniform3iv = Symbol("dartx.uniform3iv");
>+const $uniform4f = dartx.uniform4f = Symbol("dartx.uniform4f");
>+const $uniform4fv = dartx.uniform4fv = Symbol("dartx.uniform4fv");
>+const $uniform4i = dartx.uniform4i = Symbol("dartx.uniform4i");
>+const $uniform4iv = dartx.uniform4iv = Symbol("dartx.uniform4iv");
>+const $uniformMatrix2fv = dartx.uniformMatrix2fv = Symbol("dartx.uniformMatrix2fv");
>+const $uniformMatrix3fv = dartx.uniformMatrix3fv = Symbol("dartx.uniformMatrix3fv");
>+const $uniformMatrix4fv = dartx.uniformMatrix4fv = Symbol("dartx.uniformMatrix4fv");
>+const $useProgram = dartx.useProgram = Symbol("dartx.useProgram");
>+const $validateProgram = dartx.validateProgram = Symbol("dartx.validateProgram");
>+const $vertexAttrib1f = dartx.vertexAttrib1f = Symbol("dartx.vertexAttrib1f");
>+const $vertexAttrib1fv = dartx.vertexAttrib1fv = Symbol("dartx.vertexAttrib1fv");
>+const $vertexAttrib2f = dartx.vertexAttrib2f = Symbol("dartx.vertexAttrib2f");
>+const $vertexAttrib2fv = dartx.vertexAttrib2fv = Symbol("dartx.vertexAttrib2fv");
>+const $vertexAttrib3f = dartx.vertexAttrib3f = Symbol("dartx.vertexAttrib3f");
>+const $vertexAttrib3fv = dartx.vertexAttrib3fv = Symbol("dartx.vertexAttrib3fv");
>+const $vertexAttrib4f = dartx.vertexAttrib4f = Symbol("dartx.vertexAttrib4f");
>+const $vertexAttrib4fv = dartx.vertexAttrib4fv = Symbol("dartx.vertexAttrib4fv");
>+const $vertexAttribPointer = dartx.vertexAttribPointer = Symbol("dartx.vertexAttribPointer");
>+const $viewport = dartx.viewport = Symbol("dartx.viewport");
>+const $readPixels = dartx.readPixels = Symbol("dartx.readPixels");
>+const $texImage2DUntyped = dartx.texImage2DUntyped = Symbol("dartx.texImage2DUntyped");
>+const $texImage2DTyped = dartx.texImage2DTyped = Symbol("dartx.texImage2DTyped");
>+const $texSubImage2DUntyped = dartx.texSubImage2DUntyped = Symbol("dartx.texSubImage2DUntyped");
>+const $texSubImage2DTyped = dartx.texSubImage2DTyped = Symbol("dartx.texSubImage2DTyped");
>+const $bufferDataTyped = dartx.bufferDataTyped = Symbol("dartx.bufferDataTyped");
>+const $bufferSubDataTyped = dartx.bufferSubDataTyped = Symbol("dartx.bufferSubDataTyped");
>+const $beginQuery = dartx.beginQuery = Symbol("dartx.beginQuery");
>+const $beginTransformFeedback = dartx.beginTransformFeedback = Symbol("dartx.beginTransformFeedback");
>+const $bindBufferBase = dartx.bindBufferBase = Symbol("dartx.bindBufferBase");
>+const $bindBufferRange = dartx.bindBufferRange = Symbol("dartx.bindBufferRange");
>+const $bindSampler = dartx.bindSampler = Symbol("dartx.bindSampler");
>+const $bindTransformFeedback = dartx.bindTransformFeedback = Symbol("dartx.bindTransformFeedback");
>+const $blitFramebuffer = dartx.blitFramebuffer = Symbol("dartx.blitFramebuffer");
>+const $bufferData2 = dartx.bufferData2 = Symbol("dartx.bufferData2");
>+const $bufferSubData2 = dartx.bufferSubData2 = Symbol("dartx.bufferSubData2");
>+const $clearBufferfi = dartx.clearBufferfi = Symbol("dartx.clearBufferfi");
>+const $clearBufferfv = dartx.clearBufferfv = Symbol("dartx.clearBufferfv");
>+const $clearBufferiv = dartx.clearBufferiv = Symbol("dartx.clearBufferiv");
>+const $clearBufferuiv = dartx.clearBufferuiv = Symbol("dartx.clearBufferuiv");
>+const $clientWaitSync = dartx.clientWaitSync = Symbol("dartx.clientWaitSync");
>+const $compressedTexImage2D2 = dartx.compressedTexImage2D2 = Symbol("dartx.compressedTexImage2D2");
>+const $compressedTexImage2D3 = dartx.compressedTexImage2D3 = Symbol("dartx.compressedTexImage2D3");
>+const $compressedTexImage3D = dartx.compressedTexImage3D = Symbol("dartx.compressedTexImage3D");
>+const $compressedTexImage3D2 = dartx.compressedTexImage3D2 = Symbol("dartx.compressedTexImage3D2");
>+const $compressedTexSubImage2D2 = dartx.compressedTexSubImage2D2 = Symbol("dartx.compressedTexSubImage2D2");
>+const $compressedTexSubImage2D3 = dartx.compressedTexSubImage2D3 = Symbol("dartx.compressedTexSubImage2D3");
>+const $compressedTexSubImage3D = dartx.compressedTexSubImage3D = Symbol("dartx.compressedTexSubImage3D");
>+const $compressedTexSubImage3D2 = dartx.compressedTexSubImage3D2 = Symbol("dartx.compressedTexSubImage3D2");
>+const $copyBufferSubData = dartx.copyBufferSubData = Symbol("dartx.copyBufferSubData");
>+const $copyTexSubImage3D = dartx.copyTexSubImage3D = Symbol("dartx.copyTexSubImage3D");
>+const $createQuery = dartx.createQuery = Symbol("dartx.createQuery");
>+const $createSampler = dartx.createSampler = Symbol("dartx.createSampler");
>+const $createTransformFeedback = dartx.createTransformFeedback = Symbol("dartx.createTransformFeedback");
>+const $deleteQuery = dartx.deleteQuery = Symbol("dartx.deleteQuery");
>+const $deleteSampler = dartx.deleteSampler = Symbol("dartx.deleteSampler");
>+const $deleteSync = dartx.deleteSync = Symbol("dartx.deleteSync");
>+const $deleteTransformFeedback = dartx.deleteTransformFeedback = Symbol("dartx.deleteTransformFeedback");
>+const $drawArraysInstanced = dartx.drawArraysInstanced = Symbol("dartx.drawArraysInstanced");
>+const $drawBuffers = dartx.drawBuffers = Symbol("dartx.drawBuffers");
>+const $drawElementsInstanced = dartx.drawElementsInstanced = Symbol("dartx.drawElementsInstanced");
>+const $drawRangeElements = dartx.drawRangeElements = Symbol("dartx.drawRangeElements");
>+const $endQuery = dartx.endQuery = Symbol("dartx.endQuery");
>+const $endTransformFeedback = dartx.endTransformFeedback = Symbol("dartx.endTransformFeedback");
>+const $fenceSync = dartx.fenceSync = Symbol("dartx.fenceSync");
>+const $framebufferTextureLayer = dartx.framebufferTextureLayer = Symbol("dartx.framebufferTextureLayer");
>+const $getActiveUniformBlockName = dartx.getActiveUniformBlockName = Symbol("dartx.getActiveUniformBlockName");
>+const $getActiveUniformBlockParameter = dartx.getActiveUniformBlockParameter = Symbol("dartx.getActiveUniformBlockParameter");
>+const $getActiveUniforms = dartx.getActiveUniforms = Symbol("dartx.getActiveUniforms");
>+const $getBufferSubData = dartx.getBufferSubData = Symbol("dartx.getBufferSubData");
>+const $getFragDataLocation = dartx.getFragDataLocation = Symbol("dartx.getFragDataLocation");
>+const $getIndexedParameter = dartx.getIndexedParameter = Symbol("dartx.getIndexedParameter");
>+const $getInternalformatParameter = dartx.getInternalformatParameter = Symbol("dartx.getInternalformatParameter");
>+const $getQuery = dartx.getQuery = Symbol("dartx.getQuery");
>+const $getQueryParameter = dartx.getQueryParameter = Symbol("dartx.getQueryParameter");
>+const $getSamplerParameter = dartx.getSamplerParameter = Symbol("dartx.getSamplerParameter");
>+const $getSyncParameter = dartx.getSyncParameter = Symbol("dartx.getSyncParameter");
>+const $getTransformFeedbackVarying = dartx.getTransformFeedbackVarying = Symbol("dartx.getTransformFeedbackVarying");
>+const $getUniformBlockIndex = dartx.getUniformBlockIndex = Symbol("dartx.getUniformBlockIndex");
>+const $getUniformIndices = dartx.getUniformIndices = Symbol("dartx.getUniformIndices");
>+const $invalidateFramebuffer = dartx.invalidateFramebuffer = Symbol("dartx.invalidateFramebuffer");
>+const $invalidateSubFramebuffer = dartx.invalidateSubFramebuffer = Symbol("dartx.invalidateSubFramebuffer");
>+const $isQuery = dartx.isQuery = Symbol("dartx.isQuery");
>+const $isSampler = dartx.isSampler = Symbol("dartx.isSampler");
>+const $isSync = dartx.isSync = Symbol("dartx.isSync");
>+const $isTransformFeedback = dartx.isTransformFeedback = Symbol("dartx.isTransformFeedback");
>+const $pauseTransformFeedback = dartx.pauseTransformFeedback = Symbol("dartx.pauseTransformFeedback");
>+const $readBuffer = dartx.readBuffer = Symbol("dartx.readBuffer");
>+const $readPixels2 = dartx.readPixels2 = Symbol("dartx.readPixels2");
>+const $renderbufferStorageMultisample = dartx.renderbufferStorageMultisample = Symbol("dartx.renderbufferStorageMultisample");
>+const $resumeTransformFeedback = dartx.resumeTransformFeedback = Symbol("dartx.resumeTransformFeedback");
>+const $samplerParameterf = dartx.samplerParameterf = Symbol("dartx.samplerParameterf");
>+const $samplerParameteri = dartx.samplerParameteri = Symbol("dartx.samplerParameteri");
>+const $texImage2D2 = dartx.texImage2D2 = Symbol("dartx.texImage2D2");
>+const $texImage3D = dartx.texImage3D = Symbol("dartx.texImage3D");
>+const $texStorage2D = dartx.texStorage2D = Symbol("dartx.texStorage2D");
>+const $texStorage3D = dartx.texStorage3D = Symbol("dartx.texStorage3D");
>+const $texSubImage2D2 = dartx.texSubImage2D2 = Symbol("dartx.texSubImage2D2");
>+const $texSubImage3D = dartx.texSubImage3D = Symbol("dartx.texSubImage3D");
>+const $transformFeedbackVaryings = dartx.transformFeedbackVaryings = Symbol("dartx.transformFeedbackVaryings");
>+const $uniform1fv2 = dartx.uniform1fv2 = Symbol("dartx.uniform1fv2");
>+const $uniform1iv2 = dartx.uniform1iv2 = Symbol("dartx.uniform1iv2");
>+const $uniform1ui = dartx.uniform1ui = Symbol("dartx.uniform1ui");
>+const $uniform1uiv = dartx.uniform1uiv = Symbol("dartx.uniform1uiv");
>+const $uniform2fv2 = dartx.uniform2fv2 = Symbol("dartx.uniform2fv2");
>+const $uniform2iv2 = dartx.uniform2iv2 = Symbol("dartx.uniform2iv2");
>+const $uniform2ui = dartx.uniform2ui = Symbol("dartx.uniform2ui");
>+const $uniform2uiv = dartx.uniform2uiv = Symbol("dartx.uniform2uiv");
>+const $uniform3fv2 = dartx.uniform3fv2 = Symbol("dartx.uniform3fv2");
>+const $uniform3iv2 = dartx.uniform3iv2 = Symbol("dartx.uniform3iv2");
>+const $uniform3ui = dartx.uniform3ui = Symbol("dartx.uniform3ui");
>+const $uniform3uiv = dartx.uniform3uiv = Symbol("dartx.uniform3uiv");
>+const $uniform4fv2 = dartx.uniform4fv2 = Symbol("dartx.uniform4fv2");
>+const $uniform4iv2 = dartx.uniform4iv2 = Symbol("dartx.uniform4iv2");
>+const $uniform4ui = dartx.uniform4ui = Symbol("dartx.uniform4ui");
>+const $uniform4uiv = dartx.uniform4uiv = Symbol("dartx.uniform4uiv");
>+const $uniformBlockBinding = dartx.uniformBlockBinding = Symbol("dartx.uniformBlockBinding");
>+const $uniformMatrix2fv2 = dartx.uniformMatrix2fv2 = Symbol("dartx.uniformMatrix2fv2");
>+const $uniformMatrix2x3fv = dartx.uniformMatrix2x3fv = Symbol("dartx.uniformMatrix2x3fv");
>+const $uniformMatrix2x4fv = dartx.uniformMatrix2x4fv = Symbol("dartx.uniformMatrix2x4fv");
>+const $uniformMatrix3fv2 = dartx.uniformMatrix3fv2 = Symbol("dartx.uniformMatrix3fv2");
>+const $uniformMatrix3x2fv = dartx.uniformMatrix3x2fv = Symbol("dartx.uniformMatrix3x2fv");
>+const $uniformMatrix3x4fv = dartx.uniformMatrix3x4fv = Symbol("dartx.uniformMatrix3x4fv");
>+const $uniformMatrix4fv2 = dartx.uniformMatrix4fv2 = Symbol("dartx.uniformMatrix4fv2");
>+const $uniformMatrix4x2fv = dartx.uniformMatrix4x2fv = Symbol("dartx.uniformMatrix4x2fv");
>+const $uniformMatrix4x3fv = dartx.uniformMatrix4x3fv = Symbol("dartx.uniformMatrix4x3fv");
>+const $vertexAttribDivisor = dartx.vertexAttribDivisor = Symbol("dartx.vertexAttribDivisor");
>+const $vertexAttribI4i = dartx.vertexAttribI4i = Symbol("dartx.vertexAttribI4i");
>+const $vertexAttribI4iv = dartx.vertexAttribI4iv = Symbol("dartx.vertexAttribI4iv");
>+const $vertexAttribI4ui = dartx.vertexAttribI4ui = Symbol("dartx.vertexAttribI4ui");
>+const $vertexAttribI4uiv = dartx.vertexAttribI4uiv = Symbol("dartx.vertexAttribI4uiv");
>+const $vertexAttribIPointer = dartx.vertexAttribIPointer = Symbol("dartx.vertexAttribIPointer");
>+const $waitSync = dartx.waitSync = Symbol("dartx.waitSync");
>+const $precision = dartx.precision = Symbol("dartx.precision");
>+const $rangeMax = dartx.rangeMax = Symbol("dartx.rangeMax");
>+const $rangeMin = dartx.rangeMin = Symbol("dartx.rangeMin");
>+const $lastUploadedVideoFrameWasSkipped = dartx.lastUploadedVideoFrameWasSkipped = Symbol("dartx.lastUploadedVideoFrameWasSkipped");
>+const $lastUploadedVideoHeight = dartx.lastUploadedVideoHeight = Symbol("dartx.lastUploadedVideoHeight");
>+const $lastUploadedVideoTimestamp = dartx.lastUploadedVideoTimestamp = Symbol("dartx.lastUploadedVideoTimestamp");
>+const $lastUploadedVideoWidth = dartx.lastUploadedVideoWidth = Symbol("dartx.lastUploadedVideoWidth");
>+const $changeVersion = dartx.changeVersion = Symbol("dartx.changeVersion");
>+const $readTransaction = dartx.readTransaction = Symbol("dartx.readTransaction");
>+const $transaction_future = dartx.transaction_future = Symbol("dartx.transaction_future");
>+const $insertId = dartx.insertId = Symbol("dartx.insertId");
>+const $rowsAffected = dartx.rowsAffected = Symbol("dartx.rowsAffected");
>+const $executeSql = dartx.executeSql = Symbol("dartx.executeSql");
>+let JSArrayOfString = () => (JSArrayOfString = dart.constFn(_interceptors.JSArray$(core.String)))();
>+let IdentityMapOfString$Object = () => (IdentityMapOfString$Object = dart.constFn(_js_helper.IdentityMap$(core.String, core.Object)))();
>+let ListOfString = () => (ListOfString = dart.constFn(core.List$(core.String)))();
>+let IdentityMapOfString$ListOfString = () => (IdentityMapOfString$ListOfString = dart.constFn(_js_helper.IdentityMap$(core.String, ListOfString())))();
>+let IterableOfString = () => (IterableOfString = dart.constFn(core.Iterable$(core.String)))();
>+let VoidTodynamic = () => (VoidTodynamic = dart.constFn(dart.fnType(dart.dynamic, [])))();
>+let IdentityMapOfObject$int = () => (IdentityMapOfObject$int = dart.constFn(_js_helper.IdentityMap$(core.Object, core.int)))();
>+let ListOfObject = () => (ListOfObject = dart.constFn(core.List$(core.Object)))();
>+let IdentityMapOfTypeVariable$Object = () => (IdentityMapOfTypeVariable$Object = dart.constFn(_js_helper.IdentityMap$(dart.TypeVariable, core.Object)))();
>+let ListOfTypeVariable = () => (ListOfTypeVariable = dart.constFn(core.List$(dart.TypeVariable)))();
>+let IterableOfTypeVariable = () => (IterableOfTypeVariable = dart.constFn(core.Iterable$(dart.TypeVariable)))();
>+let JSArrayOfTypeVariable = () => (JSArrayOfTypeVariable = dart.constFn(_interceptors.JSArray$(dart.TypeVariable)))();
>+let ListOfType = () => (ListOfType = dart.constFn(core.List$(core.Type)))();
>+let IterableOfTypeConstraint = () => (IterableOfTypeConstraint = dart.constFn(core.Iterable$(dart.TypeConstraint)))();
>+let MapOfTypeVariable$TypeConstraint = () => (MapOfTypeVariable$TypeConstraint = dart.constFn(core.Map$(dart.TypeVariable, dart.TypeConstraint)))();
>+let JSArrayOfObject = () => (JSArrayOfObject = dart.constFn(_interceptors.JSArray$(core.Object)))();
>+let MapOfSymbol$dynamic = () => (MapOfSymbol$dynamic = dart.constFn(core.Map$(core.Symbol, dart.dynamic)))();
>+let NameValuePairAndNameValuePairToint = () => (NameValuePairAndNameValuePairToint = dart.constFn(dart.fnType(core.int, [_debugger.NameValuePair, _debugger.NameValuePair])))();
>+let JSArrayOfNameValuePair = () => (JSArrayOfNameValuePair = dart.constFn(_interceptors.JSArray$(_debugger.NameValuePair)))();
>+let intAnddynamicToNull = () => (intAnddynamicToNull = dart.constFn(dart.fnType(core.Null, [core.int, dart.dynamic])))();
>+let StringTobool = () => (StringTobool = dart.constFn(dart.fnType(core.bool, [core.String])))();
>+let dynamicTodynamic = () => (dynamicTodynamic = dart.constFn(dart.fnType(dart.dynamic, [dart.dynamic])))();
>+let dynamicToObject = () => (dynamicToObject = dart.constFn(dart.fnType(core.Object, [dart.dynamic])))();
>+let MapOfdynamic$Object = () => (MapOfdynamic$Object = dart.constFn(core.Map$(dart.dynamic, core.Object)))();
>+let JSArrayOfFormatter = () => (JSArrayOfFormatter = dart.constFn(_interceptors.JSArray$(_debugger.Formatter)))();
>+let ListOfFormatter = () => (ListOfFormatter = dart.constFn(core.List$(_debugger.Formatter)))();
>+let _HashSetOfNameValuePair = () => (_HashSetOfNameValuePair = dart.constFn(collection._HashSet$(_debugger.NameValuePair)))();
>+let IdentityMapOfString$String = () => (IdentityMapOfString$String = dart.constFn(_js_helper.IdentityMap$(core.String, core.String)))();
>+let dynamicAnddynamicToNull = () => (dynamicAnddynamicToNull = dart.constFn(dart.fnType(core.Null, [dart.dynamic, dart.dynamic])))();
>+let HashMapOfString$String = () => (HashMapOfString$String = dart.constFn(collection.HashMap$(core.String, core.String)))();
>+let dynamicToString = () => (dynamicToString = dart.constFn(dart.fnType(core.String, [dart.dynamic])))();
>+let ListOfNameValuePair = () => (ListOfNameValuePair = dart.constFn(core.List$(_debugger.NameValuePair)))();
>+let VoidToNull = () => (VoidToNull = dart.constFn(dart.fnType(core.Null, [])))();
>+let StringToNameValuePair = () => (StringToNameValuePair = dart.constFn(dart.fnType(_debugger.NameValuePair, [core.String])))();
>+let IterableOfNameValuePair = () => (IterableOfNameValuePair = dart.constFn(core.Iterable$(_debugger.NameValuePair)))();
>+let JSArrayOf_CallMethodRecord = () => (JSArrayOf_CallMethodRecord = dart.constFn(_interceptors.JSArray$(_debugger._CallMethodRecord)))();
>+let IdentityMapOfString$_MethodStats = () => (IdentityMapOfString$_MethodStats = dart.constFn(_js_helper.IdentityMap$(core.String, _debugger._MethodStats)))();
>+let VoidToString = () => (VoidToString = dart.constFn(dart.fnType(core.String, [])))();
>+let StringToString = () => (StringToString = dart.constFn(dart.fnType(core.String, [core.String])))();
>+let VoidTo_MethodStats = () => (VoidTo_MethodStats = dart.constFn(dart.fnType(_debugger._MethodStats, [])))();
>+let StringAndStringToint = () => (StringAndStringToint = dart.constFn(dart.fnType(core.int, [core.String, core.String])))();
>+let JSArrayOfListOfObject = () => (JSArrayOfListOfObject = dart.constFn(_interceptors.JSArray$(ListOfObject())))();
>+let dynamicAnddynamicToint = () => (dynamicAnddynamicToint = dart.constFn(dart.fnType(core.int, [dart.dynamic, dart.dynamic])))();
>+let JSIndexableOfString = () => (JSIndexableOfString = dart.constFn(_interceptors.JSIndexable$(core.String)))();
>+let dynamicToNull = () => (dynamicToNull = dart.constFn(dart.fnType(core.Null, [dart.dynamic])))();
>+let ComparableOfnum = () => (ComparableOfnum = dart.constFn(core.Comparable$(core.num)))();
>+let FutureOfNull = () => (FutureOfNull = dart.constFn(async.Future$(core.Null)))();
>+let dynamicAndStackTraceToNull = () => (dynamicAndStackTraceToNull = dart.constFn(dart.fnType(core.Null, [dart.dynamic, core.StackTrace])))();
>+let VoidTovoid = () => (VoidTovoid = dart.constFn(dart.fnType(dart.void, [])))();
>+let TimerToNull = () => (TimerToNull = dart.constFn(dart.fnType(core.Null, [async.Timer])))();
>+let _FutureOfNull = () => (_FutureOfNull = dart.constFn(async._Future$(core.Null)))();
>+let VoidTo_FutureOfNull = () => (VoidTo_FutureOfNull = dart.constFn(dart.fnType(_FutureOfNull(), [])))();
>+let VoidToFuture = () => (VoidToFuture = dart.constFn(dart.fnType(async.Future, [])))();
>+let dynamicToFuture = () => (dynamicToFuture = dart.constFn(dart.fnType(async.Future, [dart.dynamic])))();
>+let _FutureOfString = () => (_FutureOfString = dart.constFn(async._Future$(core.String)))();
>+let _FutureOfbool = () => (_FutureOfbool = dart.constFn(async._Future$(core.bool)))();
>+let VoidTobool = () => (VoidTobool = dart.constFn(dart.fnType(core.bool, [])))();
>+let boolToNull = () => (boolToNull = dart.constFn(dart.fnType(core.Null, [core.bool])))();
>+let _FutureOfint = () => (_FutureOfint = dart.constFn(async._Future$(core.int)))();
>+let dynamicAndStackTraceTovoid = () => (dynamicAndStackTraceTovoid = dart.constFn(dart.fnType(dart.void, [dart.dynamic, core.StackTrace])))();
>+let NullAndNullTodynamic = () => (NullAndNullTodynamic = dart.constFn(dart.fnType(dart.dynamic, [core.Null, core.Null])))();
>+let ObjectAndStackTraceTodynamic = () => (ObjectAndStackTraceTodynamic = dart.constFn(dart.fnType(dart.dynamic, [core.Object, core.StackTrace])))();
>+let ObjectTodynamic = () => (ObjectTodynamic = dart.constFn(dart.fnType(dart.dynamic, [core.Object])))();
>+let dynamicTovoid = () => (dynamicTovoid = dart.constFn(dart.fnType(dart.void, [dart.dynamic])))();
>+let EventSinkTo_ConverterStreamEventSink = () => (EventSinkTo_ConverterStreamEventSink = dart.constFn(dart.fnType(convert._ConverterStreamEventSink, [async.EventSink])))();
>+let VoidToSetOfR = () => (VoidToSetOfR = dart.constFn(dart.gFnType(R => [core.Set$(R), []])))();
>+let EmptyIteratorOfNull = () => (EmptyIteratorOfNull = dart.constFn(_internal.EmptyIterator$(core.Null)))();
>+let IterableOfObject = () => (IterableOfObject = dart.constFn(core.Iterable$(core.Object)))();
>+let IteratorOfObject = () => (IteratorOfObject = dart.constFn(core.Iterator$(core.Object)))();
>+let VoidToint = () => (VoidToint = dart.constFn(dart.fnType(core.int, [])))();
>+let JSArrayOfint = () => (JSArrayOfint = dart.constFn(_interceptors.JSArray$(core.int)))();
>+let ObjectTobool = () => (ObjectTobool = dart.constFn(dart.fnType(core.bool, [core.Object])))();
>+let SubListIterableOfString = () => (SubListIterableOfString = dart.constFn(_internal.SubListIterable$(core.String)))();
>+let IteratorOfRegExpMatch = () => (IteratorOfRegExpMatch = dart.constFn(core.Iterator$(core.RegExpMatch)))();
>+let IteratorOfMatch = () => (IteratorOfMatch = dart.constFn(core.Iterator$(core.Match)))();
>+let MatchToString = () => (MatchToString = dart.constFn(dart.fnType(core.String, [core.Match])))();
>+let LinkedMapOfSymbol$dynamic = () => (LinkedMapOfSymbol$dynamic = dart.constFn(_js_helper.LinkedMap$(core.Symbol, dart.dynamic)))();
>+let SymbolAnddynamicToNull = () => (SymbolAnddynamicToNull = dart.constFn(dart.fnType(core.Null, [core.Symbol, dart.dynamic])))();
>+let ListOfSymbol = () => (ListOfSymbol = dart.constFn(core.List$(core.Symbol)))();
>+let ListOfInstanceMirror = () => (ListOfInstanceMirror = dart.constFn(core.List$(mirrors.InstanceMirror)))();
>+let FutureOfLibraryMirror = () => (FutureOfLibraryMirror = dart.constFn(async.Future$(mirrors.LibraryMirror)))();
>+let ListOfCombinatorMirror = () => (ListOfCombinatorMirror = dart.constFn(core.List$(mirrors.CombinatorMirror)))();
>+let dynamicToTypeMirror = () => (dynamicToTypeMirror = dart.constFn(dart.fnType(mirrors.TypeMirror, [dart.dynamic])))();
>+let ListOfTypeMirror = () => (ListOfTypeMirror = dart.constFn(core.List$(mirrors.TypeMirror)))();
>+let dynamicToInstanceMirror = () => (dynamicToInstanceMirror = dart.constFn(dart.fnType(mirrors.InstanceMirror, [dart.dynamic])))();
>+let LinkedMapOfSymbol$DeclarationMirror = () => (LinkedMapOfSymbol$DeclarationMirror = dart.constFn(_js_helper.LinkedMap$(core.Symbol, mirrors.DeclarationMirror)))();
>+let MapOfSymbol$DeclarationMirror = () => (MapOfSymbol$DeclarationMirror = dart.constFn(core.Map$(core.Symbol, mirrors.DeclarationMirror)))();
>+let JSArrayOfClassMirror = () => (JSArrayOfClassMirror = dart.constFn(_interceptors.JSArray$(mirrors.ClassMirror)))();
>+let TypeToTypeMirror = () => (TypeToTypeMirror = dart.constFn(dart.fnType(mirrors.TypeMirror, [core.Type])))();
>+let IterableOfTypeMirror = () => (IterableOfTypeMirror = dart.constFn(core.Iterable$(mirrors.TypeMirror)))();
>+let ListOfClassMirror = () => (ListOfClassMirror = dart.constFn(core.List$(mirrors.ClassMirror)))();
>+let ListOfTypeVariableMirror = () => (ListOfTypeVariableMirror = dart.constFn(core.List$(mirrors.TypeVariableMirror)))();
>+let MapOfSymbol$MethodMirror = () => (MapOfSymbol$MethodMirror = dart.constFn(core.Map$(core.Symbol, mirrors.MethodMirror)))();
>+let ListOfParameterMirror = () => (ListOfParameterMirror = dart.constFn(core.List$(mirrors.ParameterMirror)))();
>+let IterableOfdouble = () => (IterableOfdouble = dart.constFn(core.Iterable$(core.double)))();
>+let IterableOfint = () => (IterableOfint = dart.constFn(core.Iterable$(core.int)))();
>+let ListOfint = () => (ListOfint = dart.constFn(core.List$(core.int)))();
>+let ObjectAndStackTraceToNull = () => (ObjectAndStackTraceToNull = dart.constFn(dart.fnType(core.Null, [core.Object, core.StackTrace])))();
>+let __Tovoid = () => (__Tovoid = dart.constFn(dart.fnType(dart.void, [], [core.Object])))();
>+let ObjectTovoid = () => (ObjectTovoid = dart.constFn(dart.fnType(dart.void, [core.Object])))();
>+let Object__Tovoid = () => (Object__Tovoid = dart.constFn(dart.fnType(dart.void, [core.Object], [core.StackTrace])))();
>+let ObjectAndStackTraceTovoid = () => (ObjectAndStackTraceTovoid = dart.constFn(dart.fnType(dart.void, [core.Object, core.StackTrace])))();
>+let dynamicTobool = () => (dynamicTobool = dart.constFn(dart.fnType(core.bool, [dart.dynamic])))();
>+let FutureOfbool = () => (FutureOfbool = dart.constFn(async.Future$(core.bool)))();
>+let FutureOrOfbool = () => (FutureOrOfbool = dart.constFn(async.FutureOr$(core.bool)))();
>+let VoidToFutureOrOfbool = () => (VoidToFutureOrOfbool = dart.constFn(dart.fnType(FutureOrOfbool(), [])))();
>+let dynamic__ToNull = () => (dynamic__ToNull = dart.constFn(dart.fnType(core.Null, [dart.dynamic], [core.StackTrace])))();
>+let dynamicTo_Future = () => (dynamicTo_Future = dart.constFn(dart.fnType(async._Future, [dart.dynamic])))();
>+let ZoneAndZoneDelegateAndZone__Tovoid = () => (ZoneAndZoneDelegateAndZone__Tovoid = dart.constFn(dart.fnType(dart.void, [async.Zone, async.ZoneDelegate, async.Zone, core.Object, core.StackTrace])))();
>+let ZoneAndZoneDelegateAndZone__ToR = () => (ZoneAndZoneDelegateAndZone__ToR = dart.constFn(dart.gFnType(R => [R, [async.Zone, async.ZoneDelegate, async.Zone, dart.fnType(R, [])]])))();
>+let ZoneAndZoneDelegateAndZone__ToR$ = () => (ZoneAndZoneDelegateAndZone__ToR$ = dart.constFn(dart.gFnType((R, T) => [R, [async.Zone, async.ZoneDelegate, async.Zone, dart.fnType(R, [T]), T]])))();
>+let ZoneAndZoneDelegateAndZone__ToR$0 = () => (ZoneAndZoneDelegateAndZone__ToR$0 = dart.constFn(dart.gFnType((R, T1, T2) => [R, [async.Zone, async.ZoneDelegate, async.Zone, dart.fnType(R, [T1, T2]), T1, T2]])))();
>+let ZoneAndZoneDelegateAndZone__ToFn = () => (ZoneAndZoneDelegateAndZone__ToFn = dart.constFn(dart.gFnType(R => [dart.fnType(R, []), [async.Zone, async.ZoneDelegate, async.Zone, dart.fnType(R, [])]])))();
>+let ZoneAndZoneDelegateAndZone__ToFn$ = () => (ZoneAndZoneDelegateAndZone__ToFn$ = dart.constFn(dart.gFnType((R, T) => [dart.fnType(R, [T]), [async.Zone, async.ZoneDelegate, async.Zone, dart.fnType(R, [T])]])))();
>+let ZoneAndZoneDelegateAndZone__ToFn$0 = () => (ZoneAndZoneDelegateAndZone__ToFn$0 = dart.constFn(dart.gFnType((R, T1, T2) => [dart.fnType(R, [T1, T2]), [async.Zone, async.ZoneDelegate, async.Zone, dart.fnType(R, [T1, T2])]])))();
>+let ZoneAndZoneDelegateAndZone__ToAsyncError = () => (ZoneAndZoneDelegateAndZone__ToAsyncError = dart.constFn(dart.fnType(async.AsyncError, [async.Zone, async.ZoneDelegate, async.Zone, core.Object, core.StackTrace])))();
>+let ZoneAndZoneDelegateAndZone__Tovoid$ = () => (ZoneAndZoneDelegateAndZone__Tovoid$ = dart.constFn(dart.fnType(dart.void, [async.Zone, async.ZoneDelegate, async.Zone, VoidTovoid()])))();
>+let ZoneAndZoneDelegateAndZone__ToTimer = () => (ZoneAndZoneDelegateAndZone__ToTimer = dart.constFn(dart.fnType(async.Timer, [async.Zone, async.ZoneDelegate, async.Zone, core.Duration, VoidTovoid()])))();
>+let TimerTovoid = () => (TimerTovoid = dart.constFn(dart.fnType(dart.void, [async.Timer])))();
>+let ZoneAndZoneDelegateAndZone__ToTimer$ = () => (ZoneAndZoneDelegateAndZone__ToTimer$ = dart.constFn(dart.fnType(async.Timer, [async.Zone, async.ZoneDelegate, async.Zone, core.Duration, TimerTovoid()])))();
>+let ZoneAndZoneDelegateAndZone__Tovoid$0 = () => (ZoneAndZoneDelegateAndZone__Tovoid$0 = dart.constFn(dart.fnType(dart.void, [async.Zone, async.ZoneDelegate, async.Zone, core.String])))();
>+let ZoneAndZoneDelegateAndZone__ToZone = () => (ZoneAndZoneDelegateAndZone__ToZone = dart.constFn(dart.fnType(async.Zone, [async.Zone, async.ZoneDelegate, async.Zone, async.ZoneSpecification, core.Map])))();
>+let _ZoneFunctionOfFunction = () => (_ZoneFunctionOfFunction = dart.constFn(async._ZoneFunction$(core.Function)))();
>+let _ZoneFunctionOfZoneAndZoneDelegateAndZone__ToAsyncError = () => (_ZoneFunctionOfZoneAndZoneDelegateAndZone__ToAsyncError = dart.constFn(async._ZoneFunction$(ZoneAndZoneDelegateAndZone__ToAsyncError())))();
>+let _ZoneFunctionOfZoneAndZoneDelegateAndZone__Tovoid = () => (_ZoneFunctionOfZoneAndZoneDelegateAndZone__Tovoid = dart.constFn(async._ZoneFunction$(ZoneAndZoneDelegateAndZone__Tovoid$())))();
>+let _ZoneFunctionOfZoneAndZoneDelegateAndZone__ToTimer = () => (_ZoneFunctionOfZoneAndZoneDelegateAndZone__ToTimer = dart.constFn(async._ZoneFunction$(ZoneAndZoneDelegateAndZone__ToTimer())))();
>+let _ZoneFunctionOfZoneAndZoneDelegateAndZone__ToTimer$ = () => (_ZoneFunctionOfZoneAndZoneDelegateAndZone__ToTimer$ = dart.constFn(async._ZoneFunction$(ZoneAndZoneDelegateAndZone__ToTimer$())))();
>+let _ZoneFunctionOfZoneAndZoneDelegateAndZone__Tovoid$ = () => (_ZoneFunctionOfZoneAndZoneDelegateAndZone__Tovoid$ = dart.constFn(async._ZoneFunction$(ZoneAndZoneDelegateAndZone__Tovoid$0())))();
>+let _ZoneFunctionOfZoneAndZoneDelegateAndZone__ToZone = () => (_ZoneFunctionOfZoneAndZoneDelegateAndZone__ToZone = dart.constFn(async._ZoneFunction$(ZoneAndZoneDelegateAndZone__ToZone())))();
>+let _ZoneFunctionOfZoneAndZoneDelegateAndZone__Tovoid$0 = () => (_ZoneFunctionOfZoneAndZoneDelegateAndZone__Tovoid$0 = dart.constFn(async._ZoneFunction$(ZoneAndZoneDelegateAndZone__Tovoid())))();
>+let StringTovoid = () => (StringTovoid = dart.constFn(dart.fnType(dart.void, [core.String])))();
>+let ZoneAndZoneDelegateAndZone__Tovoid$1 = () => (ZoneAndZoneDelegateAndZone__Tovoid$1 = dart.constFn(dart.fnType(dart.void, [async.Zone, async.ZoneDelegate, async.Zone, dart.dynamic, core.StackTrace])))();
>+let ZoneAndZoneDelegateAndZone__ToNull = () => (ZoneAndZoneDelegateAndZone__ToNull = dart.constFn(dart.fnType(core.Null, [async.Zone, async.ZoneDelegate, async.Zone, core.Object, core.StackTrace])))();
>+let ObjectToint = () => (ObjectToint = dart.constFn(dart.fnType(core.int, [core.Object])))();
>+let ObjectAndObjectTobool = () => (ObjectAndObjectTobool = dart.constFn(dart.fnType(core.bool, [core.Object, core.Object])))();
>+let ComparableAndComparableToint = () => (ComparableAndComparableToint = dart.constFn(dart.fnType(core.int, [core.Comparable, core.Comparable])))();
>+let _SplayTreeMapNodeTobool = () => (_SplayTreeMapNodeTobool = dart.constFn(dart.fnType(core.bool, [collection._SplayTreeMapNode])))();
>+let MappedIterableOfString$dynamic = () => (MappedIterableOfString$dynamic = dart.constFn(_internal.MappedIterable$(core.String, dart.dynamic)))();
>+let MapOfString$dynamic = () => (MapOfString$dynamic = dart.constFn(core.Map$(core.String, dart.dynamic)))();
>+let StringAnddynamicToNull = () => (StringAnddynamicToNull = dart.constFn(dart.fnType(core.Null, [core.String, dart.dynamic])))();
>+let IdentityMapOfString$dynamic = () => (IdentityMapOfString$dynamic = dart.constFn(_js_helper.IdentityMap$(core.String, dart.dynamic)))();
>+let ComparableOfString = () => (ComparableOfString = dart.constFn(core.Comparable$(core.String)))();
>+let ObjectAndObjectTodynamic = () => (ObjectAndObjectTodynamic = dart.constFn(dart.fnType(dart.dynamic, [core.Object, core.Object])))();
>+let SinkOfObject = () => (SinkOfObject = dart.constFn(core.Sink$(core.Object)))();
>+let StringBufferToString = () => (StringBufferToString = dart.constFn(dart.fnType(core.String, [core.StringBuffer])))();
>+let StringBufferAndStringToStringBuffer = () => (StringBufferAndStringToStringBuffer = dart.constFn(dart.fnType(core.StringBuffer, [core.StringBuffer, core.String])))();
>+let StreamOfString = () => (StreamOfString = dart.constFn(async.Stream$(core.String)))();
>+let FutureOfStringBuffer = () => (FutureOfStringBuffer = dart.constFn(async.Future$(core.StringBuffer)))();
>+let FutureOfString = () => (FutureOfString = dart.constFn(async.Future$(core.String)))();
>+let IdentityMapOfString$Encoding = () => (IdentityMapOfString$Encoding = dart.constFn(_js_helper.IdentityMap$(core.String, convert.Encoding)))();
>+let SinkOfListOfint = () => (SinkOfListOfint = dart.constFn(core.Sink$(ListOfint())))();
>+let StreamOfListOfint = () => (StreamOfListOfint = dart.constFn(async.Stream$(ListOfint())))();
>+let SinkOfString = () => (SinkOfString = dart.constFn(core.Sink$(core.String)))();
>+let ListOfintTovoid = () => (ListOfintTovoid = dart.constFn(dart.fnType(dart.void, [ListOfint()])))();
>+let JSArrayOfListOfint = () => (JSArrayOfListOfint = dart.constFn(_interceptors.JSArray$(ListOfint())))();
>+let Uint8ListAndintAndintTovoid = () => (Uint8ListAndintAndintTovoid = dart.constFn(dart.fnType(dart.void, [typed_data.Uint8List, core.int, core.int])))();
>+let SyncIterableOfString = () => (SyncIterableOfString = dart.constFn(_js_helper.SyncIterable$(core.String)))();
>+let EventSinkOfString = () => (EventSinkOfString = dart.constFn(async.EventSink$(core.String)))();
>+let EventSinkOfStringTo_LineSplitterEventSink = () => (EventSinkOfStringTo_LineSplitterEventSink = dart.constFn(dart.fnType(convert._LineSplitterEventSink, [EventSinkOfString()])))();
>+let _StringSinkConversionSinkOfStringSink = () => (_StringSinkConversionSinkOfStringSink = dart.constFn(convert._StringSinkConversionSink$(core.StringSink)))();
>+let intAndintToint = () => (intAndintToint = dart.constFn(dart.fnType(core.int, [core.int, core.int])))();
>+let intToint = () => (intToint = dart.constFn(dart.fnType(core.int, [core.int])))();
>+let ComparableOfBigInt = () => (ComparableOfBigInt = dart.constFn(core.Comparable$(core.BigInt)))();
>+let StringToint = () => (StringToint = dart.constFn(dart.fnType(core.int, [core.String])))();
>+let ComparableOfDateTime = () => (ComparableOfDateTime = dart.constFn(core.Comparable$(core.DateTime)))();
>+let intToString = () => (intToString = dart.constFn(dart.fnType(core.String, [core.int])))();
>+let ComparableOfDuration = () => (ComparableOfDuration = dart.constFn(core.Comparable$(core.Duration)))();
>+let MapOfSymbol$Object = () => (MapOfSymbol$Object = dart.constFn(core.Map$(core.Symbol, core.Object)))();
>+let BidirectionalIteratorOfint = () => (BidirectionalIteratorOfint = dart.constFn(core.BidirectionalIterator$(core.int)))();
>+let MapOfString$String = () => (MapOfString$String = dart.constFn(core.Map$(core.String, core.String)))();
>+let MapOfString$StringAndStringToMapOfString$String = () => (MapOfString$StringAndStringToMapOfString$String = dart.constFn(dart.fnType(MapOfString$String(), [MapOfString$String(), core.String])))();
>+let StringAndintTovoid = () => (StringAndintTovoid = dart.constFn(dart.fnType(dart.void, [core.String, core.int])))();
>+let String__Tovoid = () => (String__Tovoid = dart.constFn(dart.fnType(dart.void, [core.String], [dart.dynamic])))();
>+let StringToNull = () => (StringToNull = dart.constFn(dart.fnType(core.Null, [core.String])))();
>+let UnmodifiableMapViewOfString$String = () => (UnmodifiableMapViewOfString$String = dart.constFn(collection.UnmodifiableMapView$(core.String, core.String)))();
>+let MapOfString$ListOfString = () => (MapOfString$ListOfString = dart.constFn(core.Map$(core.String, ListOfString())))();
>+let StringAndStringTovoid = () => (StringAndStringTovoid = dart.constFn(dart.fnType(dart.void, [core.String, core.String])))();
>+let VoidToListOfString = () => (VoidToListOfString = dart.constFn(dart.fnType(ListOfString(), [])))();
>+let intAndintAndintTovoid = () => (intAndintAndintTovoid = dart.constFn(dart.fnType(dart.void, [core.int, core.int, core.int])))();
>+let StringAndStringToNull = () => (StringAndStringToNull = dart.constFn(dart.fnType(core.Null, [core.String, core.String])))();
>+let intToUint8List = () => (intToUint8List = dart.constFn(dart.fnType(typed_data.Uint8List, [core.int])))();
>+let ListOfUint8List = () => (ListOfUint8List = dart.constFn(core.List$(typed_data.Uint8List)))();
>+let dynamicAnddynamicToUint8List = () => (dynamicAnddynamicToUint8List = dart.constFn(dart.fnType(typed_data.Uint8List, [dart.dynamic, dart.dynamic])))();
>+let Uint8ListAndStringAndintTovoid = () => (Uint8ListAndStringAndintTovoid = dart.constFn(dart.fnType(dart.void, [typed_data.Uint8List, core.String, core.int])))();
>+let FutureOfServiceExtensionResponse = () => (FutureOfServiceExtensionResponse = dart.constFn(async.Future$(developer.ServiceExtensionResponse)))();
>+let StringAndMapOfString$StringToFutureOfServiceExtensionResponse = () => (StringAndMapOfString$StringToFutureOfServiceExtensionResponse = dart.constFn(dart.fnType(FutureOfServiceExtensionResponse(), [core.String, MapOfString$String()])))();
>+let IdentityMapOfString$StringAndMapOfString$StringToFutureOfServiceExtensionResponse = () => (IdentityMapOfString$StringAndMapOfString$StringToFutureOfServiceExtensionResponse = dart.constFn(_js_helper.IdentityMap$(core.String, StringAndMapOfString$StringToFutureOfServiceExtensionResponse())))();
>+let IdentityMapOfString$Metric = () => (IdentityMapOfString$Metric = dart.constFn(_js_helper.IdentityMap$(core.String, developer.Metric)))();
>+let CompleterOfUri = () => (CompleterOfUri = dart.constFn(async.Completer$(core.Uri)))();
>+let UriTovoid = () => (UriTovoid = dart.constFn(dart.fnType(dart.void, [core.Uri])))();
>+let JSArrayOf_SyncBlock = () => (JSArrayOf_SyncBlock = dart.constFn(_interceptors.JSArray$(developer._SyncBlock)))();
>+let JSArrayOf_AsyncBlock = () => (JSArrayOf_AsyncBlock = dart.constFn(_interceptors.JSArray$(developer._AsyncBlock)))();
>+let ListOf_AsyncBlock = () => (ListOf_AsyncBlock = dart.constFn(core.List$(developer._AsyncBlock)))();
>+let JSArrayOfUint8List = () => (JSArrayOfUint8List = dart.constFn(_interceptors.JSArray$(typed_data.Uint8List)))();
>+let FutureOfDirectory = () => (FutureOfDirectory = dart.constFn(async.Future$(io.Directory)))();
>+let DirectoryToFutureOfDirectory = () => (DirectoryToFutureOfDirectory = dart.constFn(dart.fnType(FutureOfDirectory(), [io.Directory])))();
>+let FutureOrOfDirectory = () => (FutureOrOfDirectory = dart.constFn(async.FutureOr$(io.Directory)))();
>+let boolToFutureOrOfDirectory = () => (boolToFutureOrOfDirectory = dart.constFn(dart.fnType(FutureOrOfDirectory(), [core.bool])))();
>+let dynamicTo_Directory = () => (dynamicTo_Directory = dart.constFn(dart.fnType(io._Directory, [dart.dynamic])))();
>+let dynamicToDirectory = () => (dynamicToDirectory = dart.constFn(dart.fnType(io.Directory, [dart.dynamic])))();
>+let JSArrayOfFileSystemEntity = () => (JSArrayOfFileSystemEntity = dart.constFn(_interceptors.JSArray$(io.FileSystemEntity)))();
>+let FutureOrOfString = () => (FutureOrOfString = dart.constFn(async.FutureOr$(core.String)))();
>+let dynamicToFutureOrOfString = () => (dynamicToFutureOrOfString = dart.constFn(dart.fnType(FutureOrOfString(), [dart.dynamic])))();
>+let dynamicToFutureOrOfbool = () => (dynamicToFutureOrOfbool = dart.constFn(dart.fnType(FutureOrOfbool(), [dart.dynamic])))();
>+let FileSystemEntityTypeTobool = () => (FileSystemEntityTypeTobool = dart.constFn(dart.fnType(core.bool, [io.FileSystemEntityType])))();
>+let dynamicToFileSystemEntityType = () => (dynamicToFileSystemEntityType = dart.constFn(dart.fnType(io.FileSystemEntityType, [dart.dynamic])))();
>+let FutureOfFileSystemEntityType = () => (FutureOfFileSystemEntityType = dart.constFn(async.Future$(io.FileSystemEntityType)))();
>+let StreamControllerOfFileSystemEntity = () => (StreamControllerOfFileSystemEntity = dart.constFn(async.StreamController$(io.FileSystemEntity)))();
>+let StreamControllerOfListOfint = () => (StreamControllerOfListOfint = dart.constFn(async.StreamController$(ListOfint())))();
>+let ListOfintToNull = () => (ListOfintToNull = dart.constFn(dart.fnType(core.Null, [ListOfint()])))();
>+let RandomAccessFileTovoid = () => (RandomAccessFileTovoid = dart.constFn(dart.fnType(dart.void, [io.RandomAccessFile])))();
>+let dynamicAnddynamicTovoid = () => (dynamicAnddynamicTovoid = dart.constFn(dart.fnType(dart.void, [dart.dynamic, dart.dynamic])))();
>+let FutureOfRandomAccessFile = () => (FutureOfRandomAccessFile = dart.constFn(async.Future$(io.RandomAccessFile)))();
>+let CompleterOfFile = () => (CompleterOfFile = dart.constFn(async.Completer$(io.File)))();
>+let dynamic__Tovoid = () => (dynamic__Tovoid = dart.constFn(dart.fnType(dart.void, [dart.dynamic], [core.StackTrace])))();
>+let RandomAccessFileTodynamic = () => (RandomAccessFileTodynamic = dart.constFn(dart.fnType(dart.dynamic, [io.RandomAccessFile])))();
>+let RandomAccessFileToNull = () => (RandomAccessFileToNull = dart.constFn(dart.fnType(core.Null, [io.RandomAccessFile])))();
>+let voidToFile = () => (voidToFile = dart.constFn(dart.fnType(io.File, [dart.void])))();
>+let FutureOfvoid = () => (FutureOfvoid = dart.constFn(async.Future$(dart.void)))();
>+let RandomAccessFileToFutureOfvoid = () => (RandomAccessFileToFutureOfvoid = dart.constFn(dart.fnType(FutureOfvoid(), [io.RandomAccessFile])))();
>+let FutureOfFile = () => (FutureOfFile = dart.constFn(async.Future$(io.File)))();
>+let dynamicTo_File = () => (dynamicTo_File = dart.constFn(dart.fnType(io._File, [dart.dynamic])))();
>+let DirectoryToFuture = () => (DirectoryToFuture = dart.constFn(dart.fnType(async.Future, [io.Directory])))();
>+let FileSystemEntityTo_File = () => (FileSystemEntityTo_File = dart.constFn(dart.fnType(io._File, [io.FileSystemEntity])))();
>+let dynamicToFile = () => (dynamicToFile = dart.constFn(dart.fnType(io.File, [dart.dynamic])))();
>+let dynamicTo_RandomAccessFile = () => (dynamicTo_RandomAccessFile = dart.constFn(dart.fnType(io._RandomAccessFile, [dart.dynamic])))();
>+let FutureOrOfint = () => (FutureOrOfint = dart.constFn(async.FutureOr$(core.int)))();
>+let dynamicToFutureOrOfint = () => (dynamicToFutureOrOfint = dart.constFn(dart.fnType(FutureOrOfint(), [dart.dynamic])))();
>+let FutureOfint = () => (FutureOfint = dart.constFn(async.Future$(core.int)))();
>+let dynamicToDateTime = () => (dynamicToDateTime = dart.constFn(dart.fnType(core.DateTime, [dart.dynamic])))();
>+let FutureOfDateTime = () => (FutureOfDateTime = dart.constFn(async.Future$(core.DateTime)))();
>+let CompleterOfListOfint = () => (CompleterOfListOfint = dart.constFn(async.Completer$(ListOfint())))();
>+let FutureOfListOfint = () => (FutureOfListOfint = dart.constFn(async.Future$(ListOfint())))();
>+let RandomAccessFileToFutureOfListOfint = () => (RandomAccessFileToFutureOfListOfint = dart.constFn(dart.fnType(FutureOfListOfint(), [io.RandomAccessFile])))();
>+let intToFutureOfListOfint = () => (intToFutureOfListOfint = dart.constFn(dart.fnType(FutureOfListOfint(), [core.int])))();
>+let ListOfintToFutureOrOfString = () => (ListOfintToFutureOrOfString = dart.constFn(dart.fnType(FutureOrOfString(), [ListOfint()])))();
>+let FutureOfListOfString = () => (FutureOfListOfString = dart.constFn(async.Future$(ListOfString())))();
>+let RandomAccessFileTo_File = () => (RandomAccessFileTo_File = dart.constFn(dart.fnType(io._File, [io.RandomAccessFile])))();
>+let FutureOrOfFile = () => (FutureOrOfFile = dart.constFn(async.FutureOr$(io.File)))();
>+let RandomAccessFileToFutureOrOfFile = () => (RandomAccessFileToFutureOrOfFile = dart.constFn(dart.fnType(FutureOrOfFile(), [io.RandomAccessFile])))();
>+let RandomAccessFileToFutureOfFile = () => (RandomAccessFileToFutureOfFile = dart.constFn(dart.fnType(FutureOfFile(), [io.RandomAccessFile])))();
>+let dynamicAnddynamicToFutureOfServiceExtensionResponse = () => (dynamicAnddynamicToFutureOfServiceExtensionResponse = dart.constFn(dart.fnType(FutureOfServiceExtensionResponse(), [dart.dynamic, dart.dynamic])))();
>+let dynamicToListOfint = () => (dynamicToListOfint = dart.constFn(dart.fnType(ListOfint(), [dart.dynamic])))();
>+let dynamicToint = () => (dynamicToint = dart.constFn(dart.fnType(core.int, [dart.dynamic])))();
>+let dynamicToFileStat = () => (dynamicToFileStat = dart.constFn(dart.fnType(io.FileStat, [dart.dynamic])))();
>+let FutureOfFileStat = () => (FutureOfFileStat = dart.constFn(async.Future$(io.FileStat)))();
>+let _FileResourceInfoToMapOfString$dynamic = () => (_FileResourceInfoToMapOfString$dynamic = dart.constFn(dart.fnType(MapOfString$dynamic(), [io._FileResourceInfo])))();
>+let ListOfMapOfString$dynamic = () => (ListOfMapOfString$dynamic = dart.constFn(core.List$(MapOfString$dynamic())))();
>+let IdentityMapOfint$_FileResourceInfo = () => (IdentityMapOfint$_FileResourceInfo = dart.constFn(_js_helper.IdentityMap$(core.int, io._FileResourceInfo)))();
>+let _ProcessResourceInfoToMapOfString$dynamic = () => (_ProcessResourceInfoToMapOfString$dynamic = dart.constFn(dart.fnType(MapOfString$dynamic(), [io._ProcessResourceInfo])))();
>+let IdentityMapOfint$_ProcessResourceInfo = () => (IdentityMapOfint$_ProcessResourceInfo = dart.constFn(_js_helper.IdentityMap$(core.int, io._ProcessResourceInfo)))();
>+let _SocketResourceInfoToMapOfString$dynamic = () => (_SocketResourceInfoToMapOfString$dynamic = dart.constFn(dart.fnType(MapOfString$dynamic(), [io._SocketResourceInfo])))();
>+let IdentityMapOfint$_SocketResourceInfo = () => (IdentityMapOfint$_SocketResourceInfo = dart.constFn(_js_helper.IdentityMap$(core.int, io._SocketResourceInfo)))();
>+let StreamSinkOfListOfint = () => (StreamSinkOfListOfint = dart.constFn(async.StreamSink$(ListOfint())))();
>+let dynamicTo_Link = () => (dynamicTo_Link = dart.constFn(dart.fnType(io._Link, [dart.dynamic])))();
>+let FutureOfLink = () => (FutureOfLink = dart.constFn(async.Future$(io.Link)))();
>+let FileSystemEntityToFutureOfLink = () => (FileSystemEntityToFutureOfLink = dart.constFn(dart.fnType(FutureOfLink(), [io.FileSystemEntity])))();
>+let FileSystemEntityTo_Link = () => (FileSystemEntityTo_Link = dart.constFn(dart.fnType(io._Link, [io.FileSystemEntity])))();
>+let dynamicToLink = () => (dynamicToLink = dart.constFn(dart.fnType(io.Link, [dart.dynamic])))();
>+let Fn__ToR = () => (Fn__ToR = dart.constFn(dart.gFnType(R => [R, [dart.fnType(R, [])], {zoneValues: core.Map, zoneSpecification: async.ZoneSpecification, onError: core.Function}])))();
>+let StringToDirectory = () => (StringToDirectory = dart.constFn(dart.fnType(io.Directory, [core.String])))();
>+let VoidToDirectory = () => (VoidToDirectory = dart.constFn(dart.fnType(io.Directory, [])))();
>+let StringToFile = () => (StringToFile = dart.constFn(dart.fnType(io.File, [core.String])))();
>+let StringToFutureOfFileStat = () => (StringToFutureOfFileStat = dart.constFn(dart.fnType(FutureOfFileStat(), [core.String])))();
>+let StringToFileStat = () => (StringToFileStat = dart.constFn(dart.fnType(io.FileStat, [core.String])))();
>+let StringAndStringToFutureOfbool = () => (StringAndStringToFutureOfbool = dart.constFn(dart.fnType(FutureOfbool(), [core.String, core.String])))();
>+let StringAndStringTobool = () => (StringAndStringTobool = dart.constFn(dart.fnType(core.bool, [core.String, core.String])))();
>+let StringAndboolToFutureOfFileSystemEntityType = () => (StringAndboolToFutureOfFileSystemEntityType = dart.constFn(dart.fnType(FutureOfFileSystemEntityType(), [core.String, core.bool])))();
>+let StringAndboolToFileSystemEntityType = () => (StringAndboolToFileSystemEntityType = dart.constFn(dart.fnType(io.FileSystemEntityType, [core.String, core.bool])))();
>+let StreamOfFileSystemEvent = () => (StreamOfFileSystemEvent = dart.constFn(async.Stream$(io.FileSystemEvent)))();
>+let StringAndintAndboolToStreamOfFileSystemEvent = () => (StringAndintAndboolToStreamOfFileSystemEvent = dart.constFn(dart.fnType(StreamOfFileSystemEvent(), [core.String, core.int, core.bool])))();
>+let StringToLink = () => (StringToLink = dart.constFn(dart.fnType(io.Link, [core.String])))();
>+let FutureOfSocket = () => (FutureOfSocket = dart.constFn(async.Future$(io.Socket)))();
>+let dynamicAndint__ToFutureOfSocket = () => (dynamicAndint__ToFutureOfSocket = dart.constFn(dart.fnType(FutureOfSocket(), [dart.dynamic, core.int], {sourceAddress: dart.dynamic, timeout: core.Duration})))();
>+let ConnectionTaskOfSocket = () => (ConnectionTaskOfSocket = dart.constFn(io.ConnectionTask$(io.Socket)))();
>+let FutureOfConnectionTaskOfSocket = () => (FutureOfConnectionTaskOfSocket = dart.constFn(async.Future$(ConnectionTaskOfSocket())))();
>+let dynamicAndint__ToFutureOfConnectionTaskOfSocket = () => (dynamicAndint__ToFutureOfConnectionTaskOfSocket = dart.constFn(dart.fnType(FutureOfConnectionTaskOfSocket(), [dart.dynamic, core.int], {sourceAddress: dart.dynamic})))();
>+let _CaseInsensitiveStringMapOfString = () => (_CaseInsensitiveStringMapOfString = dart.constFn(io._CaseInsensitiveStringMap$(core.String)))();
>+let RawSecureServerSocketToSecureServerSocket = () => (RawSecureServerSocketToSecureServerSocket = dart.constFn(dart.fnType(io.SecureServerSocket, [io.RawSecureServerSocket])))();
>+let FutureOfSecureServerSocket = () => (FutureOfSecureServerSocket = dart.constFn(async.Future$(io.SecureServerSocket)))();
>+let RawSecureSocketToSecureSocket = () => (RawSecureSocketToSecureSocket = dart.constFn(dart.fnType(io.SecureSocket, [io.RawSecureSocket])))();
>+let FutureOfSecureSocket = () => (FutureOfSecureSocket = dart.constFn(async.Future$(io.SecureSocket)))();
>+let ConnectionTaskOfSecureSocket = () => (ConnectionTaskOfSecureSocket = dart.constFn(io.ConnectionTask$(io.SecureSocket)))();
>+let ConnectionTaskOfRawSecureSocket = () => (ConnectionTaskOfRawSecureSocket = dart.constFn(io.ConnectionTask$(io.RawSecureSocket)))();
>+let ConnectionTaskOfRawSecureSocketToConnectionTaskOfSecureSocket = () => (ConnectionTaskOfRawSecureSocketToConnectionTaskOfSecureSocket = dart.constFn(dart.fnType(ConnectionTaskOfSecureSocket(), [ConnectionTaskOfRawSecureSocket()])))();
>+let FutureOfConnectionTaskOfSecureSocket = () => (FutureOfConnectionTaskOfSecureSocket = dart.constFn(async.Future$(ConnectionTaskOfSecureSocket())))();
>+let StreamSubscriptionOfRawSocketEvent = () => (StreamSubscriptionOfRawSocketEvent = dart.constFn(async.StreamSubscription$(io.RawSocketEvent)))();
>+let FutureOfRawSecureSocket = () => (FutureOfRawSecureSocket = dart.constFn(async.Future$(io.RawSecureSocket)))();
>+let dynamicToFutureOfRawSecureSocket = () => (dynamicToFutureOfRawSecureSocket = dart.constFn(dart.fnType(FutureOfRawSecureSocket(), [dart.dynamic])))();
>+let StreamControllerOfRawSecureSocket = () => (StreamControllerOfRawSecureSocket = dart.constFn(async.StreamController$(io.RawSecureSocket)))();
>+let RawServerSocketToRawSecureServerSocket = () => (RawServerSocketToRawSecureServerSocket = dart.constFn(dart.fnType(io.RawSecureServerSocket, [io.RawServerSocket])))();
>+let FutureOfRawSecureServerSocket = () => (FutureOfRawSecureServerSocket = dart.constFn(async.Future$(io.RawSecureServerSocket)))();
>+let RawSecureSocketToNull = () => (RawSecureSocketToNull = dart.constFn(dart.fnType(core.Null, [io.RawSecureSocket])))();
>+let RawSocketToFutureOfRawSecureSocket = () => (RawSocketToFutureOfRawSecureSocket = dart.constFn(dart.fnType(FutureOfRawSecureSocket(), [io.RawSocket])))();
>+let ConnectionTaskOfRawSocket = () => (ConnectionTaskOfRawSocket = dart.constFn(io.ConnectionTask$(io.RawSocket)))();
>+let ConnectionTaskOfRawSocketToConnectionTaskOfRawSecureSocket = () => (ConnectionTaskOfRawSocketToConnectionTaskOfRawSecureSocket = dart.constFn(dart.fnType(ConnectionTaskOfRawSecureSocket(), [ConnectionTaskOfRawSocket()])))();
>+let FutureOfConnectionTaskOfRawSecureSocket = () => (FutureOfConnectionTaskOfRawSecureSocket = dart.constFn(async.Future$(ConnectionTaskOfRawSecureSocket())))();
>+let StreamSubscriptionOfRawSocket = () => (StreamSubscriptionOfRawSocket = dart.constFn(async.StreamSubscription$(io.RawSocket)))();
>+let CompleterOf_RawSecureSocket = () => (CompleterOf_RawSecureSocket = dart.constFn(async.Completer$(io._RawSecureSocket)))();
>+let CompleterOfRawSecureSocket = () => (CompleterOfRawSecureSocket = dart.constFn(async.Completer$(io.RawSecureSocket)))();
>+let StreamControllerOfRawSocketEvent = () => (StreamControllerOfRawSocketEvent = dart.constFn(async.StreamController$(io.RawSocketEvent)))();
>+let _FilterStatusToNull = () => (_FilterStatusToNull = dart.constFn(dart.fnType(core.Null, [io._FilterStatus])))();
>+let dynamicTo_FilterStatus = () => (dynamicTo_FilterStatus = dart.constFn(dart.fnType(io._FilterStatus, [dart.dynamic])))();
>+let FutureOf_FilterStatus = () => (FutureOf_FilterStatus = dart.constFn(async.Future$(io._FilterStatus)))();
>+let StreamOfRawSocketEvent = () => (StreamOfRawSocketEvent = dart.constFn(async.Stream$(io.RawSocketEvent)))();
>+let ListOfintAndStringTovoid = () => (ListOfintAndStringTovoid = dart.constFn(dart.fnType(dart.void, [ListOfint(), core.String])))();
>+let StreamOfRawSocket = () => (StreamOfRawSocket = dart.constFn(async.Stream$(io.RawSocket)))();
>+let StreamOfSocket = () => (StreamOfSocket = dart.constFn(async.Stream$(io.Socket)))();
>+let StreamConsumerOfListOfint = () => (StreamConsumerOfListOfint = dart.constFn(async.StreamConsumer$(ListOfint())))();
>+let dynamicTo_DartObject = () => (dynamicTo_DartObject = dart.constFn(dart.fnType(js._DartObject, [dart.dynamic])))();
>+let ExpandoOfFunction = () => (ExpandoOfFunction = dart.constFn(core.Expando$(core.Function)))();
>+let PointOfnum = () => (PointOfnum = dart.constFn(math.Point$(core.num)))();
>+let RectangleOfnum = () => (RectangleOfnum = dart.constFn(math.Rectangle$(core.num)))();
>+let LibraryMirrorTobool = () => (LibraryMirrorTobool = dart.constFn(dart.fnType(core.bool, [mirrors.LibraryMirror])))();
>+let ListOfdouble = () => (ListOfdouble = dart.constFn(core.List$(core.double)))();
>+let ListOfFloat32x4 = () => (ListOfFloat32x4 = dart.constFn(core.List$(typed_data.Float32x4)))();
>+let ListOfInt32x4 = () => (ListOfInt32x4 = dart.constFn(core.List$(typed_data.Int32x4)))();
>+let ListOfFloat64x2 = () => (ListOfFloat64x2 = dart.constFn(core.List$(typed_data.Float64x2)))();
>+let EventStreamProviderOfEvent = () => (EventStreamProviderOfEvent = dart.constFn(html$.EventStreamProvider$(html$.Event)))();
>+let EventStreamProviderOfVersionChangeEvent = () => (EventStreamProviderOfVersionChangeEvent = dart.constFn(html$.EventStreamProvider$(indexed_db.VersionChangeEvent)))();
>+let FutureOfDatabase = () => (FutureOfDatabase = dart.constFn(async.Future$(indexed_db.Database)))();
>+let CompleterOfIdbFactory = () => (CompleterOfIdbFactory = dart.constFn(async.Completer$(indexed_db.IdbFactory)))();
>+let EventToNull = () => (EventToNull = dart.constFn(dart.fnType(core.Null, [html$.Event])))();
>+let FutureOfIdbFactory = () => (FutureOfIdbFactory = dart.constFn(async.Future$(indexed_db.IdbFactory)))();
>+let ObserverChangesTovoid = () => (ObserverChangesTovoid = dart.constFn(dart.fnType(dart.void, [indexed_db.ObserverChanges])))();
>+let CompleterOfDatabase = () => (CompleterOfDatabase = dart.constFn(async.Completer$(indexed_db.Database)))();
>+let JSArrayOfEventTarget = () => (JSArrayOfEventTarget = dart.constFn(_interceptors.JSArray$(html$.EventTarget)))();
>+let CompleterOfMapOfString$dynamic = () => (CompleterOfMapOfString$dynamic = dart.constFn(async.Completer$(MapOfString$dynamic())))();
>+let NodeTobool = () => (NodeTobool = dart.constFn(dart.fnType(core.bool, [html$.Node])))();
>+let CompleterOfScrollState = () => (CompleterOfScrollState = dart.constFn(async.Completer$(html$.ScrollState)))();
>+let ScrollStateToNull = () => (ScrollStateToNull = dart.constFn(dart.fnType(core.Null, [html$.ScrollState])))();
>+let MapOfString$dynamicTobool = () => (MapOfString$dynamicTobool = dart.constFn(dart.fnType(core.bool, [MapOfString$dynamic()])))();
>+let Map__Todynamic = () => (Map__Todynamic = dart.constFn(dart.fnType(dart.dynamic, [core.Map], [ObjectTovoid()])))();
>+let ListOfNode = () => (ListOfNode = dart.constFn(core.List$(html$.Node)))();
>+let EventTargetToString = () => (EventTargetToString = dart.constFn(dart.fnType(core.String, [html$.EventTarget])))();
>+let _CustomEventStreamProviderOfWheelEvent = () => (_CustomEventStreamProviderOfWheelEvent = dart.constFn(html$._CustomEventStreamProvider$(html$.WheelEvent)))();
>+let _CustomEventStreamProviderOfTransitionEvent = () => (_CustomEventStreamProviderOfTransitionEvent = dart.constFn(html$._CustomEventStreamProvider$(html$.TransitionEvent)))();
>+let EventStreamProviderOfMouseEvent = () => (EventStreamProviderOfMouseEvent = dart.constFn(html$.EventStreamProvider$(html$.MouseEvent)))();
>+let EventStreamProviderOfClipboardEvent = () => (EventStreamProviderOfClipboardEvent = dart.constFn(html$.EventStreamProvider$(html$.ClipboardEvent)))();
>+let EventStreamProviderOfKeyboardEvent = () => (EventStreamProviderOfKeyboardEvent = dart.constFn(html$.EventStreamProvider$(html$.KeyboardEvent)))();
>+let EventStreamProviderOfTouchEvent = () => (EventStreamProviderOfTouchEvent = dart.constFn(html$.EventStreamProvider$(html$.TouchEvent)))();
>+let EventStreamProviderOfWheelEvent = () => (EventStreamProviderOfWheelEvent = dart.constFn(html$.EventStreamProvider$(html$.WheelEvent)))();
>+let ListOfnum = () => (ListOfnum = dart.constFn(core.List$(core.num)))();
>+let EventStreamProviderOfProgressEvent = () => (EventStreamProviderOfProgressEvent = dart.constFn(html$.EventStreamProvider$(html$.ProgressEvent)))();
>+let ListOfBackgroundFetchSettledFetch = () => (ListOfBackgroundFetchSettledFetch = dart.constFn(core.List$(html$.BackgroundFetchSettledFetch)))();
>+let ListOfDetectedBarcode = () => (ListOfDetectedBarcode = dart.constFn(core.List$(html$.DetectedBarcode)))();
>+let EventStreamProviderOfMessageEvent = () => (EventStreamProviderOfMessageEvent = dart.constFn(html$.EventStreamProvider$(html$.MessageEvent)))();
>+let EventStreamProviderOfPopStateEvent = () => (EventStreamProviderOfPopStateEvent = dart.constFn(html$.EventStreamProvider$(html$.PopStateEvent)))();
>+let EventStreamProviderOfStorageEvent = () => (EventStreamProviderOfStorageEvent = dart.constFn(html$.EventStreamProvider$(html$.StorageEvent)))();
>+let CompleterOfBlob = () => (CompleterOfBlob = dart.constFn(async.Completer$(html$.Blob)))();
>+let BlobToNull = () => (BlobToNull = dart.constFn(dart.fnType(core.Null, [html$.Blob])))();
>+let EventStreamProviderOfContextEvent = () => (EventStreamProviderOfContextEvent = dart.constFn(html$.EventStreamProvider$(web_gl.ContextEvent)))();
>+let ListOfClient = () => (ListOfClient = dart.constFn(core.List$(html$.Client)))();
>+let ListOfCssRule = () => (ListOfCssRule = dart.constFn(core.List$(html$.CssRule)))();
>+let dynamicToCssStyleDeclaration = () => (dynamicToCssStyleDeclaration = dart.constFn(dart.fnType(html$.CssStyleDeclaration, [dart.dynamic])))();
>+let IterableOfCssStyleDeclaration = () => (IterableOfCssStyleDeclaration = dart.constFn(core.Iterable$(html$.CssStyleDeclaration)))();
>+let CssStyleDeclarationTovoid = () => (CssStyleDeclarationTovoid = dart.constFn(dart.fnType(dart.void, [html$.CssStyleDeclaration])))();
>+let IterableOfElement = () => (IterableOfElement = dart.constFn(core.Iterable$(html$.Element)))();
>+let ListOfCssTransformComponent = () => (ListOfCssTransformComponent = dart.constFn(core.List$(html$.CssTransformComponent)))();
>+let ListOfFile = () => (ListOfFile = dart.constFn(core.List$(html$.File)))();
>+let CompleterOfEntry = () => (CompleterOfEntry = dart.constFn(async.Completer$(html$.Entry)))();
>+let EntryToNull = () => (EntryToNull = dart.constFn(dart.fnType(core.Null, [html$.Entry])))();
>+let DomExceptionToNull = () => (DomExceptionToNull = dart.constFn(dart.fnType(core.Null, [html$.DomException])))();
>+let CompleterOfMetadata = () => (CompleterOfMetadata = dart.constFn(async.Completer$(html$.Metadata)))();
>+let MetadataToNull = () => (MetadataToNull = dart.constFn(dart.fnType(core.Null, [html$.Metadata])))();
>+let ListOfEntry = () => (ListOfEntry = dart.constFn(core.List$(html$.Entry)))();
>+let CompleterOfListOfEntry = () => (CompleterOfListOfEntry = dart.constFn(async.Completer$(ListOfEntry())))();
>+let ListToNull = () => (ListToNull = dart.constFn(dart.fnType(core.Null, [core.List])))();
>+let ListOfStyleSheet = () => (ListOfStyleSheet = dart.constFn(core.List$(html$.StyleSheet)))();
>+let EventStreamProviderOfSecurityPolicyViolationEvent = () => (EventStreamProviderOfSecurityPolicyViolationEvent = dart.constFn(html$.EventStreamProvider$(html$.SecurityPolicyViolationEvent)))();
>+let ListOfElement = () => (ListOfElement = dart.constFn(core.List$(html$.Element)))();
>+let ListOfRectangleOfnum = () => (ListOfRectangleOfnum = dart.constFn(core.List$(RectangleOfnum())))();
>+let JavaScriptIndexingBehaviorOfRectangleOfnum = () => (JavaScriptIndexingBehaviorOfRectangleOfnum = dart.constFn(_js_helper.JavaScriptIndexingBehavior$(RectangleOfnum())))();
>+let JavaScriptIndexingBehaviorOfString = () => (JavaScriptIndexingBehaviorOfString = dart.constFn(_js_helper.JavaScriptIndexingBehavior$(core.String)))();
>+let ElementTobool = () => (ElementTobool = dart.constFn(dart.fnType(core.bool, [html$.Element])))();
>+let _EventStreamOfEvent = () => (_EventStreamOfEvent = dart.constFn(html$._EventStream$(html$.Event)))();
>+let _ElementEventStreamImplOfEvent = () => (_ElementEventStreamImplOfEvent = dart.constFn(html$._ElementEventStreamImpl$(html$.Event)))();
>+let ListOfMessagePort = () => (ListOfMessagePort = dart.constFn(core.List$(html$.MessagePort)))();
>+let ListOfDetectedFace = () => (ListOfDetectedFace = dart.constFn(core.List$(html$.DetectedFace)))();
>+let CompleterOfFileWriter = () => (CompleterOfFileWriter = dart.constFn(async.Completer$(html$.FileWriter)))();
>+let FileWriterToNull = () => (FileWriterToNull = dart.constFn(dart.fnType(core.Null, [html$.FileWriter])))();
>+let CompleterOfFile$ = () => (CompleterOfFile$ = dart.constFn(async.Completer$(html$.File)))();
>+let FileToNull = () => (FileToNull = dart.constFn(dart.fnType(core.Null, [html$.File])))();
>+let JavaScriptIndexingBehaviorOfFile = () => (JavaScriptIndexingBehaviorOfFile = dart.constFn(_js_helper.JavaScriptIndexingBehavior$(html$.File)))();
>+let EventStreamProviderOfFontFaceSetLoadEvent = () => (EventStreamProviderOfFontFaceSetLoadEvent = dart.constFn(html$.EventStreamProvider$(html$.FontFaceSetLoadEvent)))();
>+let ListOfFontFace = () => (ListOfFontFace = dart.constFn(core.List$(html$.FontFace)))();
>+let ListOfGamepadButton = () => (ListOfGamepadButton = dart.constFn(core.List$(html$.GamepadButton)))();
>+let CompleterOfGeoposition = () => (CompleterOfGeoposition = dart.constFn(async.Completer$(html$.Geoposition)))();
>+let GeopositionToNull = () => (GeopositionToNull = dart.constFn(dart.fnType(core.Null, [html$.Geoposition])))();
>+let PositionErrorToNull = () => (PositionErrorToNull = dart.constFn(dart.fnType(core.Null, [html$.PositionError])))();
>+let StreamControllerOfGeoposition = () => (StreamControllerOfGeoposition = dart.constFn(async.StreamController$(html$.Geoposition)))();
>+let GeopositionTovoid = () => (GeopositionTovoid = dart.constFn(dart.fnType(dart.void, [html$.Geoposition])))();
>+let JavaScriptIndexingBehaviorOfNode = () => (JavaScriptIndexingBehaviorOfNode = dart.constFn(_js_helper.JavaScriptIndexingBehavior$(html$.Node)))();
>+let _CustomEventStreamProviderOfEvent = () => (_CustomEventStreamProviderOfEvent = dart.constFn(html$._CustomEventStreamProvider$(html$.Event)))();
>+let HttpRequestToString = () => (HttpRequestToString = dart.constFn(dart.fnType(core.String, [html$.HttpRequest])))();
>+let CompleterOfHttpRequest = () => (CompleterOfHttpRequest = dart.constFn(async.Completer$(html$.HttpRequest)))();
>+let ProgressEventToNull = () => (ProgressEventToNull = dart.constFn(dart.fnType(core.Null, [html$.ProgressEvent])))();
>+let CompleterOfString = () => (CompleterOfString = dart.constFn(async.Completer$(core.String)))();
>+let ListAndIntersectionObserverTovoid = () => (ListAndIntersectionObserverTovoid = dart.constFn(dart.fnType(dart.void, [core.List, html$.IntersectionObserver])))();
>+let ListOfMediaDeviceInfo = () => (ListOfMediaDeviceInfo = dart.constFn(core.List$(html$.MediaDeviceInfo)))();
>+let ListOfMediaStreamTrack = () => (ListOfMediaStreamTrack = dart.constFn(core.List$(html$.MediaStreamTrack)))();
>+let EventStreamProviderOfMidiMessageEvent = () => (EventStreamProviderOfMidiMessageEvent = dart.constFn(html$.EventStreamProvider$(html$.MidiMessageEvent)))();
>+let MapTobool = () => (MapTobool = dart.constFn(dart.fnType(core.bool, [core.Map])))();
>+let StringAnddynamicTovoid = () => (StringAnddynamicTovoid = dart.constFn(dart.fnType(dart.void, [core.String, dart.dynamic])))();
>+let JSArrayOfMap = () => (JSArrayOfMap = dart.constFn(_interceptors.JSArray$(core.Map)))();
>+let ListOfMimeType = () => (ListOfMimeType = dart.constFn(core.List$(html$.MimeType)))();
>+let JavaScriptIndexingBehaviorOfMimeType = () => (JavaScriptIndexingBehaviorOfMimeType = dart.constFn(_js_helper.JavaScriptIndexingBehavior$(html$.MimeType)))();
>+let ListAndMutationObserverTovoid = () => (ListAndMutationObserverTovoid = dart.constFn(dart.fnType(dart.void, [core.List, html$.MutationObserver])))();
>+let CompleterOfMediaStream = () => (CompleterOfMediaStream = dart.constFn(async.Completer$(html$.MediaStream)))();
>+let MediaStreamToNull = () => (MediaStreamToNull = dart.constFn(dart.fnType(core.Null, [html$.MediaStream])))();
>+let NavigatorUserMediaErrorToNull = () => (NavigatorUserMediaErrorToNull = dart.constFn(dart.fnType(core.Null, [html$.NavigatorUserMediaError])))();
>+let IterableOfNode = () => (IterableOfNode = dart.constFn(core.Iterable$(html$.Node)))();
>+let ListOfTaskAttributionTiming = () => (ListOfTaskAttributionTiming = dart.constFn(core.List$(html$.TaskAttributionTiming)))();
>+let ListOfPerformanceServerTiming = () => (ListOfPerformanceServerTiming = dart.constFn(core.List$(html$.PerformanceServerTiming)))();
>+let PerformanceObserverEntryListAndPerformanceObserverTovoid = () => (PerformanceObserverEntryListAndPerformanceObserverTovoid = dart.constFn(dart.fnType(dart.void, [html$.PerformanceObserverEntryList, html$.PerformanceObserver])))();
>+let JavaScriptIndexingBehaviorOfPlugin = () => (JavaScriptIndexingBehaviorOfPlugin = dart.constFn(_js_helper.JavaScriptIndexingBehavior$(html$.Plugin)))();
>+let ListOfPlugin = () => (ListOfPlugin = dart.constFn(core.List$(html$.Plugin)))();
>+let ListOfPresentationConnection = () => (ListOfPresentationConnection = dart.constFn(core.List$(html$.PresentationConnection)))();
>+let ListAndReportingObserverTovoid = () => (ListAndReportingObserverTovoid = dart.constFn(dart.fnType(dart.void, [core.List, html$.ReportingObserver])))();
>+let ListOfResizeObserverEntry = () => (ListOfResizeObserverEntry = dart.constFn(core.List$(html$.ResizeObserverEntry)))();
>+let ListOfResizeObserverEntryAndResizeObserverTovoid = () => (ListOfResizeObserverEntryAndResizeObserverTovoid = dart.constFn(dart.fnType(dart.void, [ListOfResizeObserverEntry(), html$.ResizeObserver])))();
>+let EventStreamProviderOfRtcDtmfToneChangeEvent = () => (EventStreamProviderOfRtcDtmfToneChangeEvent = dart.constFn(html$.EventStreamProvider$(html$.RtcDtmfToneChangeEvent)))();
>+let JSArrayOfMapOfString$String = () => (JSArrayOfMapOfString$String = dart.constFn(_interceptors.JSArray$(MapOfString$String())))();
>+let CompleterOfRtcStatsResponse = () => (CompleterOfRtcStatsResponse = dart.constFn(async.Completer$(html$.RtcStatsResponse)))();
>+let RtcStatsResponseToNull = () => (RtcStatsResponseToNull = dart.constFn(dart.fnType(core.Null, [html$.RtcStatsResponse])))();
>+let EventStreamProviderOfMediaStreamEvent = () => (EventStreamProviderOfMediaStreamEvent = dart.constFn(html$.EventStreamProvider$(html$.MediaStreamEvent)))();
>+let EventStreamProviderOfRtcDataChannelEvent = () => (EventStreamProviderOfRtcDataChannelEvent = dart.constFn(html$.EventStreamProvider$(html$.RtcDataChannelEvent)))();
>+let EventStreamProviderOfRtcPeerConnectionIceEvent = () => (EventStreamProviderOfRtcPeerConnectionIceEvent = dart.constFn(html$.EventStreamProvider$(html$.RtcPeerConnectionIceEvent)))();
>+let ListOfMediaStream = () => (ListOfMediaStream = dart.constFn(core.List$(html$.MediaStream)))();
>+let IterableOfOptionElement = () => (IterableOfOptionElement = dart.constFn(core.Iterable$(html$.OptionElement)))();
>+let UnmodifiableListViewOfOptionElement = () => (UnmodifiableListViewOfOptionElement = dart.constFn(collection.UnmodifiableListView$(html$.OptionElement)))();
>+let OptionElementTobool = () => (OptionElementTobool = dart.constFn(dart.fnType(core.bool, [html$.OptionElement])))();
>+let JSArrayOfOptionElement = () => (JSArrayOfOptionElement = dart.constFn(_interceptors.JSArray$(html$.OptionElement)))();
>+let ListOfServiceWorkerRegistration = () => (ListOfServiceWorkerRegistration = dart.constFn(core.List$(html$.ServiceWorkerRegistration)))();
>+let EventStreamProviderOfForeignFetchEvent = () => (EventStreamProviderOfForeignFetchEvent = dart.constFn(html$.EventStreamProvider$(html$.ForeignFetchEvent)))();
>+let ListOfNotification = () => (ListOfNotification = dart.constFn(core.List$(html$.Notification)))();
>+let JavaScriptIndexingBehaviorOfSourceBuffer = () => (JavaScriptIndexingBehaviorOfSourceBuffer = dart.constFn(_js_helper.JavaScriptIndexingBehavior$(html$.SourceBuffer)))();
>+let ListOfSourceBuffer = () => (ListOfSourceBuffer = dart.constFn(core.List$(html$.SourceBuffer)))();
>+let JavaScriptIndexingBehaviorOfSpeechGrammar = () => (JavaScriptIndexingBehaviorOfSpeechGrammar = dart.constFn(_js_helper.JavaScriptIndexingBehavior$(html$.SpeechGrammar)))();
>+let ListOfSpeechGrammar = () => (ListOfSpeechGrammar = dart.constFn(core.List$(html$.SpeechGrammar)))();
>+let EventStreamProviderOfSpeechRecognitionError = () => (EventStreamProviderOfSpeechRecognitionError = dart.constFn(html$.EventStreamProvider$(html$.SpeechRecognitionError)))();
>+let EventStreamProviderOfSpeechRecognitionEvent = () => (EventStreamProviderOfSpeechRecognitionEvent = dart.constFn(html$.EventStreamProvider$(html$.SpeechRecognitionEvent)))();
>+let ListOfSpeechRecognitionResult = () => (ListOfSpeechRecognitionResult = dart.constFn(core.List$(html$.SpeechRecognitionResult)))();
>+let EventStreamProviderOfSpeechSynthesisEvent = () => (EventStreamProviderOfSpeechSynthesisEvent = dart.constFn(html$.EventStreamProvider$(html$.SpeechSynthesisEvent)))();
>+let _WrappedListOfTableSectionElement = () => (_WrappedListOfTableSectionElement = dart.constFn(html$._WrappedList$(html$.TableSectionElement)))();
>+let _WrappedListOfTableRowElement = () => (_WrappedListOfTableRowElement = dart.constFn(html$._WrappedList$(html$.TableRowElement)))();
>+let _WrappedListOfTableCellElement = () => (_WrappedListOfTableCellElement = dart.constFn(html$._WrappedList$(html$.TableCellElement)))();
>+let ListOfDetectedText = () => (ListOfDetectedText = dart.constFn(core.List$(html$.DetectedText)))();
>+let ListOfTextTrackCue = () => (ListOfTextTrackCue = dart.constFn(core.List$(html$.TextTrackCue)))();
>+let JavaScriptIndexingBehaviorOfTextTrackCue = () => (JavaScriptIndexingBehaviorOfTextTrackCue = dart.constFn(_js_helper.JavaScriptIndexingBehavior$(html$.TextTrackCue)))();
>+let ListOfTextTrack = () => (ListOfTextTrack = dart.constFn(core.List$(html$.TextTrack)))();
>+let JavaScriptIndexingBehaviorOfTextTrack = () => (JavaScriptIndexingBehaviorOfTextTrack = dart.constFn(_js_helper.JavaScriptIndexingBehavior$(html$.TextTrack)))();
>+let EventStreamProviderOfTrackEvent = () => (EventStreamProviderOfTrackEvent = dart.constFn(html$.EventStreamProvider$(html$.TrackEvent)))();
>+let JavaScriptIndexingBehaviorOfTouch = () => (JavaScriptIndexingBehaviorOfTouch = dart.constFn(_js_helper.JavaScriptIndexingBehavior$(html$.Touch)))();
>+let ListOfTouch = () => (ListOfTouch = dart.constFn(core.List$(html$.Touch)))();
>+let ListOfVRStageBoundsPoint = () => (ListOfVRStageBoundsPoint = dart.constFn(core.List$(html$.VRStageBoundsPoint)))();
>+let EventStreamProviderOfCloseEvent = () => (EventStreamProviderOfCloseEvent = dart.constFn(html$.EventStreamProvider$(html$.CloseEvent)))();
>+let CompleterOfnum = () => (CompleterOfnum = dart.constFn(async.Completer$(core.num)))();
>+let numToNull = () => (numToNull = dart.constFn(dart.fnType(core.Null, [core.num])))();
>+let IdleDeadlineTovoid = () => (IdleDeadlineTovoid = dart.constFn(dart.fnType(dart.void, [html$.IdleDeadline])))();
>+let CompleterOfFileSystem = () => (CompleterOfFileSystem = dart.constFn(async.Completer$(html$.FileSystem)))();
>+let FileSystemToNull = () => (FileSystemToNull = dart.constFn(dart.fnType(core.Null, [html$.FileSystem])))();
>+let EventStreamProviderOfDeviceMotionEvent = () => (EventStreamProviderOfDeviceMotionEvent = dart.constFn(html$.EventStreamProvider$(html$.DeviceMotionEvent)))();
>+let EventStreamProviderOfDeviceOrientationEvent = () => (EventStreamProviderOfDeviceOrientationEvent = dart.constFn(html$.EventStreamProvider$(html$.DeviceOrientationEvent)))();
>+let EventStreamProviderOfAnimationEvent = () => (EventStreamProviderOfAnimationEvent = dart.constFn(html$.EventStreamProvider$(html$.AnimationEvent)))();
>+let _EventStreamOfBeforeUnloadEvent = () => (_EventStreamOfBeforeUnloadEvent = dart.constFn(html$._EventStream$(html$.BeforeUnloadEvent)))();
>+let StreamControllerOfBeforeUnloadEvent = () => (StreamControllerOfBeforeUnloadEvent = dart.constFn(async.StreamController$(html$.BeforeUnloadEvent)))();
>+let BeforeUnloadEventToNull = () => (BeforeUnloadEventToNull = dart.constFn(dart.fnType(core.Null, [html$.BeforeUnloadEvent])))();
>+let _ElementEventStreamImplOfBeforeUnloadEvent = () => (_ElementEventStreamImplOfBeforeUnloadEvent = dart.constFn(html$._ElementEventStreamImpl$(html$.BeforeUnloadEvent)))();
>+let _ElementListEventStreamImplOfBeforeUnloadEvent = () => (_ElementListEventStreamImplOfBeforeUnloadEvent = dart.constFn(html$._ElementListEventStreamImpl$(html$.BeforeUnloadEvent)))();
>+let EventStreamProviderOfBeforeUnloadEvent = () => (EventStreamProviderOfBeforeUnloadEvent = dart.constFn(html$.EventStreamProvider$(html$.BeforeUnloadEvent)))();
>+let JavaScriptIndexingBehaviorOfCssRule = () => (JavaScriptIndexingBehaviorOfCssRule = dart.constFn(_js_helper.JavaScriptIndexingBehavior$(html$.CssRule)))();
>+let ListOfGamepad = () => (ListOfGamepad = dart.constFn(core.List$(html$.Gamepad)))();
>+let JavaScriptIndexingBehaviorOfGamepad = () => (JavaScriptIndexingBehaviorOfGamepad = dart.constFn(_js_helper.JavaScriptIndexingBehavior$(html$.Gamepad)))();
>+let JavaScriptIndexingBehaviorOfSpeechRecognitionResult = () => (JavaScriptIndexingBehaviorOfSpeechRecognitionResult = dart.constFn(_js_helper.JavaScriptIndexingBehavior$(html$.SpeechRecognitionResult)))();
>+let JavaScriptIndexingBehaviorOfStyleSheet = () => (JavaScriptIndexingBehaviorOfStyleSheet = dart.constFn(_js_helper.JavaScriptIndexingBehavior$(html$.StyleSheet)))();
>+let SetOfString = () => (SetOfString = dart.constFn(core.Set$(core.String)))();
>+let ElementTodynamic = () => (ElementTodynamic = dart.constFn(dart.fnType(dart.dynamic, [html$.Element])))();
>+let ElementToCssClassSet = () => (ElementToCssClassSet = dart.constFn(dart.fnType(html$.CssClassSet, [html$.Element])))();
>+let ListOfCssClassSetImpl = () => (ListOfCssClassSetImpl = dart.constFn(core.List$(html_common.CssClassSetImpl)))();
>+let _IdentityHashSetOfString = () => (_IdentityHashSetOfString = dart.constFn(collection._IdentityHashSet$(core.String)))();
>+let CssClassSetImplTovoid = () => (CssClassSetImplTovoid = dart.constFn(dart.fnType(dart.void, [html_common.CssClassSetImpl])))();
>+let CssClassSetImplTodynamic = () => (CssClassSetImplTodynamic = dart.constFn(dart.fnType(dart.dynamic, [html_common.CssClassSetImpl])))();
>+let boolAndCssClassSetImplTobool = () => (boolAndCssClassSetImplTobool = dart.constFn(dart.fnType(core.bool, [core.bool, html_common.CssClassSetImpl])))();
>+let StringAndStringToString = () => (StringAndStringToString = dart.constFn(dart.fnType(core.String, [core.String, core.String])))();
>+let SetOfStringTobool = () => (SetOfStringTobool = dart.constFn(dart.fnType(core.bool, [SetOfString()])))();
>+let SetOfStringTovoid = () => (SetOfStringTovoid = dart.constFn(dart.fnType(dart.void, [SetOfString()])))();
>+let EventTodynamic = () => (EventTodynamic = dart.constFn(dart.fnType(dart.dynamic, [html$.Event])))();
>+let EventTovoid = () => (EventTovoid = dart.constFn(dart.fnType(dart.void, [html$.Event])))();
>+let CustomStreamOfKeyEvent = () => (CustomStreamOfKeyEvent = dart.constFn(html$.CustomStream$(html$.KeyEvent)))();
>+let ElementAndStringAndString__Tobool = () => (ElementAndStringAndString__Tobool = dart.constFn(dart.fnType(core.bool, [html$.Element, core.String, core.String, html$._Html5NodeValidator])))();
>+let IdentityMapOfString$Function = () => (IdentityMapOfString$Function = dart.constFn(_js_helper.IdentityMap$(core.String, core.Function)))();
>+let JSArrayOfKeyEvent = () => (JSArrayOfKeyEvent = dart.constFn(_interceptors.JSArray$(html$.KeyEvent)))();
>+let KeyEventTobool = () => (KeyEventTobool = dart.constFn(dart.fnType(core.bool, [html$.KeyEvent])))();
>+let ListOfKeyEvent = () => (ListOfKeyEvent = dart.constFn(core.List$(html$.KeyEvent)))();
>+let JSArrayOfNodeValidator = () => (JSArrayOfNodeValidator = dart.constFn(_interceptors.JSArray$(html$.NodeValidator)))();
>+let NodeValidatorTobool = () => (NodeValidatorTobool = dart.constFn(dart.fnType(core.bool, [html$.NodeValidator])))();
>+let ListOfNodeValidator = () => (ListOfNodeValidator = dart.constFn(core.List$(html$.NodeValidator)))();
>+let NodeAndNodeToint = () => (NodeAndNodeToint = dart.constFn(dart.fnType(core.int, [html$.Node, html$.Node])))();
>+let IteratorOfNode = () => (IteratorOfNode = dart.constFn(core.Iterator$(html$.Node)))();
>+let NodeAndNodeTovoid = () => (NodeAndNodeTovoid = dart.constFn(dart.fnType(dart.void, [html$.Node, html$.Node])))();
>+let dynamicAnddynamicTodynamic = () => (dynamicAnddynamicTodynamic = dart.constFn(dart.fnType(dart.dynamic, [dart.dynamic, dart.dynamic])))();
>+let NodeToElement = () => (NodeToElement = dart.constFn(dart.fnType(html$.Element, [html$.Node])))();
>+let ListOfLength = () => (ListOfLength = dart.constFn(core.List$(svg$.Length)))();
>+let ListOfNumber = () => (ListOfNumber = dart.constFn(core.List$(svg$.Number)))();
>+let ListOfTransform = () => (ListOfTransform = dart.constFn(core.List$(svg$.Transform)))();
>+let FutureOfAudioBuffer = () => (FutureOfAudioBuffer = dart.constFn(async.Future$(web_audio.AudioBuffer)))();
>+let CompleterOfAudioBuffer = () => (CompleterOfAudioBuffer = dart.constFn(async.Completer$(web_audio.AudioBuffer)))();
>+let AudioBufferToNull = () => (AudioBufferToNull = dart.constFn(dart.fnType(core.Null, [web_audio.AudioBuffer])))();
>+let EventStreamProviderOfAudioProcessingEvent = () => (EventStreamProviderOfAudioProcessingEvent = dart.constFn(html$.EventStreamProvider$(web_audio.AudioProcessingEvent)))();
>+let CompleterOfSqlTransaction = () => (CompleterOfSqlTransaction = dart.constFn(async.Completer$(web_sql.SqlTransaction)))();
>+let SqlTransactionToNull = () => (SqlTransactionToNull = dart.constFn(dart.fnType(core.Null, [web_sql.SqlTransaction])))();
>+let SqlErrorToNull = () => (SqlErrorToNull = dart.constFn(dart.fnType(core.Null, [web_sql.SqlError])))();
>+let ListOfMap = () => (ListOfMap = dart.constFn(core.List$(core.Map)))();
>+let CompleterOfSqlResultSet = () => (CompleterOfSqlResultSet = dart.constFn(async.Completer$(web_sql.SqlResultSet)))();
>+let SqlTransactionAndSqlResultSetToNull = () => (SqlTransactionAndSqlResultSetToNull = dart.constFn(dart.fnType(core.Null, [web_sql.SqlTransaction, web_sql.SqlResultSet])))();
>+let SqlTransactionAndSqlErrorToNull = () => (SqlTransactionAndSqlErrorToNull = dart.constFn(dart.fnType(core.Null, [web_sql.SqlTransaction, web_sql.SqlError])))();
>+let StreamOfHttpRequest = () => (StreamOfHttpRequest = dart.constFn(async.Stream$(_http.HttpRequest)))();
>+let ListOfRedirectInfo = () => (ListOfRedirectInfo = dart.constFn(core.List$(_http.RedirectInfo)))();
>+let StringAndListOfStringToListOfString = () => (StringAndListOfStringToListOfString = dart.constFn(dart.fnType(ListOfString(), [core.String, ListOfString()])))();
>+let StringAndListOfStringToNull = () => (StringAndListOfStringToNull = dart.constFn(dart.fnType(core.Null, [core.String, ListOfString()])))();
>+let JSArrayOfCookie = () => (JSArrayOfCookie = dart.constFn(_interceptors.JSArray$(_http.Cookie)))();
>+let ListOfCookie = () => (ListOfCookie = dart.constFn(core.List$(_http.Cookie)))();
>+let CookieToString = () => (CookieToString = dart.constFn(dart.fnType(core.String, [_http.Cookie])))();
>+let CookieTobool = () => (CookieTobool = dart.constFn(dart.fnType(core.bool, [_http.Cookie])))();
>+let FutureOfHttpClientResponse = () => (FutureOfHttpClientResponse = dart.constFn(async.Future$(_http.HttpClientResponse)))();
>+let _HttpClientRequestToFutureOfHttpClientResponse = () => (_HttpClientRequestToFutureOfHttpClientResponse = dart.constFn(dart.fnType(FutureOfHttpClientResponse(), [_http._HttpClientRequest])))();
>+let dynamicToFutureOfHttpClientResponse = () => (dynamicToFutureOfHttpClientResponse = dart.constFn(dart.fnType(FutureOfHttpClientResponse(), [dart.dynamic])))();
>+let VoidToFutureOfHttpClientResponse = () => (VoidToFutureOfHttpClientResponse = dart.constFn(dart.fnType(FutureOfHttpClientResponse(), [])))();
>+let _AuthenticationSchemeTo_Credentials = () => (_AuthenticationSchemeTo_Credentials = dart.constFn(dart.fnType(_http._Credentials, [_http._AuthenticationScheme])))();
>+let _CredentialsTovoid = () => (_CredentialsTovoid = dart.constFn(dart.fnType(dart.void, [_http._Credentials])))();
>+let _AuthenticationSchemeAndStringToFuture = () => (_AuthenticationSchemeAndStringToFuture = dart.constFn(dart.fnType(async.Future, [_http._AuthenticationScheme, core.String])))();
>+let FutureOrOfHttpClientResponse = () => (FutureOrOfHttpClientResponse = dart.constFn(async.FutureOr$(_http.HttpClientResponse)))();
>+let dynamicToFutureOrOfHttpClientResponse = () => (dynamicToFutureOrOfHttpClientResponse = dart.constFn(dart.fnType(FutureOrOfHttpClientResponse(), [dart.dynamic])))();
>+let CookieToNull = () => (CookieToNull = dart.constFn(dart.fnType(core.Null, [_http.Cookie])))();
>+let CompleterOfHttpClientResponse = () => (CompleterOfHttpClientResponse = dart.constFn(async.Completer$(_http.HttpClientResponse)))();
>+let JSArrayOfRedirectInfo = () => (JSArrayOfRedirectInfo = dart.constFn(_interceptors.JSArray$(_http.RedirectInfo)))();
>+let ListToFutureOrOfHttpClientResponse = () => (ListToFutureOrOfHttpClientResponse = dart.constFn(dart.fnType(FutureOrOfHttpClientResponse(), [core.List])))();
>+let JSArrayOfFuture = () => (JSArrayOfFuture = dart.constFn(_interceptors.JSArray$(async.Future)))();
>+let HttpClientResponseTovoid = () => (HttpClientResponseTovoid = dart.constFn(dart.fnType(dart.void, [_http.HttpClientResponse])))();
>+let CompleterOfSocket = () => (CompleterOfSocket = dart.constFn(async.Completer$(io.Socket)))();
>+let dynamicToIterable = () => (dynamicToIterable = dart.constFn(dart.fnType(core.Iterable, [dart.dynamic])))();
>+let dynamicTo_HttpOutboundMessage = () => (dynamicTo_HttpOutboundMessage = dart.constFn(dart.fnType(_http._HttpOutboundMessage, [dart.dynamic])))();
>+let dynamicAnddynamicTo_HttpOutboundMessage = () => (dynamicAnddynamicTo_HttpOutboundMessage = dart.constFn(dart.fnType(_http._HttpOutboundMessage, [dart.dynamic, dart.dynamic])))();
>+let _HttpIncomingToNull = () => (_HttpIncomingToNull = dart.constFn(dart.fnType(core.Null, [_http._HttpIncoming])))();
>+let CompleterOf_HttpIncoming = () => (CompleterOf_HttpIncoming = dart.constFn(async.Completer$(_http._HttpIncoming)))();
>+let SocketToSocket = () => (SocketToSocket = dart.constFn(dart.fnType(io.Socket, [io.Socket])))();
>+let SocketTo_DetachedSocket = () => (SocketTo_DetachedSocket = dart.constFn(dart.fnType(_http._DetachedSocket, [io.Socket])))();
>+let SocketTovoid = () => (SocketTovoid = dart.constFn(dart.fnType(dart.void, [io.Socket])))();
>+let SecureSocketTo_HttpClientConnection = () => (SecureSocketTo_HttpClientConnection = dart.constFn(dart.fnType(_http._HttpClientConnection, [io.SecureSocket])))();
>+let HttpClientResponseToFutureOfSecureSocket = () => (HttpClientResponseToFutureOfSecureSocket = dart.constFn(dart.fnType(FutureOfSecureSocket(), [_http.HttpClientResponse])))();
>+let FutureOf_HttpClientConnection = () => (FutureOf_HttpClientConnection = dart.constFn(async.Future$(_http._HttpClientConnection)))();
>+let _HashSetOf_HttpClientConnection = () => (_HashSetOf_HttpClientConnection = dart.constFn(collection._HashSet$(_http._HttpClientConnection)))();
>+let _HashSetOfConnectionTask = () => (_HashSetOfConnectionTask = dart.constFn(collection._HashSet$(io.ConnectionTask)))();
>+let FutureOf_ConnectionInfo = () => (FutureOf_ConnectionInfo = dart.constFn(async.Future$(_http._ConnectionInfo)))();
>+let CompleterOf_ConnectionInfo = () => (CompleterOf_ConnectionInfo = dart.constFn(async.Completer$(_http._ConnectionInfo)))();
>+let X509CertificateTobool = () => (X509CertificateTobool = dart.constFn(dart.fnType(core.bool, [io.X509Certificate])))();
>+let _HttpClientConnectionTo_ConnectionInfo = () => (_HttpClientConnectionTo_ConnectionInfo = dart.constFn(dart.fnType(_http._ConnectionInfo, [_http._HttpClientConnection])))();
>+let FutureOrOf_ConnectionInfo = () => (FutureOrOf_ConnectionInfo = dart.constFn(async.FutureOr$(_http._ConnectionInfo)))();
>+let dynamicToFutureOrOf_ConnectionInfo = () => (dynamicToFutureOrOf_ConnectionInfo = dart.constFn(dart.fnType(FutureOrOf_ConnectionInfo(), [dart.dynamic])))();
>+let ConnectionTaskToFutureOf_ConnectionInfo = () => (ConnectionTaskToFutureOf_ConnectionInfo = dart.constFn(dart.fnType(FutureOf_ConnectionInfo(), [io.ConnectionTask])))();
>+let SetOf_HttpClientConnection = () => (SetOf_HttpClientConnection = dart.constFn(core.Set$(_http._HttpClientConnection)))();
>+let SetOfConnectionTask = () => (SetOfConnectionTask = dart.constFn(core.Set$(io.ConnectionTask)))();
>+let IdentityMapOfString$_ConnectionTarget = () => (IdentityMapOfString$_ConnectionTarget = dart.constFn(_js_helper.IdentityMap$(core.String, _http._ConnectionTarget)))();
>+let JSArrayOf_Credentials = () => (JSArrayOf_Credentials = dart.constFn(_interceptors.JSArray$(_http._Credentials)))();
>+let JSArrayOf_ProxyCredentials = () => (JSArrayOf_ProxyCredentials = dart.constFn(_interceptors.JSArray$(_http._ProxyCredentials)))();
>+let Uri__ToString = () => (Uri__ToString = dart.constFn(dart.fnType(core.String, [core.Uri], {environment: MapOfString$String()})))();
>+let _ConnectionTargetTobool = () => (_ConnectionTargetTobool = dart.constFn(dart.fnType(core.bool, [_http._ConnectionTarget])))();
>+let FutureOf_HttpClientRequest = () => (FutureOf_HttpClientRequest = dart.constFn(async.Future$(_http._HttpClientRequest)))();
>+let _ConnectionInfoTo_HttpClientRequest = () => (_ConnectionInfoTo_HttpClientRequest = dart.constFn(dart.fnType(_http._HttpClientRequest, [_http._ConnectionInfo])))();
>+let FutureOrOf_HttpClientRequest = () => (FutureOrOf_HttpClientRequest = dart.constFn(async.FutureOr$(_http._HttpClientRequest)))();
>+let _ConnectionInfoToFutureOrOf_HttpClientRequest = () => (_ConnectionInfoToFutureOrOf_HttpClientRequest = dart.constFn(dart.fnType(FutureOrOf_HttpClientRequest(), [_http._ConnectionInfo])))();
>+let _HttpClientRequestTo_HttpClientRequest = () => (_HttpClientRequestTo_HttpClientRequest = dart.constFn(dart.fnType(_http._HttpClientRequest, [_http._HttpClientRequest])))();
>+let VoidTo_ConnectionTarget = () => (VoidTo_ConnectionTarget = dart.constFn(dart.fnType(_http._ConnectionTarget, [])))();
>+let dynamicToFutureOf_ConnectionInfo = () => (dynamicToFutureOf_ConnectionInfo = dart.constFn(dart.fnType(FutureOf_ConnectionInfo(), [dart.dynamic])))();
>+let _SiteCredentialsAnd_CredentialsTo_SiteCredentials = () => (_SiteCredentialsAnd_CredentialsTo_SiteCredentials = dart.constFn(dart.fnType(_http._SiteCredentials, [_http._SiteCredentials, _http._Credentials])))();
>+let MapOfString$_ConnectionTarget = () => (MapOfString$_ConnectionTarget = dart.constFn(core.Map$(core.String, _http._ConnectionTarget)))();
>+let ListOf_Credentials = () => (ListOf_Credentials = dart.constFn(core.List$(_http._Credentials)))();
>+let ListOf_ProxyCredentials = () => (ListOf_ProxyCredentials = dart.constFn(core.List$(_http._ProxyCredentials)))();
>+let X509CertificateAndStringAndintTobool = () => (X509CertificateAndStringAndintTobool = dart.constFn(dart.fnType(core.bool, [io.X509Certificate, core.String, core.int])))();
>+let SocketToNull = () => (SocketToNull = dart.constFn(dart.fnType(core.Null, [io.Socket])))();
>+let dynamicTo_DetachedSocket = () => (dynamicTo_DetachedSocket = dart.constFn(dart.fnType(_http._DetachedSocket, [dart.dynamic])))();
>+let IdentityMapOfint$_HttpConnection = () => (IdentityMapOfint$_HttpConnection = dart.constFn(_js_helper.IdentityMap$(core.int, _http._HttpConnection)))();
>+let LinkedListOf_HttpConnection = () => (LinkedListOf_HttpConnection = dart.constFn(collection.LinkedList$(_http._HttpConnection)))();
>+let StreamControllerOfHttpRequest = () => (StreamControllerOfHttpRequest = dart.constFn(async.StreamController$(_http.HttpRequest)))();
>+let ServerSocketTo_HttpServer = () => (ServerSocketTo_HttpServer = dart.constFn(dart.fnType(_http._HttpServer, [io.ServerSocket])))();
>+let FutureOfHttpServer = () => (FutureOfHttpServer = dart.constFn(async.Future$(_http.HttpServer)))();
>+let SecureServerSocketTo_HttpServer = () => (SecureServerSocketTo_HttpServer = dart.constFn(dart.fnType(_http._HttpServer, [io.SecureServerSocket])))();
>+let _HttpConnectionToNull = () => (_HttpConnectionToNull = dart.constFn(dart.fnType(core.Null, [_http._HttpConnection])))();
>+let _HttpConnectionToMap = () => (_HttpConnectionToMap = dart.constFn(dart.fnType(core.Map, [_http._HttpConnection])))();
>+let IterableOfMap = () => (IterableOfMap = dart.constFn(core.Iterable$(core.Map)))();
>+let IdentityMapOfint$_HttpServer = () => (IdentityMapOfint$_HttpServer = dart.constFn(_js_helper.IdentityMap$(core.int, _http._HttpServer)))();
>+let JSArrayOf_Proxy = () => (JSArrayOf_Proxy = dart.constFn(_interceptors.JSArray$(_http._Proxy)))();
>+let ListOf_Proxy = () => (ListOf_Proxy = dart.constFn(core.List$(_http._Proxy)))();
>+let StreamSubscriptionOfListOfint = () => (StreamSubscriptionOfListOfint = dart.constFn(async.StreamSubscription$(ListOfint())))();
>+let StreamControllerOf_HttpIncoming = () => (StreamControllerOf_HttpIncoming = dart.constFn(async.StreamController$(_http._HttpIncoming)))();
>+let IdentityMapOfString$_HttpSession = () => (IdentityMapOfString$_HttpSession = dart.constFn(_js_helper.IdentityMap$(core.String, _http._HttpSession)))();
>+let MapOfString$_HttpSession = () => (MapOfString$_HttpSession = dart.constFn(core.Map$(core.String, _http._HttpSession)))();
>+let SecurityContextToHttpClient = () => (SecurityContextToHttpClient = dart.constFn(dart.fnType(_http.HttpClient, [io.SecurityContext])))();
>+let UriAndMapOfString$StringToString = () => (UriAndMapOfString$StringToString = dart.constFn(dart.fnType(core.String, [core.Uri, MapOfString$String()])))();
>+let StreamTransformerOfHttpRequest$WebSocket = () => (StreamTransformerOfHttpRequest$WebSocket = dart.constFn(async.StreamTransformer$(_http.HttpRequest, _http.WebSocket)))();
>+let EventSinkTo_WebSocketProtocolTransformer = () => (EventSinkTo_WebSocketProtocolTransformer = dart.constFn(dart.fnType(_http._WebSocketProtocolTransformer, [async.EventSink])))();
>+let EventSinkOfListOfint = () => (EventSinkOfListOfint = dart.constFn(async.EventSink$(ListOfint())))();
>+let StreamControllerOfWebSocket = () => (StreamControllerOfWebSocket = dart.constFn(async.StreamController$(_http.WebSocket)))();
>+let WebSocketTovoid = () => (WebSocketTovoid = dart.constFn(dart.fnType(dart.void, [_http.WebSocket])))();
>+let HttpRequestToNull = () => (HttpRequestToNull = dart.constFn(dart.fnType(core.Null, [_http.HttpRequest])))();
>+let FutureOfWebSocket = () => (FutureOfWebSocket = dart.constFn(async.Future$(_http.WebSocket)))();
>+let SocketTo_WebSocketImpl = () => (SocketTo_WebSocketImpl = dart.constFn(dart.fnType(_http._WebSocketImpl, [io.Socket])))();
>+let StringToFutureOfWebSocket = () => (StringToFutureOfWebSocket = dart.constFn(dart.fnType(FutureOfWebSocket(), [core.String])))();
>+let VoidToFutureOrOfString = () => (VoidToFutureOrOfString = dart.constFn(dart.fnType(FutureOrOfString(), [])))();
>+let ListOfStringTodynamic = () => (ListOfStringTodynamic = dart.constFn(dart.fnType(dart.dynamic, [ListOfString()])))();
>+let EventSinkOfListOfintTo_WebSocketOutgoingTransformer = () => (EventSinkOfListOfintTo_WebSocketOutgoingTransformer = dart.constFn(dart.fnType(_http._WebSocketOutgoingTransformer, [EventSinkOfListOfint()])))();
>+let CompleterOfWebSocket = () => (CompleterOfWebSocket = dart.constFn(async.Completer$(_http.WebSocket)))();
>+let dynamicTo_WebSocketImpl = () => (dynamicTo_WebSocketImpl = dart.constFn(dart.fnType(_http._WebSocketImpl, [dart.dynamic])))();
>+let HttpClientResponseToFutureOfWebSocket = () => (HttpClientResponseToFutureOfWebSocket = dart.constFn(dart.fnType(FutureOfWebSocket(), [_http.HttpClientResponse])))();
>+let HttpClientRequestToFutureOfHttpClientResponse = () => (HttpClientRequestToFutureOfHttpClientResponse = dart.constFn(dart.fnType(FutureOfHttpClientResponse(), [_http.HttpClientRequest])))();
>+let dynamicToMap = () => (dynamicToMap = dart.constFn(dart.fnType(core.Map, [dart.dynamic])))();
>+let IdentityMapOfint$_WebSocketImpl = () => (IdentityMapOfint$_WebSocketImpl = dart.constFn(_js_helper.IdentityMap$(core.int, _http._WebSocketImpl)))();
>+dart.polyfill = function(window) {
>+  if (window[dart._polyfilled]) return false;
>+  window[dart._polyfilled] = true;
>+  if (typeof window.NodeList !== "undefined") {
>+    window.NodeList.prototype.get = function(i) {
>+      return this[i];
>+    };
>+    window.NamedNodeMap.prototype.get = function(i) {
>+      return this[i];
>+    };
>+    window.DOMTokenList.prototype.get = function(i) {
>+      return this[i];
>+    };
>+    window.HTMLCollection.prototype.get = function(i) {
>+      return this[i];
>+    };
>+    if (typeof window.PannerNode == "undefined") {
>+      let audioContext;
>+    }
>+    if (typeof window.AudioSourceNode == "undefined") {
>+      window.AudioSourceNode = MediaElementAudioSourceNode.__proto__;
>+    }
>+    if (typeof window.FontFaceSet == "undefined") {
>+      if (typeof window.document.fonts != "undefined") {
>+        window.FontFaceSet = window.document.fonts.__proto__.constructor;
>+      }
>+    }
>+    if (typeof window.MemoryInfo == "undefined") {
>+      if (typeof window.performance.memory != "undefined") {
>+        window.MemoryInfo = window.performance.memory.constructor;
>+      }
>+    }
>+    if (typeof window.Geolocation == "undefined") {
>+      window.Geolocation == window.navigator.geolocation.constructor;
>+    }
>+    if (typeof window.Animation == "undefined") {
>+      let d = window.document.createElement('div');
>+      if (typeof d.animate != "undefined") {
>+        window.Animation = d.animate(d).constructor;
>+      }
>+    }
>+    if (typeof window.SourceBufferList == "undefined") {
>+      if ('MediaSource' in window) {
>+        window.SourceBufferList = new window.MediaSource().sourceBuffers.constructor;
>+      }
>+    }
>+    if (typeof window.SpeechRecognition == "undefined") {
>+      window.SpeechRecognition = window.webkitSpeechRecognition;
>+      window.SpeechRecognitionError = window.webkitSpeechRecognitionError;
>+      window.SpeechRecognitionEvent = window.webkitSpeechRecognitionEvent;
>+    }
>+  }
>+  return true;
>+};
>+dart.trackProfile = function(flag) {
>+  dart.__trackProfile = flag;
>+};
>+dart.setStartAsyncSynchronously = function(value) {
>+  if (value === void 0) value = true;
>+  dart.startAsyncSynchronously = value;
>+};
>+dart.hotRestart = function() {
>+  for (let f of dart._resetFields)
>+    f();
>+  dart._resetFields[$clear]();
>+  for (let m of dart._cacheMaps)
>+    m.clear();
>+  dart._cacheMaps[$clear]();
>+  dart.constantMaps.clear();
>+  dart._ignoreSubtypeCache.clear();
>+};
>+dart.defineValue = function(obj, name, value) {
>+  dart.defineAccessor(obj, name, {value: value, configurable: true, writable: true});
>+  return value;
>+};
>+dart.throwTypeError = function(message) {
>+  if (dart.__trapRuntimeErrors) debugger;
>+  dart.throw(new _js_helper.TypeErrorImpl.new(message));
>+};
>+dart.throwInternalError = function(message) {
>+  if (dart.__trapRuntimeErrors) debugger;
>+  throw Error(message);
>+};
>+dart.getOwnNamesAndSymbols = function(obj) {
>+  let names = dart.getOwnPropertyNames(obj);
>+  let symbols = dart.getOwnPropertySymbols(obj);
>+  return names.concat(symbols);
>+};
>+dart.safeGetOwnProperty = function(obj, name) {
>+  let desc = dart.getOwnPropertyDescriptor(obj, name);
>+  if (desc != null) return desc.value;
>+};
>+dart.defineLazyField = function(to, name, desc) {
>+  const initializer = desc.get;
>+  let init = initializer;
>+  let value = null;
>+  desc.get = function() {
>+    if (init == null) return value;
>+    let f = init;
>+    init = dart.throwCyclicInitializationError;
>+    if (f === init) f(name);
>+    dart._resetFields.push(() => {
>+      init = initializer;
>+      value = null;
>+    });
>+    try {
>+      value = f();
>+      init = null;
>+      return value;
>+    } catch (e) {
>+      init = null;
>+      value = null;
>+      throw e;
>+    }
>+  };
>+  desc.configurable = true;
>+  if (desc.set != null) {
>+    desc.set = function(x) {
>+      init = null;
>+      value = x;
>+    };
>+  }
>+  return dart.defineProperty(to, name, desc);
>+};
>+dart.copyTheseProperties = function(to, from, names) {
>+  for (let i = 0, n = names.length; i < n; ++i) {
>+    let name = names[i];
>+    if (dart.equals(name, "constructor")) continue;
>+    dart.copyProperty(to, from, name);
>+  }
>+  return to;
>+};
>+dart.copyProperty = function(to, from, name) {
>+  let desc = dart.getOwnPropertyDescriptor(from, name);
>+  if (name == Symbol.iterator) {
>+    let existing = dart.getOwnPropertyDescriptor(to, name);
>+    if (existing != null) {
>+      if (existing.writable) {
>+        to[name] = desc.value;
>+      }
>+      return;
>+    }
>+  }
>+  dart.defineProperty(to, name, desc);
>+};
>+dart.export = function(to, from, name) {
>+  return dart.copyProperty(to, from, name);
>+};
>+dart.copyProperties = function(to, from) {
>+  return dart.copyTheseProperties(to, from, dart.getOwnNamesAndSymbols(from));
>+};
>+dart.applyMixin = function(to, from) {
>+  to[dart._mixin] = from;
>+  let toProto = to.prototype;
>+  let fromProto = from.prototype;
>+  dart._copyMembers(toProto, fromProto);
>+  dart._mixinSignature(to, from, dart._methodSig);
>+  dart._mixinSignature(to, from, dart._fieldSig);
>+  dart._mixinSignature(to, from, dart._getterSig);
>+  dart._mixinSignature(to, from, dart._setterSig);
>+  let mixinOnFn = from[dart.mixinOn];
>+  if (mixinOnFn != null) {
>+    let proto = mixinOnFn(to.__proto__).prototype;
>+    dart._copyMembers(toProto, proto);
>+  }
>+};
>+dart._copyMembers = function(to, from) {
>+  let names = dart.getOwnNamesAndSymbols(from);
>+  for (let i = 0, n = names.length; i < n; ++i) {
>+    let name = names[i];
>+    if (name === "constructor") continue;
>+    dart._copyMember(to, from, name);
>+  }
>+  return to;
>+};
>+dart._copyMember = function(to, from, name) {
>+  let desc = dart.getOwnPropertyDescriptor(from, name);
>+  if (name == Symbol.iterator) {
>+    let existing = dart.getOwnPropertyDescriptor(to, name);
>+    if (existing != null) {
>+      if (existing.writable) {
>+        to[name] = desc.value;
>+      }
>+      return;
>+    }
>+  }
>+  let getter = desc.get;
>+  let setter = desc.set;
>+  if (getter != null) {
>+    if (setter == null) {
>+      let obj = desc.set = {
>+        __proto__: to.__proto__,
>+        set [name](x) {
>+          return super[name] = x;
>+        }
>+      };
>+      desc.set = dart.getOwnPropertyDescriptor(obj, name).set;
>+    }
>+  } else if (setter != null) {
>+    if (getter == null) {
>+      let obj = desc.get = {
>+        __proto__: to.__proto__,
>+        get [name]() {
>+          return super[name];
>+        }
>+      };
>+      desc.get = dart.getOwnPropertyDescriptor(obj, name).get;
>+    }
>+  }
>+  dart.defineProperty(to, name, desc);
>+};
>+dart._mixinSignature = function(to, from, kind) {
>+  to[kind] = () => {
>+    let baseMembers = dart._getMembers(to.__proto__, kind);
>+    let fromMembers = dart._getMembers(from, kind);
>+    if (fromMembers == null) return baseMembers;
>+    let toSignature = {__proto__: baseMembers};
>+    dart.copyProperties(toSignature, fromMembers);
>+    return toSignature;
>+  };
>+};
>+dart.getMixin = function(clazz) {
>+  return Object.hasOwnProperty.call(clazz, dart._mixin) ? clazz[dart._mixin] : null;
>+};
>+dart.getImplements = function(clazz) {
>+  return Object.hasOwnProperty.call(clazz, dart.implements) ? clazz[dart.implements] : null;
>+};
>+dart.generic = function(typeConstructor, setBaseClass) {
>+  let length = typeConstructor.length;
>+  if (length < 1) {
>+    dart.throwInternalError('must have at least one generic type argument');
>+  }
>+  let resultMap = new Map();
>+  dart._cacheMaps.push(resultMap);
>+  function makeGenericType(...args) {
>+    if (args.length != length && args.length != 0) {
>+      dart.throwInternalError('requires ' + length + ' or 0 type arguments');
>+    }
>+    while (args.length < length)
>+      args.push(dart.dynamic);
>+    let value = resultMap;
>+    for (let i = 0; i < length; i++) {
>+      let arg = args[i];
>+      if (arg == null) {
>+        dart.throwInternalError('type arguments should not be null: ' + typeConstructor);
>+      }
>+      let map = value;
>+      value = map.get(arg);
>+      if (value === void 0) {
>+        if (i + 1 == length) {
>+          value = typeConstructor.apply(null, args);
>+          if (value) {
>+            value[dart._typeArguments] = args;
>+            value[dart._originalDeclaration] = makeGenericType;
>+          }
>+          map.set(arg, value);
>+          if (setBaseClass != null) setBaseClass.apply(null, args);
>+        } else {
>+          value = new Map();
>+          map.set(arg, value);
>+        }
>+      }
>+    }
>+    return value;
>+  }
>+  makeGenericType[dart._genericTypeCtor] = typeConstructor;
>+  return makeGenericType;
>+};
>+dart.getGenericClass = function(type) {
>+  return dart.safeGetOwnProperty(type, dart._originalDeclaration);
>+};
>+dart.getGenericArgs = function(type) {
>+  return dart.safeGetOwnProperty(type, dart._typeArguments);
>+};
>+dart.getGenericTypeFormals = function(genericClass) {
>+  return dart._typeFormalsFromFunction(dart.getGenericTypeCtor(genericClass));
>+};
>+dart.instantiateClass = function(genericClass, typeArgs) {
>+  return genericClass.apply(null, typeArgs);
>+};
>+dart.getConstructors = function(value) {
>+  return dart._getMembers(value, dart._constructorSig);
>+};
>+dart.getMethods = function(value) {
>+  return dart._getMembers(value, dart._methodSig);
>+};
>+dart.getFields = function(value) {
>+  return dart._getMembers(value, dart._fieldSig);
>+};
>+dart.getGetters = function(value) {
>+  return dart._getMembers(value, dart._getterSig);
>+};
>+dart.getSetters = function(value) {
>+  return dart._getMembers(value, dart._setterSig);
>+};
>+dart.getStaticMethods = function(value) {
>+  return dart._getMembers(value, dart._staticMethodSig);
>+};
>+dart.getStaticFields = function(value) {
>+  return dart._getMembers(value, dart._staticFieldSig);
>+};
>+dart.getStaticGetters = function(value) {
>+  return dart._getMembers(value, dart._staticGetterSig);
>+};
>+dart.getStaticSetters = function(value) {
>+  return dart._getMembers(value, dart._staticSetterSig);
>+};
>+dart.getGenericTypeCtor = function(value) {
>+  return value[dart._genericTypeCtor];
>+};
>+dart.getType = function(obj) {
>+  return obj == null ? core.Object : obj.__proto__.constructor;
>+};
>+dart.getLibraryUri = function(value) {
>+  return value[dart._libraryUri];
>+};
>+dart.setLibraryUri = function(f, uri) {
>+  return f[dart._libraryUri] = uri;
>+};
>+dart.isJsInterop = function(obj) {
>+  if (obj == null) return false;
>+  if (typeof obj === "function") {
>+    return obj[dart._runtimeType] == null;
>+  }
>+  if (typeof obj !== "object") return false;
>+  if (obj[dart._extensionType] != null) return false;
>+  return !(obj instanceof core.Object);
>+};
>+dart.getMethodType = function(type, name) {
>+  let m = dart.getMethods(type);
>+  return m != null ? m[name] : null;
>+};
>+dart.getSetterType = function(type, name) {
>+  let setters = dart.getSetters(type);
>+  if (setters != null) {
>+    let type = setters[name];
>+    if (type != null) {
>+      if (type instanceof Array) {
>+        return type[0];
>+      }
>+      return type;
>+    }
>+  }
>+  let fields = dart.getFields(type);
>+  if (fields != null) {
>+    let fieldInfo = fields[name];
>+    if (fieldInfo != null && !fieldInfo.isFinal) {
>+      return fieldInfo.type;
>+    }
>+  }
>+  return null;
>+};
>+dart.finalFieldType = function(type, metadata) {
>+  return {type: type, isFinal: true, metadata: metadata};
>+};
>+dart.fieldType = function(type, metadata) {
>+  return {type: type, isFinal: false, metadata: metadata};
>+};
>+dart.classGetConstructorType = function(cls, name) {
>+  if (cls == null) return null;
>+  if (name == null) name = "new";
>+  let ctors = dart.getConstructors(cls);
>+  return ctors != null ? ctors[name] : null;
>+};
>+dart.setMethodSignature = function(f, sigF) {
>+  return f[dart._methodSig] = sigF;
>+};
>+dart.setFieldSignature = function(f, sigF) {
>+  return f[dart._fieldSig] = sigF;
>+};
>+dart.setGetterSignature = function(f, sigF) {
>+  return f[dart._getterSig] = sigF;
>+};
>+dart.setSetterSignature = function(f, sigF) {
>+  return f[dart._setterSig] = sigF;
>+};
>+dart.setConstructorSignature = function(f, sigF) {
>+  return f[dart._constructorSig] = sigF;
>+};
>+dart.setStaticMethodSignature = function(f, sigF) {
>+  return f[dart._staticMethodSig] = sigF;
>+};
>+dart.setStaticFieldSignature = function(f, sigF) {
>+  return f[dart._staticFieldSig] = sigF;
>+};
>+dart.setStaticGetterSignature = function(f, sigF) {
>+  return f[dart._staticGetterSig] = sigF;
>+};
>+dart.setStaticSetterSignature = function(f, sigF) {
>+  return f[dart._staticSetterSig] = sigF;
>+};
>+dart._getMembers = function(type, kind) {
>+  let sig = type[kind];
>+  return typeof sig == "function" ? type[kind] = sig() : sig;
>+};
>+dart._hasMember = function(type, kind, name) {
>+  let sig = dart._getMembers(type, kind);
>+  return sig != null && name in sig;
>+};
>+dart.hasMethod = function(type, name) {
>+  return dart._hasMember(type, dart._methodSig, name);
>+};
>+dart.hasGetter = function(type, name) {
>+  return dart._hasMember(type, dart._getterSig, name);
>+};
>+dart.hasSetter = function(type, name) {
>+  return dart._hasMember(type, dart._setterSig, name);
>+};
>+dart.hasField = function(type, name) {
>+  return dart._hasMember(type, dart._fieldSig, name);
>+};
>+dart._installProperties = function(jsProto, dartType, installedParent) {
>+  if (dartType === core.Object) {
>+    dart._installPropertiesForObject(jsProto);
>+    return;
>+  }
>+  let dartSupertype = dartType.__proto__;
>+  if (dartSupertype !== installedParent) {
>+    dart._installProperties(jsProto, dartSupertype, installedParent);
>+  }
>+  let dartProto = dartType.prototype;
>+  dart.copyTheseProperties(jsProto, dartProto, dart.getOwnPropertySymbols(dartProto));
>+};
>+dart._installPropertiesForObject = function(jsProto) {
>+  let coreObjProto = core.Object.prototype;
>+  let names = dart.getOwnPropertyNames(coreObjProto);
>+  for (let i = 0, n = names.length; i < n; ++i) {
>+    let name = names[i];
>+    if (name === "constructor") continue;
>+    let desc = dart.getOwnPropertyDescriptor(coreObjProto, name);
>+    dart.defineProperty(jsProto, dart.dartx[name], desc);
>+  }
>+};
>+dart._installPropertiesForGlobalObject = function(jsProto) {
>+  dart._installPropertiesForObject(jsProto);
>+  jsProto[dartx.toString] = function() {
>+    return this.toString();
>+  };
>+  let t = dart.identityEquals;
>+  t == null ? dart.identityEquals = jsProto[dartx._equals] : t;
>+};
>+dart._applyExtension = function(jsType, dartExtType) {
>+  if (jsType == null) return;
>+  let jsProto = jsType.prototype;
>+  if (jsProto == null) return;
>+  if (dartExtType === core.Object) {
>+    dart._installPropertiesForGlobalObject(jsProto);
>+    return;
>+  }
>+  dart._installProperties(jsProto, dartExtType, jsProto[dart._extensionType]);
>+  if (dartExtType !== _interceptors.JSFunction) {
>+    jsProto[dart._extensionType] = dartExtType;
>+  }
>+  jsType[dart._methodSig] = dartExtType[dart._methodSig];
>+  jsType[dart._fieldSig] = dartExtType[dart._fieldSig];
>+  jsType[dart._getterSig] = dartExtType[dart._getterSig];
>+  jsType[dart._setterSig] = dartExtType[dart._setterSig];
>+};
>+dart.applyExtension = function(name, nativeObject) {
>+  let dartExtType = dart._extensionMap.get(name);
>+  let jsType = nativeObject.constructor;
>+  dart._applyExtension(jsType, dartExtType);
>+};
>+dart.applyAllExtensions = function(global) {
>+  dart._extensionMap.forEach((dartExtType, name) => dart._applyExtension(global[name], dartExtType));
>+};
>+dart.registerExtension = function(name, dartExtType) {
>+  dart._extensionMap.set(name, dartExtType);
>+  let jsType = dart.global[name];
>+  dart._applyExtension(jsType, dartExtType);
>+};
>+dart.defineExtensionMethods = function(type, memberNames) {
>+  let proto = type.prototype;
>+  for (let name of memberNames) {
>+    proto[dartx[name]] = proto[name];
>+  }
>+};
>+dart.defineExtensionAccessors = function(type, memberNames) {
>+  let proto = type.prototype;
>+  for (let name of memberNames) {
>+    let member = null;
>+    let p = proto;
>+    for (;; p = p.__proto__) {
>+      member = dart.getOwnPropertyDescriptor(p, name);
>+      if (member != null) break;
>+    }
>+    dart.defineProperty(proto, dartx[name], member);
>+  }
>+};
>+dart.definePrimitiveHashCode = function(proto) {
>+  dart.defineProperty(proto, dart.identityHashCode_, dart.getOwnPropertyDescriptor(proto, $hashCode));
>+};
>+dart.setBaseClass = function(derived, base) {
>+  derived.prototype.__proto__ = base.prototype;
>+  derived.__proto__ = base;
>+};
>+dart.setExtensionBaseClass = function(dartType, jsType) {
>+  let dartProto = dartType.prototype;
>+  dartProto[dart._extensionType] = dartType;
>+  dartProto.__proto__ = jsType.prototype;
>+};
>+dart.addTypeTests = function(ctor, isClass) {
>+  if (isClass == null) isClass = Symbol("_is_" + ctor.name);
>+  ctor.prototype[isClass] = true;
>+  ctor.is = function is_C(obj) {
>+    return obj != null && (obj[isClass] || dart.is(obj, this));
>+  };
>+  ctor.as = function as_C(obj) {
>+    if (obj == null || obj[isClass]) return obj;
>+    return dart.as(obj, this, false);
>+  };
>+  ctor._check = function check_C(obj) {
>+    if (obj == null || obj[isClass]) return obj;
>+    return dart.as(obj, this, true);
>+  };
>+};
>+dart.fn = function(closure, type) {
>+  closure[dart._runtimeType] = type;
>+  return closure;
>+};
>+dart.lazyFn = function(closure, computeType) {
>+  dart.defineAccessor(closure, dart._runtimeType, {
>+    get: () => dart.defineValue(closure, dart._runtimeType, computeType()),
>+    set: value => dart.defineValue(closure, dart._runtimeType, value),
>+    configurable: true
>+  });
>+  return closure;
>+};
>+dart.getFunctionType = function(obj) {
>+  let args = Array(obj.length).fill(dart.dynamic);
>+  return dart.fnType(dart.bottom, args, void 0);
>+};
>+dart.getReifiedType = function(obj) {
>+  switch (typeof obj) {
>+    case "object":
>+    {
>+      if (obj == null) return core.Null;
>+      if (obj instanceof core.Object) {
>+        return obj.constructor;
>+      }
>+      let result = obj[dart._extensionType];
>+      if (result == null) return dart.jsobject;
>+      return result;
>+    }
>+    case "function":
>+    {
>+      let result = obj[dart._runtimeType];
>+      if (result != null) return result;
>+      return dart.jsobject;
>+    }
>+    case "undefined":
>+    {
>+      return core.Null;
>+    }
>+    case "number":
>+    {
>+      return Math.floor(obj) == obj ? core.int : core.double;
>+    }
>+    case "boolean":
>+    {
>+      return core.bool;
>+    }
>+    case "string":
>+    {
>+      return core.String;
>+    }
>+    case "symbol":
>+    default:
>+    {
>+      return dart.jsobject;
>+    }
>+  }
>+};
>+dart.getModuleName = function(module) {
>+  return module[dart._moduleName];
>+};
>+dart.getModuleNames = function() {
>+  return JSArrayOfString().of(Array.from(dart._loadedModules.keys()));
>+};
>+dart.getSourceMap = function(moduleName) {
>+  return dart._loadedSourceMaps.get(moduleName);
>+};
>+dart.getModuleLibraries = function(name) {
>+  let module = dart._loadedModules.get(name);
>+  if (module == null) return null;
>+  module[dart._moduleName] = name;
>+  return module;
>+};
>+dart.getModulePartMap = function(name) {
>+  return dart._loadedPartMaps.get(name);
>+};
>+dart.trackLibraries = function(moduleName, libraries, parts, sourceMap) {
>+  if (typeof parts == 'string') {
>+    sourceMap = core.String.as(parts);
>+    parts = {};
>+  }
>+  dart._loadedSourceMaps.set(moduleName, sourceMap);
>+  dart._loadedModules.set(moduleName, libraries);
>+  dart._loadedPartMaps.set(moduleName, parts);
>+};
>+dart._computeLibraryMetadata = function() {
>+  dart._libraries = JSArrayOfString().of([]);
>+  dart._libraryObjects = new (IdentityMapOfString$Object()).new();
>+  dart._parts = new (IdentityMapOfString$ListOfString()).new();
>+  let modules = dart.getModuleNames();
>+  for (let name of modules) {
>+    let module = dart.getModuleLibraries(name);
>+    let libraries = IterableOfString()._check(dart.getOwnPropertyNames(module)[$cast](core.String));
>+    dart._libraries[$addAll](libraries);
>+    for (let library of libraries) {
>+      dart._libraryObjects[$_set](library, module[library]);
>+    }
>+    let partMap = dart.getModulePartMap(name);
>+    libraries = IterableOfString()._check(dart.getOwnPropertyNames(partMap)[$cast](core.String));
>+    for (let library of libraries) {
>+      dart._parts[$_set](library, ListOfString().from(partMap[library]));
>+    }
>+  }
>+};
>+dart.getLibrary = function(uri) {
>+  if (dart._libraryObjects == null) {
>+    dart._computeLibraryMetadata();
>+  }
>+  return dart._libraryObjects[$_get](uri);
>+};
>+dart.getLibraries = function() {
>+  if (dart._libraries == null) {
>+    dart._computeLibraryMetadata();
>+  }
>+  return dart._libraries;
>+};
>+dart.getParts = function(libraryUri) {
>+  if (dart._parts == null) {
>+    dart._computeLibraryMetadata();
>+  }
>+  let l = dart._parts[$_get](libraryUri);
>+  return l != null ? l : JSArrayOfString().of([]);
>+};
>+dart._isJsObject = function(obj) {
>+  return dart.getReifiedType(obj) === dart.jsobject;
>+};
>+dart._warn = function(arg) {
>+  console.warn(arg);
>+};
>+dart.lazyJSType = function(getJSTypeCallback, name) {
>+  let ret = dart._lazyJSTypes.get(name);
>+  if (ret == null) {
>+    ret = new dart.LazyJSType.new(getJSTypeCallback, name);
>+    dart._lazyJSTypes.set(name, ret);
>+  }
>+  return ret;
>+};
>+dart.anonymousJSType = function(name) {
>+  let ret = dart._anonymousJSTypes.get(name);
>+  if (ret == null) {
>+    ret = new dart.AnonymousJSType.new(name);
>+    dart._anonymousJSTypes.set(name, ret);
>+  }
>+  return ret;
>+};
>+dart.wrapType = function(type) {
>+  if (type.hasOwnProperty(dart._typeObject)) {
>+    return type[dart._typeObject];
>+  }
>+  let result = new dart._Type.new(type);
>+  type[dart._typeObject] = result;
>+  return result;
>+};
>+dart.unwrapType = function(obj) {
>+  return obj[_type];
>+};
>+dart._memoizeArray = function(map, arr, create) {
>+  let len = arr.length;
>+  map = dart._lookupNonTerminal(map, len);
>+  for (var i = 0; i < len - 1; ++i) {
>+    map = dart._lookupNonTerminal(map, arr[i]);
>+  }
>+  let result = map.get(arr[len - 1]);
>+  if (result !== void 0) return result;
>+  map.set(arr[len - 1], result = create());
>+  return result;
>+};
>+dart._canonicalizeArray = function(array, map) {
>+  return dart._memoizeArray(map, array, () => array);
>+};
>+dart._canonicalizeNamed = function(named, map) {
>+  let key = [];
>+  let names = dart.getOwnPropertyNames(named);
>+  for (var i = 0; i < names.length; ++i) {
>+    let name = names[i];
>+    let type = named[name];
>+    key.push(name);
>+    key.push(type);
>+  }
>+  return dart._memoizeArray(map, key, () => named);
>+};
>+dart._createSmall = function(returnType, required) {
>+  let count = required.length;
>+  let map = dart._fnTypeSmallMap[count];
>+  for (var i = 0; i < count; ++i) {
>+    map = dart._lookupNonTerminal(map, required[i]);
>+  }
>+  let result = map.get(returnType);
>+  if (result !== void 0) return result;
>+  result = new dart.FunctionType.new(returnType, required, [], {});
>+  map.set(returnType, result);
>+  return result;
>+};
>+dart._typeFormalsFromFunction = function(typeConstructor) {
>+  let str = typeConstructor.toString();
>+  let hasParens = str[$_get](0) === "(";
>+  let end = str[$indexOf](hasParens ? ")" : "=>");
>+  if (hasParens) {
>+    return IterableOfTypeVariable()._check(str[$substring](1, end)[$split](",")[$map](dart.TypeVariable, n => new dart.TypeVariable.new(n[$trim]())))[$toList]();
>+  } else {
>+    return JSArrayOfTypeVariable().of([new dart.TypeVariable.new(str[$substring](0, end)[$trim]())]);
>+  }
>+};
>+dart.fnType = function(returnType, args, extra) {
>+  return dart.FunctionType.create(returnType, args, extra);
>+};
>+dart.gFnType = function(instantiateFn, typeBounds) {
>+  return new dart.GenericFunctionType.new(instantiateFn, typeBounds);
>+};
>+dart.getFunctionTypeMirror = function(type) {
>+  if (dart.GenericFunctionType.is(type)) {
>+    let typeArgs = ListOfType().filled(type.formalCount, dart.wrapType(dart.dynamic));
>+    return type.instantiate(typeArgs);
>+  }
>+  return type;
>+};
>+dart.isType = function(obj) {
>+  return obj[dart._runtimeType] === core.Type;
>+};
>+dart.checkTypeBound = function(type, bound, name) {
>+  if (!dart.isSubtypeOf(type, bound)) {
>+    dart.throwTypeError("type `" + dart.str(type) + "` does not extend `" + dart.str(bound) + "` of `" + name + "`.");
>+  }
>+};
>+dart.typeName = function(type) {
>+  if (type === void 0) return "undefined type";
>+  if (type === null) return "null type";
>+  if (type instanceof dart.DartType) {
>+    return type.toString();
>+  }
>+  let tag = type[dart._runtimeType];
>+  if (tag === core.Type) {
>+    let name = type.name;
>+    let args = dart.getGenericArgs(type);
>+    if (args == null) return name;
>+    if (dart.getGenericClass(type) == _interceptors.JSArray$) name = 'List';
>+    let result = name;
>+    result += '<';
>+    for (let i = 0; i < args.length; ++i) {
>+      if (i > 0) result += ', ';
>+      result += dart.typeName(args[i]);
>+    }
>+    result += '>';
>+    return result;
>+  }
>+  if (tag) return "Not a type: " + tag.name;
>+  return "JSObject<" + type.name + ">";
>+};
>+dart._isFunctionSubtype = function(ft1, ft2, isCovariant) {
>+  let ret1 = ft1.returnType;
>+  let ret2 = ft2.returnType;
>+  let args1 = ft1.args;
>+  let args2 = ft2.args;
>+  if (args1.length > args2.length) {
>+    return isCovariant ? false : null;
>+  }
>+  for (let i = 0; i < args1.length; ++i) {
>+    if (!dart._isSubtype(args2[i], args1[i], !isCovariant)) {
>+      return null;
>+    }
>+  }
>+  let optionals1 = ft1.optionals;
>+  let optionals2 = ft2.optionals;
>+  if (args1.length + optionals1.length < args2.length + optionals2.length) {
>+    return isCovariant ? false : null;
>+  }
>+  let j = 0;
>+  for (let i = args1.length; i < args2.length; ++i, ++j) {
>+    if (!dart._isSubtype(args2[i], optionals1[j], !isCovariant)) {
>+      return null;
>+    }
>+  }
>+  for (let i = 0; i < optionals2.length; ++i, ++j) {
>+    if (!dart._isSubtype(optionals2[i], optionals1[j], !isCovariant)) {
>+      return null;
>+    }
>+  }
>+  let named1 = ft1.named;
>+  let named2 = ft2.named;
>+  let names = dart.getOwnPropertyNames(named2);
>+  for (let i = 0; i < names.length; ++i) {
>+    let name = names[i];
>+    let n1 = named1[name];
>+    let n2 = named2[name];
>+    if (n1 === void 0) {
>+      return isCovariant ? false : null;
>+    }
>+    if (!dart._isSubtype(n2, n1, !isCovariant)) {
>+      return null;
>+    }
>+  }
>+  if (ret1 === dart.void) return dart._isTop(ret2);
>+  if (!dart._isSubtype(ret1, ret2, isCovariant)) return null;
>+  return true;
>+};
>+dart.isSubtypeOf = function(t1, t2) {
>+  return !!dart._isSubtypeOrLegacySubtype(t1, t2);
>+};
>+dart._isSubtypeOrLegacySubtype = function(t1, t2) {
>+  let map = null;
>+  if (!t1.hasOwnProperty(dart._subtypeCache)) {
>+    t1[dart._subtypeCache] = map = new Map();
>+    dart._cacheMaps[$add](map);
>+  } else {
>+    map = t1[dart._subtypeCache];
>+    let result = map.get(t2);
>+    if (result !== void 0) return result;
>+  }
>+  let result = dart._isSubtype(t1, t2, true);
>+  map.set(t2, result);
>+  return result;
>+};
>+dart._isBottom = function(type) {
>+  return type == dart.bottom || type == core.Null;
>+};
>+dart._isTop = function(type) {
>+  if (dart._isFutureOr(type)) {
>+    return dart._isTop(dart.getGenericArgs(type)[0]);
>+  }
>+  return type == core.Object || type == dart.dynamic || type == dart.void;
>+};
>+dart._isFutureOr = function(type) {
>+  return core.identical(dart.getGenericClass(type), async.FutureOr$);
>+};
>+dart._isSubtype = function(t1, t2, isCovariant) {
>+  if (t1 === t2) return true;
>+  if (dart._isTop(t2) || dart._isBottom(t1)) {
>+    return true;
>+  }
>+  if (dart._isBottom(t2)) return null;
>+  if (dart._isTop(t1)) {
>+    if (t1 === dart.dynamic) return null;
>+    return false;
>+  }
>+  if (dart._isFutureOr(t1)) {
>+    let t1TypeArg = dart.getGenericArgs(t1)[0];
>+    if (dart._isFutureOr(t2)) {
>+      let t2TypeArg = dart.getGenericArgs(t2)[0];
>+      return dart._isSubtype(t1TypeArg, t2TypeArg, isCovariant);
>+    }
>+    let t1Future = async.Future$(t1TypeArg);
>+    return dart._isSubtype(t1Future, t2, isCovariant) && dart._isSubtype(t1TypeArg, t2, isCovariant);
>+  }
>+  if (dart._isFutureOr(t2)) {
>+    let t2TypeArg = dart.getGenericArgs(t2)[0];
>+    let t2Future = async.Future$(t2TypeArg);
>+    let s1 = dart._isSubtype(t1, t2Future, isCovariant);
>+    let s2 = dart._isSubtype(t1, t2TypeArg, isCovariant);
>+    if (s1 === true || s2 === true) return true;
>+    if (s1 === null || s2 === null) return null;
>+    return false;
>+  }
>+  if (!(t2 instanceof dart.AbstractFunctionType)) {
>+    if (t1 instanceof dart.AbstractFunctionType) {
>+      return t2 === core.Function;
>+    }
>+    if (t1 === dart.jsobject && t2 instanceof dart.AnonymousJSType) return true;
>+    return dart._isInterfaceSubtype(t1, t2, isCovariant);
>+  }
>+  if (!(t1 instanceof dart.AbstractFunctionType)) return false;
>+  if (t1 instanceof dart.GenericFunctionType) {
>+    if (!(t2 instanceof dart.GenericFunctionType)) return false;
>+    let formalCount = t1.formalCount;
>+    if (formalCount !== t2.formalCount) return false;
>+    let fresh = t2.typeFormals;
>+    let t1Bounds = t1.instantiateTypeBounds(fresh);
>+    let t2Bounds = t2.instantiateTypeBounds(fresh);
>+    for (let i = 0; i < formalCount; i++) {
>+      if (!dart._isSubtype(t2Bounds[i], t1Bounds[i], !isCovariant)) {
>+        return false;
>+      }
>+    }
>+    t1 = t1.instantiate(fresh);
>+    t2 = t2.instantiate(fresh);
>+  } else if (t2 instanceof dart.GenericFunctionType) {
>+    return false;
>+  }
>+  return dart._isFunctionSubtype(t1, t2, isCovariant);
>+};
>+dart._isInterfaceSubtype = function(t1, t2, isCovariant) {
>+  if (t1 instanceof dart.LazyJSType) t1 = t1.rawJSTypeForCheck();
>+  if (t2 instanceof dart.LazyJSType) t2 = t2.rawJSTypeForCheck();
>+  if (t1 === t2) return true;
>+  if (t1 === core.Object) return false;
>+  if (t1 === core.Function || t2 === core.Function) return false;
>+  if (t1 == null) return t2 == core.Object || t2 == dart.dynamic;
>+  let raw1 = dart.getGenericClass(t1);
>+  let raw2 = dart.getGenericClass(t2);
>+  if (raw1 != null && raw1 == raw2) {
>+    let typeArguments1 = dart.getGenericArgs(t1);
>+    let typeArguments2 = dart.getGenericArgs(t2);
>+    let length = typeArguments1.length;
>+    if (typeArguments2.length == 0) {
>+      return true;
>+    } else if (length == 0) {
>+      if (typeArguments2.every(dart._isTop)) return true;
>+      return null;
>+    }
>+    if (length != typeArguments2.length) dart.assertFailed();
>+    for (let i = 0; i < length; ++i) {
>+      let result = dart._isSubtype(typeArguments1[i], typeArguments2[i], isCovariant);
>+      if (!result) {
>+        return result;
>+      }
>+    }
>+    return true;
>+  }
>+  let indefinite = false;
>+  function definitive(t1, t2) {
>+    let result = dart._isInterfaceSubtype(t1, t2, isCovariant);
>+    if (result == null) {
>+      indefinite = true;
>+      return false;
>+    }
>+    return result;
>+  }
>+  if (definitive(t1.__proto__, t2)) return true;
>+  let m1 = dart.getMixin(t1);
>+  if (m1 != null) {
>+    if (definitive(m1, t2)) return true;
>+  }
>+  let getInterfaces = dart.getImplements(t1);
>+  if (getInterfaces) {
>+    for (let i1 of getInterfaces()) {
>+      if (definitive(i1, t2)) return true;
>+    }
>+  }
>+  if (indefinite) return null;
>+  return false;
>+};
>+dart.extractTypeArguments = function(T, instance, f) {
>+  if (instance == null) {
>+    dart.throw(new core.ArgumentError.new("Cannot extract type of null instance."));
>+  }
>+  let type = T;
>+  if (dart.AbstractFunctionType.is(type) || dart._isFutureOr(type)) {
>+    dart.throw(new core.ArgumentError.new("Cannot extract from non-class type (" + dart.str(type) + ")."));
>+  }
>+  let typeArguments = dart.getGenericArgs(type);
>+  if (dart.test(typeArguments[$isEmpty])) {
>+    dart.throw(new core.ArgumentError.new("Cannot extract from non-generic type (" + dart.str(type) + ")."));
>+  }
>+  let supertype = dart._getMatchingSupertype(dart.getReifiedType(instance), type);
>+  if (!(supertype != null)) dart.assertFailed(null, "dart:_runtime/types.dart", 1084, 10, "supertype != null");
>+  let typeArgs = dart.getGenericArgs(supertype);
>+  if (!(typeArgs != null && dart.test(typeArgs[$isNotEmpty]))) dart.assertFailed(null, "dart:_runtime/types.dart", 1086, 10, "typeArgs != null && typeArgs.isNotEmpty");
>+  return dart.dgcall(f, typeArgs, []);
>+};
>+dart._getMatchingSupertype = function(subtype, supertype) {
>+  if (core.identical(subtype, supertype)) return supertype;
>+  if (subtype == null || dart.equals(subtype, core.Object)) return null;
>+  let subclass = dart.getGenericClass(subtype);
>+  let superclass = dart.getGenericClass(supertype);
>+  if (subclass != null && core.identical(subclass, superclass)) {
>+    return subtype;
>+  }
>+  let result = dart._getMatchingSupertype(subtype.__proto__, supertype);
>+  if (result != null) return result;
>+  let mixin = dart.getMixin(subtype);
>+  if (mixin != null) {
>+    result = dart._getMatchingSupertype(mixin, supertype);
>+    if (result != null) return result;
>+  }
>+  let getInterfaces = dart.getImplements(subtype);
>+  if (getInterfaces != null) {
>+    for (let iface of getInterfaces()) {
>+      result = dart._getMatchingSupertype(iface, supertype);
>+      if (result != null) return result;
>+    }
>+  }
>+  return null;
>+};
>+dart.trapRuntimeErrors = function(flag) {
>+  dart.__trapRuntimeErrors = flag;
>+};
>+dart.ignoreWhitelistedErrors = function(flag) {
>+  dart.__ignoreWhitelistedErrors = flag;
>+};
>+dart.ignoreAllErrors = function(flag) {
>+  dart.__ignoreAllErrors = flag;
>+};
>+dart.argumentError = function(value) {
>+  if (dart.__trapRuntimeErrors) debugger;
>+  dart.throw(new core.ArgumentError.value(value));
>+};
>+dart.throwUnimplementedError = function(message) {
>+  if (dart.__trapRuntimeErrors) debugger;
>+  dart.throw(new core.UnimplementedError.new(message));
>+};
>+dart.assertFailed = function(message, fileUri, line, column, conditionSource) {
>+  if (fileUri === void 0) fileUri = null;
>+  if (line === void 0) line = null;
>+  if (column === void 0) column = null;
>+  if (conditionSource === void 0) conditionSource = null;
>+  if (dart.__trapRuntimeErrors) debugger;
>+  dart.throw(new _js_helper.AssertionErrorImpl.new(message, fileUri, line, column, conditionSource));
>+};
>+dart.throwCyclicInitializationError = function(field) {
>+  if (field === void 0) field = null;
>+  if (dart.__trapRuntimeErrors) debugger;
>+  dart.throw(new core.CyclicInitializationError.new(core.String._check(field)));
>+};
>+dart.throwNullValueError = function() {
>+  if (dart.__trapRuntimeErrors) debugger;
>+  dart.throw(new core.NoSuchMethodError.new(null, core.Symbol.new("<Unexpected Null Value>"), null, null, null));
>+};
>+dart.castError = function(obj, expectedType, isImplicit) {
>+  if (isImplicit === void 0) isImplicit = false;
>+  let actualType = dart.getReifiedType(obj);
>+  let message = dart._castErrorMessage(actualType, expectedType);
>+  if (dart.__ignoreAllErrors) {
>+    console.error(message);
>+    return obj;
>+  }
>+  if (dart.__trapRuntimeErrors) debugger;
>+  let error = isImplicit ? new _js_helper.TypeErrorImpl.new(message) : new _js_helper.CastErrorImpl.new(message);
>+  dart.throw(error);
>+};
>+dart._castErrorMessage = function(from, to) {
>+  let fromClass = dart.getGenericClass(from);
>+  if (fromClass != null) {
>+    let fromTypeFormals = dart.getGenericTypeFormals(fromClass);
>+    let fromType = dart.instantiateClass(fromClass, fromTypeFormals);
>+    let inferrer = new dart._TypeInferrer.new(fromTypeFormals);
>+    if (dart.test(inferrer.trySubtypeMatch(fromType, to))) {
>+      let inferredTypes = inferrer.getInferredTypes();
>+      if (inferredTypes != null) {
>+        let inferred = dart.instantiateClass(fromClass, inferredTypes);
>+        return "Type '" + dart.typeName(from) + "' should be '" + dart.typeName(inferred) + "' " + ("to implement expected type '" + dart.typeName(to) + "'.");
>+      }
>+    }
>+  }
>+  return "Expected a value of type '" + dart.typeName(to) + "', " + ("but got one of type '" + dart.typeName(from) + "'");
>+};
>+dart.getThrown = function(error) {
>+  if (error != null) {
>+    let value = error[dart._thrownValue];
>+    if (value != null) return value;
>+  }
>+  return error;
>+};
>+dart.stackTrace = function(error) {
>+  if (!(error instanceof Error)) {
>+    return new dart._StackTrace.missing(error);
>+  }
>+  let trace = error[dart._stackTrace];
>+  if (trace != null) return trace;
>+  return error[dart._stackTrace] = new dart._StackTrace.new(error);
>+};
>+dart.stackTraceForError = function(error) {
>+  return dart.stackTrace(error[dart._jsError]);
>+};
>+dart.rethrow = function(error) {
>+  throw error;
>+};
>+dart.throw = function(exception) {
>+  throw new dart.DartError(exception);
>+};
>+dart.createErrorWithStack = function(exception, trace) {
>+  if (trace == null) {
>+    let error = exception[dart._jsError];
>+    return error != null ? error : new dart.DartError(exception);
>+  }
>+  if (dart._StackTrace.is(trace)) {
>+    let originalError = trace[_jsError];
>+    if (core.identical(exception, dart.getThrown(originalError))) {
>+      return originalError;
>+    }
>+  }
>+  return new dart.RethrownDartError(exception, trace);
>+};
>+dart.stackPrint = function(error) {
>+  console.log(error.stack ? error.stack : "No stack trace for: " + error);
>+};
>+dart.bind = function(obj, name, method) {
>+  if (obj == null) obj = _interceptors.jsNull;
>+  if (method == null) method = obj[name];
>+  let f = method.bind(obj);
>+  f._boundObject = obj;
>+  f._boundMethod = method;
>+  f[dart._runtimeType] = dart.getMethodType(dart.getType(obj), name);
>+  return f;
>+};
>+dart.bindCall = function(obj, name) {
>+  if (obj == null) return null;
>+  let ftype = dart.getMethodType(dart.getType(obj), name);
>+  if (ftype == null) return null;
>+  let method = obj[name];
>+  let f = method.bind(obj);
>+  f._boundObject = obj;
>+  f._boundMethod = method;
>+  f[dart._runtimeType] = ftype;
>+  return f;
>+};
>+dart.gbind = function(f, ...typeArgs) {
>+  let type = f[dart._runtimeType];
>+  type.checkBounds(typeArgs);
>+  let result = (...args) => f.apply(null, typeArgs.concat(args));
>+  return dart.fn(result, type.instantiate(typeArgs));
>+};
>+dart.dloadRepl = function(obj, field) {
>+  return dart.dload(obj, dart.replNameLookup(obj, field), false);
>+};
>+dart.dload = function(obj, field, mirrors) {
>+  if (typeof obj == "function" && field == "call") {
>+    return obj;
>+  }
>+  let f = dart._canonicalMember(obj, field);
>+  _debugger.trackCall(obj);
>+  if (f != null) {
>+    let type = dart.getType(obj);
>+    if (dart.test(dart.hasField(type, f)) || dart.test(dart.hasGetter(type, f))) return obj[f];
>+    if (dart.test(dart.hasMethod(type, f))) return dart.bind(obj, f, null);
>+    if (!mirrors && dart.test(dart.isJsInterop(obj))) {
>+      return obj[f];
>+    }
>+  }
>+  return dart.noSuchMethod(obj, new dart.InvocationImpl.new(field, [], {isGetter: true}));
>+};
>+dart.dloadMirror = function(obj, field) {
>+  return dart.dload(obj, field, true);
>+};
>+dart._stripGenericArguments = function(type) {
>+  let genericClass = dart.getGenericClass(type);
>+  if (genericClass != null) return genericClass();
>+  return type;
>+};
>+dart.dputMirror = function(obj, field, value) {
>+  return dart.dput(obj, field, value, true);
>+};
>+dart.dputRepl = function(obj, field, value) {
>+  return dart.dput(obj, dart.replNameLookup(obj, field), value, false);
>+};
>+dart.dput = function(obj, field, value, mirrors) {
>+  let f = dart._canonicalMember(obj, field);
>+  _debugger.trackCall(obj);
>+  if (f != null) {
>+    let setterType = dart.getSetterType(dart.getType(obj), f);
>+    if (setterType != null) {
>+      if (mirrors) setterType = dart._stripGenericArguments(setterType);
>+      return obj[f] = setterType._check(value);
>+    }
>+    if (!mirrors && dart.test(dart.isJsInterop(obj))) {
>+      return obj[f] = value;
>+    }
>+  }
>+  dart.noSuchMethod(obj, new dart.InvocationImpl.new(field, [value], {isSetter: true}));
>+  return value;
>+};
>+dart._argumentErrors = function(type, actuals, namedActuals) {
>+  let actualsCount = actuals.length;
>+  let required = type.args;
>+  let requiredCount = required.length;
>+  if (actualsCount < requiredCount) {
>+    return "Dynamic call with too few arguments. " + ("Expected: " + dart.str(requiredCount) + " Actual: " + dart.str(actualsCount));
>+  }
>+  let extras = actualsCount - requiredCount;
>+  let optionals = type.optionals;
>+  if (extras > optionals.length) {
>+    return "Dynamic call with too many arguments. " + ("Expected: " + dart.str(requiredCount) + " Actual: " + dart.str(actualsCount));
>+  }
>+  let names = null;
>+  let named = type.named;
>+  if (namedActuals != null) {
>+    names = dart.getOwnPropertyNames(namedActuals);
>+    for (let name of names) {
>+      if (!named.hasOwnProperty(name)) {
>+        return "Dynamic call with unexpected named argument '" + dart.str(name) + "'.";
>+      }
>+    }
>+  }
>+  for (let i = 0; i < requiredCount; ++i) {
>+    required[i]._check(actuals[i]);
>+  }
>+  for (let i = 0; i < extras; ++i) {
>+    optionals[i]._check(actuals[i + requiredCount]);
>+  }
>+  if (names != null) {
>+    for (let name of names) {
>+      named[name]._check(namedActuals[name]);
>+    }
>+  }
>+  return null;
>+};
>+dart._toSymbolName = function(symbol) {
>+  let str = symbol.toString();
>+  return str.substring(7, str.length - 1);
>+};
>+dart._toDisplayName = function(name) {
>+  if (name[0] === '_') {
>+    switch (name) {
>+      case '_get':
>+      {
>+        return '[]';
>+      }
>+      case '_set':
>+      {
>+        return '[]=';
>+      }
>+      case '_negate':
>+      {
>+        return 'unary-';
>+      }
>+      case '_constructor':
>+      case '_prototype':
>+      {
>+        return name.substring(1);
>+      }
>+    }
>+  }
>+  return name;
>+};
>+dart._dartSymbol = function(name) {
>+  return typeof name === "symbol" ? dart.const(new _js_helper.PrivateSymbol.new(dart._toSymbolName(name), name)) : dart.const(new _internal.Symbol.new(dart._toDisplayName(name)));
>+};
>+dart._setterSymbol = function(name) {
>+  return typeof name === "symbol" ? dart.const(new _js_helper.PrivateSymbol.new(dart._toSymbolName(name) + "=", name)) : dart.const(new _internal.Symbol.new(dart._toDisplayName(name) + "="));
>+};
>+dart._checkAndCall = function(f, ftype, obj, typeArgs, args, named, displayName) {
>+  _debugger.trackCall(obj);
>+  let originalTarget = obj === void 0 ? f : obj;
>+  function callNSM(errorMessage) {
>+    return dart.noSuchMethod(originalTarget, new dart.InvocationImpl.new(displayName, args, {namedArguments: named, typeArguments: typeArgs, isMethod: true, failureMessage: errorMessage}));
>+  }
>+  if (f == null) return callNSM('Dynamic call of null.');
>+  if (!(f instanceof Function)) {
>+    if (f != null) {
>+      originalTarget = f;
>+      f = dart.bindCall(f, dart._canonicalMember(f, "call"));
>+      ftype = null;
>+    }
>+    if (f == null) return callNSM("Dynamic call of object has no instance method 'call'.");
>+  }
>+  if (ftype == null) ftype = f[dart._runtimeType];
>+  if (ftype == null) {
>+    if (typeArgs != null) {
>+      dart.throwTypeError('call to JS object `' + obj + '` with type arguments <' + typeArgs + '> is not supported.');
>+    }
>+    if (named != null) args.push(named);
>+    return f.apply(obj, args);
>+  }
>+  if (ftype instanceof Array) ftype = ftype[0];
>+  if (ftype instanceof dart.GenericFunctionType) {
>+    let formalCount = ftype.formalCount;
>+    if (typeArgs == null) {
>+      typeArgs = ftype.instantiateDefaultBounds();
>+    } else if (typeArgs.length != formalCount) {
>+      return callNSM('Dynamic call with incorrect number of type arguments. ' + 'Expected: ' + formalCount + ' Actual: ' + typeArgs.length);
>+    } else {
>+      ftype.checkBounds(typeArgs);
>+    }
>+    ftype = ftype.instantiate(typeArgs);
>+  } else if (typeArgs != null) {
>+    return callNSM('Dynamic call with unexpected type arguments. ' + 'Expected: 0 Actual: ' + typeArgs.length);
>+  }
>+  let errorMessage = dart._argumentErrors(ftype, args, named);
>+  if (errorMessage == null) {
>+    if (typeArgs != null) args = typeArgs.concat(args);
>+    if (named != null) args.push(named);
>+    return f.apply(obj, args);
>+  }
>+  return callNSM(errorMessage);
>+};
>+dart.dcall = function(f, args, named) {
>+  return dart._checkAndCall(f, null, void 0, null, args, named, "call");
>+};
>+dart.dgcall = function(f, typeArgs, args, named) {
>+  return dart._checkAndCall(f, null, void 0, typeArgs, args, named, "call");
>+};
>+dart.replNameLookup = function(object, field) {
>+  let rawField = field;
>+  if (typeof field == 'symbol') {
>+    if (field in object) return field;
>+    field = field.toString();
>+    field = field.substring('Symbol('.length, field.length - 1);
>+  } else if (field.charAt(0) != '_') {
>+    return field;
>+  }
>+  if (field in object) return field;
>+  let proto = object;
>+  while (proto !== null) {
>+    let symbols = Object.getOwnPropertySymbols(proto);
>+    let target = 'Symbol(' + field + ')';
>+    for (let s = 0; s < symbols.length; s++) {
>+      let sym = symbols[s];
>+      if (target == sym.toString()) return sym;
>+    }
>+    proto = proto.__proto__;
>+  }
>+  return rawField;
>+};
>+dart._dhelperRepl = function(obj, field, callback) {
>+  return callback(dart.replNameLookup(obj, field));
>+};
>+dart.callMethod = function(obj, name, typeArgs, args, named, displayName) {
>+  if (typeof obj == "function" && name == "call") {
>+    return dart.dgcall(obj, typeArgs, args, named);
>+  }
>+  let symbol = dart._canonicalMember(obj, name);
>+  if (symbol == null) {
>+    return dart.noSuchMethod(obj, new dart.InvocationImpl.new(displayName, ListOfObject()._check(args), {isMethod: true}));
>+  }
>+  let f = obj != null ? obj[symbol] : null;
>+  let type = dart.getType(obj);
>+  let ftype = dart.getMethodType(type, symbol);
>+  return dart._checkAndCall(f, ftype, obj, typeArgs, args, named, displayName);
>+};
>+dart.dsend = function(obj, method, args, named) {
>+  return dart.callMethod(obj, method, null, args, named, method);
>+};
>+dart.dgsend = function(obj, typeArgs, method, args, named) {
>+  return dart.callMethod(obj, method, typeArgs, args, named, method);
>+};
>+dart.dsendRepl = function(obj, method, args, named) {
>+  return dart.callMethod(obj, dart.replNameLookup(obj, method), null, args, named, method);
>+};
>+dart.dgsendRepl = function(obj, typeArgs, method, args, named) {
>+  return dart.callMethod(obj, dart.replNameLookup(obj, method), typeArgs, args, named, method);
>+};
>+dart.dindex = function(obj, index) {
>+  return dart.callMethod(obj, "_get", null, [index], null, "[]");
>+};
>+dart.dsetindex = function(obj, index, value) {
>+  return dart.callMethod(obj, "_set", null, [index, value], null, "[]=");
>+};
>+dart._isSubtypeOrIgnorableCastFailure = function(t1, t2, isImplicit) {
>+  let result = dart._isSubtypeOrLegacySubtype(t1, t2);
>+  return result === true || result == null && isImplicit && dart.__ignoreWhitelistedErrors && dart._ignoreTypeFailure(t1, t2);
>+};
>+dart._ignoreTypeFailure = function(t1, t2) {
>+  let map = dart._ignoreSubtypeCache.get(t1);
>+  if (map != null) {
>+    let result = map.get(t2);
>+    if (result !== void 0) return result;
>+  } else {
>+    map = new Map();
>+    dart._ignoreSubtypeCache.set(t1, map);
>+  }
>+  let result = null;
>+  if (dart._isFutureOr(t2)) {
>+    let typeArg = dart.getGenericArgs(t2)[$_get](0);
>+    let typeFuture = async.Future$(typeArg);
>+    result = dart._ignoreTypeFailure(t1, typeFuture) || dart._ignoreTypeFailure(t1, typeArg);
>+  } else {
>+    result = dart.isSubtypeOf(t2, core.Iterable) && dart.isSubtypeOf(t1, core.Iterable);
>+    if (result) {
>+      dart._warn("Ignoring cast fail from " + dart.typeName(t1) + " to " + dart.typeName(t2));
>+    }
>+  }
>+  map.set(t2, result);
>+  return result;
>+};
>+dart.is = function(obj, type) {
>+  if (obj == null) {
>+    return core.identical(type, core.Null) || dart._isTop(type);
>+  }
>+  return dart.isSubtypeOf(dart.getReifiedType(obj), type);
>+};
>+dart.as = function(obj, type, isImplicit) {
>+  if (obj == null) return obj;
>+  let actual = dart.getReifiedType(obj);
>+  if (dart._isSubtypeOrIgnorableCastFailure(actual, type, isImplicit)) {
>+    return obj;
>+  }
>+  return dart.castError(obj, type, isImplicit);
>+};
>+dart.test = function(obj) {
>+  if (obj == null) dart._throwBooleanConversionError();
>+  return obj;
>+};
>+dart.dtest = function(obj) {
>+  if (!(typeof obj == 'boolean')) dart.booleanConversionFailed(obj);
>+  return core.bool._check(obj);
>+};
>+dart._throwBooleanConversionError = function() {
>+  return dart.throw(new _js_helper.BooleanConversionAssertionError.new());
>+};
>+dart.booleanConversionFailed = function(obj) {
>+  let actual = dart.typeName(dart.getReifiedType(dart.test(core.bool._check(obj))));
>+  dart.throw(new _js_helper.TypeErrorImpl.new("type '" + actual + "' is not a 'bool' in boolean expression"));
>+};
>+dart.asInt = function(obj) {
>+  if (obj == null) return null;
>+  if (Math.floor(obj) != obj) {
>+    dart.castError(obj, core.int, false);
>+  }
>+  return obj;
>+};
>+dart.notNull = function(x) {
>+  if (x == null) dart.throwNullValueError();
>+  return x;
>+};
>+dart._lookupNonTerminal = function(map, key) {
>+  let result = map.get(key);
>+  if (result != null) return result;
>+  map.set(key, result = new Map());
>+  return result;
>+};
>+dart.constMap = function(K, V, elements) {
>+  let count = elements[$length];
>+  let map = dart._lookupNonTerminal(dart.constantMaps, count);
>+  for (let i = 0; i < count; i++) {
>+    map = dart._lookupNonTerminal(map, elements[i]);
>+  }
>+  map = dart._lookupNonTerminal(map, dart.wrapType(K));
>+  let result = map.get(V);
>+  if (result != null) return core.Map$(K, V)._check(result);
>+  result = new (_js_helper.ImmutableMap$(K, V)).from(elements);
>+  map.set(V, result);
>+  return core.Map$(K, V)._check(result);
>+};
>+dart._createImmutableSet = function(E, elements) {
>+  let t = dart._immutableSetConstructor;
>+  t == null ? dart._immutableSetConstructor = dart.getLibrary("dart:collection")._ImmutableSet$ : t;
>+  return new (dart._immutableSetConstructor(E)).from(elements);
>+};
>+dart.constSet = function(E, elements) {
>+  let count = elements[$length];
>+  let map = dart._lookupNonTerminal(dart.constantSets, count);
>+  for (let i = 0; i < count; i++) {
>+    map = dart._lookupNonTerminal(map, elements[i]);
>+  }
>+  let result = map.get(E);
>+  if (result != null) return core.Set$(E)._check(result);
>+  result = dart._createImmutableSet(E, elements);
>+  map.set(E, result);
>+  return core.Set$(E)._check(result);
>+};
>+dart.dassert = function(value) {
>+  if (value != null && value[dart._runtimeType] instanceof dart.AbstractFunctionType) {
>+    value = dart.dcall(value, []);
>+  }
>+  return dart.dtest(value);
>+};
>+dart.multiKeyPutIfAbsent = function(map, keys, valueFn) {
>+  for (let k of keys) {
>+    let value = map.get(k);
>+    if (!value) {
>+      map.set(k, value = new Map());
>+    }
>+    map = value;
>+  }
>+  if (map.has(dart._value)) return map.get(dart._value);
>+  let value = valueFn();
>+  map.set(dart._value, value);
>+  return value;
>+};
>+dart.const = function(obj) {
>+  let names = dart.getOwnNamesAndSymbols(obj);
>+  let count = names.length;
>+  let map = dart._lookupNonTerminal(dart.constants, count);
>+  for (let i = 0; i < count; i++) {
>+    let name = names[i];
>+    map = dart._lookupNonTerminal(map, name);
>+    map = dart._lookupNonTerminal(map, obj[name]);
>+  }
>+  let type = dart.getReifiedType(obj);
>+  let value = map.get(type);
>+  if (value) return value;
>+  map.set(type, obj);
>+  return obj;
>+};
>+dart.constList = function(elements, elementType) {
>+  let count = elements.length;
>+  let map = dart._lookupNonTerminal(dart.constantLists, count);
>+  for (let i = 0; i < count; i++) {
>+    map = dart._lookupNonTerminal(map, elements[i]);
>+  }
>+  let value = map.get(elementType);
>+  if (value) return value;
>+  _interceptors.JSArray$(elementType).unmodifiable(elements);
>+  map.set(elementType, elements);
>+  return elements;
>+};
>+dart.constFn = function(x) {
>+  return () => x;
>+};
>+dart.extensionSymbol = function(name) {
>+  return dartx[name];
>+};
>+dart.equals = function(x, y) {
>+  return x == null ? y == null : x[$_equals](y);
>+};
>+dart.hashCode = function(obj) {
>+  return obj == null ? 0 : obj[$hashCode];
>+};
>+dart.toString = function(obj) {
>+  if (obj == null) return "null";
>+  if (typeof obj == 'string') return obj;
>+  return obj[$toString]();
>+};
>+dart.str = function(obj) {
>+  if (obj == null) return "null";
>+  if (typeof obj == 'string') return obj;
>+  return core.String._check(dart.notNull(obj[$toString]()));
>+};
>+dart.noSuchMethod = function(obj, invocation) {
>+  if (obj == null) dart.defaultNoSuchMethod(obj, invocation);
>+  return obj[$noSuchMethod](invocation);
>+};
>+dart.defaultNoSuchMethod = function(obj, i) {
>+  if (dart.__trapRuntimeErrors) debugger;
>+  dart.throw(new core.NoSuchMethodError.withInvocation(obj, i));
>+};
>+dart.runtimeType = function(obj) {
>+  return obj == null ? dart.wrapType(core.Null) : obj[dartx.runtimeType];
>+};
>+dart._canonicalMember = function(obj, name) {
>+  if (typeof name === "symbol") return name;
>+  if (obj != null && obj[dart._extensionType] != null) {
>+    return dartx[name];
>+  }
>+  if (name == "constructor" || name == "prototype") {
>+    name = "+" + name;
>+  }
>+  return name;
>+};
>+dart.loadLibrary = function() {
>+  return async.Future.value();
>+};
>+dart.defineLazy = function(to, from) {
>+  for (let name of dart.getOwnNamesAndSymbols(from)) {
>+    dart.defineLazyField(to, name, dart.getOwnPropertyDescriptor(from, name));
>+  }
>+};
>+dart._polyfilled = Symbol("_polyfilled");
>+dart.global = (function() {
>+  var globalState = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : null;
>+  if (!globalState) {
>+    globalState = new Function('return this;')();
>+  }
>+  dart.polyfill(globalState);
>+  if (globalState.Error) {
>+    globalState.Error.stackTraceLimit = Infinity;
>+  }
>+  let settings = 'ddcSettings' in globalState ? globalState.ddcSettings : {};
>+  dart.trapRuntimeErrors('trapRuntimeErrors' in settings ? settings.trapRuntimeErrors : false);
>+  dart.ignoreWhitelistedErrors('ignoreWhitelistedErrors' in settings ? settings.ignoreWhitelistedErrors : false);
>+  dart.ignoreAllErrors('ignoreAllErrors' in settings ? settings.ignoreAllErrors : false);
>+  dart.trackProfile('trackProfile' in settings ? settings.trackProfile : false);
>+  return globalState;
>+})();
>+dart.JsSymbol = Symbol;
>+dart.libraryPrototype = dart.library;
>+dart.startAsyncSynchronously = true;
>+dart._cacheMaps = [];
>+dart._resetFields = [];
>+dart.addAsyncCallback = function() {
>+};
>+dart.removeAsyncCallback = function() {
>+};
>+dart.defineProperty = Object.defineProperty;
>+dart.defineAccessor = Object.defineProperty;
>+dart.getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
>+dart.getOwnPropertyNames = Object.getOwnPropertyNames;
>+dart.getOwnPropertySymbols = Object.getOwnPropertySymbols;
>+dart.getPrototypeOf = Object.getPrototypeOf;
>+dart._mixin = Symbol("mixin");
>+dart.mixinOn = Symbol("mixinOn");
>+dart.implements = Symbol("implements");
>+dart._typeArguments = Symbol("typeArguments");
>+dart._originalDeclaration = Symbol("originalDeclaration");
>+dart.mixinNew = Symbol("dart.mixinNew");
>+dart._constructorSig = Symbol("sigCtor");
>+dart._methodSig = Symbol("sigMethod");
>+dart._fieldSig = Symbol("sigField");
>+dart._getterSig = Symbol("sigGetter");
>+dart._setterSig = Symbol("sigSetter");
>+dart._staticMethodSig = Symbol("sigStaticMethod");
>+dart._staticFieldSig = Symbol("sigStaticField");
>+dart._staticGetterSig = Symbol("sigStaticGetter");
>+dart._staticSetterSig = Symbol("sigStaticSetter");
>+dart._genericTypeCtor = Symbol("genericType");
>+dart._libraryUri = Symbol("libraryUri");
>+dart._extensionType = Symbol("extensionType");
>+dart.dartx = dartx;
>+dart._extensionMap = new Map();
>+dart.isFuture = Symbol("_is_Future");
>+dart.isIterable = Symbol("_is_Iterable");
>+dart.isList = Symbol("_is_List");
>+dart.isMap = Symbol("_is_Map");
>+dart.isStream = Symbol("_is_Stream");
>+dart.isStreamSubscription = Symbol("_is_StreamSubscription");
>+dart.identityEquals = null;
>+dart._runtimeType = Symbol("_runtimeType");
>+dart._moduleName = Symbol("_moduleName");
>+dart._loadedModules = new Map();
>+dart._loadedPartMaps = new Map();
>+dart._loadedSourceMaps = new Map();
>+dart._libraries = null;
>+dart._libraryObjects = null;
>+dart._parts = null;
>+dart.metadata = Symbol("metadata");
>+core.Object = class Object {
>+  constructor() {
>+    throw Error("use `new " + dart.typeName(dart.getReifiedType(this)) + ".new(...)` to create a Dart object");
>+  }
>+  _equals(other) {
>+    return this === other;
>+  }
>+  get hashCode() {
>+    return core.identityHashCode(this);
>+  }
>+  toString() {
>+    return "Instance of '" + dart.typeName(dart.getReifiedType(this)) + "'";
>+  }
>+  noSuchMethod(invocation) {
>+    return dart.defaultNoSuchMethod(this, invocation);
>+  }
>+  get runtimeType() {
>+    return dart.wrapType(dart.getReifiedType(this));
>+  }
>+};
>+(core.Object.new = function() {
>+}).prototype = core.Object.prototype;
>+core.Object.is = function is_Object(o) {
>+  return true;
>+};
>+core.Object.as = function as_Object(o) {
>+  return o;
>+};
>+core.Object._check = function check_Object(o) {
>+  return o;
>+};
>+dart.setMethodSignature(core.Object, () => ({
>+  __proto__: Object.create(null),
>+  _equals: dart.fnType(core.bool, [dart.dynamic]),
>+  [$_equals]: dart.fnType(core.bool, [dart.dynamic]),
>+  toString: dart.fnType(core.String, []),
>+  [$toString]: dart.fnType(core.String, []),
>+  noSuchMethod: dart.fnType(dart.dynamic, [core.Invocation]),
>+  [$noSuchMethod]: dart.fnType(dart.dynamic, [core.Invocation])
>+}));
>+dart.setGetterSignature(core.Object, () => ({
>+  __proto__: Object.create(null),
>+  hashCode: core.int,
>+  [$hashCode]: core.int,
>+  runtimeType: core.Type,
>+  [$runtimeType]: core.Type
>+}));
>+dart.setLibraryUri(core.Object, "dart:core");
>+dart.lazyFn(core.Object, () => core.Type);
>+dart.defineExtensionMethods(core.Object, ['_equals', 'toString', 'noSuchMethod']);
>+dart.defineExtensionAccessors(core.Object, ['hashCode', 'runtimeType']);
>+dart.registerExtension("Object", core.Object);
>+dart.DartType = class DartType extends core.Object {
>+  get name() {
>+    return this.toString();
>+  }
>+  is(object) {
>+    return dart.is(object, this);
>+  }
>+  as(object) {
>+    return dart.as(object, this, false);
>+  }
>+  _check(object) {
>+    return dart.as(object, this, true);
>+  }
>+};
>+(dart.DartType.new = function() {
>+}).prototype = dart.DartType.prototype;
>+dart.addTypeTests(dart.DartType);
>+dart.DartType[dart.implements] = () => [core.Type];
>+dart.setMethodSignature(dart.DartType, () => ({
>+  __proto__: dart.getMethods(dart.DartType.__proto__),
>+  is: dart.fnType(core.bool, [dart.dynamic]),
>+  as: dart.fnType(dart.dynamic, [dart.dynamic]),
>+  _check: dart.fnType(dart.dynamic, [dart.dynamic])
>+}));
>+dart.setGetterSignature(dart.DartType, () => ({
>+  __proto__: dart.getGetters(dart.DartType.__proto__),
>+  name: core.String
>+}));
>+dart.setLibraryUri(dart.DartType, "dart:_runtime");
>+dart.DynamicType = class DynamicType extends dart.DartType {
>+  toString() {
>+    return "dynamic";
>+  }
>+  is(object) {
>+    return true;
>+  }
>+  as(object) {
>+    return object;
>+  }
>+  _check(object) {
>+    return object;
>+  }
>+};
>+(dart.DynamicType.new = function() {
>+}).prototype = dart.DynamicType.prototype;
>+dart.addTypeTests(dart.DynamicType);
>+dart.setLibraryUri(dart.DynamicType, "dart:_runtime");
>+dart.defineExtensionMethods(dart.DynamicType, ['toString']);
>+const _getRawJSTypeFn = dart.privateName(dart, "_getRawJSTypeFn");
>+const _dartName = dart.privateName(dart, "_dartName");
>+const _rawJSType = dart.privateName(dart, "_rawJSType");
>+const _getRawJSType = dart.privateName(dart, "_getRawJSType");
>+dart.LazyJSType = class LazyJSType extends dart.DartType {
>+  toString() {
>+    let raw = this[_getRawJSType]();
>+    return raw != null ? dart.typeName(raw) : "JSObject<" + this[_dartName] + ">";
>+  }
>+  [_getRawJSType]() {
>+    let raw = this[_rawJSType];
>+    if (raw != null) return raw;
>+    try {
>+      raw = this[_getRawJSTypeFn]();
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+    }
>+    if (raw == null) {
>+      dart._warn("Cannot find native JavaScript type (" + this[_dartName] + ") for type check");
>+    } else {
>+      this[_rawJSType] = raw;
>+      this[_getRawJSTypeFn] = null;
>+    }
>+    return raw;
>+  }
>+  rawJSTypeForCheck() {
>+    let l = this[_getRawJSType]();
>+    return l != null ? l : dart.jsobject;
>+  }
>+  isRawJSType(obj) {
>+    let raw = this[_getRawJSType]();
>+    if (raw != null) return obj instanceof raw;
>+    return dart._isJsObject(obj);
>+  }
>+  is(obj) {
>+    return this.isRawJSType(obj) || dart.is(obj, this);
>+  }
>+  as(obj) {
>+    return obj == null || this.is(obj) ? obj : dart.castError(obj, this, false);
>+  }
>+  _check(obj) {
>+    return obj == null || this.is(obj) ? obj : dart.castError(obj, this, true);
>+  }
>+};
>+(dart.LazyJSType.new = function(getRawJSTypeFn, dartName) {
>+  this[_rawJSType] = null;
>+  this[_getRawJSTypeFn] = getRawJSTypeFn;
>+  this[_dartName] = dartName;
>+}).prototype = dart.LazyJSType.prototype;
>+dart.addTypeTests(dart.LazyJSType);
>+dart.setMethodSignature(dart.LazyJSType, () => ({
>+  __proto__: dart.getMethods(dart.LazyJSType.__proto__),
>+  [_getRawJSType]: dart.fnType(core.Object, []),
>+  rawJSTypeForCheck: dart.fnType(core.Object, []),
>+  isRawJSType: dart.fnType(core.bool, [dart.dynamic])
>+}));
>+dart.setLibraryUri(dart.LazyJSType, "dart:_runtime");
>+dart.setFieldSignature(dart.LazyJSType, () => ({
>+  __proto__: dart.getFields(dart.LazyJSType.__proto__),
>+  [_getRawJSTypeFn]: dart.fieldType(VoidTodynamic()),
>+  [_dartName]: dart.finalFieldType(core.String),
>+  [_rawJSType]: dart.fieldType(core.Object)
>+}));
>+dart.defineExtensionMethods(dart.LazyJSType, ['toString']);
>+dart.AnonymousJSType = class AnonymousJSType extends dart.DartType {
>+  toString() {
>+    return this[_dartName];
>+  }
>+  is(obj) {
>+    return dart._isJsObject(obj) || dart.is(obj, this);
>+  }
>+  as(obj) {
>+    return obj == null || dart._isJsObject(obj) ? obj : dart.as(obj, this, false);
>+  }
>+  _check(obj) {
>+    return obj == null || dart._isJsObject(obj) ? obj : dart.as(obj, this, true);
>+  }
>+};
>+(dart.AnonymousJSType.new = function(dartName) {
>+  this[_dartName] = dartName;
>+}).prototype = dart.AnonymousJSType.prototype;
>+dart.addTypeTests(dart.AnonymousJSType);
>+dart.setLibraryUri(dart.AnonymousJSType, "dart:_runtime");
>+dart.setFieldSignature(dart.AnonymousJSType, () => ({
>+  __proto__: dart.getFields(dart.AnonymousJSType.__proto__),
>+  [_dartName]: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionMethods(dart.AnonymousJSType, ['toString']);
>+dart._lazyJSTypes = new Map();
>+dart._anonymousJSTypes = new Map();
>+dart.dynamic = new dart.DynamicType.new();
>+dart.VoidType = class VoidType extends dart.DartType {
>+  toString() {
>+    return "void";
>+  }
>+};
>+(dart.VoidType.new = function() {
>+}).prototype = dart.VoidType.prototype;
>+dart.addTypeTests(dart.VoidType);
>+dart.setLibraryUri(dart.VoidType, "dart:_runtime");
>+dart.defineExtensionMethods(dart.VoidType, ['toString']);
>+dart.void = new dart.VoidType.new();
>+dart.BottomType = class BottomType extends dart.DartType {
>+  toString() {
>+    return "bottom";
>+  }
>+};
>+(dart.BottomType.new = function() {
>+}).prototype = dart.BottomType.prototype;
>+dart.addTypeTests(dart.BottomType);
>+dart.setLibraryUri(dart.BottomType, "dart:_runtime");
>+dart.defineExtensionMethods(dart.BottomType, ['toString']);
>+dart.defineLazy(dart, {
>+  /*dart.bottom*/get bottom() {
>+    return core.Null;
>+  }
>+});
>+dart.JSObjectType = class JSObjectType extends dart.DartType {
>+  toString() {
>+    return "NativeJavaScriptObject";
>+  }
>+};
>+(dart.JSObjectType.new = function() {
>+}).prototype = dart.JSObjectType.prototype;
>+dart.addTypeTests(dart.JSObjectType);
>+dart.setLibraryUri(dart.JSObjectType, "dart:_runtime");
>+dart.defineExtensionMethods(dart.JSObjectType, ['toString']);
>+dart.jsobject = new dart.JSObjectType.new();
>+const _type = dart.privateName(dart, "_type");
>+core.Type = class Type extends core.Object {};
>+(core.Type.new = function() {
>+}).prototype = core.Type.prototype;
>+dart.addTypeTests(core.Type);
>+dart.setLibraryUri(core.Type, "dart:core");
>+dart._Type = class _Type extends core.Type {
>+  toString() {
>+    return dart.typeName(this[_type]);
>+  }
>+  get runtimeType() {
>+    return dart.wrapType(core.Type);
>+  }
>+};
>+(dart._Type.new = function(type) {
>+  this[_type] = type;
>+}).prototype = dart._Type.prototype;
>+dart.addTypeTests(dart._Type);
>+dart.setLibraryUri(dart._Type, "dart:_runtime");
>+dart.setFieldSignature(dart._Type, () => ({
>+  __proto__: dart.getFields(dart._Type.__proto__),
>+  [_type]: dart.finalFieldType(core.Object)
>+}));
>+dart.defineExtensionMethods(dart._Type, ['toString']);
>+dart.defineExtensionAccessors(dart._Type, ['runtimeType']);
>+dart._typeObject = Symbol("typeObject");
>+dart.AbstractFunctionType = class AbstractFunctionType extends dart.DartType {};
>+(dart.AbstractFunctionType.new = function() {
>+}).prototype = dart.AbstractFunctionType.prototype;
>+dart.addTypeTests(dart.AbstractFunctionType);
>+dart.setLibraryUri(dart.AbstractFunctionType, "dart:_runtime");
>+dart._fnTypeNamedArgMap = new Map();
>+dart._fnTypeArrayArgMap = new Map();
>+dart._fnTypeTypeMap = new Map();
>+dart._fnTypeSmallMap = [new Map(), new Map(), new Map()];
>+const _stringValue = dart.privateName(dart, "_stringValue");
>+const _process = dart.privateName(dart, "_process");
>+dart.FunctionType = class FunctionType extends dart.AbstractFunctionType {
>+  static create(returnType, args, extra) {
>+    if (extra == null && args.length < 3) {
>+      return dart._createSmall(returnType, args);
>+    }
>+    args = dart._canonicalizeArray(args, dart._fnTypeArrayArgMap);
>+    let keys = null;
>+    let create = null;
>+    if (extra == null) {
>+      keys = [returnType, args];
>+      create = () => new dart.FunctionType.new(returnType, args, [], {});
>+    } else if (extra instanceof Array) {
>+      let optionals = dart._canonicalizeArray(extra, dart._fnTypeArrayArgMap);
>+      keys = [returnType, args, optionals];
>+      create = () => new dart.FunctionType.new(returnType, args, optionals, {});
>+    } else {
>+      let named = dart._canonicalizeNamed(extra, dart._fnTypeNamedArgMap);
>+      keys = [returnType, args, named];
>+      create = () => new dart.FunctionType.new(returnType, args, [], named);
>+    }
>+    return dart._memoizeArray(dart._fnTypeTypeMap, keys, create);
>+  }
>+  [_process](array) {
>+    let result = [];
>+    for (let i = 0; i < array.length; ++i) {
>+      let arg = array[i];
>+      if (arg instanceof Array) {
>+        this.metadata.push(arg.slice(1));
>+        result.push(arg[0]);
>+      } else {
>+        this.metadata.push([]);
>+        result.push(arg);
>+      }
>+    }
>+    return result;
>+  }
>+  toString() {
>+    return this.name;
>+  }
>+  get requiredParameterCount() {
>+    return this.args[$length];
>+  }
>+  get positionalParameterCount() {
>+    return dart.notNull(this.args[$length]) + dart.notNull(this.optionals[$length]);
>+  }
>+  getPositionalParameter(i) {
>+    let n = this.args[$length];
>+    return dart.notNull(i) < dart.notNull(n) ? this.args[$_get](i) : this.optionals[$_get](dart.notNull(i) + dart.notNull(n));
>+  }
>+  getNamedParameters() {
>+    let result = new (IdentityMapOfString$Object()).new();
>+    let names = dart.getOwnPropertyNames(this.named);
>+    names.sort();
>+    for (let i = 0; i < names.length; ++i) {
>+      let name = names[i];
>+      result[$_set](name, this.named[name]);
>+    }
>+    return result;
>+  }
>+  get name() {
>+    if (this[_stringValue] != null) return this[_stringValue];
>+    let buffer = "(";
>+    for (let i = 0; i < this.args.length; ++i) {
>+      if (i > 0) {
>+        buffer = buffer + ", ";
>+      }
>+      buffer = buffer + dart.typeName(this.args[i]);
>+    }
>+    if (this.optionals.length > 0) {
>+      if (this.args.length > 0) {
>+        buffer = buffer + ", ";
>+      }
>+      buffer = buffer + "[";
>+      for (let i = 0; i < this.optionals.length; ++i) {
>+        if (i > 0) {
>+          buffer = buffer + ", ";
>+        }
>+        buffer = buffer + dart.typeName(this.optionals[i]);
>+      }
>+      buffer = buffer + "]";
>+    } else if (Object.keys(this.named).length > 0) {
>+      if (this.args.length > 0) {
>+        buffer = buffer + ", ";
>+      }
>+      buffer = buffer + "{";
>+      let names = dart.getOwnPropertyNames(this.named);
>+      names.sort();
>+      for (let i = 0; i < names.length; ++i) {
>+        if (i > 0) {
>+          buffer = buffer + ", ";
>+        }
>+        let typeNameString = dart.typeName(this.named[names[i]]);
>+        buffer = buffer + (typeNameString + " " + dart.str(names[i]));
>+      }
>+      buffer = buffer + "}";
>+    }
>+    let returnTypeName = dart.typeName(this.returnType);
>+    buffer = buffer + (") => " + returnTypeName);
>+    this[_stringValue] = buffer;
>+    return buffer;
>+  }
>+  is(obj) {
>+    if (typeof obj == "function") {
>+      let actual = obj[dart._runtimeType];
>+      return actual == null || dart.isSubtypeOf(actual, this);
>+    }
>+    return false;
>+  }
>+  as(obj, isImplicit) {
>+    if (isImplicit === void 0) isImplicit = false;
>+    if (obj == null) return obj;
>+    if (typeof obj == "function") {
>+      let actual = obj[dart._runtimeType];
>+      if (actual == null || dart._isSubtypeOrIgnorableCastFailure(actual, this, isImplicit)) {
>+        return obj;
>+      }
>+    }
>+    return dart.castError(obj, this, isImplicit);
>+  }
>+  _check(obj) {
>+    return this.as(obj, true);
>+  }
>+};
>+(dart.FunctionType.new = function(returnType, args, optionals, named) {
>+  this.metadata = [];
>+  this[_stringValue] = null;
>+  this.returnType = returnType;
>+  this.args = args;
>+  this.optionals = optionals;
>+  this.named = named;
>+  this.args = this[_process](this.args);
>+  this.optionals = this[_process](this.optionals);
>+}).prototype = dart.FunctionType.prototype;
>+dart.addTypeTests(dart.FunctionType);
>+dart.setMethodSignature(dart.FunctionType, () => ({
>+  __proto__: dart.getMethods(dart.FunctionType.__proto__),
>+  [_process]: dart.fnType(core.List, [core.List]),
>+  getPositionalParameter: dart.fnType(dart.dynamic, [core.int]),
>+  getNamedParameters: dart.fnType(core.Map$(core.String, core.Object), []),
>+  as: dart.fnType(dart.dynamic, [dart.dynamic], [core.bool])
>+}));
>+dart.setGetterSignature(dart.FunctionType, () => ({
>+  __proto__: dart.getGetters(dart.FunctionType.__proto__),
>+  requiredParameterCount: core.int,
>+  positionalParameterCount: core.int
>+}));
>+dart.setLibraryUri(dart.FunctionType, "dart:_runtime");
>+dart.setFieldSignature(dart.FunctionType, () => ({
>+  __proto__: dart.getFields(dart.FunctionType.__proto__),
>+  returnType: dart.finalFieldType(dart.dynamic),
>+  args: dart.fieldType(core.List),
>+  optionals: dart.fieldType(core.List),
>+  named: dart.finalFieldType(dart.dynamic),
>+  metadata: dart.fieldType(core.List),
>+  [_stringValue]: dart.fieldType(core.String)
>+}));
>+dart.defineExtensionMethods(dart.FunctionType, ['toString']);
>+dart.TypeVariable = class TypeVariable extends dart.DartType {
>+  get name() {
>+    return this[name$];
>+  }
>+  set name(value) {
>+    super.name = value;
>+  }
>+  toString() {
>+    return this.name;
>+  }
>+};
>+(dart.TypeVariable.new = function(name) {
>+  this[name$] = name;
>+}).prototype = dart.TypeVariable.prototype;
>+dart.addTypeTests(dart.TypeVariable);
>+const name$ = Symbol("TypeVariable.name");
>+dart.setLibraryUri(dart.TypeVariable, "dart:_runtime");
>+dart.setFieldSignature(dart.TypeVariable, () => ({
>+  __proto__: dart.getFields(dart.TypeVariable.__proto__),
>+  name: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionMethods(dart.TypeVariable, ['toString']);
>+const _instantiateTypeBounds = dart.privateName(dart, "_instantiateTypeBounds");
>+const _instantiateTypeParts = dart.privateName(dart, "_instantiateTypeParts");
>+const _typeFormals = dart.privateName(dart, "_typeFormals");
>+dart.GenericFunctionType = class GenericFunctionType extends dart.AbstractFunctionType {
>+  get typeFormals() {
>+    if (this[_typeFormals] != null) return this[_typeFormals];
>+    return this[_typeFormals] = dart._typeFormalsFromFunction(this[_instantiateTypeParts]);
>+  }
>+  checkBounds(typeArgs) {
>+    if (this[_instantiateTypeBounds] == null) return;
>+    let bounds = this.instantiateTypeBounds(typeArgs);
>+    let typeFormals = this.typeFormals;
>+    for (let i = 0; i < dart.notNull(typeArgs[$length]); i++) {
>+      dart.checkTypeBound(typeArgs[$_get](i), bounds[$_get](i), typeFormals[$_get](i).name);
>+    }
>+  }
>+  instantiate(typeArgs) {
>+    let parts = this[_instantiateTypeParts].apply(null, typeArgs);
>+    return dart.FunctionType.create(parts[0], parts[1], parts[2]);
>+  }
>+  instantiateTypeBounds(typeArgs) {
>+    let boundsFn = this[_instantiateTypeBounds];
>+    if (boundsFn == null) {
>+      return core.List.filled(this.formalCount, dart.dynamic);
>+    }
>+    return boundsFn.apply(null, typeArgs);
>+  }
>+  toString() {
>+    let s = "<";
>+    let typeFormals = this.typeFormals;
>+    let typeBounds = this.instantiateTypeBounds(typeFormals);
>+    for (let i = 0, n = typeFormals[$length]; i < dart.notNull(n); i++) {
>+      if (i !== 0) {
>+        s = s + ", ";
>+      }
>+      s = s + typeFormals[i].name;
>+      let bound = typeBounds[$_get](i);
>+      if (bound !== dart.dynamic && bound !== core.Object) {
>+        s = s + (" extends " + dart.str(bound));
>+      }
>+    }
>+    s = s + (">" + dart.notNull(dart.toString(this.instantiate(typeFormals))));
>+    return s;
>+  }
>+  instantiateDefaultBounds() {
>+    let typeFormals = this.typeFormals;
>+    let all = new (IdentityMapOfObject$int()).new();
>+    let defaults = ListOfObject().new(typeFormals[$length]);
>+    let partials = new (IdentityMapOfTypeVariable$Object()).new();
>+    let typeBounds = this.instantiateTypeBounds(typeFormals);
>+    for (let i = 0; i < dart.notNull(typeFormals[$length]); i++) {
>+      let typeFormal = typeFormals[$_get](i);
>+      let bound = typeBounds[$_get](i);
>+      all._set(typeFormal, i);
>+      if (core.identical(bound, dart.dynamic)) {
>+        defaults[$_set](i, bound);
>+      } else {
>+        defaults[$_set](i, typeFormal);
>+        partials[$_set](typeFormal, bound);
>+      }
>+    }
>+    function hasFreeFormal(t) {
>+      if (dart.test(partials[$containsKey](t))) return true;
>+      let typeArgs = dart.getGenericArgs(t);
>+      if (typeArgs != null) return typeArgs[$any](hasFreeFormal);
>+      if (dart.GenericFunctionType.is(t)) {
>+        return hasFreeFormal(t.instantiate(t.typeFormals));
>+      }
>+      if (dart.FunctionType.is(t)) {
>+        return dart.test(hasFreeFormal(t.returnType)) || dart.test(t.args[$any](hasFreeFormal));
>+      }
>+      return false;
>+    }
>+    let hasProgress = true;
>+    while (hasProgress) {
>+      hasProgress = false;
>+      for (let typeFormal of partials[$keys]) {
>+        let partialBound = partials[$_get](typeFormal);
>+        if (!dart.test(hasFreeFormal(partialBound))) {
>+          let index = all._get(typeFormal);
>+          defaults[$_set](index, this.instantiateTypeBounds(defaults)[$_get](index));
>+          partials[$remove](typeFormal);
>+          hasProgress = true;
>+          break;
>+        }
>+      }
>+    }
>+    if (dart.test(partials[$isNotEmpty])) {
>+      dart.throwTypeError("Instantiate to bounds failed for type with " + ("recursive generic bounds: " + dart.typeName(this) + ". ") + "Try passing explicit type arguments.");
>+    }
>+    return defaults;
>+  }
>+  is(obj) {
>+    if (typeof obj == "function") {
>+      let actual = obj[dart._runtimeType];
>+      return actual != null && dart.isSubtypeOf(actual, this);
>+    }
>+    return false;
>+  }
>+  as(obj) {
>+    if (obj == null || this.is(obj)) return obj;
>+    return dart.castError(obj, this, false);
>+  }
>+  _check(obj) {
>+    if (obj == null || this.is(obj)) return obj;
>+    return dart.castError(obj, this, true);
>+  }
>+};
>+(dart.GenericFunctionType.new = function(instantiateTypeParts, instantiateTypeBounds) {
>+  this[_typeFormals] = null;
>+  this[_instantiateTypeBounds] = instantiateTypeBounds;
>+  this[_instantiateTypeParts] = instantiateTypeParts;
>+  this.formalCount = instantiateTypeParts.length;
>+}).prototype = dart.GenericFunctionType.prototype;
>+dart.addTypeTests(dart.GenericFunctionType);
>+dart.setMethodSignature(dart.GenericFunctionType, () => ({
>+  __proto__: dart.getMethods(dart.GenericFunctionType.__proto__),
>+  checkBounds: dart.fnType(dart.void, [core.List]),
>+  instantiate: dart.fnType(dart.FunctionType, [dart.dynamic]),
>+  instantiateTypeBounds: dart.fnType(core.List, [core.List]),
>+  instantiateDefaultBounds: dart.fnType(core.List, [])
>+}));
>+dart.setGetterSignature(dart.GenericFunctionType, () => ({
>+  __proto__: dart.getGetters(dart.GenericFunctionType.__proto__),
>+  typeFormals: core.List$(dart.TypeVariable)
>+}));
>+dart.setLibraryUri(dart.GenericFunctionType, "dart:_runtime");
>+dart.setFieldSignature(dart.GenericFunctionType, () => ({
>+  __proto__: dart.getFields(dart.GenericFunctionType.__proto__),
>+  [_instantiateTypeParts]: dart.finalFieldType(dart.dynamic),
>+  formalCount: dart.finalFieldType(core.int),
>+  [_instantiateTypeBounds]: dart.finalFieldType(dart.dynamic),
>+  [_typeFormals]: dart.fieldType(ListOfTypeVariable())
>+}));
>+dart.defineExtensionMethods(dart.GenericFunctionType, ['toString']);
>+dart._subtypeCache = Symbol("_subtypeCache");
>+const _typeVariables = dart.privateName(dart, "_typeVariables");
>+const _isSubtypeMatch = dart.privateName(dart, "_isSubtypeMatch");
>+const _constrainLower = dart.privateName(dart, "_constrainLower");
>+const _constrainUpper = dart.privateName(dart, "_constrainUpper");
>+const _isFunctionSubtypeMatch = dart.privateName(dart, "_isFunctionSubtypeMatch");
>+const _isInterfaceSubtypeMatch = dart.privateName(dart, "_isInterfaceSubtypeMatch");
>+const _isNull = dart.privateName(dart, "_isNull");
>+const _isTop = dart.privateName(dart, "_isTop");
>+dart._TypeInferrer = class _TypeInferrer extends core.Object {
>+  getInferredTypes() {
>+    let result = JSArrayOfObject().of([]);
>+    for (let constraint of this[_typeVariables][$values]) {
>+      if (constraint.lower != null) {
>+        result[$add](constraint.lower);
>+      } else if (constraint.upper != null) {
>+        result[$add](constraint.upper);
>+      } else {
>+        return null;
>+      }
>+    }
>+    return result;
>+  }
>+  trySubtypeMatch(subtype, supertype) {
>+    return this[_isSubtypeMatch](subtype, supertype);
>+  }
>+  [_constrainLower](parameter, lower) {
>+    this[_typeVariables][$_get](parameter)[_constrainLower](lower);
>+  }
>+  [_constrainUpper](parameter, upper) {
>+    this[_typeVariables][$_get](parameter)[_constrainUpper](upper);
>+  }
>+  [_isFunctionSubtypeMatch](subtype, supertype) {
>+    if (dart.notNull(subtype.requiredParameterCount) > dart.notNull(supertype.requiredParameterCount)) {
>+      return false;
>+    }
>+    if (dart.notNull(subtype.positionalParameterCount) < dart.notNull(supertype.positionalParameterCount)) {
>+      return false;
>+    }
>+    if (!dart.VoidType.is(supertype.returnType) && !dart.test(this[_isSubtypeMatch](subtype.returnType, supertype.returnType))) {
>+      return false;
>+    }
>+    for (let i = 0, n = supertype.positionalParameterCount; i < dart.notNull(n); ++i) {
>+      if (!dart.test(this[_isSubtypeMatch](supertype.getPositionalParameter(i), subtype.getPositionalParameter(i)))) {
>+        return false;
>+      }
>+    }
>+    let supertypeNamed = supertype.getNamedParameters();
>+    let subtypeNamed = supertype.getNamedParameters();
>+    for (let name of supertypeNamed[$keys]) {
>+      let subtypeParamType = subtypeNamed[$_get](name);
>+      if (subtypeParamType == null) return false;
>+      if (!dart.test(this[_isSubtypeMatch](supertypeNamed[$_get](name), subtypeParamType))) {
>+        return false;
>+      }
>+    }
>+    return true;
>+  }
>+  [_isInterfaceSubtypeMatch](subtype, supertype) {
>+    let matchingSupertype = dart._getMatchingSupertype(subtype, supertype);
>+    if (matchingSupertype == null) return false;
>+    let matchingTypeArgs = dart.getGenericArgs(matchingSupertype);
>+    let supertypeTypeArgs = dart.getGenericArgs(supertype);
>+    for (let i = 0; i < dart.notNull(supertypeTypeArgs[$length]); i++) {
>+      if (!dart.test(this[_isSubtypeMatch](matchingTypeArgs[$_get](i), supertypeTypeArgs[$_get](i)))) {
>+        return false;
>+      }
>+    }
>+    return true;
>+  }
>+  [_isNull](type) {
>+    return core.identical(type, core.Null);
>+  }
>+  [_isSubtypeMatch](subtype, supertype) {
>+    if (dart.TypeVariable.is(subtype) && dart.test(this[_typeVariables][$containsKey](subtype))) {
>+      this[_constrainUpper](subtype, supertype);
>+      return true;
>+    }
>+    if (dart.TypeVariable.is(supertype) && dart.test(this[_typeVariables][$containsKey](supertype))) {
>+      this[_constrainLower](supertype, subtype);
>+      return true;
>+    }
>+    if (core.identical(subtype, supertype)) return true;
>+    if (dart.test(this[_isTop](supertype))) return true;
>+    if (dart.test(this[_isNull](subtype))) return true;
>+    if (dart._isFutureOr(subtype)) {
>+      let subtypeArg = dart.getGenericArgs(subtype)[$_get](0);
>+      if (dart._isFutureOr(supertype)) {
>+        let supertypeArg = dart.getGenericArgs(supertype)[$_get](0);
>+        return this[_isSubtypeMatch](subtypeArg, supertypeArg);
>+      }
>+      let subtypeFuture = async.Future$(subtypeArg);
>+      return dart.test(this[_isSubtypeMatch](subtypeFuture, supertype)) && dart.test(this[_isSubtypeMatch](subtypeArg, supertype));
>+    }
>+    if (dart._isFutureOr(supertype)) {
>+      let supertypeArg = dart.getGenericArgs(supertype)[$_get](0);
>+      let supertypeFuture = async.Future$(supertypeArg);
>+      return dart.test(this[_isSubtypeMatch](subtype, supertypeFuture)) || dart.test(this[_isSubtypeMatch](subtype, supertypeArg));
>+    }
>+    if (dart.TypeVariable.is(subtype)) {
>+      return dart.TypeVariable.is(supertype) && subtype == supertype;
>+    }
>+    if (dart.GenericFunctionType.is(subtype)) {
>+      if (dart.GenericFunctionType.is(supertype)) {
>+        let formalCount = subtype.formalCount;
>+        if (formalCount != supertype.formalCount) return false;
>+        let fresh = supertype.typeFormals;
>+        let t1Bounds = subtype.instantiateTypeBounds(fresh);
>+        let t2Bounds = supertype.instantiateTypeBounds(fresh);
>+        for (let i = 0; i < dart.notNull(formalCount); i++) {
>+          if (!dart.test(this[_isSubtypeMatch](t2Bounds[$_get](i), t1Bounds[$_get](i)))) {
>+            return false;
>+          }
>+        }
>+        return this[_isFunctionSubtypeMatch](subtype.instantiate(fresh), supertype.instantiate(fresh));
>+      } else {
>+        return false;
>+      }
>+    } else if (dart.GenericFunctionType.is(supertype)) {
>+      return false;
>+    }
>+    if (dart.FunctionType.is(subtype)) {
>+      if (!dart.FunctionType.is(supertype)) {
>+        if (core.identical(supertype, core.Function) || core.identical(supertype, core.Object)) {
>+          return true;
>+        } else {
>+          return false;
>+        }
>+      }
>+      if (dart.FunctionType.is(supertype)) {
>+        return this[_isFunctionSubtypeMatch](subtype, supertype);
>+      }
>+    }
>+    return this[_isInterfaceSubtypeMatch](subtype, supertype);
>+  }
>+  [_isTop](type) {
>+    return core.identical(type, dart.dynamic) || core.identical(type, dart.void) || core.identical(type, core.Object);
>+  }
>+};
>+(dart._TypeInferrer.new = function(typeVariables) {
>+  this[_typeVariables] = MapOfTypeVariable$TypeConstraint().fromIterables(typeVariables, IterableOfTypeConstraint()._check(typeVariables[$map](dart.TypeConstraint, _ => new dart.TypeConstraint.new())));
>+}).prototype = dart._TypeInferrer.prototype;
>+dart.addTypeTests(dart._TypeInferrer);
>+dart.setMethodSignature(dart._TypeInferrer, () => ({
>+  __proto__: dart.getMethods(dart._TypeInferrer.__proto__),
>+  getInferredTypes: dart.fnType(core.List$(core.Object), []),
>+  trySubtypeMatch: dart.fnType(core.bool, [core.Object, core.Object]),
>+  [_constrainLower]: dart.fnType(dart.void, [dart.TypeVariable, core.Object]),
>+  [_constrainUpper]: dart.fnType(dart.void, [dart.TypeVariable, core.Object]),
>+  [_isFunctionSubtypeMatch]: dart.fnType(core.bool, [dart.FunctionType, dart.FunctionType]),
>+  [_isInterfaceSubtypeMatch]: dart.fnType(core.bool, [core.Object, core.Object]),
>+  [_isNull]: dart.fnType(core.bool, [core.Object]),
>+  [_isSubtypeMatch]: dart.fnType(core.bool, [core.Object, core.Object]),
>+  [_isTop]: dart.fnType(core.bool, [core.Object])
>+}));
>+dart.setLibraryUri(dart._TypeInferrer, "dart:_runtime");
>+dart.setFieldSignature(dart._TypeInferrer, () => ({
>+  __proto__: dart.getFields(dart._TypeInferrer.__proto__),
>+  [_typeVariables]: dart.finalFieldType(MapOfTypeVariable$TypeConstraint())
>+}));
>+dart.TypeConstraint = class TypeConstraint extends core.Object {
>+  [_constrainLower](type) {
>+    if (this.lower != null) {
>+      if (dart.isSubtypeOf(this.lower, type)) {
>+        return;
>+      }
>+      if (!dart.isSubtypeOf(type, this.lower)) {
>+        type = core.Null;
>+      }
>+    }
>+    this.lower = type;
>+  }
>+  [_constrainUpper](type) {
>+    if (this.upper != null) {
>+      if (dart.isSubtypeOf(type, this.upper)) {
>+        return;
>+      }
>+      if (!dart.isSubtypeOf(this.upper, type)) {
>+        type = core.Object;
>+      }
>+    }
>+    this.upper = type;
>+  }
>+  toString() {
>+    return dart.typeName(this.lower) + " <: <type> <: " + dart.typeName(this.upper);
>+  }
>+};
>+(dart.TypeConstraint.new = function() {
>+  this.lower = null;
>+  this.upper = null;
>+}).prototype = dart.TypeConstraint.prototype;
>+dart.addTypeTests(dart.TypeConstraint);
>+dart.setMethodSignature(dart.TypeConstraint, () => ({
>+  __proto__: dart.getMethods(dart.TypeConstraint.__proto__),
>+  [_constrainLower]: dart.fnType(dart.void, [core.Object]),
>+  [_constrainUpper]: dart.fnType(dart.void, [core.Object])
>+}));
>+dart.setLibraryUri(dart.TypeConstraint, "dart:_runtime");
>+dart.setFieldSignature(dart.TypeConstraint, () => ({
>+  __proto__: dart.getFields(dart.TypeConstraint.__proto__),
>+  lower: dart.fieldType(core.Object),
>+  upper: dart.fieldType(core.Object)
>+}));
>+dart.defineExtensionMethods(dart.TypeConstraint, ['toString']);
>+dart._thrownValue = Symbol("_thrownValue");
>+dart._jsError = Symbol("_jsError");
>+dart._stackTrace = Symbol("_stackTrace");
>+dart.DartError = class DartError extends Error {
>+  constructor(error) {
>+    super();
>+    if (error == null) error = new core.NullThrownError.new();
>+    this[dart._thrownValue] = error;
>+    if (error != null && typeof error == "object" && error[dart._jsError] == null) {
>+      error[dart._jsError] = this;
>+    }
>+  }
>+  get message() {
>+    return dart.toString(this[dart._thrownValue]);
>+  }
>+};
>+dart.RethrownDartError = class RethrownDartError extends dart.DartError {
>+  constructor(error, stackTrace) {
>+    super(error);
>+    this[dart._stackTrace] = stackTrace;
>+  }
>+  get message() {
>+    return super.message + "\n    " + dart.toString(this[dart._stackTrace]) + "\n";
>+  }
>+};
>+const _jsError = dart.privateName(dart, "_jsError");
>+const _jsObjectMissingTrace = dart.privateName(dart, "_jsObjectMissingTrace");
>+const _trace = dart.privateName(dart, "_trace");
>+dart._StackTrace = class _StackTrace extends core.Object {
>+  toString() {
>+    if (this[_trace] != null) return this[_trace];
>+    let e = this[_jsError];
>+    let trace = "";
>+    if (e != null && typeof e === "object") {
>+      trace = _interceptors.NativeError.is(e) ? e[$dartStack]() : e.stack;
>+      if (trace != null && _debugger.stackTraceMapper != null) {
>+        trace = _debugger.stackTraceMapper(trace);
>+      }
>+    }
>+    if (trace[$isEmpty] || this[_jsObjectMissingTrace] != null) {
>+      let jsToString = null;
>+      try {
>+        jsToString = "" + this[_jsObjectMissingTrace];
>+      } catch (e$) {
>+        let _ = dart.getThrown(e$);
>+        jsToString = "<error converting JS object to string>";
>+      }
>+      trace = "Non-error `" + dart.str(jsToString) + "` thrown by JS does not have stack trace." + ("\nCaught in Dart at:\n\n" + dart.str(trace));
>+    }
>+    return this[_trace] = trace;
>+  }
>+};
>+(dart._StackTrace.new = function(jsError) {
>+  this[_trace] = null;
>+  this[_jsError] = jsError;
>+  this[_jsObjectMissingTrace] = null;
>+}).prototype = dart._StackTrace.prototype;
>+(dart._StackTrace.missing = function(caughtObj) {
>+  this[_trace] = null;
>+  this[_jsObjectMissingTrace] = caughtObj != null ? caughtObj : "null";
>+  this[_jsError] = Error();
>+}).prototype = dart._StackTrace.prototype;
>+dart.addTypeTests(dart._StackTrace);
>+dart._StackTrace[dart.implements] = () => [core.StackTrace];
>+dart.setLibraryUri(dart._StackTrace, "dart:_runtime");
>+dart.setFieldSignature(dart._StackTrace, () => ({
>+  __proto__: dart.getFields(dart._StackTrace.__proto__),
>+  [_jsError]: dart.finalFieldType(core.Object),
>+  [_jsObjectMissingTrace]: dart.finalFieldType(core.Object),
>+  [_trace]: dart.fieldType(core.String)
>+}));
>+dart.defineExtensionMethods(dart._StackTrace, ['toString']);
>+let const$;
>+let const$0;
>+let const$1;
>+core.Invocation = class Invocation extends core.Object {
>+  static method(memberName, positionalArguments, namedArguments) {
>+    if (namedArguments === void 0) namedArguments = null;
>+    return new core._Invocation.method(memberName, null, positionalArguments, namedArguments);
>+  }
>+  static genericMethod(memberName, typeArguments, positionalArguments, namedArguments) {
>+    if (namedArguments === void 0) namedArguments = null;
>+    return new core._Invocation.method(memberName, typeArguments, positionalArguments, namedArguments);
>+  }
>+  static getter(name) {
>+    return new core._Invocation.getter(name);
>+  }
>+  static setter(memberName, argument) {
>+    return new core._Invocation.setter(memberName, argument);
>+  }
>+  get typeArguments() {
>+    return const$1 || (const$1 = dart.constList([], core.Type));
>+  }
>+  get isAccessor() {
>+    return dart.test(this.isGetter) || dart.test(this.isSetter);
>+  }
>+};
>+(core.Invocation.new = function() {
>+}).prototype = core.Invocation.prototype;
>+dart.addTypeTests(core.Invocation);
>+dart.setGetterSignature(core.Invocation, () => ({
>+  __proto__: dart.getGetters(core.Invocation.__proto__),
>+  typeArguments: core.List$(core.Type),
>+  isAccessor: core.bool
>+}));
>+dart.setLibraryUri(core.Invocation, "dart:core");
>+dart.InvocationImpl = class InvocationImpl extends core.Invocation {
>+  get typeArguments() {
>+    return this[typeArguments$];
>+  }
>+  set typeArguments(value) {
>+    super.typeArguments = value;
>+  }
>+  static _namedArgsToSymbols(namedArgs) {
>+    if (namedArgs == null) return const$0 || (const$0 = dart.constMap(core.Symbol, dart.dynamic, []));
>+    return MapOfSymbol$dynamic().unmodifiable(core.Map.fromIterable(dart.getOwnPropertyNames(namedArgs), {
>+      key: dart._dartSymbol,
>+      value: k => namedArgs[k]
>+    }));
>+  }
>+};
>+(dart.InvocationImpl.new = function(memberName, positionalArguments, opts) {
>+  let namedArguments = opts && 'namedArguments' in opts ? opts.namedArguments : null;
>+  let typeArguments = opts && 'typeArguments' in opts ? opts.typeArguments : null;
>+  let isMethod = opts && 'isMethod' in opts ? opts.isMethod : false;
>+  let isGetter = opts && 'isGetter' in opts ? opts.isGetter : false;
>+  let isSetter = opts && 'isSetter' in opts ? opts.isSetter : false;
>+  let failureMessage = opts && 'failureMessage' in opts ? opts.failureMessage : "method not found";
>+  this.isMethod = isMethod;
>+  this.isGetter = isGetter;
>+  this.isSetter = isSetter;
>+  this.failureMessage = failureMessage;
>+  this.memberName = dart.test(isSetter) ? dart._setterSymbol(memberName) : dart._dartSymbol(memberName);
>+  this.positionalArguments = core.List.unmodifiable(positionalArguments);
>+  this.namedArguments = dart.InvocationImpl._namedArgsToSymbols(namedArguments);
>+  this[typeArguments$] = typeArguments == null ? const$ || (const$ = dart.constList([], core.Type)) : ListOfType().unmodifiable(typeArguments[$map](dart.dynamic, dart.wrapType));
>+  dart.InvocationImpl.__proto__.new.call(this);
>+}).prototype = dart.InvocationImpl.prototype;
>+dart.addTypeTests(dart.InvocationImpl);
>+const typeArguments$ = Symbol("InvocationImpl.typeArguments");
>+dart.setLibraryUri(dart.InvocationImpl, "dart:_runtime");
>+dart.setFieldSignature(dart.InvocationImpl, () => ({
>+  __proto__: dart.getFields(dart.InvocationImpl.__proto__),
>+  memberName: dart.finalFieldType(core.Symbol),
>+  positionalArguments: dart.finalFieldType(core.List),
>+  namedArguments: dart.finalFieldType(MapOfSymbol$dynamic()),
>+  typeArguments: dart.finalFieldType(ListOfType()),
>+  isMethod: dart.finalFieldType(core.bool),
>+  isGetter: dart.finalFieldType(core.bool),
>+  isSetter: dart.finalFieldType(core.bool),
>+  failureMessage: dart.finalFieldType(core.String)
>+}));
>+dart._ignoreSubtypeCache = new Map();
>+dart.constantMaps = new Map();
>+dart.constantSets = new Map();
>+dart._immutableSetConstructor = null;
>+dart._value = Symbol("_value");
>+dart.constants = new Map();
>+dart.constantLists = new Map();
>+dart.identityHashCode_ = Symbol("_identityHashCode");
>+dart.JsIterator = class JsIterator {
>+  constructor(dartIterator) {
>+    this.dartIterator = dartIterator;
>+  }
>+  next() {
>+    let i = this.dartIterator;
>+    let done = !i.moveNext();
>+    return {done: done, value: done ? void 0 : i.current};
>+  }
>+};
>+_debugger.JsonMLConfig = class JsonMLConfig extends core.Object {
>+  toString() {
>+    return "JsonMLConfig(" + dart.str(this.name) + ")";
>+  }
>+};
>+(_debugger.JsonMLConfig.new = function(name) {
>+  this.name = name;
>+}).prototype = _debugger.JsonMLConfig.prototype;
>+dart.addTypeTests(_debugger.JsonMLConfig);
>+dart.setLibraryUri(_debugger.JsonMLConfig, "dart:_debugger");
>+dart.setFieldSignature(_debugger.JsonMLConfig, () => ({
>+  __proto__: dart.getFields(_debugger.JsonMLConfig.__proto__),
>+  name: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionMethods(_debugger.JsonMLConfig, ['toString']);
>+dart.defineLazy(_debugger.JsonMLConfig, {
>+  /*_debugger.JsonMLConfig.none*/get none() {
>+    return dart.const(new _debugger.JsonMLConfig.new("none"));
>+  },
>+  /*_debugger.JsonMLConfig.skipDart*/get skipDart() {
>+    return dart.const(new _debugger.JsonMLConfig.new("skipDart"));
>+  },
>+  /*_debugger.JsonMLConfig.keyToString*/get keyToString() {
>+    return dart.const(new _debugger.JsonMLConfig.new("keyToString"));
>+  },
>+  /*_debugger.JsonMLConfig.asClass*/get asClass() {
>+    return dart.const(new _debugger.JsonMLConfig.new("asClass"));
>+  },
>+  /*_debugger.JsonMLConfig.asObject*/get asObject() {
>+    return dart.const(new _debugger.JsonMLConfig.new("asObject"));
>+  },
>+  /*_debugger.JsonMLConfig.asMap*/get asMap() {
>+    return dart.const(new _debugger.JsonMLConfig.new("asMap"));
>+  }
>+});
>+dart.defineLazy(_debugger, {
>+  /*_debugger._maxSpanLength*/get _maxSpanLength() {
>+    return 100;
>+  },
>+  set _maxSpanLength(_) {},
>+  /*_debugger._devtoolsFormatter*/get _devtoolsFormatter() {
>+    return new _debugger.JsonMLFormatter.new(new _debugger.DartFormatter.new());
>+  },
>+  set _devtoolsFormatter(_) {},
>+  /*_debugger.maxFormatterStringLength*/get maxFormatterStringLength() {
>+    return 100;
>+  },
>+  set maxFormatterStringLength(_) {}
>+});
>+_debugger._typeof = function(object) {
>+  return typeof object;
>+};
>+_debugger.getOwnPropertyNames = function(object) {
>+  return JSArrayOfString().of(dart.getOwnPropertyNames(object));
>+};
>+_debugger.getOwnPropertySymbols = function(object) {
>+  return Object.getOwnPropertySymbols(object);
>+};
>+_debugger.JSNative = class JSNative extends core.Object {
>+  static getProperty(object, name) {
>+    return object[name];
>+  }
>+  static setProperty(object, name, value) {
>+    return object[name] = value;
>+  }
>+};
>+(_debugger.JSNative.new = function() {
>+}).prototype = _debugger.JSNative.prototype;
>+dart.addTypeTests(_debugger.JSNative);
>+dart.setLibraryUri(_debugger.JSNative, "dart:_debugger");
>+_debugger.addMetadataChildren = function(object, ret) {
>+  ret.add(new _debugger.NameValuePair.new({name: "[[class]]", value: dart.getReifiedType(object), config: _debugger.JsonMLConfig.asClass}));
>+};
>+_debugger.addPropertiesFromSignature = function(sig, properties, object, walkPrototypeChain, opts) {
>+  let tagTypes = opts && 'tagTypes' in opts ? opts.tagTypes : false;
>+  let skippedNames = new collection._HashSet.new();
>+  skippedNames.add("hashCode");
>+  let objectPrototype = Object.prototype;
>+  while (sig != null && !core.identical(sig, objectPrototype)) {
>+    for (let symbol of _debugger.getOwnPropertySymbols(sig)) {
>+      let dartName = _debugger.symbolName(symbol);
>+      let dartXPrefix = "dartx.";
>+      if (dartName[$startsWith](dartXPrefix)) {
>+        dartName = dartName[$substring](dartXPrefix.length);
>+      }
>+      if (dart.test(skippedNames.contains(dartName))) continue;
>+      let value = _debugger.safeGetProperty(object, symbol);
>+      if (dart.dtest(tagTypes) && _debugger._typeof(value) === "function") {
>+        dart.fn(value, sig[symbol]);
>+      }
>+      properties.add(new _debugger.NameValuePair.new({name: dartName, value: value}));
>+    }
>+    for (let name of _debugger.getOwnPropertyNames(sig)) {
>+      let value = _debugger.safeGetProperty(object, name);
>+      if (dart.test(skippedNames.contains(name))) continue;
>+      if (dart.dtest(tagTypes) && _debugger._typeof(value) === "function") {
>+        dart.fn(value, sig[name]);
>+      }
>+      properties.add(new _debugger.NameValuePair.new({name: name, value: value}));
>+    }
>+    if (!dart.test(walkPrototypeChain)) break;
>+    sig = dart.getPrototypeOf(sig);
>+  }
>+};
>+_debugger.sortProperties = function(properties) {
>+  let sortedProperties = properties[$toList]();
>+  sortedProperties[$sort](dart.fn((a, b) => {
>+    let aPrivate = a.name[$startsWith]("_");
>+    let bPrivate = b.name[$startsWith]("_");
>+    if (aPrivate !== bPrivate) return aPrivate ? 1 : -1;
>+    return a.name[$compareTo](b.name);
>+  }, NameValuePairAndNameValuePairToint()));
>+  return sortedProperties;
>+};
>+_debugger.getObjectTypeName = function(object) {
>+  let reifiedType = dart.getReifiedType(object);
>+  if (reifiedType == null) {
>+    if (_debugger._typeof(object) === "function") {
>+      return "[[Raw JavaScript Function]]";
>+    }
>+    return "<Error getting type name>";
>+  }
>+  return _debugger.getTypeName(reifiedType);
>+};
>+_debugger.getTypeName = function(type) {
>+  return dart.typeName(type);
>+};
>+const _simpleFormatter = dart.privateName(_debugger, "_simpleFormatter");
>+_debugger.safePreview = function(object, config) {
>+  try {
>+    let preview = _debugger._devtoolsFormatter[_simpleFormatter].preview(object, config);
>+    if (preview != null) return preview;
>+    return dart.toString(object);
>+  } catch (e$) {
>+    let e = dart.getThrown(e$);
>+    return "<Exception thrown> " + dart.str(e);
>+  }
>+};
>+_debugger.symbolName = function(symbol) {
>+  let name = dart.toString(symbol);
>+  if (!name[$startsWith]("Symbol(")) dart.assertFailed(null, "dart:_debugger", 158, 10, "name.startsWith('Symbol(')");
>+  return name[$substring]("Symbol(".length, name.length - 1);
>+};
>+_debugger.hasMethod = function(object, name) {
>+  try {
>+    return dart.hasMethod(object, name);
>+  } catch (e$) {
>+    let e = dart.getThrown(e$);
>+    return false;
>+  }
>+};
>+_debugger.NameValuePair = class NameValuePair extends core.Object {
>+  _equals(other) {
>+    if (!_debugger.NameValuePair.is(other)) return false;
>+    if (dart.test(this.hideName) || dart.dtest(dart.dload(other, 'hideName'))) return this === other;
>+    return dart.equals(dart.dload(other, 'name'), this.name);
>+  }
>+  get hashCode() {
>+    return dart.hashCode(this.name);
>+  }
>+  get displayName() {
>+    return dart.test(this.hideName) ? "" : this.name;
>+  }
>+};
>+(_debugger.NameValuePair.new = function(opts) {
>+  let name = opts && 'name' in opts ? opts.name : null;
>+  let value = opts && 'value' in opts ? opts.value : null;
>+  let config = opts && 'config' in opts ? opts.config : _debugger.JsonMLConfig.none;
>+  let hideName = opts && 'hideName' in opts ? opts.hideName : false;
>+  this.name = name;
>+  this.value = value;
>+  this.config = config;
>+  this.hideName = hideName;
>+}).prototype = _debugger.NameValuePair.prototype;
>+dart.addTypeTests(_debugger.NameValuePair);
>+dart.setGetterSignature(_debugger.NameValuePair, () => ({
>+  __proto__: dart.getGetters(_debugger.NameValuePair.__proto__),
>+  displayName: core.String
>+}));
>+dart.setLibraryUri(_debugger.NameValuePair, "dart:_debugger");
>+dart.setFieldSignature(_debugger.NameValuePair, () => ({
>+  __proto__: dart.getFields(_debugger.NameValuePair.__proto__),
>+  name: dart.finalFieldType(core.String),
>+  value: dart.finalFieldType(core.Object),
>+  config: dart.finalFieldType(_debugger.JsonMLConfig),
>+  hideName: dart.finalFieldType(core.bool)
>+}));
>+dart.defineExtensionMethods(_debugger.NameValuePair, ['_equals']);
>+dart.defineExtensionAccessors(_debugger.NameValuePair, ['hashCode']);
>+_debugger.MapEntry = class MapEntry extends core.Object {};
>+(_debugger.MapEntry.new = function(opts) {
>+  let key = opts && 'key' in opts ? opts.key : null;
>+  let value = opts && 'value' in opts ? opts.value : null;
>+  this.key = key;
>+  this.value = value;
>+}).prototype = _debugger.MapEntry.prototype;
>+dart.addTypeTests(_debugger.MapEntry);
>+dart.setLibraryUri(_debugger.MapEntry, "dart:_debugger");
>+dart.setFieldSignature(_debugger.MapEntry, () => ({
>+  __proto__: dart.getFields(_debugger.MapEntry.__proto__),
>+  key: dart.finalFieldType(core.Object),
>+  value: dart.finalFieldType(core.Object)
>+}));
>+_debugger.IterableSpan = class IterableSpan extends core.Object {
>+  get length() {
>+    return dart.notNull(this.end) - dart.notNull(this.start);
>+  }
>+  get maxPowerOfSubsetSize() {
>+    return (math.log(dart.notNull(this.length) - 0.5) / math.log(_debugger._maxSpanLength))[$truncate]();
>+  }
>+  get subsetSize() {
>+    return dart.asInt(math.pow(_debugger._maxSpanLength, this.maxPowerOfSubsetSize));
>+  }
>+  asMap() {
>+    return this.iterable[$skip](this.start)[$take](this.length)[$toList]()[$asMap]();
>+  }
>+  children() {
>+    let children = JSArrayOfNameValuePair().of([]);
>+    if (dart.notNull(this.length) <= dart.notNull(_debugger._maxSpanLength)) {
>+      this.asMap()[$forEach](dart.fn((i, element) => {
>+        children[$add](new _debugger.NameValuePair.new({name: (dart.notNull(i) + dart.notNull(this.start))[$toString](), value: element}));
>+      }, intAnddynamicToNull()));
>+    } else {
>+      for (let i = this.start; dart.notNull(i) < dart.notNull(this.end); i = dart.notNull(i) + dart.notNull(this.subsetSize)) {
>+        let subSpan = new _debugger.IterableSpan.new(i, math.min(core.int, this.end, dart.notNull(this.subsetSize) + dart.notNull(i)), this.iterable);
>+        if (subSpan.length === 1) {
>+          children[$add](new _debugger.NameValuePair.new({name: dart.toString(i), value: this.iterable[$elementAt](i)}));
>+        } else {
>+          children[$add](new _debugger.NameValuePair.new({name: "[" + dart.str(i) + "..." + dart.str(dart.notNull(subSpan.end) - 1) + "]", value: subSpan, hideName: true}));
>+        }
>+      }
>+    }
>+    return children;
>+  }
>+};
>+(_debugger.IterableSpan.new = function(start, end, iterable) {
>+  this.start = start;
>+  this.end = end;
>+  this.iterable = iterable;
>+}).prototype = _debugger.IterableSpan.prototype;
>+dart.addTypeTests(_debugger.IterableSpan);
>+dart.setMethodSignature(_debugger.IterableSpan, () => ({
>+  __proto__: dart.getMethods(_debugger.IterableSpan.__proto__),
>+  asMap: dart.fnType(core.Map$(core.int, dart.dynamic), []),
>+  children: dart.fnType(core.List$(_debugger.NameValuePair), [])
>+}));
>+dart.setGetterSignature(_debugger.IterableSpan, () => ({
>+  __proto__: dart.getGetters(_debugger.IterableSpan.__proto__),
>+  length: core.int,
>+  maxPowerOfSubsetSize: core.int,
>+  subsetSize: core.int
>+}));
>+dart.setLibraryUri(_debugger.IterableSpan, "dart:_debugger");
>+dart.setFieldSignature(_debugger.IterableSpan, () => ({
>+  __proto__: dart.getFields(_debugger.IterableSpan.__proto__),
>+  start: dart.finalFieldType(core.int),
>+  end: dart.finalFieldType(core.int),
>+  iterable: dart.finalFieldType(core.Iterable)
>+}));
>+_debugger.Library = class Library extends core.Object {};
>+(_debugger.Library.new = function(name, object) {
>+  this.name = name;
>+  this.object = object;
>+}).prototype = _debugger.Library.prototype;
>+dart.addTypeTests(_debugger.Library);
>+dart.setLibraryUri(_debugger.Library, "dart:_debugger");
>+dart.setFieldSignature(_debugger.Library, () => ({
>+  __proto__: dart.getFields(_debugger.Library.__proto__),
>+  name: dart.finalFieldType(core.String),
>+  object: dart.finalFieldType(core.Object)
>+}));
>+_debugger.NamedConstructor = class NamedConstructor extends core.Object {};
>+(_debugger.NamedConstructor.new = function(object) {
>+  this.object = object;
>+}).prototype = _debugger.NamedConstructor.prototype;
>+dart.addTypeTests(_debugger.NamedConstructor);
>+dart.setLibraryUri(_debugger.NamedConstructor, "dart:_debugger");
>+dart.setFieldSignature(_debugger.NamedConstructor, () => ({
>+  __proto__: dart.getFields(_debugger.NamedConstructor.__proto__),
>+  object: dart.finalFieldType(core.Object)
>+}));
>+_debugger.HeritageClause = class HeritageClause extends core.Object {};
>+(_debugger.HeritageClause.new = function(name, types) {
>+  this.name = name;
>+  this.types = types;
>+}).prototype = _debugger.HeritageClause.prototype;
>+dart.addTypeTests(_debugger.HeritageClause);
>+dart.setLibraryUri(_debugger.HeritageClause, "dart:_debugger");
>+dart.setFieldSignature(_debugger.HeritageClause, () => ({
>+  __proto__: dart.getFields(_debugger.HeritageClause.__proto__),
>+  name: dart.finalFieldType(core.String),
>+  types: dart.finalFieldType(core.List)
>+}));
>+_debugger.safeGetProperty = function(protoChain, name) {
>+  try {
>+    return _debugger.JSNative.getProperty(protoChain, name);
>+  } catch (e$) {
>+    let e = dart.getThrown(e$);
>+    return "<Exception thrown> " + dart.str(e);
>+  }
>+};
>+_debugger.safeProperties = function(object) {
>+  return MapOfdynamic$Object().fromIterable(_debugger.getOwnPropertyNames(object)[$where](dart.fn(each => _debugger.safeGetProperty(object, each) != null, StringTobool())), {key: dart.fn(name => name, dynamicTodynamic()), value: dart.fn(name => _debugger.safeGetProperty(object, name), dynamicToObject())});
>+};
>+const _attributes = dart.privateName(_debugger, "_attributes");
>+const _jsonML = dart.privateName(_debugger, "_jsonML");
>+_debugger.JsonMLElement = class JsonMLElement extends core.Object {
>+  appendChild(element) {
>+    this[_jsonML][$add](dart.dsend(element, 'toJsonML', []));
>+  }
>+  createChild(tagName) {
>+    let c = new _debugger.JsonMLElement.new(tagName);
>+    this[_jsonML][$add](c.toJsonML());
>+    return c;
>+  }
>+  createObjectTag(object) {
>+    let _ = this.createChild("object");
>+    _.addAttribute("object", object);
>+    return _;
>+  }
>+  setStyle(style) {
>+    dart.dput(this[_attributes], 'style', style);
>+  }
>+  addStyle(style) {
>+    if (dart.dload(this[_attributes], 'style') == null) {
>+      dart.dput(this[_attributes], 'style', style);
>+    } else {
>+      let o = this[_attributes];
>+      dart.dput(o, 'style', dart.dsend(dart.dload(o, 'style'), '+', [style]));
>+    }
>+  }
>+  addAttribute(key, value) {
>+    _debugger.JSNative.setProperty(this[_attributes], key, value);
>+  }
>+  createTextChild(text) {
>+    this[_jsonML][$add](text);
>+  }
>+  toJsonML() {
>+    return this[_jsonML];
>+  }
>+};
>+(_debugger.JsonMLElement.new = function(tagName) {
>+  this[_attributes] = null;
>+  this[_jsonML] = null;
>+  this[_attributes] = {};
>+  this[_jsonML] = [tagName, this[_attributes]];
>+}).prototype = _debugger.JsonMLElement.prototype;
>+dart.addTypeTests(_debugger.JsonMLElement);
>+dart.setMethodSignature(_debugger.JsonMLElement, () => ({
>+  __proto__: dart.getMethods(_debugger.JsonMLElement.__proto__),
>+  appendChild: dart.fnType(dart.dynamic, [dart.dynamic]),
>+  createChild: dart.fnType(_debugger.JsonMLElement, [core.String]),
>+  createObjectTag: dart.fnType(_debugger.JsonMLElement, [dart.dynamic]),
>+  setStyle: dart.fnType(dart.void, [core.String]),
>+  addStyle: dart.fnType(dart.dynamic, [core.String]),
>+  addAttribute: dart.fnType(dart.dynamic, [dart.dynamic, dart.dynamic]),
>+  createTextChild: dart.fnType(dart.dynamic, [core.String]),
>+  toJsonML: dart.fnType(dart.dynamic, [])
>+}));
>+dart.setLibraryUri(_debugger.JsonMLElement, "dart:_debugger");
>+dart.setFieldSignature(_debugger.JsonMLElement, () => ({
>+  __proto__: dart.getFields(_debugger.JsonMLElement.__proto__),
>+  [_attributes]: dart.fieldType(dart.dynamic),
>+  [_jsonML]: dart.fieldType(core.List)
>+}));
>+_debugger.isNativeJavaScriptObject = function(object) {
>+  let type = _debugger._typeof(object);
>+  if (type !== "object" && type !== "function") return true;
>+  if (dart.test(dart.isJsInterop(object)) && dart.getModuleName(object) == null) {
>+    return true;
>+  }
>+  return html$.Node.is(object);
>+};
>+_debugger.JsonMLFormatter = class JsonMLFormatter extends core.Object {
>+  setMaxSpanLengthForTestingOnly(spanLength) {
>+    _debugger._maxSpanLength = spanLength;
>+  }
>+  header(object, config) {
>+    this.customFormattersOn = true;
>+    if (dart.equals(config, _debugger.JsonMLConfig.skipDart) || dart.test(_debugger.isNativeJavaScriptObject(object))) {
>+      return null;
>+    }
>+    let c = this[_simpleFormatter].preview(object, config);
>+    if (c == null) return null;
>+    if (dart.equals(config, _debugger.JsonMLConfig.keyToString)) {
>+      c = dart.toString(object);
>+    }
>+    let element = new _debugger.JsonMLElement.new("span");
>+    element.setStyle("background-color: #d9edf7;color: black");
>+    element.createTextChild(c);
>+    return element.toJsonML();
>+  }
>+  hasBody(object, config) {
>+    return this[_simpleFormatter].hasChildren(object, config);
>+  }
>+  body(object, config) {
>+    let body = new _debugger.JsonMLElement.new("ol");
>+    body.setStyle("list-style-type: none;" + "padding-left: 0px;" + "margin-top: 0px;" + "margin-bottom: 0px;" + "margin-left: 12px;");
>+    if (core.StackTrace.is(object)) {
>+      body.addStyle("background-color: thistle;color: rgb(196, 26, 22);");
>+    }
>+    let children = this[_simpleFormatter].children(object, config);
>+    if (children == null) return body.toJsonML();
>+    for (let child of children) {
>+      let li = body.createChild("li");
>+      li.setStyle("padding-left: 13px;");
>+      let nameSpan = null;
>+      let valueStyle = "";
>+      if (!dart.test(child.hideName)) {
>+        nameSpan = new _debugger.JsonMLElement.new("span");
>+        nameSpan.createTextChild(child.displayName[$isNotEmpty] ? dart.str(child.displayName) + ": " : "");
>+        nameSpan.setStyle("background-color: thistle; color: rgb(136, 19, 145); margin-right: -13px");
>+        valueStyle = "margin-left: 13px";
>+      }
>+      if (_debugger._typeof(child.value) === "object" || _debugger._typeof(child.value) === "function") {
>+        let valueSpan = new _debugger.JsonMLElement.new("span");
>+        valueSpan.setStyle(valueStyle);
>+        valueSpan.createObjectTag(child.value).addAttribute("config", child.config);
>+        if (nameSpan != null) {
>+          li.appendChild(nameSpan);
>+        }
>+        li.appendChild(valueSpan);
>+      } else {
>+        let line = li.createChild("span");
>+        if (nameSpan != null) {
>+          line.appendChild(nameSpan);
>+        }
>+        line.appendChild((() => {
>+          let _ = new _debugger.JsonMLElement.new("span");
>+          _.createTextChild(_debugger.safePreview(child.value, child.config));
>+          _.setStyle(valueStyle);
>+          return _;
>+        })());
>+      }
>+    }
>+    return body.toJsonML();
>+  }
>+};
>+(_debugger.JsonMLFormatter.new = function(simpleFormatter) {
>+  this.customFormattersOn = false;
>+  this[_simpleFormatter] = simpleFormatter;
>+}).prototype = _debugger.JsonMLFormatter.prototype;
>+dart.addTypeTests(_debugger.JsonMLFormatter);
>+dart.setMethodSignature(_debugger.JsonMLFormatter, () => ({
>+  __proto__: dart.getMethods(_debugger.JsonMLFormatter.__proto__),
>+  setMaxSpanLengthForTestingOnly: dart.fnType(dart.void, [core.int]),
>+  header: dart.fnType(dart.dynamic, [dart.dynamic, dart.dynamic]),
>+  hasBody: dart.fnType(core.bool, [dart.dynamic, dart.dynamic]),
>+  body: dart.fnType(dart.dynamic, [dart.dynamic, dart.dynamic])
>+}));
>+dart.setLibraryUri(_debugger.JsonMLFormatter, "dart:_debugger");
>+dart.setFieldSignature(_debugger.JsonMLFormatter, () => ({
>+  __proto__: dart.getFields(_debugger.JsonMLFormatter.__proto__),
>+  [_simpleFormatter]: dart.fieldType(_debugger.DartFormatter),
>+  customFormattersOn: dart.fieldType(core.bool)
>+}));
>+_debugger.Formatter = class Formatter extends core.Object {};
>+(_debugger.Formatter.new = function() {
>+}).prototype = _debugger.Formatter.prototype;
>+dart.addTypeTests(_debugger.Formatter);
>+dart.setLibraryUri(_debugger.Formatter, "dart:_debugger");
>+const _formatters = dart.privateName(_debugger, "_formatters");
>+_debugger.DartFormatter = class DartFormatter extends core.Object {
>+  preview(object, config) {
>+    try {
>+      if (object == null || typeof object == 'number' || typeof object == 'string' || dart.test(_debugger.isNativeJavaScriptObject(object))) {
>+        return dart.toString(object);
>+      }
>+      for (let formatter of this[_formatters]) {
>+        if (dart.test(formatter.accept(object, config))) return formatter.preview(object);
>+      }
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      let trace = dart.stackTrace(e$);
>+      html$.window[$console].error("Caught exception " + dart.str(e) + "\n trace:\n" + dart.str(trace));
>+    }
>+    return null;
>+  }
>+  hasChildren(object, config) {
>+    if (object == null) return false;
>+    try {
>+      for (let formatter of this[_formatters]) {
>+        if (dart.test(formatter.accept(object, config))) return formatter.hasChildren(object);
>+      }
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      let trace = dart.stackTrace(e$);
>+      html$.window[$console].error("[hasChildren] Caught exception " + dart.str(e) + "\n trace:\n" + dart.str(trace));
>+    }
>+    return false;
>+  }
>+  children(object, config) {
>+    try {
>+      if (object != null) {
>+        for (let formatter of this[_formatters]) {
>+          if (dart.test(formatter.accept(object, config))) return formatter.children(object);
>+        }
>+      }
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      let trace = dart.stackTrace(e$);
>+      html$.window[$console].error("Caught exception " + dart.str(e) + "\n trace:\n" + dart.str(trace));
>+    }
>+    return JSArrayOfNameValuePair().of([]);
>+  }
>+};
>+(_debugger.DartFormatter.new = function() {
>+  this[_formatters] = null;
>+  this[_formatters] = JSArrayOfFormatter().of([new _debugger.ObjectInternalsFormatter.new(), new _debugger.ClassFormatter.new(), new _debugger.TypeFormatter.new(), new _debugger.NamedConstructorFormatter.new(), new _debugger.MapFormatter.new(), new _debugger.MapOverviewFormatter.new(), new _debugger.IterableFormatter.new(), new _debugger.IterableSpanFormatter.new(), new _debugger.MapEntryFormatter.new(), new _debugger.StackTraceFormatter.new(), new _debugger.ErrorAndExceptionFormatter.new(), new _debugger.FunctionFormatter.new(), new _debugger.HeritageClauseFormatter.new(), new _debugger.LibraryModuleFormatter.new(), new _debugger.LibraryFormatter.new(), new _debugger.ObjectFormatter.new()]);
>+}).prototype = _debugger.DartFormatter.prototype;
>+dart.addTypeTests(_debugger.DartFormatter);
>+dart.setMethodSignature(_debugger.DartFormatter, () => ({
>+  __proto__: dart.getMethods(_debugger.DartFormatter.__proto__),
>+  preview: dart.fnType(core.String, [dart.dynamic, dart.dynamic]),
>+  hasChildren: dart.fnType(core.bool, [dart.dynamic, dart.dynamic]),
>+  children: dart.fnType(core.List$(_debugger.NameValuePair), [dart.dynamic, dart.dynamic])
>+}));
>+dart.setLibraryUri(_debugger.DartFormatter, "dart:_debugger");
>+dart.setFieldSignature(_debugger.DartFormatter, () => ({
>+  __proto__: dart.getFields(_debugger.DartFormatter.__proto__),
>+  [_formatters]: dart.fieldType(ListOfFormatter())
>+}));
>+_debugger.ObjectFormatter = class ObjectFormatter extends _debugger.Formatter {
>+  accept(object, config) {
>+    return !dart.test(_debugger.isNativeJavaScriptObject(object));
>+  }
>+  preview(object) {
>+    let typeName = _debugger.getObjectTypeName(object);
>+    try {
>+      let toString = dart.str(object);
>+      if (toString.length > dart.notNull(_debugger.maxFormatterStringLength)) {
>+        toString = toString[$substring](0, dart.notNull(_debugger.maxFormatterStringLength) - 3) + "...";
>+      }
>+      if (toString[$contains](typeName)) {
>+        return toString;
>+      } else {
>+        return toString + " (" + dart.str(typeName) + ")";
>+      }
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+    }
>+    return typeName;
>+  }
>+  hasChildren(object) {
>+    return true;
>+  }
>+  children(object) {
>+    let type = dart.getType(object);
>+    let ret = new (_HashSetOfNameValuePair()).new();
>+    let fields = new (_HashSetOfNameValuePair()).new();
>+    _debugger.addPropertiesFromSignature(dart.getFields(type), fields, object, true);
>+    let getters = new (_HashSetOfNameValuePair()).new();
>+    _debugger.addPropertiesFromSignature(dart.getGetters(type), getters, object, true);
>+    ret.addAll(_debugger.sortProperties(fields));
>+    ret.addAll(_debugger.sortProperties(getters));
>+    _debugger.addMetadataChildren(object, ret);
>+    return ret.toList();
>+  }
>+};
>+(_debugger.ObjectFormatter.new = function() {
>+}).prototype = _debugger.ObjectFormatter.prototype;
>+dart.addTypeTests(_debugger.ObjectFormatter);
>+dart.setMethodSignature(_debugger.ObjectFormatter, () => ({
>+  __proto__: dart.getMethods(_debugger.ObjectFormatter.__proto__),
>+  accept: dart.fnType(core.bool, [dart.dynamic, dart.dynamic]),
>+  preview: dart.fnType(core.String, [dart.dynamic]),
>+  hasChildren: dart.fnType(core.bool, [dart.dynamic]),
>+  children: dart.fnType(core.List$(_debugger.NameValuePair), [dart.dynamic])
>+}));
>+dart.setLibraryUri(_debugger.ObjectFormatter, "dart:_debugger");
>+_debugger.ObjectInternalsFormatter = class ObjectInternalsFormatter extends _debugger.ObjectFormatter {
>+  accept(object, config) {
>+    return dart.test(super.accept(object, config)) && dart.equals(config, _debugger.JsonMLConfig.asObject);
>+  }
>+  preview(object) {
>+    return _debugger.getObjectTypeName(object);
>+  }
>+};
>+(_debugger.ObjectInternalsFormatter.new = function() {
>+}).prototype = _debugger.ObjectInternalsFormatter.prototype;
>+dart.addTypeTests(_debugger.ObjectInternalsFormatter);
>+dart.setLibraryUri(_debugger.ObjectInternalsFormatter, "dart:_debugger");
>+_debugger.LibraryModuleFormatter = class LibraryModuleFormatter extends core.Object {
>+  accept(object, config) {
>+    return dart.getModuleName(object) != null;
>+  }
>+  hasChildren(object) {
>+    return true;
>+  }
>+  preview(object) {
>+    let libraryNames = dart.getModuleName(object)[$split]("/");
>+    if (dart.notNull(libraryNames[$length]) > 1 && libraryNames[$last] == libraryNames[$_get](dart.notNull(libraryNames[$length]) - 2)) {
>+      libraryNames[$_set](dart.notNull(libraryNames[$length]) - 1, "");
>+    }
>+    return "Library Module: " + dart.str(libraryNames[$join]("/"));
>+  }
>+  children(object) {
>+    let children = new (_HashSetOfNameValuePair()).new();
>+    for (let name of _debugger.getOwnPropertyNames(object)) {
>+      let value = _debugger.safeGetProperty(object, name);
>+      children.add(new _debugger.NameValuePair.new({name: name, value: new _debugger.Library.new(name, value), hideName: true}));
>+    }
>+    return children.toList();
>+  }
>+};
>+(_debugger.LibraryModuleFormatter.new = function() {
>+}).prototype = _debugger.LibraryModuleFormatter.prototype;
>+dart.addTypeTests(_debugger.LibraryModuleFormatter);
>+_debugger.LibraryModuleFormatter[dart.implements] = () => [_debugger.Formatter];
>+dart.setMethodSignature(_debugger.LibraryModuleFormatter, () => ({
>+  __proto__: dart.getMethods(_debugger.LibraryModuleFormatter.__proto__),
>+  accept: dart.fnType(core.bool, [dart.dynamic, dart.dynamic]),
>+  hasChildren: dart.fnType(core.bool, [dart.dynamic]),
>+  preview: dart.fnType(core.String, [dart.dynamic]),
>+  children: dart.fnType(core.List$(_debugger.NameValuePair), [dart.dynamic])
>+}));
>+dart.setLibraryUri(_debugger.LibraryModuleFormatter, "dart:_debugger");
>+_debugger.LibraryFormatter = class LibraryFormatter extends core.Object {
>+  accept(object, config) {
>+    return _debugger.Library.is(object);
>+  }
>+  hasChildren(object) {
>+    return true;
>+  }
>+  preview(object) {
>+    return core.String._check(dart.dload(object, 'name'));
>+  }
>+  children(object) {
>+    let children = new (_HashSetOfNameValuePair()).new();
>+    let objectProperties = _debugger.safeProperties(dart.dload(object, 'object'));
>+    dart.dsend(objectProperties, 'forEach', [dart.fn((name, value) => {
>+        if (dart.getGenericTypeCtor(value) != null) return;
>+        children.add(_debugger.NameValuePair._check(dart.isType(value) ? this.classChild(core.String._check(name), value) : new _debugger.NameValuePair.new({name: core.String._check(name), value: value})));
>+      }, dynamicAnddynamicToNull())]);
>+    return children.toList();
>+  }
>+  classChild(name, child) {
>+    let typeName = _debugger.getTypeName(child);
>+    return new _debugger.NameValuePair.new({name: typeName, value: child, config: _debugger.JsonMLConfig.asClass});
>+  }
>+};
>+(_debugger.LibraryFormatter.new = function() {
>+  this.genericParameters = new (IdentityMapOfString$String()).new();
>+}).prototype = _debugger.LibraryFormatter.prototype;
>+dart.addTypeTests(_debugger.LibraryFormatter);
>+_debugger.LibraryFormatter[dart.implements] = () => [_debugger.Formatter];
>+dart.setMethodSignature(_debugger.LibraryFormatter, () => ({
>+  __proto__: dart.getMethods(_debugger.LibraryFormatter.__proto__),
>+  accept: dart.fnType(core.bool, [dart.dynamic, dart.dynamic]),
>+  hasChildren: dart.fnType(core.bool, [dart.dynamic]),
>+  preview: dart.fnType(core.String, [dart.dynamic]),
>+  children: dart.fnType(core.List$(_debugger.NameValuePair), [dart.dynamic]),
>+  classChild: dart.fnType(dart.dynamic, [core.String, core.Object])
>+}));
>+dart.setLibraryUri(_debugger.LibraryFormatter, "dart:_debugger");
>+dart.setFieldSignature(_debugger.LibraryFormatter, () => ({
>+  __proto__: dart.getFields(_debugger.LibraryFormatter.__proto__),
>+  genericParameters: dart.fieldType(HashMapOfString$String())
>+}));
>+_debugger.FunctionFormatter = class FunctionFormatter extends core.Object {
>+  accept(object, config) {
>+    if (_debugger._typeof(object) !== "function") return false;
>+    return dart.getReifiedType(object) != null;
>+  }
>+  hasChildren(object) {
>+    return true;
>+  }
>+  preview(object) {
>+    try {
>+      return dart.typeName(dart.getReifiedType(object));
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      return _debugger.safePreview(object, _debugger.JsonMLConfig.none);
>+    }
>+  }
>+  children(object) {
>+    return JSArrayOfNameValuePair().of([new _debugger.NameValuePair.new({name: "signature", value: this.preview(object)}), new _debugger.NameValuePair.new({name: "JavaScript Function", value: object, config: _debugger.JsonMLConfig.skipDart})]);
>+  }
>+};
>+(_debugger.FunctionFormatter.new = function() {
>+}).prototype = _debugger.FunctionFormatter.prototype;
>+dart.addTypeTests(_debugger.FunctionFormatter);
>+_debugger.FunctionFormatter[dart.implements] = () => [_debugger.Formatter];
>+dart.setMethodSignature(_debugger.FunctionFormatter, () => ({
>+  __proto__: dart.getMethods(_debugger.FunctionFormatter.__proto__),
>+  accept: dart.fnType(core.bool, [dart.dynamic, dart.dynamic]),
>+  hasChildren: dart.fnType(core.bool, [dart.dynamic]),
>+  preview: dart.fnType(core.String, [dart.dynamic]),
>+  children: dart.fnType(core.List$(_debugger.NameValuePair), [dart.dynamic])
>+}));
>+dart.setLibraryUri(_debugger.FunctionFormatter, "dart:_debugger");
>+_debugger.MapOverviewFormatter = class MapOverviewFormatter extends core.Object {
>+  accept(object, config) {
>+    return core.Map.is(object);
>+  }
>+  hasChildren(object) {
>+    return true;
>+  }
>+  preview(object) {
>+    let map = core.Map._check(object);
>+    try {
>+      return dart.str(_debugger.getObjectTypeName(map));
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      return _debugger.safePreview(object, _debugger.JsonMLConfig.none);
>+    }
>+  }
>+  children(object) {
>+    return JSArrayOfNameValuePair().of([new _debugger.NameValuePair.new({name: "[[instance view]]", value: object, config: _debugger.JsonMLConfig.asObject}), new _debugger.NameValuePair.new({name: "[[entries]]", value: object, config: _debugger.JsonMLConfig.asMap})]);
>+  }
>+};
>+(_debugger.MapOverviewFormatter.new = function() {
>+}).prototype = _debugger.MapOverviewFormatter.prototype;
>+dart.addTypeTests(_debugger.MapOverviewFormatter);
>+_debugger.MapOverviewFormatter[dart.implements] = () => [_debugger.Formatter];
>+dart.setMethodSignature(_debugger.MapOverviewFormatter, () => ({
>+  __proto__: dart.getMethods(_debugger.MapOverviewFormatter.__proto__),
>+  accept: dart.fnType(core.bool, [dart.dynamic, dart.dynamic]),
>+  hasChildren: dart.fnType(core.bool, [dart.dynamic]),
>+  preview: dart.fnType(core.String, [dart.dynamic]),
>+  children: dart.fnType(core.List$(_debugger.NameValuePair), [dart.dynamic])
>+}));
>+dart.setLibraryUri(_debugger.MapOverviewFormatter, "dart:_debugger");
>+_debugger.MapFormatter = class MapFormatter extends core.Object {
>+  accept(object, config) {
>+    return _js_helper.InternalMap.is(object) || dart.equals(config, _debugger.JsonMLConfig.asMap);
>+  }
>+  hasChildren(object) {
>+    return true;
>+  }
>+  preview(object) {
>+    let map = core.Map._check(object);
>+    try {
>+      return dart.str(_debugger.getObjectTypeName(map)) + " length " + dart.str(map[$length]);
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      return _debugger.safePreview(object, _debugger.JsonMLConfig.none);
>+    }
>+  }
>+  children(object) {
>+    let map = core.Map._check(object);
>+    let entries = new (_HashSetOfNameValuePair()).new();
>+    map[$forEach](dart.fn((key, value) => {
>+      let entryWrapper = new _debugger.MapEntry.new({key: key, value: value});
>+      entries.add(new _debugger.NameValuePair.new({name: dart.toString(entries.length), value: entryWrapper}));
>+    }, dynamicAnddynamicToNull()));
>+    _debugger.addMetadataChildren(object, entries);
>+    return entries.toList();
>+  }
>+};
>+(_debugger.MapFormatter.new = function() {
>+}).prototype = _debugger.MapFormatter.prototype;
>+dart.addTypeTests(_debugger.MapFormatter);
>+_debugger.MapFormatter[dart.implements] = () => [_debugger.Formatter];
>+dart.setMethodSignature(_debugger.MapFormatter, () => ({
>+  __proto__: dart.getMethods(_debugger.MapFormatter.__proto__),
>+  accept: dart.fnType(core.bool, [dart.dynamic, dart.dynamic]),
>+  hasChildren: dart.fnType(core.bool, [dart.dynamic]),
>+  preview: dart.fnType(core.String, [dart.dynamic]),
>+  children: dart.fnType(core.List$(_debugger.NameValuePair), [dart.dynamic])
>+}));
>+dart.setLibraryUri(_debugger.MapFormatter, "dart:_debugger");
>+_debugger.IterableFormatter = class IterableFormatter extends core.Object {
>+  accept(object, config) {
>+    return core.Iterable.is(object);
>+  }
>+  preview(object) {
>+    let iterable = core.Iterable._check(object);
>+    try {
>+      let length = iterable[$length];
>+      return dart.str(_debugger.getObjectTypeName(iterable)) + " length " + dart.str(length);
>+    } catch (e) {
>+      let _ = dart.getThrown(e);
>+      return dart.str(_debugger.getObjectTypeName(iterable));
>+    }
>+  }
>+  hasChildren(object) {
>+    return true;
>+  }
>+  children(object) {
>+    let children = new (_HashSetOfNameValuePair()).new();
>+    children.addAll(new _debugger.IterableSpan.new(0, core.int._check(dart.dload(object, 'length')), core.Iterable._check(object)).children());
>+    _debugger.addMetadataChildren(object, children);
>+    return children.toList();
>+  }
>+};
>+(_debugger.IterableFormatter.new = function() {
>+}).prototype = _debugger.IterableFormatter.prototype;
>+dart.addTypeTests(_debugger.IterableFormatter);
>+_debugger.IterableFormatter[dart.implements] = () => [_debugger.Formatter];
>+dart.setMethodSignature(_debugger.IterableFormatter, () => ({
>+  __proto__: dart.getMethods(_debugger.IterableFormatter.__proto__),
>+  accept: dart.fnType(core.bool, [dart.dynamic, dart.dynamic]),
>+  preview: dart.fnType(core.String, [dart.dynamic]),
>+  hasChildren: dart.fnType(core.bool, [dart.dynamic]),
>+  children: dart.fnType(core.List$(_debugger.NameValuePair), [dart.dynamic])
>+}));
>+dart.setLibraryUri(_debugger.IterableFormatter, "dart:_debugger");
>+_debugger.NamedConstructorFormatter = class NamedConstructorFormatter extends core.Object {
>+  accept(object, config) {
>+    return _debugger.NamedConstructor.is(object);
>+  }
>+  preview(object) {
>+    return "Named Constructor";
>+  }
>+  hasChildren(object) {
>+    return true;
>+  }
>+  children(object) {
>+    return JSArrayOfNameValuePair().of([new _debugger.NameValuePair.new({name: "JavaScript Function", value: object, config: _debugger.JsonMLConfig.skipDart})]);
>+  }
>+};
>+(_debugger.NamedConstructorFormatter.new = function() {
>+}).prototype = _debugger.NamedConstructorFormatter.prototype;
>+dart.addTypeTests(_debugger.NamedConstructorFormatter);
>+_debugger.NamedConstructorFormatter[dart.implements] = () => [_debugger.Formatter];
>+dart.setMethodSignature(_debugger.NamedConstructorFormatter, () => ({
>+  __proto__: dart.getMethods(_debugger.NamedConstructorFormatter.__proto__),
>+  accept: dart.fnType(core.bool, [dart.dynamic, dart.dynamic]),
>+  preview: dart.fnType(core.String, [dart.dynamic]),
>+  hasChildren: dart.fnType(core.bool, [dart.dynamic]),
>+  children: dart.fnType(core.List$(_debugger.NameValuePair), [dart.dynamic])
>+}));
>+dart.setLibraryUri(_debugger.NamedConstructorFormatter, "dart:_debugger");
>+_debugger.MapEntryFormatter = class MapEntryFormatter extends core.Object {
>+  accept(object, config) {
>+    return _debugger.MapEntry.is(object);
>+  }
>+  preview(object) {
>+    let entry = _debugger.MapEntry._check(object);
>+    return dart.str(_debugger.safePreview(entry.key, _debugger.JsonMLConfig.none)) + " => " + dart.str(_debugger.safePreview(entry.value, _debugger.JsonMLConfig.none));
>+  }
>+  hasChildren(object) {
>+    return true;
>+  }
>+  children(object) {
>+    return JSArrayOfNameValuePair().of([new _debugger.NameValuePair.new({name: "key", value: dart.dload(object, 'key'), config: _debugger.JsonMLConfig.keyToString}), new _debugger.NameValuePair.new({name: "value", value: dart.dload(object, 'value')})]);
>+  }
>+};
>+(_debugger.MapEntryFormatter.new = function() {
>+}).prototype = _debugger.MapEntryFormatter.prototype;
>+dart.addTypeTests(_debugger.MapEntryFormatter);
>+_debugger.MapEntryFormatter[dart.implements] = () => [_debugger.Formatter];
>+dart.setMethodSignature(_debugger.MapEntryFormatter, () => ({
>+  __proto__: dart.getMethods(_debugger.MapEntryFormatter.__proto__),
>+  accept: dart.fnType(core.bool, [dart.dynamic, dart.dynamic]),
>+  preview: dart.fnType(core.String, [dart.dynamic]),
>+  hasChildren: dart.fnType(core.bool, [dart.dynamic]),
>+  children: dart.fnType(core.List$(_debugger.NameValuePair), [dart.dynamic])
>+}));
>+dart.setLibraryUri(_debugger.MapEntryFormatter, "dart:_debugger");
>+_debugger.HeritageClauseFormatter = class HeritageClauseFormatter extends core.Object {
>+  accept(object, config) {
>+    return _debugger.HeritageClause.is(object);
>+  }
>+  preview(object) {
>+    let clause = _debugger.HeritageClause._check(object);
>+    let typeNames = IterableOfString()._check(clause.types[$map](core.String, dart.fn(_debugger.getTypeName, dynamicToString())));
>+    return dart.str(clause.name) + " " + dart.str(typeNames[$join](", "));
>+  }
>+  hasChildren(object) {
>+    return true;
>+  }
>+  children(object) {
>+    let clause = _debugger.HeritageClause._check(object);
>+    let children = JSArrayOfNameValuePair().of([]);
>+    for (let type of clause.types) {
>+      children[$add](new _debugger.NameValuePair.new({value: type, config: _debugger.JsonMLConfig.asClass}));
>+    }
>+    return children;
>+  }
>+};
>+(_debugger.HeritageClauseFormatter.new = function() {
>+}).prototype = _debugger.HeritageClauseFormatter.prototype;
>+dart.addTypeTests(_debugger.HeritageClauseFormatter);
>+_debugger.HeritageClauseFormatter[dart.implements] = () => [_debugger.Formatter];
>+dart.setMethodSignature(_debugger.HeritageClauseFormatter, () => ({
>+  __proto__: dart.getMethods(_debugger.HeritageClauseFormatter.__proto__),
>+  accept: dart.fnType(core.bool, [dart.dynamic, dart.dynamic]),
>+  preview: dart.fnType(core.String, [dart.dynamic]),
>+  hasChildren: dart.fnType(core.bool, [dart.dynamic]),
>+  children: dart.fnType(core.List$(_debugger.NameValuePair), [dart.dynamic])
>+}));
>+dart.setLibraryUri(_debugger.HeritageClauseFormatter, "dart:_debugger");
>+_debugger.IterableSpanFormatter = class IterableSpanFormatter extends core.Object {
>+  accept(object, config) {
>+    return _debugger.IterableSpan.is(object);
>+  }
>+  preview(object) {
>+    return "[" + dart.str(dart.dload(object, 'start')) + "..." + dart.str(dart.dsend(dart.dload(object, 'end'), '-', [1])) + "]";
>+  }
>+  hasChildren(object) {
>+    return true;
>+  }
>+  children(object) {
>+    return ListOfNameValuePair()._check(dart.dsend(object, 'children', []));
>+  }
>+};
>+(_debugger.IterableSpanFormatter.new = function() {
>+}).prototype = _debugger.IterableSpanFormatter.prototype;
>+dart.addTypeTests(_debugger.IterableSpanFormatter);
>+_debugger.IterableSpanFormatter[dart.implements] = () => [_debugger.Formatter];
>+dart.setMethodSignature(_debugger.IterableSpanFormatter, () => ({
>+  __proto__: dart.getMethods(_debugger.IterableSpanFormatter.__proto__),
>+  accept: dart.fnType(core.bool, [dart.dynamic, dart.dynamic]),
>+  preview: dart.fnType(core.String, [dart.dynamic]),
>+  hasChildren: dart.fnType(core.bool, [dart.dynamic]),
>+  children: dart.fnType(core.List$(_debugger.NameValuePair), [dart.dynamic])
>+}));
>+dart.setLibraryUri(_debugger.IterableSpanFormatter, "dart:_debugger");
>+_debugger.ErrorAndExceptionFormatter = class ErrorAndExceptionFormatter extends _debugger.ObjectFormatter {
>+  accept(object, config) {
>+    return core.Error.is(object) || core.Exception.is(object);
>+  }
>+  hasChildren(object) {
>+    return true;
>+  }
>+  preview(object) {
>+    let trace = dart.stackTrace(object);
>+    let line = dart.str(trace)[$split]("\n")[$firstWhere](dart.fn(l => l[$contains](_debugger.ErrorAndExceptionFormatter._pattern) && !l[$contains]("dart:sdk") && !l[$contains]("dart_sdk"), StringTobool()), {orElse: dart.fn(() => null, VoidToNull())});
>+    return line != null ? dart.str(object) + " at " + dart.str(line) : dart.str(object);
>+  }
>+  children(object) {
>+    let trace = dart.stackTrace(object);
>+    let entries = new (_HashSetOfNameValuePair()).new();
>+    entries.add(new _debugger.NameValuePair.new({name: "stackTrace", value: trace}));
>+    this.addInstanceMembers(object, entries);
>+    _debugger.addMetadataChildren(object, entries);
>+    return entries.toList();
>+  }
>+  addInstanceMembers(object, ret) {
>+    ret.add(new _debugger.NameValuePair.new({name: "[[instance members]]", value: object, config: _debugger.JsonMLConfig.asObject}));
>+  }
>+};
>+(_debugger.ErrorAndExceptionFormatter.new = function() {
>+}).prototype = _debugger.ErrorAndExceptionFormatter.prototype;
>+dart.addTypeTests(_debugger.ErrorAndExceptionFormatter);
>+dart.setMethodSignature(_debugger.ErrorAndExceptionFormatter, () => ({
>+  __proto__: dart.getMethods(_debugger.ErrorAndExceptionFormatter.__proto__),
>+  addInstanceMembers: dart.fnType(dart.void, [dart.dynamic, core.Set$(_debugger.NameValuePair)])
>+}));
>+dart.setLibraryUri(_debugger.ErrorAndExceptionFormatter, "dart:_debugger");
>+dart.defineLazy(_debugger.ErrorAndExceptionFormatter, {
>+  /*_debugger.ErrorAndExceptionFormatter._pattern*/get _pattern() {
>+    return core.RegExp.new("\\d+\\:\\d+");
>+  }
>+});
>+_debugger.StackTraceFormatter = class StackTraceFormatter extends core.Object {
>+  accept(object, config) {
>+    return core.StackTrace.is(object);
>+  }
>+  preview(object) {
>+    return "StackTrace";
>+  }
>+  hasChildren(object) {
>+    return true;
>+  }
>+  children(object) {
>+    return IterableOfNameValuePair()._check(dart.toString(object)[$split]("\n")[$map](_debugger.NameValuePair, dart.fn(line => new _debugger.NameValuePair.new({value: line[$replaceFirst](core.RegExp.new("^\\s+at\\s"), ""), hideName: true}), StringToNameValuePair())))[$toList]();
>+  }
>+};
>+(_debugger.StackTraceFormatter.new = function() {
>+}).prototype = _debugger.StackTraceFormatter.prototype;
>+dart.addTypeTests(_debugger.StackTraceFormatter);
>+_debugger.StackTraceFormatter[dart.implements] = () => [_debugger.Formatter];
>+dart.setMethodSignature(_debugger.StackTraceFormatter, () => ({
>+  __proto__: dart.getMethods(_debugger.StackTraceFormatter.__proto__),
>+  accept: dart.fnType(core.bool, [dart.dynamic, dart.dynamic]),
>+  preview: dart.fnType(core.String, [dart.dynamic]),
>+  hasChildren: dart.fnType(core.bool, [dart.dynamic]),
>+  children: dart.fnType(core.List$(_debugger.NameValuePair), [dart.dynamic])
>+}));
>+dart.setLibraryUri(_debugger.StackTraceFormatter, "dart:_debugger");
>+_debugger.ClassFormatter = class ClassFormatter extends core.Object {
>+  accept(object, config) {
>+    return dart.equals(config, _debugger.JsonMLConfig.asClass);
>+  }
>+  preview(type) {
>+    let implements$ = dart.getImplements(type);
>+    let typeName = _debugger.getTypeName(type);
>+    if (implements$ != null) {
>+      let typeNames = IterableOfString()._check(implements$()[$map](core.String, dart.fn(_debugger.getTypeName, dynamicToString())));
>+      return dart.str(typeName) + " implements " + dart.str(typeNames[$join](", "));
>+    } else {
>+      return typeName;
>+    }
>+  }
>+  hasChildren(object) {
>+    return true;
>+  }
>+  children(type) {
>+    let ret = new (_HashSetOfNameValuePair()).new();
>+    let staticProperties = new (_HashSetOfNameValuePair()).new();
>+    let staticMethods = new (_HashSetOfNameValuePair()).new();
>+    _debugger.addPropertiesFromSignature(dart.getStaticFields(type), staticProperties, type, false);
>+    _debugger.addPropertiesFromSignature(dart.getStaticGetters(type), staticProperties, type, false);
>+    _debugger.addPropertiesFromSignature(dart.getStaticMethods(type), staticMethods, type, false);
>+    if (dart.test(staticProperties.isNotEmpty) || dart.test(staticMethods.isNotEmpty)) {
>+      ret.add(new _debugger.NameValuePair.new({value: "[[Static members]]", hideName: true}));
>+      ret.addAll(_debugger.sortProperties(staticProperties));
>+      ret.addAll(_debugger.sortProperties(staticMethods));
>+    }
>+    let instanceMethods = new (_HashSetOfNameValuePair()).new();
>+    _debugger.addPropertiesFromSignature(dart.getMethods(type), instanceMethods, type.prototype, false, {tagTypes: true});
>+    if (dart.test(instanceMethods.isNotEmpty)) {
>+      ret.add(new _debugger.NameValuePair.new({value: "[[Instance Methods]]", hideName: true}));
>+      ret.addAll(_debugger.sortProperties(instanceMethods));
>+    }
>+    let mixin = dart.getMixin(type);
>+    if (mixin != null) {
>+      ret.add(new _debugger.NameValuePair.new({name: "[[Mixins]]", value: new _debugger.HeritageClause.new("mixins", [mixin])}));
>+    }
>+    let baseProto = type.__proto__;
>+    if (baseProto != null && !dart.test(dart.isJsInterop(baseProto))) {
>+      ret.add(new _debugger.NameValuePair.new({name: "[[base class]]", value: baseProto, config: _debugger.JsonMLConfig.asClass}));
>+    }
>+    return ret.toList();
>+  }
>+};
>+(_debugger.ClassFormatter.new = function() {
>+}).prototype = _debugger.ClassFormatter.prototype;
>+dart.addTypeTests(_debugger.ClassFormatter);
>+_debugger.ClassFormatter[dart.implements] = () => [_debugger.Formatter];
>+dart.setMethodSignature(_debugger.ClassFormatter, () => ({
>+  __proto__: dart.getMethods(_debugger.ClassFormatter.__proto__),
>+  accept: dart.fnType(core.bool, [dart.dynamic, dart.dynamic]),
>+  preview: dart.fnType(core.String, [dart.dynamic]),
>+  hasChildren: dart.fnType(core.bool, [dart.dynamic]),
>+  children: dart.fnType(core.List$(_debugger.NameValuePair), [dart.dynamic])
>+}));
>+dart.setLibraryUri(_debugger.ClassFormatter, "dart:_debugger");
>+_debugger.TypeFormatter = class TypeFormatter extends core.Object {
>+  accept(object, config) {
>+    return core.Type.is(object);
>+  }
>+  preview(object) {
>+    return dart.toString(object);
>+  }
>+  hasChildren(object) {
>+    return false;
>+  }
>+  children(object) {
>+    return JSArrayOfNameValuePair().of([]);
>+  }
>+};
>+(_debugger.TypeFormatter.new = function() {
>+}).prototype = _debugger.TypeFormatter.prototype;
>+dart.addTypeTests(_debugger.TypeFormatter);
>+_debugger.TypeFormatter[dart.implements] = () => [_debugger.Formatter];
>+dart.setMethodSignature(_debugger.TypeFormatter, () => ({
>+  __proto__: dart.getMethods(_debugger.TypeFormatter.__proto__),
>+  accept: dart.fnType(core.bool, [dart.dynamic, dart.dynamic]),
>+  preview: dart.fnType(core.String, [dart.dynamic]),
>+  hasChildren: dart.fnType(core.bool, [dart.dynamic]),
>+  children: dart.fnType(core.List$(_debugger.NameValuePair), [dart.dynamic])
>+}));
>+dart.setLibraryUri(_debugger.TypeFormatter, "dart:_debugger");
>+dart.copyProperties(_debugger, {
>+  get stackTraceMapper() {
>+    let _util = dart.global.$dartStackTraceUtility;
>+    return _util != null ? _util.mapper : null;
>+  }
>+});
>+_debugger.registerDevtoolsFormatter = function() {
>+  dart.global.devtoolsFormatters = [_debugger._devtoolsFormatter];
>+};
>+_debugger.getModuleNames = function() {
>+  return dart.getModuleNames();
>+};
>+_debugger.getModuleLibraries = function(name) {
>+  return dart.getModuleLibraries(name);
>+};
>+_debugger._MethodStats = class _MethodStats extends core.Object {};
>+(_debugger._MethodStats.new = function(typeName, frame) {
>+  this.count = null;
>+  this.typeName = typeName;
>+  this.frame = frame;
>+  this.count = 0.0;
>+}).prototype = _debugger._MethodStats.prototype;
>+dart.addTypeTests(_debugger._MethodStats);
>+dart.setLibraryUri(_debugger._MethodStats, "dart:_debugger");
>+dart.setFieldSignature(_debugger._MethodStats, () => ({
>+  __proto__: dart.getFields(_debugger._MethodStats.__proto__),
>+  typeName: dart.finalFieldType(core.String),
>+  frame: dart.finalFieldType(core.String),
>+  count: dart.fieldType(core.double)
>+}));
>+_debugger._CallMethodRecord = class _CallMethodRecord extends core.Object {};
>+(_debugger._CallMethodRecord.new = function(jsError, type) {
>+  this.jsError = jsError;
>+  this.type = type;
>+}).prototype = _debugger._CallMethodRecord.prototype;
>+dart.addTypeTests(_debugger._CallMethodRecord);
>+dart.setLibraryUri(_debugger._CallMethodRecord, "dart:_debugger");
>+dart.setFieldSignature(_debugger._CallMethodRecord, () => ({
>+  __proto__: dart.getFields(_debugger._CallMethodRecord.__proto__),
>+  jsError: dart.fieldType(dart.dynamic),
>+  type: dart.fieldType(dart.dynamic)
>+}));
>+dart.defineLazy(_debugger, {
>+  /*_debugger._callRecordSampleSize*/get _callRecordSampleSize() {
>+    return 5000;
>+  },
>+  set _callRecordSampleSize(_) {},
>+  /*_debugger._callMethodRecords*/get _callMethodRecords() {
>+    return JSArrayOf_CallMethodRecord().of([]);
>+  },
>+  set _callMethodRecords(_) {},
>+  /*_debugger._totalCallRecords*/get _totalCallRecords() {
>+    return 0;
>+  },
>+  set _totalCallRecords(_) {},
>+  /*_debugger._minCount*/get _minCount() {
>+    return 2;
>+  },
>+  set _minCount(_) {},
>+  /*_debugger._frameMappingCache*/get _frameMappingCache() {
>+    return new (IdentityMapOfString$String()).new();
>+  },
>+  set _frameMappingCache(_) {}
>+});
>+_debugger.getDynamicStats = function() {
>+  let callMethodStats = new (IdentityMapOfString$_MethodStats()).new();
>+  if (dart.notNull(_debugger._callMethodRecords[$length]) > 0) {
>+    let recordRatio = dart.notNull(_debugger._totalCallRecords) / dart.notNull(_debugger._callMethodRecords[$length]);
>+    for (let record of _debugger._callMethodRecords) {
>+      let stackStr = record.jsError.stack;
>+      let frames = stackStr[$split]("\n");
>+      let src = IterableOfString()._check(frames[$skip](2)[$map](core.String, dart.fn(f => _debugger._frameMappingCache[$putIfAbsent](f, dart.fn(() => _debugger.stackTraceMapper("\n" + dart.str(f)), VoidToString())), StringToString())))[$firstWhere](dart.fn(f => !f[$startsWith]("dart:"), StringTobool()), {orElse: dart.fn(() => "", VoidToString())});
>+      let actualTypeName = dart.typeName(record.type);
>+      let o = callMethodStats[$putIfAbsent](actualTypeName + " <" + dart.str(src) + ">", dart.fn(() => new _debugger._MethodStats.new(actualTypeName, src), VoidTo_MethodStats()));
>+      o.count = dart.notNull(o.count) + recordRatio;
>+    }
>+    if (_debugger._totalCallRecords != _debugger._callMethodRecords[$length]) {
>+      for (let k of callMethodStats[$keys][$toList]()) {
>+        let stats = callMethodStats[$_get](k);
>+        let threshold = dart.notNull(_debugger._minCount) * recordRatio;
>+        if (dart.notNull(stats.count) + 0.001 < threshold) {
>+          callMethodStats[$remove](k);
>+        }
>+      }
>+    }
>+  }
>+  _debugger._callMethodRecords[$clear]();
>+  _debugger._totalCallRecords = 0;
>+  let keys = callMethodStats[$keys][$toList]();
>+  keys[$sort](dart.fn((a, b) => callMethodStats[$_get](b).count[$compareTo](callMethodStats[$_get](a).count), StringAndStringToint()));
>+  let ret = JSArrayOfListOfObject().of([]);
>+  for (let key of keys) {
>+    let stats = callMethodStats[$_get](key);
>+    ret[$add](JSArrayOfObject().of([stats.typeName, stats.frame, stats.count[$round]()]));
>+  }
>+  return ret;
>+};
>+_debugger.clearDynamicStats = function() {
>+  _debugger._callMethodRecords[$clear]();
>+};
>+dart.copyProperties(_debugger, {
>+  get _trackProfile() {
>+    return dart.__trackProfile;
>+  }
>+});
>+_debugger.trackCall = function(obj) {
>+  if (!_debugger._trackProfile) return;
>+  let index = -1;
>+  _debugger._totalCallRecords = dart.notNull(_debugger._totalCallRecords) + 1;
>+  if (_debugger._callMethodRecords[$length] == _debugger._callRecordSampleSize) {
>+    index = Math.floor(Math.random() * _debugger._totalCallRecords);
>+    if (index >= dart.notNull(_debugger._callMethodRecords[$length])) return;
>+  }
>+  let record = new _debugger._CallMethodRecord.new(new Error(), dart.getReifiedType(obj));
>+  if (index === -1) {
>+    _debugger._callMethodRecords[$add](record);
>+  } else {
>+    _debugger._callMethodRecords[$_set](index, record);
>+  }
>+};
>+_foreign_helper.JS = function(T, typeDescription, codeTemplate, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19) {
>+  if (arg0 === void 0) arg0 = null;
>+  if (arg1 === void 0) arg1 = null;
>+  if (arg2 === void 0) arg2 = null;
>+  if (arg3 === void 0) arg3 = null;
>+  if (arg4 === void 0) arg4 = null;
>+  if (arg5 === void 0) arg5 = null;
>+  if (arg6 === void 0) arg6 = null;
>+  if (arg7 === void 0) arg7 = null;
>+  if (arg8 === void 0) arg8 = null;
>+  if (arg9 === void 0) arg9 = null;
>+  if (arg10 === void 0) arg10 = null;
>+  if (arg11 === void 0) arg11 = null;
>+  if (arg12 === void 0) arg12 = null;
>+  if (arg13 === void 0) arg13 = null;
>+  if (arg14 === void 0) arg14 = null;
>+  if (arg15 === void 0) arg15 = null;
>+  if (arg16 === void 0) arg16 = null;
>+  if (arg17 === void 0) arg17 = null;
>+  if (arg18 === void 0) arg18 = null;
>+  if (arg19 === void 0) arg19 = null;
>+};
>+_foreign_helper.JSExportName = class JSExportName extends core.Object {};
>+(_foreign_helper.JSExportName.new = function(name) {
>+  this.name = name;
>+}).prototype = _foreign_helper.JSExportName.prototype;
>+dart.addTypeTests(_foreign_helper.JSExportName);
>+dart.setLibraryUri(_foreign_helper.JSExportName, "dart:_foreign_helper");
>+dart.setFieldSignature(_foreign_helper.JSExportName, () => ({
>+  __proto__: dart.getFields(_foreign_helper.JSExportName.__proto__),
>+  name: dart.finalFieldType(core.String)
>+}));
>+_foreign_helper.JS_DART_OBJECT_CONSTRUCTOR = function() {
>+};
>+_foreign_helper.JS_INTERCEPTOR_CONSTANT = function(type) {
>+};
>+_foreign_helper.JS_OPERATOR_IS_PREFIX = function() {
>+};
>+_foreign_helper.JS_OPERATOR_AS_PREFIX = function() {
>+};
>+_foreign_helper.JS_OBJECT_CLASS_NAME = function() {
>+};
>+_foreign_helper.JS_NULL_CLASS_NAME = function() {
>+};
>+_foreign_helper.JS_FUNCTION_CLASS_NAME = function() {
>+};
>+_foreign_helper.JS_IS_INDEXABLE_FIELD_NAME = function() {
>+};
>+_foreign_helper.JS_SIGNATURE_NAME = function() {
>+};
>+_foreign_helper.JS_TYPEDEF_TAG = function() {
>+};
>+_foreign_helper.JS_FUNCTION_TYPE_TAG = function() {
>+};
>+_foreign_helper.JS_FUNCTION_TYPE_VOID_RETURN_TAG = function() {
>+};
>+_foreign_helper.JS_FUNCTION_TYPE_RETURN_TYPE_TAG = function() {
>+};
>+_foreign_helper.JS_FUNCTION_TYPE_REQUIRED_PARAMETERS_TAG = function() {
>+};
>+_foreign_helper.JS_FUNCTION_TYPE_OPTIONAL_PARAMETERS_TAG = function() {
>+};
>+_foreign_helper.JS_FUNCTION_TYPE_NAMED_PARAMETERS_TAG = function() {
>+};
>+_foreign_helper.JS_GET_NAME = function(name) {
>+};
>+_foreign_helper.JS_GET_FLAG = function(name) {
>+};
>+_foreign_helper.JS_EFFECT = function(code) {
>+  dart.dcall(code, [null]);
>+};
>+_foreign_helper.JS_CONST = class JS_CONST extends core.Object {};
>+(_foreign_helper.JS_CONST.new = function(code) {
>+  this.code = code;
>+}).prototype = _foreign_helper.JS_CONST.prototype;
>+dart.addTypeTests(_foreign_helper.JS_CONST);
>+dart.setLibraryUri(_foreign_helper.JS_CONST, "dart:_foreign_helper");
>+dart.setFieldSignature(_foreign_helper.JS_CONST, () => ({
>+  __proto__: dart.getFields(_foreign_helper.JS_CONST.__proto__),
>+  code: dart.finalFieldType(core.String)
>+}));
>+_foreign_helper.JS_STRING_CONCAT = function(a, b) {
>+  return a + b;
>+};
>+_foreign_helper._Rest = class _Rest extends core.Object {};
>+(_foreign_helper._Rest.new = function() {
>+}).prototype = _foreign_helper._Rest.prototype;
>+dart.addTypeTests(_foreign_helper._Rest);
>+dart.setLibraryUri(_foreign_helper._Rest, "dart:_foreign_helper");
>+dart.defineLazy(_foreign_helper, {
>+  /*_foreign_helper.rest*/get rest() {
>+    return dart.const(new _foreign_helper._Rest.new());
>+  }
>+});
>+_foreign_helper.spread = function(args) {
>+  dart.throw(new core.StateError.new("The spread function cannot be called, " + "it should be compiled away."));
>+};
>+_interceptors.Interceptor = class Interceptor extends core.Object {
>+  toString() {
>+    return this.toString();
>+  }
>+};
>+(_interceptors.Interceptor.new = function() {
>+}).prototype = _interceptors.Interceptor.prototype;
>+dart.addTypeTests(_interceptors.Interceptor);
>+dart.setLibraryUri(_interceptors.Interceptor, "dart:_interceptors");
>+dart.defineExtensionMethods(_interceptors.Interceptor, ['toString']);
>+_interceptors.getInterceptor = function(obj) {
>+  return obj;
>+};
>+_interceptors.JSBool = class JSBool extends _interceptors.Interceptor {
>+  [$toString]() {
>+    return String(this);
>+  }
>+  get [$hashCode]() {
>+    return this ? 2 * 3 * 23 * 3761 : 269 * 811;
>+  }
>+  [$bitAnd](other) {
>+    if (other == null) dart.argumentError(other);
>+    return other && this;
>+  }
>+  [$bitOr](other) {
>+    if (other == null) dart.argumentError(other);
>+    return other || this;
>+  }
>+  [$bitXor](other) {
>+    if (other == null) dart.argumentError(other);
>+    return !(this === other);
>+  }
>+  get [$runtimeType]() {
>+    return dart.wrapType(core.bool);
>+  }
>+};
>+(_interceptors.JSBool.new = function() {
>+  _interceptors.JSBool.__proto__.new.call(this);
>+}).prototype = _interceptors.JSBool.prototype;
>+dart.addTypeTests(_interceptors.JSBool);
>+_interceptors.JSBool[dart.implements] = () => [core.bool];
>+dart.setMethodSignature(_interceptors.JSBool, () => ({
>+  __proto__: dart.getMethods(_interceptors.JSBool.__proto__),
>+  [$bitAnd]: dart.fnType(core.bool, [core.bool]),
>+  [$bitOr]: dart.fnType(core.bool, [core.bool]),
>+  [$bitXor]: dart.fnType(core.bool, [core.bool])
>+}));
>+dart.setLibraryUri(_interceptors.JSBool, "dart:_interceptors");
>+dart.definePrimitiveHashCode(_interceptors.JSBool.prototype);
>+dart.registerExtension("Boolean", _interceptors.JSBool);
>+const _is_JSIndexable_default = Symbol('_is_JSIndexable_default');
>+_interceptors.JSIndexable$ = dart.generic(E => {
>+  class JSIndexable extends core.Object {}
>+  (JSIndexable.new = function() {
>+  }).prototype = JSIndexable.prototype;
>+  dart.addTypeTests(JSIndexable);
>+  JSIndexable.prototype[_is_JSIndexable_default] = true;
>+  dart.setLibraryUri(JSIndexable, "dart:_interceptors");
>+  return JSIndexable;
>+});
>+_interceptors.JSIndexable = _interceptors.JSIndexable$();
>+dart.addTypeTests(_interceptors.JSIndexable, _is_JSIndexable_default);
>+_interceptors.JSObject = class JSObject extends core.Object {};
>+(_interceptors.JSObject.new = function() {
>+}).prototype = _interceptors.JSObject.prototype;
>+dart.addTypeTests(_interceptors.JSObject);
>+dart.setLibraryUri(_interceptors.JSObject, "dart:_interceptors");
>+_interceptors.JavaScriptObject = class JavaScriptObject extends _interceptors.Interceptor {
>+  get hashCode() {
>+    return 0;
>+  }
>+  get runtimeType() {
>+    return dart.wrapType(_interceptors.JSObject);
>+  }
>+};
>+(_interceptors.JavaScriptObject.new = function() {
>+  _interceptors.JavaScriptObject.__proto__.new.call(this);
>+}).prototype = _interceptors.JavaScriptObject.prototype;
>+dart.addTypeTests(_interceptors.JavaScriptObject);
>+_interceptors.JavaScriptObject[dart.implements] = () => [_interceptors.JSObject];
>+dart.setLibraryUri(_interceptors.JavaScriptObject, "dart:_interceptors");
>+dart.defineExtensionAccessors(_interceptors.JavaScriptObject, ['hashCode', 'runtimeType']);
>+_interceptors.PlainJavaScriptObject = class PlainJavaScriptObject extends _interceptors.JavaScriptObject {};
>+(_interceptors.PlainJavaScriptObject.new = function() {
>+  _interceptors.PlainJavaScriptObject.__proto__.new.call(this);
>+}).prototype = _interceptors.PlainJavaScriptObject.prototype;
>+dart.addTypeTests(_interceptors.PlainJavaScriptObject);
>+dart.setLibraryUri(_interceptors.PlainJavaScriptObject, "dart:_interceptors");
>+_interceptors.UnknownJavaScriptObject = class UnknownJavaScriptObject extends _interceptors.JavaScriptObject {
>+  toString() {
>+    return String(this);
>+  }
>+};
>+(_interceptors.UnknownJavaScriptObject.new = function() {
>+  _interceptors.UnknownJavaScriptObject.__proto__.new.call(this);
>+}).prototype = _interceptors.UnknownJavaScriptObject.prototype;
>+dart.addTypeTests(_interceptors.UnknownJavaScriptObject);
>+dart.setLibraryUri(_interceptors.UnknownJavaScriptObject, "dart:_interceptors");
>+dart.defineExtensionMethods(_interceptors.UnknownJavaScriptObject, ['toString']);
>+_interceptors.NativeError = class NativeError extends _interceptors.Interceptor {
>+  dartStack() {
>+    return this.stack;
>+  }
>+};
>+(_interceptors.NativeError.new = function() {
>+  _interceptors.NativeError.__proto__.new.call(this);
>+}).prototype = _interceptors.NativeError.prototype;
>+dart.addTypeTests(_interceptors.NativeError);
>+dart.setMethodSignature(_interceptors.NativeError, () => ({
>+  __proto__: dart.getMethods(_interceptors.NativeError.__proto__),
>+  dartStack: dart.fnType(core.String, []),
>+  [$dartStack]: dart.fnType(core.String, [])
>+}));
>+dart.setLibraryUri(_interceptors.NativeError, "dart:_interceptors");
>+dart.defineExtensionMethods(_interceptors.NativeError, ['dartStack']);
>+const _fieldName = dart.privateName(_interceptors, "_fieldName");
>+const _functionCallTarget = dart.privateName(_interceptors, "_functionCallTarget");
>+_interceptors.JSNoSuchMethodError = class JSNoSuchMethodError extends _interceptors.NativeError {
>+  [_fieldName](message) {
>+    let match = _interceptors.JSNoSuchMethodError._nullError.firstMatch(message);
>+    if (match == null) return null;
>+    let name = match._get(1);
>+    let l = _interceptors.JSNoSuchMethodError._extensionName.firstMatch(name);
>+    match = l != null ? l : _interceptors.JSNoSuchMethodError._privateName.firstMatch(name);
>+    return match != null ? match._get(1) : name;
>+  }
>+  [_functionCallTarget](message) {
>+    let match = _interceptors.JSNoSuchMethodError._notAFunction.firstMatch(message);
>+    return match != null ? match._get(1) : null;
>+  }
>+  [$dartStack]() {
>+    let stack = super[$dartStack]();
>+    stack = dart.notNull(this[$toString]()) + "\n" + dart.notNull(stack[$split]("\n")[$sublist](1)[$join]("\n"));
>+    return stack;
>+  }
>+  get [$stackTrace]() {
>+    return dart.stackTrace(this);
>+  }
>+  [$toString]() {
>+    let message = this.message;
>+    let callTarget = this[_functionCallTarget](message);
>+    if (callTarget != null) {
>+      return "NoSuchMethodError: tried to call a non-function, such as null: " + ("'" + dart.str(callTarget) + "'");
>+    }
>+    let name = this[_fieldName](message);
>+    if (name == null) {
>+      return this.toString();
>+    }
>+    return "NoSuchMethodError: invalid member on null: '" + dart.str(name) + "'";
>+  }
>+};
>+(_interceptors.JSNoSuchMethodError.new = function() {
>+  _interceptors.JSNoSuchMethodError.__proto__.new.call(this);
>+}).prototype = _interceptors.JSNoSuchMethodError.prototype;
>+dart.addTypeTests(_interceptors.JSNoSuchMethodError);
>+_interceptors.JSNoSuchMethodError[dart.implements] = () => [core.NoSuchMethodError];
>+dart.setMethodSignature(_interceptors.JSNoSuchMethodError, () => ({
>+  __proto__: dart.getMethods(_interceptors.JSNoSuchMethodError.__proto__),
>+  [_fieldName]: dart.fnType(core.String, [core.String]),
>+  [_functionCallTarget]: dart.fnType(core.String, [core.String])
>+}));
>+dart.setGetterSignature(_interceptors.JSNoSuchMethodError, () => ({
>+  __proto__: dart.getGetters(_interceptors.JSNoSuchMethodError.__proto__),
>+  [$stackTrace]: core.StackTrace
>+}));
>+dart.setLibraryUri(_interceptors.JSNoSuchMethodError, "dart:_interceptors");
>+dart.defineLazy(_interceptors.JSNoSuchMethodError, {
>+  /*_interceptors.JSNoSuchMethodError._nullError*/get _nullError() {
>+    return core.RegExp.new("^Cannot read property '(.+)' of null$");
>+  },
>+  /*_interceptors.JSNoSuchMethodError._notAFunction*/get _notAFunction() {
>+    return core.RegExp.new("^(.+) is not a function$");
>+  },
>+  /*_interceptors.JSNoSuchMethodError._extensionName*/get _extensionName() {
>+    return core.RegExp.new("^Symbol\$dartx\\.(.+)\$$");
>+  },
>+  /*_interceptors.JSNoSuchMethodError._privateName*/get _privateName() {
>+    return core.RegExp.new("^Symbol\$(_.+)\$$");
>+  }
>+});
>+dart.registerExtension("TypeError", _interceptors.JSNoSuchMethodError);
>+_interceptors.JSFunction = class JSFunction extends _interceptors.Interceptor {
>+  [$toString]() {
>+    if (dart.isType(this)) return dart.typeName(this);
>+    return "Closure: " + dart.typeName(dart.getReifiedType(this)) + " from: " + this;
>+  }
>+  [$_equals](other) {
>+    if (other == null) return false;
>+    let boundObj = this._boundObject;
>+    if (boundObj == null) return this === other;
>+    return boundObj === other._boundObject && this._boundMethod === other._boundMethod;
>+  }
>+  get [$hashCode]() {
>+    let boundObj = this._boundObject;
>+    if (boundObj == null) return core.identityHashCode(this);
>+    let boundMethod = this._boundMethod;
>+    let hash = 17 * 31 + dart.notNull(dart.hashCode(boundObj)) & 536870911;
>+    return hash * 31 + dart.notNull(core.identityHashCode(boundMethod)) & 536870911;
>+  }
>+  get [$runtimeType]() {
>+    return dart.wrapType(dart.getReifiedType(this));
>+  }
>+};
>+(_interceptors.JSFunction.new = function() {
>+  _interceptors.JSFunction.__proto__.new.call(this);
>+}).prototype = _interceptors.JSFunction.prototype;
>+dart.addTypeTests(_interceptors.JSFunction);
>+dart.setLibraryUri(_interceptors.JSFunction, "dart:_interceptors");
>+dart.registerExtension("Function", _interceptors.JSFunction);
>+_interceptors.JSNull = class JSNull extends core.Object {
>+  toString() {
>+    return "null";
>+  }
>+  noSuchMethod(i) {
>+    return dart.defaultNoSuchMethod(null, i);
>+  }
>+};
>+(_interceptors.JSNull.new = function() {
>+}).prototype = _interceptors.JSNull.prototype;
>+dart.addTypeTests(_interceptors.JSNull);
>+dart.setLibraryUri(_interceptors.JSNull, "dart:_interceptors");
>+dart.defineExtensionMethods(_interceptors.JSNull, ['toString', 'noSuchMethod']);
>+dart.defineLazy(_interceptors, {
>+  /*_interceptors.jsNull*/get jsNull() {
>+    return new _interceptors.JSNull.new();
>+  }
>+});
>+_interceptors.JSRangeError = class JSRangeError extends _interceptors.Interceptor {
>+  get [$stackTrace]() {
>+    return dart.stackTrace(this);
>+  }
>+  get [$invalidValue]() {
>+    return null;
>+  }
>+  get [$name]() {
>+    return null;
>+  }
>+  get [$message]() {
>+    return this.message;
>+  }
>+  [$toString]() {
>+    return "Invalid argument: " + dart.str(this[$message]);
>+  }
>+};
>+(_interceptors.JSRangeError.new = function() {
>+  _interceptors.JSRangeError.__proto__.new.call(this);
>+}).prototype = _interceptors.JSRangeError.prototype;
>+dart.addTypeTests(_interceptors.JSRangeError);
>+_interceptors.JSRangeError[dart.implements] = () => [core.ArgumentError];
>+dart.setGetterSignature(_interceptors.JSRangeError, () => ({
>+  __proto__: dart.getGetters(_interceptors.JSRangeError.__proto__),
>+  [$stackTrace]: core.StackTrace,
>+  [$invalidValue]: dart.dynamic,
>+  [$name]: core.String,
>+  [$message]: dart.dynamic
>+}));
>+dart.setLibraryUri(_interceptors.JSRangeError, "dart:_interceptors");
>+dart.registerExtension("RangeError", _interceptors.JSRangeError);
>+_interceptors.findInterceptorConstructorForType = function(type) {
>+};
>+_interceptors.findConstructorForNativeSubclassType = function(type, name) {
>+};
>+_interceptors.getNativeInterceptor = function(object) {
>+};
>+_interceptors.setDispatchProperty = function(object, value) {
>+};
>+const _removeWhere = dart.privateName(_interceptors, "_removeWhere");
>+const _is_JSArray_default = Symbol('_is_JSArray_default');
>+_interceptors.JSArray$ = dart.generic(E => {
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  let WhereIterableOfE = () => (WhereIterableOfE = dart.constFn(_internal.WhereIterable$(E)))();
>+  let SubListIterableOfE = () => (SubListIterableOfE = dart.constFn(_internal.SubListIterable$(E)))();
>+  let TakeWhileIterableOfE = () => (TakeWhileIterableOfE = dart.constFn(_internal.TakeWhileIterable$(E)))();
>+  let SkipWhileIterableOfE = () => (SkipWhileIterableOfE = dart.constFn(_internal.SkipWhileIterable$(E)))();
>+  let EAndEToE = () => (EAndEToE = dart.constFn(dart.fnType(E, [E, E])))();
>+  let VoidToE = () => (VoidToE = dart.constFn(dart.fnType(E, [])))();
>+  let JSArrayOfE = () => (JSArrayOfE = dart.constFn(_interceptors.JSArray$(E)))();
>+  let ListOfE = () => (ListOfE = dart.constFn(core.List$(E)))();
>+  let ReversedListIterableOfE = () => (ReversedListIterableOfE = dart.constFn(_internal.ReversedListIterable$(E)))();
>+  let SetOfE = () => (SetOfE = dart.constFn(core.Set$(E)))();
>+  let ArrayIteratorOfE = () => (ArrayIteratorOfE = dart.constFn(_interceptors.ArrayIterator$(E)))();
>+  let ListMapViewOfE = () => (ListMapViewOfE = dart.constFn(_internal.ListMapView$(E)))();
>+  let FollowedByIterableOfE = () => (FollowedByIterableOfE = dart.constFn(_internal.FollowedByIterable$(E)))();
>+  let JSIndexableOfE = () => (JSIndexableOfE = dart.constFn(_interceptors.JSIndexable$(E)))();
>+  class JSArray extends core.Object {
>+    constructor() {
>+      return [];
>+    }
>+    static of(list) {
>+      list.__proto__ = JSArray.prototype;
>+      return list;
>+    }
>+    static fixed(list) {
>+      list.__proto__ = JSArray.prototype;
>+      list.fixed$length = Array;
>+      return list;
>+    }
>+    static unmodifiable(list) {
>+      list.__proto__ = JSArray.prototype;
>+      list.fixed$length = Array;
>+      list.immutable$list = Array;
>+      return list;
>+    }
>+    static markFixedList(list) {
>+      list.fixed$length = Array;
>+    }
>+    static markUnmodifiableList(list) {
>+      list.fixed$length = Array;
>+      list.immutable$list = Array;
>+    }
>+    [$checkMutable](reason) {
>+      if (this.immutable$list) {
>+        dart.throw(new core.UnsupportedError.new(core.String._check(reason)));
>+      }
>+    }
>+    [$checkGrowable](reason) {
>+      if (this.fixed$length) {
>+        dart.throw(new core.UnsupportedError.new(core.String._check(reason)));
>+      }
>+    }
>+    [$cast](R) {
>+      return core.List.castFrom(E, R, this);
>+    }
>+    [$add](value) {
>+      E._check(value);
>+      this[$checkGrowable]("add");
>+      this.push(value);
>+    }
>+    [$removeAt](index) {
>+      if (index == null) dart.argumentError(index);
>+      this[$checkGrowable]("removeAt");
>+      if (index < 0 || index >= this[$length]) {
>+        dart.throw(new core.RangeError.value(index));
>+      }
>+      return this.splice(index, 1)[0];
>+    }
>+    [$insert](index, value) {
>+      if (index == null) dart.argumentError(index);
>+      E._check(value);
>+      this[$checkGrowable]("insert");
>+      if (index < 0 || index > this[$length]) {
>+        dart.throw(new core.RangeError.value(index));
>+      }
>+      this.splice(index, 0, value);
>+    }
>+    [$insertAll](index, iterable) {
>+      if (index == null) dart.argumentError(index);
>+      IterableOfE()._check(iterable);
>+      this[$checkGrowable]("insertAll");
>+      core.RangeError.checkValueInInterval(index, 0, this[$length], "index");
>+      if (!_internal.EfficientLengthIterable.is(iterable)) {
>+        iterable = iterable[$toList]();
>+      }
>+      let insertionLength = dart.notNull(iterable[$length]);
>+      this[$length] = dart.notNull(this[$length]) + insertionLength;
>+      let end = index + insertionLength;
>+      this[$setRange](end, this[$length], this, index);
>+      this[$setRange](index, end, iterable);
>+    }
>+    [$setAll](index, iterable) {
>+      if (index == null) dart.argumentError(index);
>+      IterableOfE()._check(iterable);
>+      this[$checkMutable]("setAll");
>+      core.RangeError.checkValueInInterval(index, 0, this[$length], "index");
>+      for (let element of iterable) {
>+        this[$_set](index++, element);
>+      }
>+    }
>+    [$removeLast]() {
>+      this[$checkGrowable]("removeLast");
>+      if (this[$length] === 0) dart.throw(_js_helper.diagnoseIndexError(this, -1));
>+      return this.pop();
>+    }
>+    [$remove](element) {
>+      this[$checkGrowable]("remove");
>+      let length = this[$length];
>+      for (let i = 0; i < length; i++) {
>+        if (dart.equals(this[$_get](i), element)) {
>+          this.splice(i, 1);
>+          return true;
>+        }
>+      }
>+      return false;
>+    }
>+    [$removeWhere](test) {
>+      this[$checkGrowable]("removeWhere");
>+      this[_removeWhere](test, true);
>+    }
>+    [$retainWhere](test) {
>+      this[$checkGrowable]("retainWhere");
>+      this[_removeWhere](test, false);
>+    }
>+    [_removeWhere](test, removeMatching) {
>+      let retained = [];
>+      let end = this[$length];
>+      for (let i = 0; i < end; i++) {
>+        let element = this[i];
>+        if (!dart.test(test(element)) === removeMatching) {
>+          retained[$add](element);
>+        }
>+        if (this[$length] !== end) dart.throw(new core.ConcurrentModificationError.new(this));
>+      }
>+      if (retained[$length] === end) return;
>+      this[$length] = retained[$length];
>+      let length = dart.notNull(retained[$length]);
>+      for (let i = 0; i < length; i++) {
>+        this[i] = retained[i];
>+      }
>+    }
>+    [$where](f) {
>+      return new (WhereIterableOfE()).new(this, f);
>+    }
>+    [$expand](T, f) {
>+      return new (_internal.ExpandIterable$(E, T)).new(this, f);
>+    }
>+    [$addAll](collection) {
>+      IterableOfE()._check(collection);
>+      let i = this[$length];
>+      this[$checkGrowable]("addAll");
>+      for (let e of collection) {
>+        if (!(i === this[$length] || dart.test(dart.throw(new core.ConcurrentModificationError.new(this))))) dart.assertFailed(null, "dart:_interceptors/js_array.dart", 187, 14, "i == this.length || (throw ConcurrentModificationError(this))");
>+        i++;
>+        this.push(e);
>+      }
>+    }
>+    [$clear]() {
>+      this[$length] = 0;
>+    }
>+    [$forEach](f) {
>+      let end = this[$length];
>+      for (let i = 0; i < end; i++) {
>+        let element = this[i];
>+        f(E._check(element));
>+        if (this[$length] !== end) dart.throw(new core.ConcurrentModificationError.new(this));
>+      }
>+    }
>+    [$map](T, f) {
>+      return new (_internal.MappedListIterable$(E, T)).new(this, f);
>+    }
>+    [$join](separator) {
>+      if (separator === void 0) separator = "";
>+      let length = this[$length];
>+      let list = core.List.new(length);
>+      for (let i = 0; i < length; i++) {
>+        list[$_set](i, dart.str(this[$_get](i)));
>+      }
>+      return list.join(separator);
>+    }
>+    [$take](n) {
>+      return new (SubListIterableOfE()).new(this, 0, n);
>+    }
>+    [$takeWhile](test) {
>+      return new (TakeWhileIterableOfE()).new(this, test);
>+    }
>+    [$skip](n) {
>+      return new (SubListIterableOfE()).new(this, n, null);
>+    }
>+    [$skipWhile](test) {
>+      return new (SkipWhileIterableOfE()).new(this, test);
>+    }
>+    [$reduce](combine) {
>+      EAndEToE()._check(combine);
>+      let length = this[$length];
>+      if (length === 0) dart.throw(_internal.IterableElementError.noElement());
>+      let value = this[$_get](0);
>+      for (let i = 1; i < length; i++) {
>+        let element = this[i];
>+        value = combine(value, E._check(element));
>+        if (length !== this[$length]) dart.throw(new core.ConcurrentModificationError.new(this));
>+      }
>+      return value;
>+    }
>+    [$fold](T, initialValue, combine) {
>+      let value = initialValue;
>+      let length = this[$length];
>+      for (let i = 0; i < length; i++) {
>+        let element = this[i];
>+        value = combine(value, E._check(element));
>+        if (this[$length] !== length) dart.throw(new core.ConcurrentModificationError.new(this));
>+      }
>+      return value;
>+    }
>+    [$firstWhere](test, opts) {
>+      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+      VoidToE()._check(orElse);
>+      let end = this[$length];
>+      for (let i = 0; i < end; ++i) {
>+        let element = this[i];
>+        if (dart.test(test(E._check(element)))) return E._check(element);
>+        if (this[$length] !== end) dart.throw(new core.ConcurrentModificationError.new(this));
>+      }
>+      if (orElse != null) return orElse();
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    [$lastWhere](test, opts) {
>+      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+      VoidToE()._check(orElse);
>+      let length = this[$length];
>+      for (let i = length - 1; i >= 0; i--) {
>+        let element = this[i];
>+        if (dart.test(test(E._check(element)))) return E._check(element);
>+        if (length !== this[$length]) {
>+          dart.throw(new core.ConcurrentModificationError.new(this));
>+        }
>+      }
>+      if (orElse != null) return orElse();
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    [$singleWhere](test, opts) {
>+      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+      VoidToE()._check(orElse);
>+      let length = this[$length];
>+      let match = null;
>+      let matchFound = false;
>+      for (let i = 0; i < length; i++) {
>+        let element = this[i];
>+        if (dart.test(test(element))) {
>+          if (matchFound) {
>+            dart.throw(_internal.IterableElementError.tooMany());
>+          }
>+          matchFound = true;
>+          match = element;
>+        }
>+        if (length !== this[$length]) {
>+          dart.throw(new core.ConcurrentModificationError.new(this));
>+        }
>+      }
>+      if (matchFound) return match;
>+      if (orElse != null) return orElse();
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    [$elementAt](index) {
>+      return this[$_get](index);
>+    }
>+    [$sublist](start, end) {
>+      if (start == null) dart.argumentError(start);
>+      if (end === void 0) end = null;
>+      if (start < 0 || start > this[$length]) {
>+        dart.throw(new core.RangeError.range(start, 0, this[$length], "start"));
>+      }
>+      if (end == null) {
>+        end = this[$length];
>+      } else {
>+        let _end = end;
>+        if (_end < start || _end > this[$length]) {
>+          dart.throw(new core.RangeError.range(end, start, this[$length], "end"));
>+        }
>+      }
>+      if (start === end) return JSArrayOfE().of([]);
>+      return JSArrayOfE().of(this.slice(start, end));
>+    }
>+    [$getRange](start, end) {
>+      core.RangeError.checkValidRange(start, end, this[$length]);
>+      return new (SubListIterableOfE()).new(this, start, end);
>+    }
>+    get [$first]() {
>+      if (this[$length] > 0) return this[$_get](0);
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    get [$last]() {
>+      if (this[$length] > 0) return this[$_get](this[$length] - 1);
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    get [$single]() {
>+      if (this[$length] === 1) return this[$_get](0);
>+      if (this[$length] === 0) dart.throw(_internal.IterableElementError.noElement());
>+      dart.throw(_internal.IterableElementError.tooMany());
>+    }
>+    [$removeRange](start, end) {
>+      if (start == null) dart.argumentError(start);
>+      if (end == null) dart.argumentError(end);
>+      this[$checkGrowable]("removeRange");
>+      core.RangeError.checkValidRange(start, end, this[$length]);
>+      let deleteCount = end - start;
>+      this.splice(start, deleteCount);
>+    }
>+    [$setRange](start, end, iterable, skipCount) {
>+      if (start == null) dart.argumentError(start);
>+      if (end == null) dart.argumentError(end);
>+      IterableOfE()._check(iterable);
>+      if (skipCount === void 0) skipCount = 0;
>+      if (skipCount == null) dart.argumentError(skipCount);
>+      this[$checkMutable]("set range");
>+      core.RangeError.checkValidRange(start, end, this[$length]);
>+      let length = end - start;
>+      if (length === 0) return;
>+      core.RangeError.checkNotNegative(skipCount, "skipCount");
>+      let otherList = null;
>+      let otherStart = 0;
>+      if (ListOfE().is(iterable)) {
>+        otherList = iterable;
>+        otherStart = skipCount;
>+      } else {
>+        otherList = iterable[$skip](skipCount)[$toList]({growable: false});
>+        otherStart = 0;
>+      }
>+      if (otherStart + length > dart.notNull(otherList[$length])) {
>+        dart.throw(_internal.IterableElementError.tooFew());
>+      }
>+      if (otherStart < start) {
>+        for (let i = length - 1; i >= 0; i--) {
>+          let element = otherList[$_get](otherStart + i);
>+          this[start + i] = element;
>+        }
>+      } else {
>+        for (let i = 0; i < length; i++) {
>+          let element = otherList[$_get](otherStart + i);
>+          this[start + i] = element;
>+        }
>+      }
>+    }
>+    [$fillRange](start, end, fillValue) {
>+      if (start == null) dart.argumentError(start);
>+      if (end == null) dart.argumentError(end);
>+      if (fillValue === void 0) fillValue = null;
>+      E._check(fillValue);
>+      this[$checkMutable]("fill range");
>+      core.RangeError.checkValidRange(start, end, this[$length]);
>+      for (let i = start; i < end; i++) {
>+        this[i] = fillValue;
>+      }
>+    }
>+    [$replaceRange](start, end, replacement) {
>+      if (start == null) dart.argumentError(start);
>+      if (end == null) dart.argumentError(end);
>+      IterableOfE()._check(replacement);
>+      this[$checkGrowable]("replace range");
>+      core.RangeError.checkValidRange(start, end, this[$length]);
>+      if (!_internal.EfficientLengthIterable.is(replacement)) {
>+        replacement = replacement[$toList]();
>+      }
>+      let removeLength = end - start;
>+      let insertLength = dart.notNull(replacement[$length]);
>+      if (removeLength >= insertLength) {
>+        let delta = removeLength - insertLength;
>+        let insertEnd = start + insertLength;
>+        let newLength = this[$length] - delta;
>+        this[$setRange](start, insertEnd, replacement);
>+        if (delta !== 0) {
>+          this[$setRange](insertEnd, newLength, this, end);
>+          this[$length] = newLength;
>+        }
>+      } else {
>+        let delta = insertLength - removeLength;
>+        let newLength = this[$length] + delta;
>+        let insertEnd = start + insertLength;
>+        this[$length] = newLength;
>+        this[$setRange](insertEnd, newLength, this, end);
>+        this[$setRange](start, insertEnd, replacement);
>+      }
>+    }
>+    [$any](test) {
>+      let end = this[$length];
>+      for (let i = 0; i < end; i++) {
>+        let element = this[i];
>+        if (dart.test(test(E._check(element)))) return true;
>+        if (this[$length] !== end) dart.throw(new core.ConcurrentModificationError.new(this));
>+      }
>+      return false;
>+    }
>+    [$every](test) {
>+      let end = this[$length];
>+      for (let i = 0; i < end; i++) {
>+        let element = this[i];
>+        if (!dart.test(test(element))) return false;
>+        if (this[$length] !== end) dart.throw(new core.ConcurrentModificationError.new(this));
>+      }
>+      return true;
>+    }
>+    get [$reversed]() {
>+      return new (ReversedListIterableOfE()).new(this);
>+    }
>+    [$sort](compare) {
>+      if (compare === void 0) compare = null;
>+      this[$checkMutable]("sort");
>+      if (compare == null) {
>+        _internal.Sort.sort(E, this, dart.fn((a, b) => core.Comparable.compare(core.Comparable._check(a), core.Comparable._check(b)), dynamicAnddynamicToint()));
>+      } else {
>+        _internal.Sort.sort(E, this, compare);
>+      }
>+    }
>+    [$shuffle](random) {
>+      if (random === void 0) random = null;
>+      this[$checkMutable]("shuffle");
>+      if (random == null) random = math.Random.new();
>+      let length = this[$length];
>+      while (length > 1) {
>+        let pos = random.nextInt(length);
>+        length = length - 1;
>+        let tmp = this[$_get](length);
>+        this[$_set](length, this[$_get](pos));
>+        this[$_set](pos, tmp);
>+      }
>+    }
>+    [$indexOf](element, start) {
>+      if (start === void 0) start = 0;
>+      if (start == null) dart.argumentError(start);
>+      let length = this[$length];
>+      if (start >= length) {
>+        return -1;
>+      }
>+      if (start < 0) {
>+        start = 0;
>+      }
>+      for (let i = start; i < length; i++) {
>+        if (dart.equals(this[$_get](i), element)) {
>+          return i;
>+        }
>+      }
>+      return -1;
>+    }
>+    [$lastIndexOf](element, _startIndex) {
>+      if (_startIndex === void 0) _startIndex = null;
>+      let startIndex = _startIndex != null ? _startIndex : this[$length] - 1;
>+      if (startIndex >= this[$length]) {
>+        startIndex = this[$length] - 1;
>+      } else if (startIndex < 0) {
>+        return -1;
>+      }
>+      for (let i = startIndex; i >= 0; i--) {
>+        if (dart.equals(this[$_get](i), element)) {
>+          return i;
>+        }
>+      }
>+      return -1;
>+    }
>+    [$contains](other) {
>+      let length = this[$length];
>+      for (let i = 0; i < length; i++) {
>+        let element = this[i];
>+        if (dart.equals(element, other)) return true;
>+      }
>+      return false;
>+    }
>+    get [$isEmpty]() {
>+      return this[$length] === 0;
>+    }
>+    get [$isNotEmpty]() {
>+      return !this[$isEmpty];
>+    }
>+    [$toString]() {
>+      return collection.ListBase.listToString(this);
>+    }
>+    [$toList](opts) {
>+      let growable = opts && 'growable' in opts ? opts.growable : true;
>+      if (growable == null) dart.argumentError(growable);
>+      let list = this.slice();
>+      if (!growable) _interceptors.JSArray.markFixedList(list);
>+      return JSArrayOfE().of(list);
>+    }
>+    [$toSet]() {
>+      return SetOfE().from(this);
>+    }
>+    get [$iterator]() {
>+      return new (ArrayIteratorOfE()).new(this);
>+    }
>+    get [$hashCode]() {
>+      return core.identityHashCode(this);
>+    }
>+    [$_equals](other) {
>+      return this === other;
>+    }
>+    get [$length]() {
>+      return this.length;
>+    }
>+    set [$length](newLength) {
>+      if (newLength == null) dart.argumentError(newLength);
>+      this[$checkGrowable]("set length");
>+      if (newLength < 0) {
>+        dart.throw(new core.RangeError.range(newLength, 0, null, "newLength"));
>+      }
>+      this.length = newLength;
>+    }
>+    [$_get](index) {
>+      if (index == null || index >= this.length || index < 0) {
>+        dart.throw(_js_helper.diagnoseIndexError(this, index));
>+      }
>+      return this[index];
>+    }
>+    [$_set](index, value) {
>+      E._check(value);
>+      this[$checkMutable]("indexed set");
>+      if (index == null || index >= this.length || index < 0) {
>+        dart.throw(_js_helper.diagnoseIndexError(this, index));
>+      }
>+      this[index] = value;
>+      return value;
>+    }
>+    [$asMap]() {
>+      return new (ListMapViewOfE()).new(this);
>+    }
>+    get [$runtimeType]() {
>+      return dart.wrapType(core.List$(E));
>+    }
>+    [$followedBy](other) {
>+      IterableOfE()._check(other);
>+      return FollowedByIterableOfE().firstEfficient(this, other);
>+    }
>+    [$whereType](T) {
>+      return new (_internal.WhereTypeIterable$(T)).new(this);
>+    }
>+    [$plus](other) {
>+      ListOfE()._check(other);
>+      let totalLength = this[$length] + dart.notNull(other[$length]);
>+      let _ = JSArrayOfE().of([]);
>+      _[$length] = totalLength;
>+      _[$setRange](0, this[$length], this);
>+      _[$setRange](this[$length], totalLength, other);
>+      return _;
>+    }
>+    [$indexWhere](test, start) {
>+      if (start === void 0) start = 0;
>+      if (dart.notNull(start) >= this[$length]) return -1;
>+      if (dart.notNull(start) < 0) start = 0;
>+      for (let i = start; dart.notNull(i) < this[$length]; i = dart.notNull(i) + 1) {
>+        if (dart.test(test(this[$_get](i)))) return i;
>+      }
>+      return -1;
>+    }
>+    [$lastIndexWhere](test, start) {
>+      if (start === void 0) start = null;
>+      if (start == null) start = this[$length] - 1;
>+      if (dart.notNull(start) < 0) return -1;
>+      for (let i = start; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
>+        if (dart.test(test(this[$_get](i)))) return i;
>+      }
>+      return -1;
>+    }
>+    set [$first](element) {
>+      E._check(element);
>+      if (this[$isEmpty]) dart.throw(core.RangeError.index(0, this));
>+      this[$_set](0, element);
>+    }
>+    set [$last](element) {
>+      E._check(element);
>+      if (this[$isEmpty]) dart.throw(core.RangeError.index(0, this));
>+      this[$_set](this[$length] - 1, element);
>+    }
>+  }
>+  (JSArray.new = function() {
>+  }).prototype = JSArray.prototype;
>+  dart.setExtensionBaseClass(JSArray, dart.global.Array);
>+  JSArray.prototype[dart.isList] = true;
>+  dart.addTypeTests(JSArray);
>+  JSArray.prototype[_is_JSArray_default] = true;
>+  JSArray[dart.implements] = () => [ListOfE(), JSIndexableOfE()];
>+  dart.setMethodSignature(JSArray, () => ({
>+    __proto__: dart.getMethods(JSArray.__proto__),
>+    [$checkMutable]: dart.fnType(dart.dynamic, [dart.dynamic]),
>+    [$checkGrowable]: dart.fnType(dart.dynamic, [dart.dynamic]),
>+    [$cast]: dart.gFnType(R => [core.List$(R), []]),
>+    [$add]: dart.fnType(dart.void, [core.Object]),
>+    [$removeAt]: dart.fnType(E, [core.int]),
>+    [$insert]: dart.fnType(dart.void, [core.int, core.Object]),
>+    [$insertAll]: dart.fnType(dart.void, [core.int, core.Object]),
>+    [$setAll]: dart.fnType(dart.void, [core.int, core.Object]),
>+    [$removeLast]: dart.fnType(E, []),
>+    [$remove]: dart.fnType(core.bool, [core.Object]),
>+    [$removeWhere]: dart.fnType(dart.void, [dart.fnType(core.bool, [E])]),
>+    [$retainWhere]: dart.fnType(dart.void, [dart.fnType(core.bool, [E])]),
>+    [_removeWhere]: dart.fnType(dart.void, [dart.fnType(core.bool, [E]), core.bool]),
>+    [$where]: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    [$expand]: dart.gFnType(T => [core.Iterable$(T), [dart.fnType(core.Iterable$(T), [E])]]),
>+    [$addAll]: dart.fnType(dart.void, [core.Object]),
>+    [$clear]: dart.fnType(dart.void, []),
>+    [$forEach]: dart.fnType(dart.void, [dart.fnType(dart.void, [E])]),
>+    [$map]: dart.gFnType(T => [core.Iterable$(T), [dart.fnType(T, [E])]]),
>+    [$join]: dart.fnType(core.String, [], [core.String]),
>+    [$take]: dart.fnType(core.Iterable$(E), [core.int]),
>+    [$takeWhile]: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    [$skip]: dart.fnType(core.Iterable$(E), [core.int]),
>+    [$skipWhile]: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    [$reduce]: dart.fnType(E, [core.Object]),
>+    [$fold]: dart.gFnType(T => [T, [T, dart.fnType(T, [T, E])]]),
>+    [$firstWhere]: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    [$lastWhere]: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    [$singleWhere]: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    [$elementAt]: dart.fnType(E, [core.int]),
>+    [$sublist]: dart.fnType(core.List$(E), [core.int], [core.int]),
>+    [$getRange]: dart.fnType(core.Iterable$(E), [core.int, core.int]),
>+    [$removeRange]: dart.fnType(dart.void, [core.int, core.int]),
>+    [$setRange]: dart.fnType(dart.void, [core.int, core.int, core.Object], [core.int]),
>+    [$fillRange]: dart.fnType(dart.void, [core.int, core.int], [core.Object]),
>+    [$replaceRange]: dart.fnType(dart.void, [core.int, core.int, core.Object]),
>+    [$any]: dart.fnType(core.bool, [dart.fnType(core.bool, [E])]),
>+    [$every]: dart.fnType(core.bool, [dart.fnType(core.bool, [E])]),
>+    [$sort]: dart.fnType(dart.void, [], [dart.fnType(core.int, [E, E])]),
>+    [$shuffle]: dart.fnType(dart.void, [], [math.Random]),
>+    [$indexOf]: dart.fnType(core.int, [core.Object], [core.int]),
>+    [$lastIndexOf]: dart.fnType(core.int, [core.Object], [core.int]),
>+    [$contains]: dart.fnType(core.bool, [core.Object]),
>+    [$toString]: dart.fnType(core.String, []),
>+    [$toList]: dart.fnType(core.List$(E), [], {growable: core.bool}),
>+    [$toSet]: dart.fnType(core.Set$(E), []),
>+    [$_equals]: dart.fnType(core.bool, [dart.dynamic]),
>+    [$_get]: dart.fnType(E, [core.int]),
>+    [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+    [$asMap]: dart.fnType(core.Map$(core.int, E), []),
>+    [$followedBy]: dart.fnType(core.Iterable$(E), [core.Object]),
>+    [$whereType]: dart.gFnType(T => [core.Iterable$(T), []]),
>+    [$plus]: dart.fnType(core.List$(E), [core.Object]),
>+    [$indexWhere]: dart.fnType(core.int, [dart.fnType(core.bool, [E])], [core.int]),
>+    [$lastIndexWhere]: dart.fnType(core.int, [dart.fnType(core.bool, [E])], [core.int])
>+  }));
>+  dart.setGetterSignature(JSArray, () => ({
>+    __proto__: dart.getGetters(JSArray.__proto__),
>+    [$first]: E,
>+    [$last]: E,
>+    [$single]: E,
>+    [$reversed]: core.Iterable$(E),
>+    [$isEmpty]: core.bool,
>+    [$isNotEmpty]: core.bool,
>+    [$iterator]: core.Iterator$(E),
>+    [$hashCode]: core.int,
>+    [$length]: core.int,
>+    [$runtimeType]: core.Type
>+  }));
>+  dart.setSetterSignature(JSArray, () => ({
>+    __proto__: dart.getSetters(JSArray.__proto__),
>+    [$length]: core.int,
>+    [$first]: E,
>+    [$last]: E
>+  }));
>+  dart.setLibraryUri(JSArray, "dart:_interceptors");
>+  return JSArray;
>+});
>+_interceptors.JSArray = _interceptors.JSArray$();
>+dart.addTypeTests(_interceptors.JSArray, _is_JSArray_default);
>+dart.registerExtension("Array", _interceptors.JSArray);
>+const _is_JSMutableArray_default = Symbol('_is_JSMutableArray_default');
>+_interceptors.JSMutableArray$ = dart.generic(E => {
>+  class JSMutableArray extends _interceptors.JSArray$(E) {}
>+  (JSMutableArray.new = function() {
>+    JSMutableArray.__proto__.new.call(this);
>+  }).prototype = JSMutableArray.prototype;
>+  dart.addTypeTests(JSMutableArray);
>+  JSMutableArray.prototype[_is_JSMutableArray_default] = true;
>+  dart.setLibraryUri(JSMutableArray, "dart:_interceptors");
>+  return JSMutableArray;
>+});
>+_interceptors.JSMutableArray = _interceptors.JSMutableArray$();
>+dart.addTypeTests(_interceptors.JSMutableArray, _is_JSMutableArray_default);
>+const _is_JSFixedArray_default = Symbol('_is_JSFixedArray_default');
>+_interceptors.JSFixedArray$ = dart.generic(E => {
>+  class JSFixedArray extends _interceptors.JSMutableArray$(E) {}
>+  (JSFixedArray.new = function() {
>+    JSFixedArray.__proto__.new.call(this);
>+  }).prototype = JSFixedArray.prototype;
>+  dart.addTypeTests(JSFixedArray);
>+  JSFixedArray.prototype[_is_JSFixedArray_default] = true;
>+  dart.setLibraryUri(JSFixedArray, "dart:_interceptors");
>+  return JSFixedArray;
>+});
>+_interceptors.JSFixedArray = _interceptors.JSFixedArray$();
>+dart.addTypeTests(_interceptors.JSFixedArray, _is_JSFixedArray_default);
>+const _is_JSExtendableArray_default = Symbol('_is_JSExtendableArray_default');
>+_interceptors.JSExtendableArray$ = dart.generic(E => {
>+  class JSExtendableArray extends _interceptors.JSMutableArray$(E) {}
>+  (JSExtendableArray.new = function() {
>+    JSExtendableArray.__proto__.new.call(this);
>+  }).prototype = JSExtendableArray.prototype;
>+  dart.addTypeTests(JSExtendableArray);
>+  JSExtendableArray.prototype[_is_JSExtendableArray_default] = true;
>+  dart.setLibraryUri(JSExtendableArray, "dart:_interceptors");
>+  return JSExtendableArray;
>+});
>+_interceptors.JSExtendableArray = _interceptors.JSExtendableArray$();
>+dart.addTypeTests(_interceptors.JSExtendableArray, _is_JSExtendableArray_default);
>+const _is_JSUnmodifiableArray_default = Symbol('_is_JSUnmodifiableArray_default');
>+_interceptors.JSUnmodifiableArray$ = dart.generic(E => {
>+  class JSUnmodifiableArray extends _interceptors.JSArray$(E) {}
>+  (JSUnmodifiableArray.new = function() {
>+    JSUnmodifiableArray.__proto__.new.call(this);
>+  }).prototype = JSUnmodifiableArray.prototype;
>+  dart.addTypeTests(JSUnmodifiableArray);
>+  JSUnmodifiableArray.prototype[_is_JSUnmodifiableArray_default] = true;
>+  dart.setLibraryUri(JSUnmodifiableArray, "dart:_interceptors");
>+  return JSUnmodifiableArray;
>+});
>+_interceptors.JSUnmodifiableArray = _interceptors.JSUnmodifiableArray$();
>+dart.addTypeTests(_interceptors.JSUnmodifiableArray, _is_JSUnmodifiableArray_default);
>+const _iterable = dart.privateName(_interceptors, "_iterable");
>+const _length = dart.privateName(_interceptors, "_length");
>+const _index = dart.privateName(_interceptors, "_index");
>+const _current = dart.privateName(_interceptors, "_current");
>+const _is_ArrayIterator_default = Symbol('_is_ArrayIterator_default');
>+_interceptors.ArrayIterator$ = dart.generic(E => {
>+  let IteratorOfE = () => (IteratorOfE = dart.constFn(core.Iterator$(E)))();
>+  let JSArrayOfE = () => (JSArrayOfE = dart.constFn(_interceptors.JSArray$(E)))();
>+  class ArrayIterator extends core.Object {
>+    get current() {
>+      return this[_current];
>+    }
>+    moveNext() {
>+      let length = this[_iterable][$length];
>+      if (this[_length] !== length) {
>+        dart.throw(_js_helper.throwConcurrentModificationError(this[_iterable]));
>+      }
>+      if (this[_index] >= length) {
>+        this[_current] = null;
>+        return false;
>+      }
>+      this[_current] = this[_iterable][$_get](this[_index]);
>+      this[_index]++;
>+      return true;
>+    }
>+  }
>+  (ArrayIterator.new = function(iterable) {
>+    this[_current] = null;
>+    this[_iterable] = iterable;
>+    this[_length] = iterable[$length];
>+    this[_index] = 0;
>+  }).prototype = ArrayIterator.prototype;
>+  dart.addTypeTests(ArrayIterator);
>+  ArrayIterator.prototype[_is_ArrayIterator_default] = true;
>+  ArrayIterator[dart.implements] = () => [IteratorOfE()];
>+  dart.setMethodSignature(ArrayIterator, () => ({
>+    __proto__: dart.getMethods(ArrayIterator.__proto__),
>+    moveNext: dart.fnType(core.bool, [])
>+  }));
>+  dart.setGetterSignature(ArrayIterator, () => ({
>+    __proto__: dart.getGetters(ArrayIterator.__proto__),
>+    current: E
>+  }));
>+  dart.setLibraryUri(ArrayIterator, "dart:_interceptors");
>+  dart.setFieldSignature(ArrayIterator, () => ({
>+    __proto__: dart.getFields(ArrayIterator.__proto__),
>+    [_iterable]: dart.finalFieldType(JSArrayOfE()),
>+    [_length]: dart.finalFieldType(core.int),
>+    [_index]: dart.fieldType(core.int),
>+    [_current]: dart.fieldType(E)
>+  }));
>+  return ArrayIterator;
>+});
>+_interceptors.ArrayIterator = _interceptors.ArrayIterator$();
>+dart.addTypeTests(_interceptors.ArrayIterator, _is_ArrayIterator_default);
>+const _isInt32 = dart.privateName(_interceptors, "_isInt32");
>+const _tdivSlow = dart.privateName(_interceptors, "_tdivSlow");
>+const _shlPositive = dart.privateName(_interceptors, "_shlPositive");
>+const _shrOtherPositive = dart.privateName(_interceptors, "_shrOtherPositive");
>+const _shrBothPositive = dart.privateName(_interceptors, "_shrBothPositive");
>+_interceptors.JSNumber = class JSNumber extends _interceptors.Interceptor {
>+  [$compareTo](b) {
>+    core.num._check(b);
>+    if (b == null) dart.argumentError(b);
>+    if (this < b) {
>+      return -1;
>+    } else if (this > b) {
>+      return 1;
>+    } else if (this === b) {
>+      if (this === 0) {
>+        let bIsNegative = b[$isNegative];
>+        if (this[$isNegative] === bIsNegative) return 0;
>+        if (this[$isNegative]) return -1;
>+        return 1;
>+      }
>+      return 0;
>+    } else if (this[$isNaN]) {
>+      if (b[$isNaN]) {
>+        return 0;
>+      }
>+      return 1;
>+    } else {
>+      return -1;
>+    }
>+  }
>+  get [$isNegative]() {
>+    return this === 0 ? 1 / this < 0 : this < 0;
>+  }
>+  get [$isNaN]() {
>+    return isNaN(this);
>+  }
>+  get [$isInfinite]() {
>+    return this == 1 / 0 || this == -1 / 0;
>+  }
>+  get [$isFinite]() {
>+    return isFinite(this);
>+  }
>+  [$remainder](b) {
>+    if (b == null) dart.argumentError(b);
>+    return this % b;
>+  }
>+  [$abs]() {
>+    return Math.abs(this);
>+  }
>+  get [$sign]() {
>+    return this > 0 ? 1 : this < 0 ? -1 : this;
>+  }
>+  [$toInt]() {
>+    if (this >= -2147483648 && this <= 2147483647) {
>+      return this | 0;
>+    }
>+    if (isFinite(this)) {
>+      return this[$truncateToDouble]() + 0;
>+    }
>+    dart.throw(new core.UnsupportedError.new("" + this));
>+  }
>+  [$truncate]() {
>+    return this[$toInt]();
>+  }
>+  [$ceil]() {
>+    return this[$ceilToDouble]()[$toInt]();
>+  }
>+  [$floor]() {
>+    return this[$floorToDouble]()[$toInt]();
>+  }
>+  [$round]() {
>+    if (this > 0) {
>+      if (this !== 1 / 0) {
>+        return Math.round(this);
>+      }
>+    } else if (this > -1 / 0) {
>+      return 0 - Math.round(0 - this);
>+    }
>+    dart.throw(new core.UnsupportedError.new("" + this));
>+  }
>+  [$ceilToDouble]() {
>+    return Math.ceil(this);
>+  }
>+  [$floorToDouble]() {
>+    return Math.floor(this);
>+  }
>+  [$roundToDouble]() {
>+    if (this < 0) {
>+      return -Math.round(-this);
>+    } else {
>+      return Math.round(this);
>+    }
>+  }
>+  [$truncateToDouble]() {
>+    return this < 0 ? this[$ceilToDouble]() : this[$floorToDouble]();
>+  }
>+  [$clamp](lowerLimit, upperLimit) {
>+    if (lowerLimit == null) dart.argumentError(lowerLimit);
>+    if (upperLimit == null) dart.argumentError(upperLimit);
>+    if (lowerLimit[$compareTo](upperLimit) > 0) {
>+      dart.throw(_js_helper.argumentErrorValue(lowerLimit));
>+    }
>+    if (this[$compareTo](lowerLimit) < 0) return lowerLimit;
>+    if (this[$compareTo](upperLimit) > 0) return upperLimit;
>+    return this;
>+  }
>+  [$toDouble]() {
>+    return this;
>+  }
>+  [$toStringAsFixed](fractionDigits) {
>+    if (fractionDigits < 0 || fractionDigits > 20) {
>+      dart.throw(new core.RangeError.range(fractionDigits, 0, 20, "fractionDigits"));
>+    }
>+    let result = this.toFixed(fractionDigits);
>+    if (this === 0 && this[$isNegative]) return "-" + result;
>+    return result;
>+  }
>+  [$toStringAsExponential](fractionDigits) {
>+    if (fractionDigits === void 0) fractionDigits = null;
>+    let result = null;
>+    if (fractionDigits != null) {
>+      let _fractionDigits = fractionDigits;
>+      if (_fractionDigits < 0 || _fractionDigits > 20) {
>+        dart.throw(new core.RangeError.range(_fractionDigits, 0, 20, "fractionDigits"));
>+      }
>+      result = this.toExponential(_fractionDigits);
>+    } else {
>+      result = this.toExponential();
>+    }
>+    if (this === 0 && this[$isNegative]) return "-" + dart.str(result);
>+    return result;
>+  }
>+  [$toStringAsPrecision](precision) {
>+    if (precision == null) dart.argumentError(precision);
>+    if (precision < 1 || precision > 21) {
>+      dart.throw(new core.RangeError.range(precision, 1, 21, "precision"));
>+    }
>+    let result = this.toPrecision(precision);
>+    if (this === 0 && this[$isNegative]) return "-" + result;
>+    return result;
>+  }
>+  [$toRadixString](radix) {
>+    if (radix == null) dart.argumentError(radix);
>+    if (radix < 2 || radix > 36) {
>+      dart.throw(new core.RangeError.range(radix, 2, 36, "radix"));
>+    }
>+    let result = this.toString(radix);
>+    let rightParenCode = 41;
>+    if (result[$codeUnitAt](result.length - 1) !== rightParenCode) {
>+      return result;
>+    }
>+    return _interceptors.JSNumber._handleIEtoString(result);
>+  }
>+  static _handleIEtoString(result) {
>+    let match = /^([\da-z]+)(?:\.([\da-z]+))?$e\+(\d+)$$/.exec(result);
>+    if (match == null) {
>+      dart.throw(new core.UnsupportedError.new("Unexpected toString result: " + dart.str(result)));
>+    }
>+    result = match[$_get](1);
>+    let exponent = +match[$_get](3);
>+    if (match[$_get](2) != null) {
>+      result = result + match[$_get](2);
>+      exponent = exponent - match[$_get](2).length;
>+    }
>+    return dart.notNull(result) + "0"[$times](exponent);
>+  }
>+  [$toString]() {
>+    if (this === 0 && 1 / this < 0) {
>+      return "-0.0";
>+    } else {
>+      return "" + this;
>+    }
>+  }
>+  get [$hashCode]() {
>+    let intValue = this | 0;
>+    if (this === intValue) return 536870911 & intValue;
>+    let absolute = Math.abs(this);
>+    let lnAbsolute = Math.log(absolute);
>+    let log2 = lnAbsolute / 0.6931471805599453;
>+    let floorLog2 = log2 | 0;
>+    let factor = Math.pow(2, floorLog2);
>+    let scaled = absolute < 1 ? absolute / factor : factor / absolute;
>+    let rescaled1 = scaled * 9007199254740992;
>+    let rescaled2 = scaled * 3542243181176521;
>+    let d1 = rescaled1 | 0;
>+    let d2 = rescaled2 | 0;
>+    let d3 = floorLog2;
>+    let h = 536870911 & (d1 + d2) * (601 * 997) + d3 * 1259;
>+    return h;
>+  }
>+  [$_negate]() {
>+    return -this;
>+  }
>+  [$plus](other) {
>+    if (other == null) dart.argumentError(other);
>+    return this + other;
>+  }
>+  [$minus](other) {
>+    if (other == null) dart.argumentError(other);
>+    return this - other;
>+  }
>+  [$divide](other) {
>+    if (other == null) dart.argumentError(other);
>+    return this / other;
>+  }
>+  [$times](other) {
>+    if (other == null) dart.argumentError(other);
>+    return this * other;
>+  }
>+  [$modulo](other) {
>+    if (other == null) dart.argumentError(other);
>+    let result = this % other;
>+    if (result === 0) return 0;
>+    if (result > 0) return result;
>+    if (other < 0) {
>+      return result - other;
>+    } else {
>+      return result + other;
>+    }
>+  }
>+  [_isInt32](value) {
>+    return (value | 0) === value;
>+  }
>+  [$floorDivide](other) {
>+    if (other == null) dart.argumentError(other);
>+    if (this[_isInt32](this) && this[_isInt32](other) && 0 !== other && -1 !== other) {
>+      return this / other | 0;
>+    } else {
>+      return this[_tdivSlow](other);
>+    }
>+  }
>+  [_tdivSlow](other) {
>+    return (this / other)[$toInt]();
>+  }
>+  [$leftShift](other) {
>+    if (other == null) dart.argumentError(other);
>+    if (other < 0) _js_helper.throwArgumentErrorValue(other);
>+    return this[_shlPositive](other);
>+  }
>+  [_shlPositive](other) {
>+    return other > 31 ? 0 : this << other >>> 0;
>+  }
>+  [$rightShift](other) {
>+    if (other == null) dart.argumentError(other);
>+    if (other < 0) _js_helper.throwArgumentErrorValue(other);
>+    return this[_shrOtherPositive](other);
>+  }
>+  [_shrOtherPositive](other) {
>+    return this > 0 ? this[_shrBothPositive](other) : this >> (other > 31 ? 31 : other) >>> 0;
>+  }
>+  [_shrBothPositive](other) {
>+    return other > 31 ? 0 : this >>> other;
>+  }
>+  [$bitAnd](other) {
>+    if (other == null) dart.argumentError(other);
>+    return (this & other) >>> 0;
>+  }
>+  [$bitOr](other) {
>+    if (other == null) dart.argumentError(other);
>+    return (this | other) >>> 0;
>+  }
>+  [$bitXor](other) {
>+    if (other == null) dart.argumentError(other);
>+    return (this ^ other) >>> 0;
>+  }
>+  [$lessThan](other) {
>+    if (other == null) dart.argumentError(other);
>+    return this < other;
>+  }
>+  [$greaterThan](other) {
>+    if (other == null) dart.argumentError(other);
>+    return this > other;
>+  }
>+  [$lessOrEquals](other) {
>+    if (other == null) dart.argumentError(other);
>+    return this <= other;
>+  }
>+  [$greaterOrEquals](other) {
>+    if (other == null) dart.argumentError(other);
>+    return this >= other;
>+  }
>+  get [$isEven]() {
>+    return (this & 1) === 0;
>+  }
>+  get [$isOdd]() {
>+    return (this & 1) === 1;
>+  }
>+  [$toUnsigned](width) {
>+    if (width == null) dart.argumentError(width);
>+    return (this & (1)[$leftShift](width) - 1) >>> 0;
>+  }
>+  [$toSigned](width) {
>+    if (width == null) dart.argumentError(width);
>+    let signMask = (1)[$leftShift](width - 1);
>+    return ((this & signMask - 1) >>> 0) - ((this & signMask) >>> 0);
>+  }
>+  get [$bitLength]() {
>+    let nonneg = this < 0 ? -this - 1 : this;
>+    let wordBits = 32;
>+    while (nonneg >= 4294967296) {
>+      nonneg = (nonneg / 4294967296)[$truncate]();
>+      wordBits = wordBits + 32;
>+    }
>+    return wordBits - _interceptors.JSNumber._clz32(nonneg);
>+  }
>+  static _clz32(uint32) {
>+    return 32 - _interceptors.JSNumber._bitCount(_interceptors.JSNumber._spread(uint32));
>+  }
>+  [$modPow](e, m) {
>+    if (e == null) dart.argumentError(e);
>+    if (m == null) dart.argumentError(m);
>+    if (e < 0) dart.throw(new core.RangeError.range(e, 0, null, "exponent"));
>+    if (m <= 0) dart.throw(new core.RangeError.range(m, 1, null, "modulus"));
>+    if (e === 0) return 1;
>+    let b = this;
>+    if (b < 0 || b > m) {
>+      b = b[$modulo](m);
>+    }
>+    let r = 1;
>+    while (e > 0) {
>+      if (e[$isOdd]) {
>+        r = (r * b)[$modulo](m);
>+      }
>+      e = (e / 2)[$truncate]();
>+      b = (b * b)[$modulo](m);
>+    }
>+    return r;
>+  }
>+  static _binaryGcd(x, y, inv) {
>+    let s = 1;
>+    if (!inv) {
>+      while (x[$isEven] && y[$isEven]) {
>+        x = (x / 2)[$truncate]();
>+        y = (y / 2)[$truncate]();
>+        s = s * 2;
>+      }
>+      if (y[$isOdd]) {
>+        let t = x;
>+        x = y;
>+        y = t;
>+      }
>+    }
>+    let ac = x[$isEven];
>+    let u = x;
>+    let v = y;
>+    let a = 1, b = 0, c = 0, d = 1;
>+    do {
>+      while (u[$isEven]) {
>+        u = (u / 2)[$truncate]();
>+        if (ac) {
>+          if (!a[$isEven] || !b[$isEven]) {
>+            a = a + y;
>+            b = b - x;
>+          }
>+          a = (a / 2)[$truncate]();
>+        } else if (!b[$isEven]) {
>+          b = b - x;
>+        }
>+        b = (b / 2)[$truncate]();
>+      }
>+      while (v[$isEven]) {
>+        v = (v / 2)[$truncate]();
>+        if (ac) {
>+          if (!c[$isEven] || !d[$isEven]) {
>+            c = c + y;
>+            d = d - x;
>+          }
>+          c = (c / 2)[$truncate]();
>+        } else if (!d[$isEven]) {
>+          d = d - x;
>+        }
>+        d = (d / 2)[$truncate]();
>+      }
>+      if (u >= v) {
>+        u = u - v;
>+        if (ac) {
>+          a = a - c;
>+        }
>+        b = b - d;
>+      } else {
>+        v = v - u;
>+        if (ac) {
>+          c = c - a;
>+        }
>+        d = d - b;
>+      }
>+    } while (u !== 0);
>+    if (!inv) return s * v;
>+    if (v !== 1) dart.throw(core.Exception.new("Not coprime"));
>+    if (d < 0) {
>+      d = d + x;
>+      if (d < 0) {
>+        d = d + x;
>+      }
>+    } else if (d > x) {
>+      d = d - x;
>+      if (d > x) {
>+        d = d - x;
>+      }
>+    }
>+    return d;
>+  }
>+  [$modInverse](m) {
>+    if (m == null) dart.argumentError(m);
>+    if (m <= 0) dart.throw(new core.RangeError.range(m, 1, null, "modulus"));
>+    if (m === 1) return 0;
>+    let t = this;
>+    if (t < 0 || t >= m) {
>+      t = t[$modulo](m);
>+    }
>+    if (t === 1) return 1;
>+    if (t === 0 || t[$isEven] && m[$isEven]) {
>+      dart.throw(core.Exception.new("Not coprime"));
>+    }
>+    return _interceptors.JSNumber._binaryGcd(m, t, true);
>+  }
>+  [$gcd](other) {
>+    if (other == null) dart.argumentError(other);
>+    let x = this[$abs]();
>+    let y = other[$abs]();
>+    if (x === 0) return y;
>+    if (y === 0) return x;
>+    if (x === 1 || y === 1) return 1;
>+    return _interceptors.JSNumber._binaryGcd(x, y, false);
>+  }
>+  static _bitCount(i) {
>+    i = _interceptors.JSNumber._shru(i, 0) - (_interceptors.JSNumber._shru(i, 1) & 1431655765);
>+    i = (i & 858993459) + (_interceptors.JSNumber._shru(i, 2) & 858993459);
>+    i = 252645135 & i + _interceptors.JSNumber._shru(i, 4);
>+    i = i + _interceptors.JSNumber._shru(i, 8);
>+    i = i + _interceptors.JSNumber._shru(i, 16);
>+    return i & 63;
>+  }
>+  static _shru(value, shift) {
>+    return value >>> shift;
>+  }
>+  static _shrs(value, shift) {
>+    return value >> shift;
>+  }
>+  static _ors(a, b) {
>+    return a | b;
>+  }
>+  static _spread(i) {
>+    i = _interceptors.JSNumber._ors(i, _interceptors.JSNumber._shrs(i, 1));
>+    i = _interceptors.JSNumber._ors(i, _interceptors.JSNumber._shrs(i, 2));
>+    i = _interceptors.JSNumber._ors(i, _interceptors.JSNumber._shrs(i, 4));
>+    i = _interceptors.JSNumber._ors(i, _interceptors.JSNumber._shrs(i, 8));
>+    i = _interceptors.JSNumber._shru(_interceptors.JSNumber._ors(i, _interceptors.JSNumber._shrs(i, 16)), 0);
>+    return i;
>+  }
>+  [$bitNot]() {
>+    return ~this >>> 0;
>+  }
>+};
>+(_interceptors.JSNumber.new = function() {
>+  _interceptors.JSNumber.__proto__.new.call(this);
>+}).prototype = _interceptors.JSNumber.prototype;
>+dart.addTypeTests(_interceptors.JSNumber);
>+_interceptors.JSNumber[dart.implements] = () => [core.int, core.double];
>+dart.setMethodSignature(_interceptors.JSNumber, () => ({
>+  __proto__: dart.getMethods(_interceptors.JSNumber.__proto__),
>+  [$compareTo]: dart.fnType(core.int, [core.Object]),
>+  [$remainder]: dart.fnType(_interceptors.JSNumber, [core.num]),
>+  [$abs]: dart.fnType(_interceptors.JSNumber, []),
>+  [$toInt]: dart.fnType(core.int, []),
>+  [$truncate]: dart.fnType(core.int, []),
>+  [$ceil]: dart.fnType(core.int, []),
>+  [$floor]: dart.fnType(core.int, []),
>+  [$round]: dart.fnType(core.int, []),
>+  [$ceilToDouble]: dart.fnType(core.double, []),
>+  [$floorToDouble]: dart.fnType(core.double, []),
>+  [$roundToDouble]: dart.fnType(core.double, []),
>+  [$truncateToDouble]: dart.fnType(core.double, []),
>+  [$clamp]: dart.fnType(core.num, [core.num, core.num]),
>+  [$toDouble]: dart.fnType(core.double, []),
>+  [$toStringAsFixed]: dart.fnType(core.String, [core.int]),
>+  [$toStringAsExponential]: dart.fnType(core.String, [], [core.int]),
>+  [$toStringAsPrecision]: dart.fnType(core.String, [core.int]),
>+  [$toRadixString]: dart.fnType(core.String, [core.int]),
>+  [$_negate]: dart.fnType(_interceptors.JSNumber, []),
>+  [$plus]: dart.fnType(_interceptors.JSNumber, [core.num]),
>+  [$minus]: dart.fnType(_interceptors.JSNumber, [core.num]),
>+  [$divide]: dart.fnType(core.double, [core.num]),
>+  [$times]: dart.fnType(_interceptors.JSNumber, [core.num]),
>+  [$modulo]: dart.fnType(_interceptors.JSNumber, [core.num]),
>+  [_isInt32]: dart.fnType(core.bool, [core.num]),
>+  [$floorDivide]: dart.fnType(core.int, [core.num]),
>+  [_tdivSlow]: dart.fnType(core.int, [core.num]),
>+  [$leftShift]: dart.fnType(core.int, [core.num]),
>+  [_shlPositive]: dart.fnType(core.int, [core.num]),
>+  [$rightShift]: dart.fnType(core.int, [core.num]),
>+  [_shrOtherPositive]: dart.fnType(core.int, [core.num]),
>+  [_shrBothPositive]: dart.fnType(core.int, [core.num]),
>+  [$bitAnd]: dart.fnType(core.int, [core.num]),
>+  [$bitOr]: dart.fnType(core.int, [core.num]),
>+  [$bitXor]: dart.fnType(core.int, [core.num]),
>+  [$lessThan]: dart.fnType(core.bool, [core.num]),
>+  [$greaterThan]: dart.fnType(core.bool, [core.num]),
>+  [$lessOrEquals]: dart.fnType(core.bool, [core.num]),
>+  [$greaterOrEquals]: dart.fnType(core.bool, [core.num]),
>+  [$toUnsigned]: dart.fnType(core.int, [core.int]),
>+  [$toSigned]: dart.fnType(core.int, [core.int]),
>+  [$modPow]: dart.fnType(core.int, [core.int, core.int]),
>+  [$modInverse]: dart.fnType(core.int, [core.int]),
>+  [$gcd]: dart.fnType(core.int, [core.int]),
>+  [$bitNot]: dart.fnType(core.int, [])
>+}));
>+dart.setGetterSignature(_interceptors.JSNumber, () => ({
>+  __proto__: dart.getGetters(_interceptors.JSNumber.__proto__),
>+  [$isNegative]: core.bool,
>+  [$isNaN]: core.bool,
>+  [$isInfinite]: core.bool,
>+  [$isFinite]: core.bool,
>+  [$sign]: _interceptors.JSNumber,
>+  [$isEven]: core.bool,
>+  [$isOdd]: core.bool,
>+  [$bitLength]: core.int
>+}));
>+dart.setLibraryUri(_interceptors.JSNumber, "dart:_interceptors");
>+dart.defineLazy(_interceptors.JSNumber, {
>+  /*_interceptors.JSNumber._MIN_INT32*/get _MIN_INT32() {
>+    return -2147483648;
>+  },
>+  /*_interceptors.JSNumber._MAX_INT32*/get _MAX_INT32() {
>+    return 2147483647;
>+  }
>+});
>+dart.definePrimitiveHashCode(_interceptors.JSNumber.prototype);
>+dart.registerExtension("Number", _interceptors.JSNumber);
>+const _defaultSplit = dart.privateName(_interceptors, "_defaultSplit");
>+let const$2;
>+_interceptors.JSString = class JSString extends _interceptors.Interceptor {
>+  [$codeUnitAt](index) {
>+    if (index == null) dart.argumentError(index);
>+    let len = this.length;
>+    if (index < 0 || index >= len) {
>+      dart.throw(core.RangeError.index(index, this, "index", null, len));
>+    }
>+    return this.charCodeAt(index);
>+  }
>+  [$allMatches](string, start) {
>+    if (string == null) dart.argumentError(string);
>+    if (start === void 0) start = 0;
>+    if (start == null) dart.argumentError(start);
>+    let len = string.length;
>+    if (0 > start || start > len) {
>+      dart.throw(new core.RangeError.range(start, 0, len));
>+    }
>+    return _js_helper.allMatchesInStringUnchecked(this, string, start);
>+  }
>+  [$matchAsPrefix](string, start) {
>+    if (string == null) dart.argumentError(string);
>+    if (start === void 0) start = 0;
>+    if (start == null) dart.argumentError(start);
>+    let stringLength = string.length;
>+    if (start < 0 || start > stringLength) {
>+      dart.throw(new core.RangeError.range(start, 0, stringLength));
>+    }
>+    let thisLength = this.length;
>+    if (start + thisLength > stringLength) return null;
>+    for (let i = 0; i < thisLength; i++) {
>+      if (string[$codeUnitAt](start + i) !== this[$codeUnitAt](i)) {
>+        return null;
>+      }
>+    }
>+    return new _js_helper.StringMatch.new(start, string, this);
>+  }
>+  [$plus](other) {
>+    if (other == null) dart.argumentError(other);
>+    return this + other;
>+  }
>+  [$endsWith](other) {
>+    if (other == null) dart.argumentError(other);
>+    let otherLength = other.length;
>+    let thisLength = this.length;
>+    if (otherLength > thisLength) return false;
>+    return other === this[$substring](thisLength - otherLength);
>+  }
>+  [$replaceAll](from, to) {
>+    if (to == null) dart.argumentError(to);
>+    return _js_helper.stringReplaceAllUnchecked(this, from, to);
>+  }
>+  [$replaceAllMapped](from, convert) {
>+    return this[$splitMapJoin](from, {onMatch: convert});
>+  }
>+  [$splitMapJoin](from, opts) {
>+    let onMatch = opts && 'onMatch' in opts ? opts.onMatch : null;
>+    let onNonMatch = opts && 'onNonMatch' in opts ? opts.onNonMatch : null;
>+    return _js_helper.stringReplaceAllFuncUnchecked(this, from, onMatch, onNonMatch);
>+  }
>+  [$replaceFirst](from, to, startIndex) {
>+    if (to == null) dart.argumentError(to);
>+    if (startIndex === void 0) startIndex = 0;
>+    if (startIndex == null) dart.argumentError(startIndex);
>+    core.RangeError.checkValueInInterval(startIndex, 0, this.length, "startIndex");
>+    return _js_helper.stringReplaceFirstUnchecked(this, from, to, startIndex);
>+  }
>+  [$replaceFirstMapped](from, replace, startIndex) {
>+    if (replace == null) dart.argumentError(replace);
>+    if (startIndex === void 0) startIndex = 0;
>+    if (startIndex == null) dart.argumentError(startIndex);
>+    core.RangeError.checkValueInInterval(startIndex, 0, this.length, "startIndex");
>+    return _js_helper.stringReplaceFirstMappedUnchecked(this, from, replace, startIndex);
>+  }
>+  [$split](pattern) {
>+    if (pattern == null) dart.argumentError(pattern);
>+    if (typeof pattern == 'string') {
>+      return JSArrayOfString().of(this.split(pattern));
>+    } else if (_js_helper.JSSyntaxRegExp.is(pattern) && _js_helper.regExpCaptureCount(pattern) === 0) {
>+      let re = _js_helper.regExpGetNative(pattern);
>+      return JSArrayOfString().of(this.split(re));
>+    } else {
>+      return this[_defaultSplit](pattern);
>+    }
>+  }
>+  [$replaceRange](start, end, replacement) {
>+    if (start == null) dart.argumentError(start);
>+    if (replacement == null) dart.argumentError(replacement);
>+    end = core.RangeError.checkValidRange(start, end, this.length);
>+    return _js_helper.stringReplaceRangeUnchecked(this, start, end, replacement);
>+  }
>+  [_defaultSplit](pattern) {
>+    let result = JSArrayOfString().of([]);
>+    let start = 0;
>+    let length = 1;
>+    for (let match of pattern[$allMatches](this)) {
>+      let matchStart = match.start;
>+      let matchEnd = match.end;
>+      length = matchEnd - matchStart;
>+      if (length === 0 && start === matchStart) {
>+        continue;
>+      }
>+      let end = matchStart;
>+      result[$add](this[$substring](start, end));
>+      start = matchEnd;
>+    }
>+    if (start < this.length || length > 0) {
>+      result[$add](this[$substring](start));
>+    }
>+    return result;
>+  }
>+  [$startsWith](pattern, index) {
>+    if (index === void 0) index = 0;
>+    if (index == null) dart.argumentError(index);
>+    let length = this.length;
>+    if (index < 0 || index > length) {
>+      dart.throw(new core.RangeError.range(index, 0, this.length));
>+    }
>+    if (typeof pattern == 'string') {
>+      let other = pattern;
>+      let otherLength = other.length;
>+      let endIndex = index + otherLength;
>+      if (endIndex > length) return false;
>+      return other === this.substring(index, endIndex);
>+    }
>+    return pattern[$matchAsPrefix](this, index) != null;
>+  }
>+  [$substring](startIndex, _endIndex) {
>+    if (startIndex == null) dart.argumentError(startIndex);
>+    if (_endIndex === void 0) _endIndex = null;
>+    let length = this.length;
>+    let endIndex = _endIndex != null ? _endIndex : length;
>+    if (startIndex < 0) dart.throw(new core.RangeError.value(startIndex));
>+    if (startIndex > endIndex) dart.throw(new core.RangeError.value(startIndex));
>+    if (endIndex > length) dart.throw(new core.RangeError.value(endIndex));
>+    return this.substring(startIndex, endIndex);
>+  }
>+  [$toLowerCase]() {
>+    return this.toLowerCase();
>+  }
>+  [$toUpperCase]() {
>+    return this.toUpperCase();
>+  }
>+  static _isWhitespace(codeUnit) {
>+    if (codeUnit < 256) {
>+      switch (codeUnit) {
>+        case 9:
>+        case 10:
>+        case 11:
>+        case 12:
>+        case 13:
>+        case 32:
>+        case 133:
>+        case 160:
>+        {
>+          return true;
>+        }
>+        default:
>+        {
>+          return false;
>+        }
>+      }
>+    }
>+    switch (codeUnit) {
>+      case 5760:
>+      case 8192:
>+      case 8193:
>+      case 8194:
>+      case 8195:
>+      case 8196:
>+      case 8197:
>+      case 8198:
>+      case 8199:
>+      case 8200:
>+      case 8201:
>+      case 8202:
>+      case 8232:
>+      case 8233:
>+      case 8239:
>+      case 8287:
>+      case 12288:
>+      case 65279:
>+      {
>+        return true;
>+      }
>+      default:
>+      {
>+        return false;
>+      }
>+    }
>+  }
>+  static _skipLeadingWhitespace(string, index) {
>+    if (index == null) dart.argumentError(index);
>+    let SPACE = 32;
>+    let CARRIAGE_RETURN = 13;
>+    let stringLength = string.length;
>+    while (index < stringLength) {
>+      let codeUnit = string[$codeUnitAt](index);
>+      if (codeUnit !== SPACE && codeUnit !== CARRIAGE_RETURN && !_interceptors.JSString._isWhitespace(codeUnit)) {
>+        break;
>+      }
>+      index++;
>+    }
>+    return index;
>+  }
>+  static _skipTrailingWhitespace(string, index) {
>+    if (index == null) dart.argumentError(index);
>+    let SPACE = 32;
>+    let CARRIAGE_RETURN = 13;
>+    while (index > 0) {
>+      let codeUnit = string[$codeUnitAt](index - 1);
>+      if (codeUnit !== SPACE && codeUnit !== CARRIAGE_RETURN && !_interceptors.JSString._isWhitespace(codeUnit)) {
>+        break;
>+      }
>+      index--;
>+    }
>+    return index;
>+  }
>+  [$trim]() {
>+    let NEL = 133;
>+    let result = this.trim();
>+    let length = result.length;
>+    if (length === 0) return result;
>+    let firstCode = result[$codeUnitAt](0);
>+    let startIndex = 0;
>+    if (firstCode === NEL) {
>+      startIndex = _interceptors.JSString._skipLeadingWhitespace(result, 1);
>+      if (startIndex === length) return "";
>+    }
>+    let endIndex = length;
>+    let lastCode = result[$codeUnitAt](endIndex - 1);
>+    if (lastCode === NEL) {
>+      endIndex = _interceptors.JSString._skipTrailingWhitespace(result, endIndex - 1);
>+    }
>+    if (startIndex === 0 && endIndex === length) return result;
>+    return result.substring(startIndex, endIndex);
>+  }
>+  [$trimLeft]() {
>+    let NEL = 133;
>+    let result = null;
>+    let startIndex = 0;
>+    if (typeof this.trimLeft != "undefined") {
>+      result = this.trimLeft();
>+      if (result.length === 0) return result;
>+      let firstCode = result[$codeUnitAt](0);
>+      if (firstCode === NEL) {
>+        startIndex = _interceptors.JSString._skipLeadingWhitespace(result, 1);
>+      }
>+    } else {
>+      result = this;
>+      startIndex = _interceptors.JSString._skipLeadingWhitespace(this, 0);
>+    }
>+    if (startIndex === 0) return result;
>+    if (startIndex === result.length) return "";
>+    return result.substring(startIndex);
>+  }
>+  [$trimRight]() {
>+    let NEL = 133;
>+    let result = null;
>+    let endIndex = 0;
>+    if (typeof this.trimRight != "undefined") {
>+      result = this.trimRight();
>+      endIndex = result.length;
>+      if (endIndex === 0) return result;
>+      let lastCode = result[$codeUnitAt](endIndex - 1);
>+      if (lastCode === NEL) {
>+        endIndex = _interceptors.JSString._skipTrailingWhitespace(result, endIndex - 1);
>+      }
>+    } else {
>+      result = this;
>+      endIndex = _interceptors.JSString._skipTrailingWhitespace(this, this.length);
>+    }
>+    if (endIndex === result.length) return result;
>+    if (endIndex === 0) return "";
>+    return result.substring(0, endIndex);
>+  }
>+  [$times](times) {
>+    if (times == null) dart.argumentError(times);
>+    if (0 >= times) return "";
>+    if (times === 1 || this.length === 0) return this;
>+    if (times !== times >>> 0) {
>+      dart.throw(const$2 || (const$2 = dart.const(new core.OutOfMemoryError.new())));
>+    }
>+    let result = "";
>+    let s = this;
>+    while (true) {
>+      if ((times & 1) === 1) result = s + result;
>+      times = times >>> 1;
>+      if (times === 0) break;
>+      s = s + s;
>+    }
>+    return result;
>+  }
>+  [$padLeft](width, padding) {
>+    if (width == null) dart.argumentError(width);
>+    if (padding === void 0) padding = " ";
>+    let delta = width - this.length;
>+    if (delta <= 0) return this;
>+    return padding[$times](delta) + this;
>+  }
>+  [$padRight](width, padding) {
>+    if (width == null) dart.argumentError(width);
>+    if (padding === void 0) padding = " ";
>+    let delta = width - this.length;
>+    if (delta <= 0) return this;
>+    return this[$plus](padding[$times](delta));
>+  }
>+  get [$codeUnits]() {
>+    return new _internal.CodeUnits.new(this);
>+  }
>+  get [$runes]() {
>+    return new core.Runes.new(this);
>+  }
>+  [$indexOf](pattern, start) {
>+    if (pattern == null) dart.argumentError(pattern);
>+    if (start === void 0) start = 0;
>+    if (start == null) dart.argumentError(start);
>+    if (start < 0 || start > this.length) {
>+      dart.throw(new core.RangeError.range(start, 0, this.length));
>+    }
>+    if (typeof pattern == 'string') {
>+      return _js_helper.stringIndexOfStringUnchecked(this, pattern, start);
>+    }
>+    if (_js_helper.JSSyntaxRegExp.is(pattern)) {
>+      let re = pattern;
>+      let match = _js_helper.firstMatchAfter(re, this, start);
>+      return match == null ? -1 : match.start;
>+    }
>+    let length = this.length;
>+    for (let i = start; i <= length; i++) {
>+      if (pattern[$matchAsPrefix](this, i) != null) return i;
>+    }
>+    return -1;
>+  }
>+  [$lastIndexOf](pattern, _start) {
>+    if (pattern == null) dart.argumentError(pattern);
>+    if (_start === void 0) _start = null;
>+    let length = this.length;
>+    let start = _start != null ? _start : length;
>+    if (start < 0 || start > length) {
>+      dart.throw(new core.RangeError.range(start, 0, length));
>+    }
>+    if (typeof pattern == 'string') {
>+      let other = pattern;
>+      if (start + other.length > length) {
>+        start = length - other.length;
>+      }
>+      return _js_helper.stringLastIndexOfUnchecked(this, other, start);
>+    }
>+    for (let i = start; i >= 0; i--) {
>+      if (pattern[$matchAsPrefix](this, i) != null) return i;
>+    }
>+    return -1;
>+  }
>+  [$contains](other, startIndex) {
>+    if (other == null) dart.argumentError(other);
>+    if (startIndex === void 0) startIndex = 0;
>+    if (startIndex == null) dart.argumentError(startIndex);
>+    if (startIndex < 0 || startIndex > this.length) {
>+      dart.throw(new core.RangeError.range(startIndex, 0, this.length));
>+    }
>+    return _js_helper.stringContainsUnchecked(this, other, startIndex);
>+  }
>+  get [$isEmpty]() {
>+    return this.length === 0;
>+  }
>+  get [$isNotEmpty]() {
>+    return !this[$isEmpty];
>+  }
>+  [$compareTo](other) {
>+    core.String._check(other);
>+    if (other == null) dart.argumentError(other);
>+    return this === other ? 0 : this < other ? -1 : 1;
>+  }
>+  [$toString]() {
>+    return this;
>+  }
>+  get [$hashCode]() {
>+    let hash = 0;
>+    let length = this.length;
>+    for (let i = 0; i < length; i++) {
>+      hash = 536870911 & hash + this.charCodeAt(i);
>+      hash = 536870911 & hash + ((524287 & hash) << 10);
>+      hash = hash ^ hash >> 6;
>+    }
>+    hash = 536870911 & hash + ((67108863 & hash) << 3);
>+    hash = hash ^ hash >> 11;
>+    return 536870911 & hash + ((16383 & hash) << 15);
>+  }
>+  get [$runtimeType]() {
>+    return dart.wrapType(core.String);
>+  }
>+  get [$length]() {
>+    return this.length;
>+  }
>+  [$_get](index) {
>+    if (index == null) dart.argumentError(index);
>+    if (index >= this.length || index < 0) {
>+      dart.throw(_js_helper.diagnoseIndexError(this, index));
>+    }
>+    return this[index];
>+  }
>+};
>+(_interceptors.JSString.new = function() {
>+  this[$length] = null;
>+  _interceptors.JSString.__proto__.new.call(this);
>+}).prototype = _interceptors.JSString.prototype;
>+dart.addTypeTests(_interceptors.JSString);
>+_interceptors.JSString[dart.implements] = () => [core.String, JSIndexableOfString()];
>+dart.setMethodSignature(_interceptors.JSString, () => ({
>+  __proto__: dart.getMethods(_interceptors.JSString.__proto__),
>+  [$codeUnitAt]: dart.fnType(core.int, [core.int]),
>+  [$allMatches]: dart.fnType(core.Iterable$(core.Match), [core.String], [core.int]),
>+  [$matchAsPrefix]: dart.fnType(core.Match, [core.String], [core.int]),
>+  [$plus]: dart.fnType(core.String, [core.String]),
>+  [$endsWith]: dart.fnType(core.bool, [core.String]),
>+  [$replaceAll]: dart.fnType(core.String, [core.Pattern, core.String]),
>+  [$replaceAllMapped]: dart.fnType(core.String, [core.Pattern, dart.fnType(core.String, [core.Match])]),
>+  [$splitMapJoin]: dart.fnType(core.String, [core.Pattern], {onMatch: dart.fnType(core.String, [core.Match]), onNonMatch: dart.fnType(core.String, [core.String])}),
>+  [$replaceFirst]: dart.fnType(core.String, [core.Pattern, core.String], [core.int]),
>+  [$replaceFirstMapped]: dart.fnType(core.String, [core.Pattern, dart.fnType(core.String, [core.Match])], [core.int]),
>+  [$split]: dart.fnType(core.List$(core.String), [core.Pattern]),
>+  [$replaceRange]: dart.fnType(core.String, [core.int, core.int, core.String]),
>+  [_defaultSplit]: dart.fnType(core.List$(core.String), [core.Pattern]),
>+  [$startsWith]: dart.fnType(core.bool, [core.Pattern], [core.int]),
>+  [$substring]: dart.fnType(core.String, [core.int], [core.int]),
>+  [$toLowerCase]: dart.fnType(core.String, []),
>+  [$toUpperCase]: dart.fnType(core.String, []),
>+  [$trim]: dart.fnType(core.String, []),
>+  [$trimLeft]: dart.fnType(core.String, []),
>+  [$trimRight]: dart.fnType(core.String, []),
>+  [$times]: dart.fnType(core.String, [core.int]),
>+  [$padLeft]: dart.fnType(core.String, [core.int], [core.String]),
>+  [$padRight]: dart.fnType(core.String, [core.int], [core.String]),
>+  [$indexOf]: dart.fnType(core.int, [core.Pattern], [core.int]),
>+  [$lastIndexOf]: dart.fnType(core.int, [core.Pattern], [core.int]),
>+  [$contains]: dart.fnType(core.bool, [core.Pattern], [core.int]),
>+  [$compareTo]: dart.fnType(core.int, [core.Object]),
>+  [$_get]: dart.fnType(core.String, [core.int])
>+}));
>+dart.setGetterSignature(_interceptors.JSString, () => ({
>+  __proto__: dart.getGetters(_interceptors.JSString.__proto__),
>+  [$codeUnits]: core.List$(core.int),
>+  [$runes]: core.Runes,
>+  [$isEmpty]: core.bool,
>+  [$isNotEmpty]: core.bool
>+}));
>+dart.setLibraryUri(_interceptors.JSString, "dart:_interceptors");
>+dart.setFieldSignature(_interceptors.JSString, () => ({
>+  __proto__: dart.getFields(_interceptors.JSString.__proto__),
>+  [$length]: dart.finalFieldType(core.int)
>+}));
>+dart.definePrimitiveHashCode(_interceptors.JSString.prototype);
>+dart.registerExtension("String", _interceptors.JSString);
>+dart.defineLazy(_internal, {
>+  /*_internal.POWERS_OF_TEN*/get POWERS_OF_TEN() {
>+    return dart.constList([1.0, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0, 10000000000.0, 100000000000.0, 1000000000000.0, 10000000000000.0, 100000000000000.0, 1000000000000000.0, 10000000000000000.0, 100000000000000000.0, 1000000000000000000.0, 10000000000000000000.0, 100000000000000000000.0, 1e+21, 1e+22], core.double);
>+  }
>+});
>+const _string = dart.privateName(_internal, "_string");
>+const _closeGap = dart.privateName(collection, "_closeGap");
>+const _filter = dart.privateName(collection, "_filter");
>+const _is_ListMixin_default = Symbol('_is_ListMixin_default');
>+collection.ListMixin$ = dart.generic(E => {
>+  let ListIteratorOfE = () => (ListIteratorOfE = dart.constFn(_internal.ListIterator$(E)))();
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  let FollowedByIterableOfE = () => (FollowedByIterableOfE = dart.constFn(_internal.FollowedByIterable$(E)))();
>+  let VoidToE = () => (VoidToE = dart.constFn(dart.fnType(E, [])))();
>+  let WhereIterableOfE = () => (WhereIterableOfE = dart.constFn(_internal.WhereIterable$(E)))();
>+  let EAndEToE = () => (EAndEToE = dart.constFn(dart.fnType(E, [E, E])))();
>+  let SubListIterableOfE = () => (SubListIterableOfE = dart.constFn(_internal.SubListIterable$(E)))();
>+  let SkipWhileIterableOfE = () => (SkipWhileIterableOfE = dart.constFn(_internal.SkipWhileIterable$(E)))();
>+  let TakeWhileIterableOfE = () => (TakeWhileIterableOfE = dart.constFn(_internal.TakeWhileIterable$(E)))();
>+  let JSArrayOfE = () => (JSArrayOfE = dart.constFn(_interceptors.JSArray$(E)))();
>+  let ListOfE = () => (ListOfE = dart.constFn(core.List$(E)))();
>+  let _HashSetOfE = () => (_HashSetOfE = dart.constFn(collection._HashSet$(E)))();
>+  let ListMapViewOfE = () => (ListMapViewOfE = dart.constFn(_internal.ListMapView$(E)))();
>+  let ReversedListIterableOfE = () => (ReversedListIterableOfE = dart.constFn(_internal.ReversedListIterable$(E)))();
>+  class ListMixin extends core.Object {
>+    get iterator() {
>+      return new (ListIteratorOfE()).new(this);
>+    }
>+    [Symbol.iterator]() {
>+      return new dart.JsIterator(this[$iterator]);
>+    }
>+    elementAt(index) {
>+      return this[$_get](index);
>+    }
>+    followedBy(other) {
>+      IterableOfE()._check(other);
>+      return FollowedByIterableOfE().firstEfficient(this, other);
>+    }
>+    forEach(action) {
>+      let length = this[$length];
>+      for (let i = 0; i < dart.notNull(length); i++) {
>+        action(this[$_get](i));
>+        if (length != this[$length]) {
>+          dart.throw(new core.ConcurrentModificationError.new(this));
>+        }
>+      }
>+    }
>+    get isEmpty() {
>+      return this[$length] === 0;
>+    }
>+    get isNotEmpty() {
>+      return !dart.test(this[$isEmpty]);
>+    }
>+    get first() {
>+      if (this[$length] === 0) dart.throw(_internal.IterableElementError.noElement());
>+      return this[$_get](0);
>+    }
>+    set first(value) {
>+      E._check(value);
>+      if (this[$length] === 0) dart.throw(_internal.IterableElementError.noElement());
>+      this[$_set](0, value);
>+    }
>+    get last() {
>+      if (this[$length] === 0) dart.throw(_internal.IterableElementError.noElement());
>+      return this[$_get](dart.notNull(this[$length]) - 1);
>+    }
>+    set last(value) {
>+      E._check(value);
>+      if (this[$length] === 0) dart.throw(_internal.IterableElementError.noElement());
>+      this[$_set](dart.notNull(this[$length]) - 1, value);
>+    }
>+    get single() {
>+      if (this[$length] === 0) dart.throw(_internal.IterableElementError.noElement());
>+      if (dart.notNull(this[$length]) > 1) dart.throw(_internal.IterableElementError.tooMany());
>+      return this[$_get](0);
>+    }
>+    contains(element) {
>+      let length = this[$length];
>+      for (let i = 0; i < dart.notNull(length); i++) {
>+        if (dart.equals(this[$_get](i), element)) return true;
>+        if (length != this[$length]) {
>+          dart.throw(new core.ConcurrentModificationError.new(this));
>+        }
>+      }
>+      return false;
>+    }
>+    every(test) {
>+      let length = this[$length];
>+      for (let i = 0; i < dart.notNull(length); i++) {
>+        if (!dart.test(test(this[$_get](i)))) return false;
>+        if (length != this[$length]) {
>+          dart.throw(new core.ConcurrentModificationError.new(this));
>+        }
>+      }
>+      return true;
>+    }
>+    any(test) {
>+      let length = this[$length];
>+      for (let i = 0; i < dart.notNull(length); i++) {
>+        if (dart.test(test(this[$_get](i)))) return true;
>+        if (length != this[$length]) {
>+          dart.throw(new core.ConcurrentModificationError.new(this));
>+        }
>+      }
>+      return false;
>+    }
>+    firstWhere(test, opts) {
>+      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+      VoidToE()._check(orElse);
>+      let length = this[$length];
>+      for (let i = 0; i < dart.notNull(length); i++) {
>+        let element = this[$_get](i);
>+        if (dart.test(test(element))) return element;
>+        if (length != this[$length]) {
>+          dart.throw(new core.ConcurrentModificationError.new(this));
>+        }
>+      }
>+      if (orElse != null) return orElse();
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    lastWhere(test, opts) {
>+      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+      VoidToE()._check(orElse);
>+      let length = this[$length];
>+      for (let i = dart.notNull(length) - 1; i >= 0; i--) {
>+        let element = this[$_get](i);
>+        if (dart.test(test(element))) return element;
>+        if (length != this[$length]) {
>+          dart.throw(new core.ConcurrentModificationError.new(this));
>+        }
>+      }
>+      if (orElse != null) return orElse();
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    singleWhere(test, opts) {
>+      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+      VoidToE()._check(orElse);
>+      let length = this[$length];
>+      let match = null;
>+      let matchFound = false;
>+      for (let i = 0; i < dart.notNull(length); i++) {
>+        let element = this[$_get](i);
>+        if (dart.test(test(element))) {
>+          if (matchFound) {
>+            dart.throw(_internal.IterableElementError.tooMany());
>+          }
>+          matchFound = true;
>+          match = element;
>+        }
>+        if (length != this[$length]) {
>+          dart.throw(new core.ConcurrentModificationError.new(this));
>+        }
>+      }
>+      if (matchFound) return match;
>+      if (orElse != null) return orElse();
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    join(separator) {
>+      if (separator === void 0) separator = "";
>+      if (this[$length] === 0) return "";
>+      let buffer = new core.StringBuffer.new();
>+      buffer.writeAll(this, separator);
>+      return buffer.toString();
>+    }
>+    where(test) {
>+      return new (WhereIterableOfE()).new(this, test);
>+    }
>+    whereType(T) {
>+      return new (_internal.WhereTypeIterable$(T)).new(this);
>+    }
>+    map(T, f) {
>+      return new (_internal.MappedListIterable$(E, T)).new(this, f);
>+    }
>+    expand(T, f) {
>+      return new (_internal.ExpandIterable$(E, T)).new(this, f);
>+    }
>+    reduce(combine) {
>+      EAndEToE()._check(combine);
>+      let length = this[$length];
>+      if (length === 0) dart.throw(_internal.IterableElementError.noElement());
>+      let value = this[$_get](0);
>+      for (let i = 1; i < dart.notNull(length); i++) {
>+        value = combine(value, this[$_get](i));
>+        if (length != this[$length]) {
>+          dart.throw(new core.ConcurrentModificationError.new(this));
>+        }
>+      }
>+      return value;
>+    }
>+    fold(T, initialValue, combine) {
>+      let value = initialValue;
>+      let length = this[$length];
>+      for (let i = 0; i < dart.notNull(length); i++) {
>+        value = combine(value, this[$_get](i));
>+        if (length != this[$length]) {
>+          dart.throw(new core.ConcurrentModificationError.new(this));
>+        }
>+      }
>+      return value;
>+    }
>+    skip(count) {
>+      return new (SubListIterableOfE()).new(this, count, null);
>+    }
>+    skipWhile(test) {
>+      return new (SkipWhileIterableOfE()).new(this, test);
>+    }
>+    take(count) {
>+      return new (SubListIterableOfE()).new(this, 0, count);
>+    }
>+    takeWhile(test) {
>+      return new (TakeWhileIterableOfE()).new(this, test);
>+    }
>+    toList(opts) {
>+      let growable = opts && 'growable' in opts ? opts.growable : true;
>+      let result = null;
>+      if (dart.test(growable)) {
>+        result = JSArrayOfE().of([]);
>+        result[$length] = this[$length];
>+      } else {
>+        result = ListOfE().new(this[$length]);
>+      }
>+      for (let i = 0; i < dart.notNull(this[$length]); i++) {
>+        result[$_set](i, this[$_get](i));
>+      }
>+      return result;
>+    }
>+    toSet() {
>+      let result = new (_HashSetOfE()).new();
>+      for (let i = 0; i < dart.notNull(this[$length]); i++) {
>+        result.add(this[$_get](i));
>+      }
>+      return result;
>+    }
>+    add(element) {
>+      E._check(element);
>+      this[$_set]((() => {
>+        let x = this[$length];
>+        this[$length] = dart.notNull(x) + 1;
>+        return x;
>+      })(), element);
>+    }
>+    addAll(iterable) {
>+      IterableOfE()._check(iterable);
>+      let i = this[$length];
>+      for (let element of iterable) {
>+        if (!(this[$length] == i || dart.test(dart.throw(new core.ConcurrentModificationError.new(this))))) dart.assertFailed(null, "dart:collection/list.dart", 262, 14, "this.length == i || (throw ConcurrentModificationError(this))");
>+        this[$length] = dart.notNull(i) + 1;
>+        this[$_set](i, element);
>+        i = dart.notNull(i) + 1;
>+      }
>+    }
>+    remove(element) {
>+      for (let i = 0; i < dart.notNull(this[$length]); i++) {
>+        if (dart.equals(this[$_get](i), element)) {
>+          this[_closeGap](i, i + 1);
>+          return true;
>+        }
>+      }
>+      return false;
>+    }
>+    [_closeGap](start, end) {
>+      let length = this[$length];
>+      if (!(0 <= dart.notNull(start))) dart.assertFailed(null, "dart:collection/list.dart", 283, 12, "0 <= start");
>+      if (!(dart.notNull(start) < dart.notNull(end))) dart.assertFailed(null, "dart:collection/list.dart", 284, 12, "start < end");
>+      if (!(dart.notNull(end) <= dart.notNull(length))) dart.assertFailed(null, "dart:collection/list.dart", 285, 12, "end <= length");
>+      let size = dart.notNull(end) - dart.notNull(start);
>+      for (let i = end; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
>+        this[$_set](dart.notNull(i) - size, this[$_get](i));
>+      }
>+      this[$length] = dart.notNull(length) - size;
>+    }
>+    removeWhere(test) {
>+      this[_filter](test, false);
>+    }
>+    retainWhere(test) {
>+      this[_filter](test, true);
>+    }
>+    [_filter](test, retainMatching) {
>+      let retained = JSArrayOfE().of([]);
>+      let length = this[$length];
>+      for (let i = 0; i < dart.notNull(length); i++) {
>+        let element = this[$_get](i);
>+        if (test(element) == retainMatching) {
>+          retained[$add](element);
>+        }
>+        if (length != this[$length]) {
>+          dart.throw(new core.ConcurrentModificationError.new(this));
>+        }
>+      }
>+      if (retained[$length] != this[$length]) {
>+        this[$setRange](0, retained[$length], retained);
>+        this[$length] = retained[$length];
>+      }
>+    }
>+    clear() {
>+      this[$length] = 0;
>+    }
>+    cast(R) {
>+      return core.List.castFrom(E, R, this);
>+    }
>+    removeLast() {
>+      if (this[$length] === 0) {
>+        dart.throw(_internal.IterableElementError.noElement());
>+      }
>+      let result = this[$_get](dart.notNull(this[$length]) - 1);
>+      this[$length] = dart.notNull(this[$length]) - 1;
>+      return result;
>+    }
>+    sort(compare) {
>+      if (compare === void 0) compare = null;
>+      _internal.Sort.sort(E, this, compare != null ? compare : dart.fn(collection.ListMixin._compareAny, dynamicAnddynamicToint()));
>+    }
>+    static _compareAny(a, b) {
>+      return core.Comparable.compare(core.Comparable._check(a), core.Comparable._check(b));
>+    }
>+    shuffle(random) {
>+      if (random === void 0) random = null;
>+      let t = random;
>+      t == null ? random = math.Random.new() : t;
>+      let length = this[$length];
>+      while (dart.notNull(length) > 1) {
>+        let pos = random.nextInt(length);
>+        length = dart.notNull(length) - 1;
>+        let tmp = this[$_get](length);
>+        this[$_set](length, this[$_get](pos));
>+        this[$_set](pos, tmp);
>+      }
>+    }
>+    asMap() {
>+      return new (ListMapViewOfE()).new(this);
>+    }
>+    ['+'](other) {
>+      ListOfE()._check(other);
>+      let result = JSArrayOfE().of([]);
>+      result[$length] = dart.notNull(this[$length]) + dart.notNull(other[$length]);
>+      result[$setRange](0, this[$length], this);
>+      result[$setRange](this[$length], result[$length], other);
>+      return result;
>+    }
>+    sublist(start, end) {
>+      if (end === void 0) end = null;
>+      let listLength = this[$length];
>+      let t = end;
>+      t == null ? end = listLength : t;
>+      core.RangeError.checkValidRange(start, end, listLength);
>+      let length = dart.notNull(end) - dart.notNull(start);
>+      let result = JSArrayOfE().of([]);
>+      result[$length] = length;
>+      for (let i = 0; i < length; i++) {
>+        result[$_set](i, this[$_get](dart.notNull(start) + i));
>+      }
>+      return result;
>+    }
>+    getRange(start, end) {
>+      core.RangeError.checkValidRange(start, end, this[$length]);
>+      return new (SubListIterableOfE()).new(this, start, end);
>+    }
>+    removeRange(start, end) {
>+      core.RangeError.checkValidRange(start, end, this[$length]);
>+      if (dart.notNull(end) > dart.notNull(start)) {
>+        this[_closeGap](start, end);
>+      }
>+    }
>+    fillRange(start, end, fill) {
>+      if (fill === void 0) fill = null;
>+      E._check(fill);
>+      core.RangeError.checkValidRange(start, end, this[$length]);
>+      for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
>+        this[$_set](i, fill);
>+      }
>+    }
>+    setRange(start, end, iterable, skipCount) {
>+      IterableOfE()._check(iterable);
>+      if (skipCount === void 0) skipCount = 0;
>+      core.RangeError.checkValidRange(start, end, this[$length]);
>+      let length = dart.notNull(end) - dart.notNull(start);
>+      if (length === 0) return;
>+      core.RangeError.checkNotNegative(skipCount, "skipCount");
>+      let otherList = null;
>+      let otherStart = null;
>+      if (ListOfE().is(iterable)) {
>+        otherList = iterable;
>+        otherStart = skipCount;
>+      } else {
>+        otherList = iterable[$skip](skipCount)[$toList]({growable: false});
>+        otherStart = 0;
>+      }
>+      if (dart.notNull(otherStart) + length > dart.notNull(otherList[$length])) {
>+        dart.throw(_internal.IterableElementError.tooFew());
>+      }
>+      if (dart.notNull(otherStart) < dart.notNull(start)) {
>+        for (let i = length - 1; i >= 0; i--) {
>+          this[$_set](dart.notNull(start) + i, otherList[$_get](dart.notNull(otherStart) + i));
>+        }
>+      } else {
>+        for (let i = 0; i < length; i++) {
>+          this[$_set](dart.notNull(start) + i, otherList[$_get](dart.notNull(otherStart) + i));
>+        }
>+      }
>+    }
>+    replaceRange(start, end, newContents) {
>+      IterableOfE()._check(newContents);
>+      core.RangeError.checkValidRange(start, end, this[$length]);
>+      if (!_internal.EfficientLengthIterable.is(newContents)) {
>+        newContents = newContents[$toList]();
>+      }
>+      let removeLength = dart.notNull(end) - dart.notNull(start);
>+      let insertLength = newContents[$length];
>+      if (removeLength >= dart.notNull(insertLength)) {
>+        let insertEnd = dart.notNull(start) + dart.notNull(insertLength);
>+        this[$setRange](start, insertEnd, newContents);
>+        if (removeLength > dart.notNull(insertLength)) {
>+          this[_closeGap](insertEnd, end);
>+        }
>+      } else {
>+        let delta = dart.notNull(insertLength) - removeLength;
>+        let newLength = dart.notNull(this[$length]) + delta;
>+        let insertEnd = dart.notNull(start) + dart.notNull(insertLength);
>+        this[$length] = newLength;
>+        this[$setRange](insertEnd, newLength, this, end);
>+        this[$setRange](start, insertEnd, newContents);
>+      }
>+    }
>+    indexOf(element, start) {
>+      if (start === void 0) start = 0;
>+      if (dart.notNull(start) < 0) start = 0;
>+      for (let i = start; dart.notNull(i) < dart.notNull(this[$length]); i = dart.notNull(i) + 1) {
>+        if (dart.equals(this[$_get](i), element)) return i;
>+      }
>+      return -1;
>+    }
>+    indexWhere(test, start) {
>+      if (start === void 0) start = 0;
>+      if (dart.notNull(start) < 0) start = 0;
>+      for (let i = start; dart.notNull(i) < dart.notNull(this[$length]); i = dart.notNull(i) + 1) {
>+        if (dart.test(test(this[$_get](i)))) return i;
>+      }
>+      return -1;
>+    }
>+    lastIndexOf(element, start) {
>+      if (start === void 0) start = null;
>+      if (start == null || dart.notNull(start) >= dart.notNull(this[$length])) start = dart.notNull(this[$length]) - 1;
>+      for (let i = start; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
>+        if (dart.equals(this[$_get](i), element)) return i;
>+      }
>+      return -1;
>+    }
>+    lastIndexWhere(test, start) {
>+      if (start === void 0) start = null;
>+      if (start == null || dart.notNull(start) >= dart.notNull(this[$length])) start = dart.notNull(this[$length]) - 1;
>+      for (let i = start; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
>+        if (dart.test(test(this[$_get](i)))) return i;
>+      }
>+      return -1;
>+    }
>+    insert(index, element) {
>+      E._check(element);
>+      core.ArgumentError.checkNotNull(index, "index");
>+      core.RangeError.checkValueInInterval(index, 0, this[$length], "index");
>+      if (index == this[$length]) {
>+        this[$add](element);
>+        return;
>+      }
>+      this[$length] = dart.notNull(this[$length]) + 1;
>+      this[$setRange](dart.notNull(index) + 1, this[$length], this, index);
>+      this[$_set](index, element);
>+    }
>+    removeAt(index) {
>+      let result = this[$_get](index);
>+      this[_closeGap](index, dart.notNull(index) + 1);
>+      return result;
>+    }
>+    insertAll(index, iterable) {
>+      IterableOfE()._check(iterable);
>+      core.RangeError.checkValueInInterval(index, 0, this[$length], "index");
>+      if (!_internal.EfficientLengthIterable.is(iterable) || iterable === this) {
>+        iterable = iterable[$toList]();
>+      }
>+      let insertionLength = iterable[$length];
>+      this[$length] = dart.notNull(this[$length]) + dart.notNull(insertionLength);
>+      if (iterable[$length] != insertionLength) {
>+        this[$length] = dart.notNull(this[$length]) - dart.notNull(insertionLength);
>+        dart.throw(new core.ConcurrentModificationError.new(iterable));
>+      }
>+      this[$setRange](dart.notNull(index) + dart.notNull(insertionLength), this[$length], this, index);
>+      this[$setAll](index, iterable);
>+    }
>+    setAll(index, iterable) {
>+      IterableOfE()._check(iterable);
>+      if (core.List.is(iterable)) {
>+        this[$setRange](index, dart.notNull(index) + dart.notNull(iterable[$length]), iterable);
>+      } else {
>+        for (let element of iterable) {
>+          this[$_set]((() => {
>+            let x = index;
>+            index = dart.notNull(x) + 1;
>+            return x;
>+          })(), element);
>+        }
>+      }
>+    }
>+    get reversed() {
>+      return new (ReversedListIterableOfE()).new(this);
>+    }
>+    toString() {
>+      return collection.IterableBase.iterableToFullString(this, "[", "]");
>+    }
>+  }
>+  (ListMixin.new = function() {
>+  }).prototype = ListMixin.prototype;
>+  ListMixin.prototype[dart.isList] = true;
>+  dart.addTypeTests(ListMixin);
>+  ListMixin.prototype[_is_ListMixin_default] = true;
>+  ListMixin[dart.implements] = () => [ListOfE()];
>+  dart.setMethodSignature(ListMixin, () => ({
>+    __proto__: dart.getMethods(ListMixin.__proto__),
>+    elementAt: dart.fnType(E, [core.int]),
>+    [$elementAt]: dart.fnType(E, [core.int]),
>+    followedBy: dart.fnType(core.Iterable$(E), [core.Object]),
>+    [$followedBy]: dart.fnType(core.Iterable$(E), [core.Object]),
>+    forEach: dart.fnType(dart.void, [dart.fnType(dart.void, [E])]),
>+    [$forEach]: dart.fnType(dart.void, [dart.fnType(dart.void, [E])]),
>+    contains: dart.fnType(core.bool, [core.Object]),
>+    [$contains]: dart.fnType(core.bool, [core.Object]),
>+    every: dart.fnType(core.bool, [dart.fnType(core.bool, [E])]),
>+    [$every]: dart.fnType(core.bool, [dart.fnType(core.bool, [E])]),
>+    any: dart.fnType(core.bool, [dart.fnType(core.bool, [E])]),
>+    [$any]: dart.fnType(core.bool, [dart.fnType(core.bool, [E])]),
>+    firstWhere: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    [$firstWhere]: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    lastWhere: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    [$lastWhere]: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    singleWhere: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    [$singleWhere]: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    join: dart.fnType(core.String, [], [core.String]),
>+    [$join]: dart.fnType(core.String, [], [core.String]),
>+    where: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    [$where]: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    whereType: dart.gFnType(T => [core.Iterable$(T), []]),
>+    [$whereType]: dart.gFnType(T => [core.Iterable$(T), []]),
>+    map: dart.gFnType(T => [core.Iterable$(T), [dart.fnType(T, [E])]]),
>+    [$map]: dart.gFnType(T => [core.Iterable$(T), [dart.fnType(T, [E])]]),
>+    expand: dart.gFnType(T => [core.Iterable$(T), [dart.fnType(core.Iterable$(T), [E])]]),
>+    [$expand]: dart.gFnType(T => [core.Iterable$(T), [dart.fnType(core.Iterable$(T), [E])]]),
>+    reduce: dart.fnType(E, [core.Object]),
>+    [$reduce]: dart.fnType(E, [core.Object]),
>+    fold: dart.gFnType(T => [T, [T, dart.fnType(T, [T, E])]]),
>+    [$fold]: dart.gFnType(T => [T, [T, dart.fnType(T, [T, E])]]),
>+    skip: dart.fnType(core.Iterable$(E), [core.int]),
>+    [$skip]: dart.fnType(core.Iterable$(E), [core.int]),
>+    skipWhile: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    [$skipWhile]: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    take: dart.fnType(core.Iterable$(E), [core.int]),
>+    [$take]: dart.fnType(core.Iterable$(E), [core.int]),
>+    takeWhile: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    [$takeWhile]: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    toList: dart.fnType(core.List$(E), [], {growable: core.bool}),
>+    [$toList]: dart.fnType(core.List$(E), [], {growable: core.bool}),
>+    toSet: dart.fnType(core.Set$(E), []),
>+    [$toSet]: dart.fnType(core.Set$(E), []),
>+    add: dart.fnType(dart.void, [core.Object]),
>+    [$add]: dart.fnType(dart.void, [core.Object]),
>+    addAll: dart.fnType(dart.void, [core.Object]),
>+    [$addAll]: dart.fnType(dart.void, [core.Object]),
>+    remove: dart.fnType(core.bool, [core.Object]),
>+    [$remove]: dart.fnType(core.bool, [core.Object]),
>+    [_closeGap]: dart.fnType(dart.void, [core.int, core.int]),
>+    removeWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [E])]),
>+    [$removeWhere]: dart.fnType(dart.void, [dart.fnType(core.bool, [E])]),
>+    retainWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [E])]),
>+    [$retainWhere]: dart.fnType(dart.void, [dart.fnType(core.bool, [E])]),
>+    [_filter]: dart.fnType(dart.void, [dart.fnType(core.bool, [E]), core.bool]),
>+    clear: dart.fnType(dart.void, []),
>+    [$clear]: dart.fnType(dart.void, []),
>+    cast: dart.gFnType(R => [core.List$(R), []]),
>+    [$cast]: dart.gFnType(R => [core.List$(R), []]),
>+    removeLast: dart.fnType(E, []),
>+    [$removeLast]: dart.fnType(E, []),
>+    sort: dart.fnType(dart.void, [], [dart.fnType(core.int, [E, E])]),
>+    [$sort]: dart.fnType(dart.void, [], [dart.fnType(core.int, [E, E])]),
>+    shuffle: dart.fnType(dart.void, [], [math.Random]),
>+    [$shuffle]: dart.fnType(dart.void, [], [math.Random]),
>+    asMap: dart.fnType(core.Map$(core.int, E), []),
>+    [$asMap]: dart.fnType(core.Map$(core.int, E), []),
>+    '+': dart.fnType(core.List$(E), [core.Object]),
>+    [$plus]: dart.fnType(core.List$(E), [core.Object]),
>+    sublist: dart.fnType(core.List$(E), [core.int], [core.int]),
>+    [$sublist]: dart.fnType(core.List$(E), [core.int], [core.int]),
>+    getRange: dart.fnType(core.Iterable$(E), [core.int, core.int]),
>+    [$getRange]: dart.fnType(core.Iterable$(E), [core.int, core.int]),
>+    removeRange: dart.fnType(dart.void, [core.int, core.int]),
>+    [$removeRange]: dart.fnType(dart.void, [core.int, core.int]),
>+    fillRange: dart.fnType(dart.void, [core.int, core.int], [core.Object]),
>+    [$fillRange]: dart.fnType(dart.void, [core.int, core.int], [core.Object]),
>+    setRange: dart.fnType(dart.void, [core.int, core.int, core.Object], [core.int]),
>+    [$setRange]: dart.fnType(dart.void, [core.int, core.int, core.Object], [core.int]),
>+    replaceRange: dart.fnType(dart.void, [core.int, core.int, core.Object]),
>+    [$replaceRange]: dart.fnType(dart.void, [core.int, core.int, core.Object]),
>+    indexOf: dart.fnType(core.int, [core.Object], [core.int]),
>+    [$indexOf]: dart.fnType(core.int, [core.Object], [core.int]),
>+    indexWhere: dart.fnType(core.int, [dart.fnType(core.bool, [E])], [core.int]),
>+    [$indexWhere]: dart.fnType(core.int, [dart.fnType(core.bool, [E])], [core.int]),
>+    lastIndexOf: dart.fnType(core.int, [core.Object], [core.int]),
>+    [$lastIndexOf]: dart.fnType(core.int, [core.Object], [core.int]),
>+    lastIndexWhere: dart.fnType(core.int, [dart.fnType(core.bool, [E])], [core.int]),
>+    [$lastIndexWhere]: dart.fnType(core.int, [dart.fnType(core.bool, [E])], [core.int]),
>+    insert: dart.fnType(dart.void, [core.int, core.Object]),
>+    [$insert]: dart.fnType(dart.void, [core.int, core.Object]),
>+    removeAt: dart.fnType(E, [core.int]),
>+    [$removeAt]: dart.fnType(E, [core.int]),
>+    insertAll: dart.fnType(dart.void, [core.int, core.Object]),
>+    [$insertAll]: dart.fnType(dart.void, [core.int, core.Object]),
>+    setAll: dart.fnType(dart.void, [core.int, core.Object]),
>+    [$setAll]: dart.fnType(dart.void, [core.int, core.Object]),
>+    toString: dart.fnType(core.String, []),
>+    [$toString]: dart.fnType(core.String, [])
>+  }));
>+  dart.setGetterSignature(ListMixin, () => ({
>+    __proto__: dart.getGetters(ListMixin.__proto__),
>+    iterator: core.Iterator$(E),
>+    [$iterator]: core.Iterator$(E),
>+    isEmpty: core.bool,
>+    [$isEmpty]: core.bool,
>+    isNotEmpty: core.bool,
>+    [$isNotEmpty]: core.bool,
>+    first: E,
>+    [$first]: E,
>+    last: E,
>+    [$last]: E,
>+    single: E,
>+    [$single]: E,
>+    reversed: core.Iterable$(E),
>+    [$reversed]: core.Iterable$(E)
>+  }));
>+  dart.setSetterSignature(ListMixin, () => ({
>+    __proto__: dart.getSetters(ListMixin.__proto__),
>+    first: E,
>+    [$first]: E,
>+    last: E,
>+    [$last]: E
>+  }));
>+  dart.setLibraryUri(ListMixin, "dart:collection");
>+  dart.defineExtensionMethods(ListMixin, [
>+    'elementAt',
>+    'followedBy',
>+    'forEach',
>+    'contains',
>+    'every',
>+    'any',
>+    'firstWhere',
>+    'lastWhere',
>+    'singleWhere',
>+    'join',
>+    'where',
>+    'whereType',
>+    'map',
>+    'expand',
>+    'reduce',
>+    'fold',
>+    'skip',
>+    'skipWhile',
>+    'take',
>+    'takeWhile',
>+    'toList',
>+    'toSet',
>+    'add',
>+    'addAll',
>+    'remove',
>+    'removeWhere',
>+    'retainWhere',
>+    'clear',
>+    'cast',
>+    'removeLast',
>+    'sort',
>+    'shuffle',
>+    'asMap',
>+    '+',
>+    'sublist',
>+    'getRange',
>+    'removeRange',
>+    'fillRange',
>+    'setRange',
>+    'replaceRange',
>+    'indexOf',
>+    'indexWhere',
>+    'lastIndexOf',
>+    'lastIndexWhere',
>+    'insert',
>+    'removeAt',
>+    'insertAll',
>+    'setAll',
>+    'toString'
>+  ]);
>+  dart.defineExtensionAccessors(ListMixin, [
>+    'iterator',
>+    'isEmpty',
>+    'isNotEmpty',
>+    'first',
>+    'last',
>+    'single',
>+    'reversed'
>+  ]);
>+  return ListMixin;
>+});
>+collection.ListMixin = collection.ListMixin$();
>+dart.addTypeTests(collection.ListMixin, _is_ListMixin_default);
>+const _is_ListBase_default = Symbol('_is_ListBase_default');
>+collection.ListBase$ = dart.generic(E => {
>+  const Object_ListMixin$ = class Object_ListMixin extends core.Object {};
>+  (Object_ListMixin$.new = function() {
>+  }).prototype = Object_ListMixin$.prototype;
>+  dart.applyMixin(Object_ListMixin$, collection.ListMixin$(E));
>+  class ListBase extends Object_ListMixin$ {
>+    static listToString(list) {
>+      return collection.IterableBase.iterableToFullString(list, "[", "]");
>+    }
>+  }
>+  (ListBase.new = function() {
>+  }).prototype = ListBase.prototype;
>+  dart.addTypeTests(ListBase);
>+  ListBase.prototype[_is_ListBase_default] = true;
>+  dart.setLibraryUri(ListBase, "dart:collection");
>+  return ListBase;
>+});
>+collection.ListBase = collection.ListBase$();
>+dart.addTypeTests(collection.ListBase, _is_ListBase_default);
>+const _is_UnmodifiableListMixin_default = Symbol('_is_UnmodifiableListMixin_default');
>+_internal.UnmodifiableListMixin$ = dart.generic(E => {
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  let ListOfE = () => (ListOfE = dart.constFn(core.List$(E)))();
>+  class UnmodifiableListMixin extends core.Object {
>+    _set(index, value) {
>+      E._check(value);
>+      dart.throw(new core.UnsupportedError.new("Cannot modify an unmodifiable list"));
>+      return value;
>+    }
>+    set length(newLength) {
>+      dart.throw(new core.UnsupportedError.new("Cannot change the length of an unmodifiable list"));
>+    }
>+    set first(element) {
>+      E._check(element);
>+      dart.throw(new core.UnsupportedError.new("Cannot modify an unmodifiable list"));
>+    }
>+    set last(element) {
>+      E._check(element);
>+      dart.throw(new core.UnsupportedError.new("Cannot modify an unmodifiable list"));
>+    }
>+    setAll(at, iterable) {
>+      IterableOfE()._check(iterable);
>+      dart.throw(new core.UnsupportedError.new("Cannot modify an unmodifiable list"));
>+    }
>+    add(value) {
>+      E._check(value);
>+      dart.throw(new core.UnsupportedError.new("Cannot add to an unmodifiable list"));
>+    }
>+    insert(index, element) {
>+      E._check(element);
>+      dart.throw(new core.UnsupportedError.new("Cannot add to an unmodifiable list"));
>+    }
>+    insertAll(at, iterable) {
>+      IterableOfE()._check(iterable);
>+      dart.throw(new core.UnsupportedError.new("Cannot add to an unmodifiable list"));
>+    }
>+    addAll(iterable) {
>+      IterableOfE()._check(iterable);
>+      dart.throw(new core.UnsupportedError.new("Cannot add to an unmodifiable list"));
>+    }
>+    remove(element) {
>+      dart.throw(new core.UnsupportedError.new("Cannot remove from an unmodifiable list"));
>+    }
>+    removeWhere(test) {
>+      dart.throw(new core.UnsupportedError.new("Cannot remove from an unmodifiable list"));
>+    }
>+    retainWhere(test) {
>+      dart.throw(new core.UnsupportedError.new("Cannot remove from an unmodifiable list"));
>+    }
>+    sort(compare) {
>+      if (compare === void 0) compare = null;
>+      dart.throw(new core.UnsupportedError.new("Cannot modify an unmodifiable list"));
>+    }
>+    shuffle(random) {
>+      if (random === void 0) random = null;
>+      dart.throw(new core.UnsupportedError.new("Cannot modify an unmodifiable list"));
>+    }
>+    clear() {
>+      dart.throw(new core.UnsupportedError.new("Cannot clear an unmodifiable list"));
>+    }
>+    removeAt(index) {
>+      dart.throw(new core.UnsupportedError.new("Cannot remove from an unmodifiable list"));
>+    }
>+    removeLast() {
>+      dart.throw(new core.UnsupportedError.new("Cannot remove from an unmodifiable list"));
>+    }
>+    setRange(start, end, iterable, skipCount) {
>+      IterableOfE()._check(iterable);
>+      if (skipCount === void 0) skipCount = 0;
>+      dart.throw(new core.UnsupportedError.new("Cannot modify an unmodifiable list"));
>+    }
>+    removeRange(start, end) {
>+      dart.throw(new core.UnsupportedError.new("Cannot remove from an unmodifiable list"));
>+    }
>+    replaceRange(start, end, iterable) {
>+      IterableOfE()._check(iterable);
>+      dart.throw(new core.UnsupportedError.new("Cannot remove from an unmodifiable list"));
>+    }
>+    fillRange(start, end, fillValue) {
>+      if (fillValue === void 0) fillValue = null;
>+      E._check(fillValue);
>+      dart.throw(new core.UnsupportedError.new("Cannot modify an unmodifiable list"));
>+    }
>+  }
>+  (UnmodifiableListMixin.new = function() {
>+  }).prototype = UnmodifiableListMixin.prototype;
>+  UnmodifiableListMixin.prototype[dart.isList] = true;
>+  dart.addTypeTests(UnmodifiableListMixin);
>+  UnmodifiableListMixin.prototype[_is_UnmodifiableListMixin_default] = true;
>+  UnmodifiableListMixin[dart.implements] = () => [ListOfE()];
>+  dart.setMethodSignature(UnmodifiableListMixin, () => ({
>+    __proto__: dart.getMethods(UnmodifiableListMixin.__proto__),
>+    _set: dart.fnType(dart.void, [core.int, core.Object]),
>+    [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+    setAll: dart.fnType(dart.void, [core.int, core.Object]),
>+    [$setAll]: dart.fnType(dart.void, [core.int, core.Object]),
>+    add: dart.fnType(dart.void, [core.Object]),
>+    [$add]: dart.fnType(dart.void, [core.Object]),
>+    insert: dart.fnType(dart.void, [core.int, core.Object]),
>+    [$insert]: dart.fnType(dart.void, [core.int, core.Object]),
>+    insertAll: dart.fnType(dart.void, [core.int, core.Object]),
>+    [$insertAll]: dart.fnType(dart.void, [core.int, core.Object]),
>+    addAll: dart.fnType(dart.void, [core.Object]),
>+    [$addAll]: dart.fnType(dart.void, [core.Object]),
>+    remove: dart.fnType(core.bool, [core.Object]),
>+    [$remove]: dart.fnType(core.bool, [core.Object]),
>+    removeWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [E])]),
>+    [$removeWhere]: dart.fnType(dart.void, [dart.fnType(core.bool, [E])]),
>+    retainWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [E])]),
>+    [$retainWhere]: dart.fnType(dart.void, [dart.fnType(core.bool, [E])]),
>+    sort: dart.fnType(dart.void, [], [dart.fnType(core.int, [E, E])]),
>+    [$sort]: dart.fnType(dart.void, [], [dart.fnType(core.int, [E, E])]),
>+    shuffle: dart.fnType(dart.void, [], [math.Random]),
>+    [$shuffle]: dart.fnType(dart.void, [], [math.Random]),
>+    clear: dart.fnType(dart.void, []),
>+    [$clear]: dart.fnType(dart.void, []),
>+    removeAt: dart.fnType(E, [core.int]),
>+    [$removeAt]: dart.fnType(E, [core.int]),
>+    removeLast: dart.fnType(E, []),
>+    [$removeLast]: dart.fnType(E, []),
>+    setRange: dart.fnType(dart.void, [core.int, core.int, core.Object], [core.int]),
>+    [$setRange]: dart.fnType(dart.void, [core.int, core.int, core.Object], [core.int]),
>+    removeRange: dart.fnType(dart.void, [core.int, core.int]),
>+    [$removeRange]: dart.fnType(dart.void, [core.int, core.int]),
>+    replaceRange: dart.fnType(dart.void, [core.int, core.int, core.Object]),
>+    [$replaceRange]: dart.fnType(dart.void, [core.int, core.int, core.Object]),
>+    fillRange: dart.fnType(dart.void, [core.int, core.int], [core.Object]),
>+    [$fillRange]: dart.fnType(dart.void, [core.int, core.int], [core.Object])
>+  }));
>+  dart.setSetterSignature(UnmodifiableListMixin, () => ({
>+    __proto__: dart.getSetters(UnmodifiableListMixin.__proto__),
>+    length: core.int,
>+    [$length]: core.int,
>+    first: E,
>+    [$first]: E,
>+    last: E,
>+    [$last]: E
>+  }));
>+  dart.setLibraryUri(UnmodifiableListMixin, "dart:_internal");
>+  dart.defineExtensionMethods(UnmodifiableListMixin, [
>+    '_set',
>+    'setAll',
>+    'add',
>+    'insert',
>+    'insertAll',
>+    'addAll',
>+    'remove',
>+    'removeWhere',
>+    'retainWhere',
>+    'sort',
>+    'shuffle',
>+    'clear',
>+    'removeAt',
>+    'removeLast',
>+    'setRange',
>+    'removeRange',
>+    'replaceRange',
>+    'fillRange'
>+  ]);
>+  dart.defineExtensionAccessors(UnmodifiableListMixin, ['length', 'first', 'last']);
>+  return UnmodifiableListMixin;
>+});
>+_internal.UnmodifiableListMixin = _internal.UnmodifiableListMixin$();
>+dart.addTypeTests(_internal.UnmodifiableListMixin, _is_UnmodifiableListMixin_default);
>+const _is_UnmodifiableListBase_default = Symbol('_is_UnmodifiableListBase_default');
>+_internal.UnmodifiableListBase$ = dart.generic(E => {
>+  const ListBase_UnmodifiableListMixin$ = class ListBase_UnmodifiableListMixin extends collection.ListBase$(E) {};
>+  (ListBase_UnmodifiableListMixin$.new = function() {
>+  }).prototype = ListBase_UnmodifiableListMixin$.prototype;
>+  dart.applyMixin(ListBase_UnmodifiableListMixin$, _internal.UnmodifiableListMixin$(E));
>+  class UnmodifiableListBase extends ListBase_UnmodifiableListMixin$ {}
>+  (UnmodifiableListBase.new = function() {
>+  }).prototype = UnmodifiableListBase.prototype;
>+  dart.addTypeTests(UnmodifiableListBase);
>+  UnmodifiableListBase.prototype[_is_UnmodifiableListBase_default] = true;
>+  dart.setLibraryUri(UnmodifiableListBase, "dart:_internal");
>+  return UnmodifiableListBase;
>+});
>+_internal.UnmodifiableListBase = _internal.UnmodifiableListBase$();
>+dart.addTypeTests(_internal.UnmodifiableListBase, _is_UnmodifiableListBase_default);
>+core.num = class num extends core.Object {
>+  static parse(input, onError) {
>+    if (onError === void 0) onError = null;
>+    let result = core.num.tryParse(input);
>+    if (result != null) return result;
>+    if (onError == null) dart.throw(new core.FormatException.new(input));
>+    return onError(input);
>+  }
>+  static tryParse(input) {
>+    let source = input[$trim]();
>+    let l = core.int.tryParse(source);
>+    return l != null ? l : core.double.tryParse(source);
>+  }
>+  static _returnIntNull(_) {
>+    return null;
>+  }
>+  static _returnDoubleNull(_) {
>+    return null;
>+  }
>+};
>+(core.num.new = function() {
>+}).prototype = core.num.prototype;
>+core.num.is = function is_num(o) {
>+  return typeof o == "number";
>+};
>+core.num.as = function as_num(o) {
>+  if (typeof o == "number" || o == null) return o;
>+  return dart.as(o, core.num, false);
>+};
>+core.num._check = function check_num(o) {
>+  if (typeof o == "number" || o == null) return o;
>+  return dart.as(o, core.num, true);
>+};
>+core.num[dart.implements] = () => [ComparableOfnum()];
>+dart.setLibraryUri(core.num, "dart:core");
>+core.int = class int extends core.num {
>+  static fromEnvironment(name, opts) {
>+    let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : null;
>+    dart.throw(new core.UnsupportedError.new("int.fromEnvironment can only be used as a const constructor"));
>+  }
>+  static parse(source, opts) {
>+    let radix = opts && 'radix' in opts ? opts.radix : null;
>+    let onError = opts && 'onError' in opts ? opts.onError : null;
>+    return _js_helper.Primitives.parseInt(source, radix, onError);
>+  }
>+  static tryParse(source, opts) {
>+    let radix = opts && 'radix' in opts ? opts.radix : null;
>+    return _js_helper.Primitives.parseInt(source, radix, dart.fn(core._kNull, dynamicToNull()));
>+  }
>+};
>+core.int.is = function is_int(o) {
>+  return typeof o == "number" && Math.floor(o) == o;
>+};
>+core.int.as = function as_int(o) {
>+  if (typeof o == "number" && Math.floor(o) == o || o == null) return o;
>+  return dart.as(o, core.int, false);
>+};
>+core.int._check = function check_int(o) {
>+  if (typeof o == "number" && Math.floor(o) == o || o == null) return o;
>+  return dart.as(o, core.int, true);
>+};
>+dart.setLibraryUri(core.int, "dart:core");
>+_internal.CodeUnits = class CodeUnits extends _internal.UnmodifiableListBase$(core.int) {
>+  get length() {
>+    return this[_string].length;
>+  }
>+  set length(value) {
>+    super.length = value;
>+  }
>+  _get(i) {
>+    return this[_string][$codeUnitAt](i);
>+  }
>+  static stringOf(u) {
>+    return u[_string];
>+  }
>+};
>+(_internal.CodeUnits.new = function(string) {
>+  this[_string] = string;
>+}).prototype = _internal.CodeUnits.prototype;
>+dart.addTypeTests(_internal.CodeUnits);
>+dart.setMethodSignature(_internal.CodeUnits, () => ({
>+  __proto__: dart.getMethods(_internal.CodeUnits.__proto__),
>+  _get: dart.fnType(core.int, [core.int]),
>+  [$_get]: dart.fnType(core.int, [core.int])
>+}));
>+dart.setGetterSignature(_internal.CodeUnits, () => ({
>+  __proto__: dart.getGetters(_internal.CodeUnits.__proto__),
>+  length: core.int,
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(_internal.CodeUnits, "dart:_internal");
>+dart.setFieldSignature(_internal.CodeUnits, () => ({
>+  __proto__: dart.getFields(_internal.CodeUnits.__proto__),
>+  [_string]: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionMethods(_internal.CodeUnits, ['_get']);
>+dart.defineExtensionAccessors(_internal.CodeUnits, ['length']);
>+_internal.ExternalName = class ExternalName extends core.Object {};
>+(_internal.ExternalName.new = function(name) {
>+  this.name = name;
>+}).prototype = _internal.ExternalName.prototype;
>+dart.addTypeTests(_internal.ExternalName);
>+dart.setLibraryUri(_internal.ExternalName, "dart:_internal");
>+dart.setFieldSignature(_internal.ExternalName, () => ({
>+  __proto__: dart.getFields(_internal.ExternalName.__proto__),
>+  name: dart.finalFieldType(core.String)
>+}));
>+_internal.hexDigitValue = function(char) {
>+  if (!(dart.notNull(char) >= 0 && dart.notNull(char) <= 65535)) dart.assertFailed(null, "dart:_internal", 101, 10, "char >= 0 && char <= 0xFFFF");
>+  let digit0 = 48;
>+  let a = 97;
>+  let f = 102;
>+  let digit = (dart.notNull(char) ^ digit0) >>> 0;
>+  if (digit <= 9) return digit;
>+  let letter = (dart.notNull(char) | 32) >>> 0;
>+  if (a <= letter && letter <= f) return letter - (a - 10);
>+  return -1;
>+};
>+_internal.parseHexByte = function(source, index) {
>+  if (!(dart.notNull(index) + 2 <= source.length)) dart.assertFailed(null, "dart:_internal", 116, 10, "index + 2 <= source.length");
>+  let digit1 = _internal.hexDigitValue(source[$codeUnitAt](index));
>+  let digit2 = _internal.hexDigitValue(source[$codeUnitAt](dart.notNull(index) + 1));
>+  return dart.notNull(digit1) * 16 + dart.notNull(digit2) - (dart.notNull(digit2) & 256);
>+};
>+_internal.extractTypeArguments = function(T, instance, extract) {
>+  return dart.extractTypeArguments(T, instance, extract);
>+};
>+_internal.Since = class Since extends core.Object {};
>+(_internal.Since.new = function(version) {
>+  this.version = version;
>+}).prototype = _internal.Since.prototype;
>+dart.addTypeTests(_internal.Since);
>+dart.setLibraryUri(_internal.Since, "dart:_internal");
>+dart.setFieldSignature(_internal.Since, () => ({
>+  __proto__: dart.getFields(_internal.Since.__proto__),
>+  version: dart.finalFieldType(core.String)
>+}));
>+_internal.HttpStatus = class HttpStatus extends core.Object {};
>+(_internal.HttpStatus.new = function() {
>+}).prototype = _internal.HttpStatus.prototype;
>+dart.addTypeTests(_internal.HttpStatus);
>+dart.setLibraryUri(_internal.HttpStatus, "dart:_internal");
>+dart.defineLazy(_internal.HttpStatus, {
>+  /*_internal.HttpStatus.continue__*/get continue__() {
>+    return 100;
>+  },
>+  /*_internal.HttpStatus.switchingProtocols*/get switchingProtocols() {
>+    return 101;
>+  },
>+  /*_internal.HttpStatus.processing*/get processing() {
>+    return 102;
>+  },
>+  /*_internal.HttpStatus.ok*/get ok() {
>+    return 200;
>+  },
>+  /*_internal.HttpStatus.created*/get created() {
>+    return 201;
>+  },
>+  /*_internal.HttpStatus.accepted*/get accepted() {
>+    return 202;
>+  },
>+  /*_internal.HttpStatus.nonAuthoritativeInformation*/get nonAuthoritativeInformation() {
>+    return 203;
>+  },
>+  /*_internal.HttpStatus.noContent*/get noContent() {
>+    return 204;
>+  },
>+  /*_internal.HttpStatus.resetContent*/get resetContent() {
>+    return 205;
>+  },
>+  /*_internal.HttpStatus.partialContent*/get partialContent() {
>+    return 206;
>+  },
>+  /*_internal.HttpStatus.multiStatus*/get multiStatus() {
>+    return 207;
>+  },
>+  /*_internal.HttpStatus.alreadyReported*/get alreadyReported() {
>+    return 208;
>+  },
>+  /*_internal.HttpStatus.imUsed*/get imUsed() {
>+    return 226;
>+  },
>+  /*_internal.HttpStatus.multipleChoices*/get multipleChoices() {
>+    return 300;
>+  },
>+  /*_internal.HttpStatus.movedPermanently*/get movedPermanently() {
>+    return 301;
>+  },
>+  /*_internal.HttpStatus.found*/get found() {
>+    return 302;
>+  },
>+  /*_internal.HttpStatus.movedTemporarily*/get movedTemporarily() {
>+    return 302;
>+  },
>+  /*_internal.HttpStatus.seeOther*/get seeOther() {
>+    return 303;
>+  },
>+  /*_internal.HttpStatus.notModified*/get notModified() {
>+    return 304;
>+  },
>+  /*_internal.HttpStatus.useProxy*/get useProxy() {
>+    return 305;
>+  },
>+  /*_internal.HttpStatus.temporaryRedirect*/get temporaryRedirect() {
>+    return 307;
>+  },
>+  /*_internal.HttpStatus.permanentRedirect*/get permanentRedirect() {
>+    return 308;
>+  },
>+  /*_internal.HttpStatus.badRequest*/get badRequest() {
>+    return 400;
>+  },
>+  /*_internal.HttpStatus.unauthorized*/get unauthorized() {
>+    return 401;
>+  },
>+  /*_internal.HttpStatus.paymentRequired*/get paymentRequired() {
>+    return 402;
>+  },
>+  /*_internal.HttpStatus.forbidden*/get forbidden() {
>+    return 403;
>+  },
>+  /*_internal.HttpStatus.notFound*/get notFound() {
>+    return 404;
>+  },
>+  /*_internal.HttpStatus.methodNotAllowed*/get methodNotAllowed() {
>+    return 405;
>+  },
>+  /*_internal.HttpStatus.notAcceptable*/get notAcceptable() {
>+    return 406;
>+  },
>+  /*_internal.HttpStatus.proxyAuthenticationRequired*/get proxyAuthenticationRequired() {
>+    return 407;
>+  },
>+  /*_internal.HttpStatus.requestTimeout*/get requestTimeout() {
>+    return 408;
>+  },
>+  /*_internal.HttpStatus.conflict*/get conflict() {
>+    return 409;
>+  },
>+  /*_internal.HttpStatus.gone*/get gone() {
>+    return 410;
>+  },
>+  /*_internal.HttpStatus.lengthRequired*/get lengthRequired() {
>+    return 411;
>+  },
>+  /*_internal.HttpStatus.preconditionFailed*/get preconditionFailed() {
>+    return 412;
>+  },
>+  /*_internal.HttpStatus.requestEntityTooLarge*/get requestEntityTooLarge() {
>+    return 413;
>+  },
>+  /*_internal.HttpStatus.requestUriTooLong*/get requestUriTooLong() {
>+    return 414;
>+  },
>+  /*_internal.HttpStatus.unsupportedMediaType*/get unsupportedMediaType() {
>+    return 415;
>+  },
>+  /*_internal.HttpStatus.requestedRangeNotSatisfiable*/get requestedRangeNotSatisfiable() {
>+    return 416;
>+  },
>+  /*_internal.HttpStatus.expectationFailed*/get expectationFailed() {
>+    return 417;
>+  },
>+  /*_internal.HttpStatus.misdirectedRequest*/get misdirectedRequest() {
>+    return 421;
>+  },
>+  /*_internal.HttpStatus.unprocessableEntity*/get unprocessableEntity() {
>+    return 422;
>+  },
>+  /*_internal.HttpStatus.locked*/get locked() {
>+    return 423;
>+  },
>+  /*_internal.HttpStatus.failedDependency*/get failedDependency() {
>+    return 424;
>+  },
>+  /*_internal.HttpStatus.upgradeRequired*/get upgradeRequired() {
>+    return 426;
>+  },
>+  /*_internal.HttpStatus.preconditionRequired*/get preconditionRequired() {
>+    return 428;
>+  },
>+  /*_internal.HttpStatus.tooManyRequests*/get tooManyRequests() {
>+    return 429;
>+  },
>+  /*_internal.HttpStatus.requestHeaderFieldsTooLarge*/get requestHeaderFieldsTooLarge() {
>+    return 431;
>+  },
>+  /*_internal.HttpStatus.connectionClosedWithoutResponse*/get connectionClosedWithoutResponse() {
>+    return 444;
>+  },
>+  /*_internal.HttpStatus.unavailableForLegalReasons*/get unavailableForLegalReasons() {
>+    return 451;
>+  },
>+  /*_internal.HttpStatus.clientClosedRequest*/get clientClosedRequest() {
>+    return 499;
>+  },
>+  /*_internal.HttpStatus.internalServerError*/get internalServerError() {
>+    return 500;
>+  },
>+  /*_internal.HttpStatus.notImplemented*/get notImplemented() {
>+    return 501;
>+  },
>+  /*_internal.HttpStatus.badGateway*/get badGateway() {
>+    return 502;
>+  },
>+  /*_internal.HttpStatus.serviceUnavailable*/get serviceUnavailable() {
>+    return 503;
>+  },
>+  /*_internal.HttpStatus.gatewayTimeout*/get gatewayTimeout() {
>+    return 504;
>+  },
>+  /*_internal.HttpStatus.httpVersionNotSupported*/get httpVersionNotSupported() {
>+    return 505;
>+  },
>+  /*_internal.HttpStatus.variantAlsoNegotiates*/get variantAlsoNegotiates() {
>+    return 506;
>+  },
>+  /*_internal.HttpStatus.insufficientStorage*/get insufficientStorage() {
>+    return 507;
>+  },
>+  /*_internal.HttpStatus.loopDetected*/get loopDetected() {
>+    return 508;
>+  },
>+  /*_internal.HttpStatus.notExtended*/get notExtended() {
>+    return 510;
>+  },
>+  /*_internal.HttpStatus.networkAuthenticationRequired*/get networkAuthenticationRequired() {
>+    return 511;
>+  },
>+  /*_internal.HttpStatus.networkConnectTimeoutError*/get networkConnectTimeoutError() {
>+    return 599;
>+  },
>+  /*_internal.HttpStatus.CONTINUE*/get CONTINUE() {
>+    return 100;
>+  },
>+  /*_internal.HttpStatus.SWITCHING_PROTOCOLS*/get SWITCHING_PROTOCOLS() {
>+    return 101;
>+  },
>+  /*_internal.HttpStatus.OK*/get OK() {
>+    return 200;
>+  },
>+  /*_internal.HttpStatus.CREATED*/get CREATED() {
>+    return 201;
>+  },
>+  /*_internal.HttpStatus.ACCEPTED*/get ACCEPTED() {
>+    return 202;
>+  },
>+  /*_internal.HttpStatus.NON_AUTHORITATIVE_INFORMATION*/get NON_AUTHORITATIVE_INFORMATION() {
>+    return 203;
>+  },
>+  /*_internal.HttpStatus.NO_CONTENT*/get NO_CONTENT() {
>+    return 204;
>+  },
>+  /*_internal.HttpStatus.RESET_CONTENT*/get RESET_CONTENT() {
>+    return 205;
>+  },
>+  /*_internal.HttpStatus.PARTIAL_CONTENT*/get PARTIAL_CONTENT() {
>+    return 206;
>+  },
>+  /*_internal.HttpStatus.MULTIPLE_CHOICES*/get MULTIPLE_CHOICES() {
>+    return 300;
>+  },
>+  /*_internal.HttpStatus.MOVED_PERMANENTLY*/get MOVED_PERMANENTLY() {
>+    return 301;
>+  },
>+  /*_internal.HttpStatus.FOUND*/get FOUND() {
>+    return 302;
>+  },
>+  /*_internal.HttpStatus.MOVED_TEMPORARILY*/get MOVED_TEMPORARILY() {
>+    return 302;
>+  },
>+  /*_internal.HttpStatus.SEE_OTHER*/get SEE_OTHER() {
>+    return 303;
>+  },
>+  /*_internal.HttpStatus.NOT_MODIFIED*/get NOT_MODIFIED() {
>+    return 304;
>+  },
>+  /*_internal.HttpStatus.USE_PROXY*/get USE_PROXY() {
>+    return 305;
>+  },
>+  /*_internal.HttpStatus.TEMPORARY_REDIRECT*/get TEMPORARY_REDIRECT() {
>+    return 307;
>+  },
>+  /*_internal.HttpStatus.BAD_REQUEST*/get BAD_REQUEST() {
>+    return 400;
>+  },
>+  /*_internal.HttpStatus.UNAUTHORIZED*/get UNAUTHORIZED() {
>+    return 401;
>+  },
>+  /*_internal.HttpStatus.PAYMENT_REQUIRED*/get PAYMENT_REQUIRED() {
>+    return 402;
>+  },
>+  /*_internal.HttpStatus.FORBIDDEN*/get FORBIDDEN() {
>+    return 403;
>+  },
>+  /*_internal.HttpStatus.NOT_FOUND*/get NOT_FOUND() {
>+    return 404;
>+  },
>+  /*_internal.HttpStatus.METHOD_NOT_ALLOWED*/get METHOD_NOT_ALLOWED() {
>+    return 405;
>+  },
>+  /*_internal.HttpStatus.NOT_ACCEPTABLE*/get NOT_ACCEPTABLE() {
>+    return 406;
>+  },
>+  /*_internal.HttpStatus.PROXY_AUTHENTICATION_REQUIRED*/get PROXY_AUTHENTICATION_REQUIRED() {
>+    return 407;
>+  },
>+  /*_internal.HttpStatus.REQUEST_TIMEOUT*/get REQUEST_TIMEOUT() {
>+    return 408;
>+  },
>+  /*_internal.HttpStatus.CONFLICT*/get CONFLICT() {
>+    return 409;
>+  },
>+  /*_internal.HttpStatus.GONE*/get GONE() {
>+    return 410;
>+  },
>+  /*_internal.HttpStatus.LENGTH_REQUIRED*/get LENGTH_REQUIRED() {
>+    return 411;
>+  },
>+  /*_internal.HttpStatus.PRECONDITION_FAILED*/get PRECONDITION_FAILED() {
>+    return 412;
>+  },
>+  /*_internal.HttpStatus.REQUEST_ENTITY_TOO_LARGE*/get REQUEST_ENTITY_TOO_LARGE() {
>+    return 413;
>+  },
>+  /*_internal.HttpStatus.REQUEST_URI_TOO_LONG*/get REQUEST_URI_TOO_LONG() {
>+    return 414;
>+  },
>+  /*_internal.HttpStatus.UNSUPPORTED_MEDIA_TYPE*/get UNSUPPORTED_MEDIA_TYPE() {
>+    return 415;
>+  },
>+  /*_internal.HttpStatus.REQUESTED_RANGE_NOT_SATISFIABLE*/get REQUESTED_RANGE_NOT_SATISFIABLE() {
>+    return 416;
>+  },
>+  /*_internal.HttpStatus.EXPECTATION_FAILED*/get EXPECTATION_FAILED() {
>+    return 417;
>+  },
>+  /*_internal.HttpStatus.UPGRADE_REQUIRED*/get UPGRADE_REQUIRED() {
>+    return 426;
>+  },
>+  /*_internal.HttpStatus.INTERNAL_SERVER_ERROR*/get INTERNAL_SERVER_ERROR() {
>+    return 500;
>+  },
>+  /*_internal.HttpStatus.NOT_IMPLEMENTED*/get NOT_IMPLEMENTED() {
>+    return 501;
>+  },
>+  /*_internal.HttpStatus.BAD_GATEWAY*/get BAD_GATEWAY() {
>+    return 502;
>+  },
>+  /*_internal.HttpStatus.SERVICE_UNAVAILABLE*/get SERVICE_UNAVAILABLE() {
>+    return 503;
>+  },
>+  /*_internal.HttpStatus.GATEWAY_TIMEOUT*/get GATEWAY_TIMEOUT() {
>+    return 504;
>+  },
>+  /*_internal.HttpStatus.HTTP_VERSION_NOT_SUPPORTED*/get HTTP_VERSION_NOT_SUPPORTED() {
>+    return 505;
>+  },
>+  /*_internal.HttpStatus.NETWORK_CONNECT_TIMEOUT_ERROR*/get NETWORK_CONNECT_TIMEOUT_ERROR() {
>+    return 599;
>+  }
>+});
>+const _source = dart.privateName(_internal, "_source");
>+const _add = dart.privateName(async, "_add");
>+const _closeUnchecked = dart.privateName(async, "_closeUnchecked");
>+const _addError = dart.privateName(async, "_addError");
>+const _completeError = dart.privateName(async, "_completeError");
>+const _complete = dart.privateName(async, "_complete");
>+const _sink = dart.privateName(async, "_sink");
>+async.Stream$ = dart.generic(T => {
>+  let _EmptyStreamOfT = () => (_EmptyStreamOfT = dart.constFn(async._EmptyStream$(T)))();
>+  let StreamControllerOfT = () => (StreamControllerOfT = dart.constFn(async.StreamController$(T)))();
>+  let _StreamControllerOfT = () => (_StreamControllerOfT = dart.constFn(async._StreamController$(T)))();
>+  let TToNull = () => (TToNull = dart.constFn(dart.fnType(core.Null, [T])))();
>+  let _IterablePendingEventsOfT = () => (_IterablePendingEventsOfT = dart.constFn(async._IterablePendingEvents$(T)))();
>+  let VoidTo_IterablePendingEventsOfT = () => (VoidTo_IterablePendingEventsOfT = dart.constFn(dart.fnType(_IterablePendingEventsOfT(), [])))();
>+  let _GeneratedStreamImplOfT = () => (_GeneratedStreamImplOfT = dart.constFn(async._GeneratedStreamImpl$(T)))();
>+  let _BoundSinkStreamOfdynamic$T = () => (_BoundSinkStreamOfdynamic$T = dart.constFn(async._BoundSinkStream$(dart.dynamic, T)))();
>+  let _AsBroadcastStreamOfT = () => (_AsBroadcastStreamOfT = dart.constFn(async._AsBroadcastStream$(T)))();
>+  let _WhereStreamOfT = () => (_WhereStreamOfT = dart.constFn(async._WhereStream$(T)))();
>+  let _HandleErrorStreamOfT = () => (_HandleErrorStreamOfT = dart.constFn(async._HandleErrorStream$(T)))();
>+  let StreamConsumerOfT = () => (StreamConsumerOfT = dart.constFn(async.StreamConsumer$(T)))();
>+  let TAndTToT = () => (TAndTToT = dart.constFn(dart.fnType(T, [T, T])))();
>+  let _FutureOfT = () => (_FutureOfT = dart.constFn(async._Future$(T)))();
>+  let VoidToT = () => (VoidToT = dart.constFn(dart.fnType(T, [])))();
>+  let JSArrayOfT = () => (JSArrayOfT = dart.constFn(_interceptors.JSArray$(T)))();
>+  let ListOfT = () => (ListOfT = dart.constFn(core.List$(T)))();
>+  let _FutureOfListOfT = () => (_FutureOfListOfT = dart.constFn(async._Future$(ListOfT())))();
>+  let _HashSetOfT = () => (_HashSetOfT = dart.constFn(collection._HashSet$(T)))();
>+  let SetOfT = () => (SetOfT = dart.constFn(core.Set$(T)))();
>+  let _FutureOfSetOfT = () => (_FutureOfSetOfT = dart.constFn(async._Future$(SetOfT())))();
>+  let _TakeStreamOfT = () => (_TakeStreamOfT = dart.constFn(async._TakeStream$(T)))();
>+  let _TakeWhileStreamOfT = () => (_TakeWhileStreamOfT = dart.constFn(async._TakeWhileStream$(T)))();
>+  let _SkipStreamOfT = () => (_SkipStreamOfT = dart.constFn(async._SkipStream$(T)))();
>+  let _SkipWhileStreamOfT = () => (_SkipWhileStreamOfT = dart.constFn(async._SkipWhileStream$(T)))();
>+  let _DistinctStreamOfT = () => (_DistinctStreamOfT = dart.constFn(async._DistinctStream$(T)))();
>+  let TTovoid = () => (TTovoid = dart.constFn(dart.fnType(dart.void, [T])))();
>+  let EventSinkOfT = () => (EventSinkOfT = dart.constFn(async.EventSink$(T)))();
>+  let _ControllerEventSinkWrapperOfT = () => (_ControllerEventSinkWrapperOfT = dart.constFn(async._ControllerEventSinkWrapper$(T)))();
>+  let _SyncBroadcastStreamControllerOfT = () => (_SyncBroadcastStreamControllerOfT = dart.constFn(async._SyncBroadcastStreamController$(T)))();
>+  let _SyncStreamControllerOfT = () => (_SyncStreamControllerOfT = dart.constFn(async._SyncStreamController$(T)))();
>+  class Stream extends core.Object {
>+    static empty() {
>+      return new (_EmptyStreamOfT()).new();
>+    }
>+    static fromFuture(future) {
>+      let controller = _StreamControllerOfT()._check(StreamControllerOfT().new({sync: true}));
>+      FutureOfNull()._check(future.then(core.Null, dart.fn(value => {
>+        controller[_add](value);
>+        controller[_closeUnchecked]();
>+      }, TToNull()), {onError: dart.fn((error, stackTrace) => {
>+          controller[_addError](error, core.StackTrace._check(stackTrace));
>+          controller[_closeUnchecked]();
>+        }, dynamicAnddynamicToNull())}));
>+      return controller.stream;
>+    }
>+    static fromFutures(futures) {
>+      let controller = _StreamControllerOfT()._check(StreamControllerOfT().new({sync: true}));
>+      let count = 0;
>+      let onValue = value => {
>+        if (!dart.test(controller.isClosed)) {
>+          controller[_add](value);
>+          if (--count === 0) controller[_closeUnchecked]();
>+        }
>+      };
>+      dart.fn(onValue, TToNull());
>+      let onError = (error, stack) => {
>+        if (!dart.test(controller.isClosed)) {
>+          controller[_addError](error, stack);
>+          if (--count === 0) controller[_closeUnchecked]();
>+        }
>+      };
>+      dart.fn(onError, dynamicAndStackTraceToNull());
>+      for (let future of futures) {
>+        count++;
>+        FutureOfNull()._check(future.then(core.Null, onValue, {onError: onError}));
>+      }
>+      if (count === 0) async.scheduleMicrotask(dart.bind(controller, 'close'));
>+      return controller.stream;
>+    }
>+    static fromIterable(elements) {
>+      return new (_GeneratedStreamImplOfT()).new(dart.fn(() => new (_IterablePendingEventsOfT()).new(elements), VoidTo_IterablePendingEventsOfT()));
>+    }
>+    static periodic(period, computation) {
>+      if (computation === void 0) computation = null;
>+      let timer = null;
>+      let computationCount = 0;
>+      let controller = null;
>+      let watch = new core.Stopwatch.new();
>+      function sendEvent() {
>+        watch.reset();
>+        let data = null;
>+        if (computation != null) {
>+          try {
>+            data = computation(computationCount++);
>+          } catch (e$) {
>+            let e = dart.getThrown(e$);
>+            let s = dart.stackTrace(e$);
>+            controller.addError(e, s);
>+            return;
>+          }
>+        }
>+        controller.add(data);
>+      }
>+      dart.fn(sendEvent, VoidTovoid());
>+      function startPeriodicTimer() {
>+        if (!(timer == null)) dart.assertFailed(null, "dart:async/stream.dart", 218, 14, "timer == null");
>+        timer = async.Timer.periodic(period, dart.fn(timer => {
>+          sendEvent();
>+        }, TimerToNull()));
>+      }
>+      dart.fn(startPeriodicTimer, VoidTovoid());
>+      controller = StreamControllerOfT().new({sync: true, onListen: dart.fn(() => {
>+          watch.start();
>+          startPeriodicTimer();
>+        }, VoidToNull()), onPause: dart.fn(() => {
>+          timer.cancel();
>+          timer = null;
>+          watch.stop();
>+        }, VoidToNull()), onResume: dart.fn(() => {
>+          if (!(timer == null)) dart.assertFailed(null, "dart:async/stream.dart", 236, 18, "timer == null");
>+          let elapsed = watch.elapsed;
>+          watch.start();
>+          timer = async.Timer.new(period['-'](elapsed), dart.fn(() => {
>+            timer = null;
>+            startPeriodicTimer();
>+            sendEvent();
>+          }, VoidToNull()));
>+        }, VoidToNull()), onCancel: dart.fn(() => {
>+          if (timer != null) timer.cancel();
>+          timer = null;
>+          return async.Future._nullFuture;
>+        }, VoidTo_FutureOfNull())});
>+      return controller.stream;
>+    }
>+    static eventTransformed(source, mapSink) {
>+      return new (_BoundSinkStreamOfdynamic$T()).new(source, mapSink);
>+    }
>+    static castFrom(S, T, source) {
>+      return new (_internal.CastStream$(S, T)).new(source);
>+    }
>+    get isBroadcast() {
>+      return false;
>+    }
>+    asBroadcastStream(opts) {
>+      let onListen = opts && 'onListen' in opts ? opts.onListen : null;
>+      let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
>+      return new (_AsBroadcastStreamOfT()).new(this, onListen, onCancel);
>+    }
>+    where(test) {
>+      return new (_WhereStreamOfT()).new(this, test);
>+    }
>+    map(S, convert) {
>+      return new (async._MapStream$(T, S)).new(this, convert);
>+    }
>+    asyncMap(E, convert) {
>+      let controller = null;
>+      let subscription = null;
>+      const onListen = () => {
>+        let add = dart.bind(controller, 'add');
>+        if (!(async._StreamController$(E).is(controller) || async._BroadcastStreamController.is(controller))) dart.assertFailed(null, "dart:async/stream.dart", 442, 14, "controller is _StreamController<E> || controller is _BroadcastStreamController");
>+        let addError = dart.bind(controller, _addError);
>+        subscription = this.listen(dart.fn(event => {
>+          let newValue = null;
>+          try {
>+            newValue = convert(event);
>+          } catch (e$) {
>+            let e = dart.getThrown(e$);
>+            let s = dart.stackTrace(e$);
>+            controller.addError(e, s);
>+            return;
>+          }
>+          if (async.Future$(E).is(newValue)) {
>+            subscription.pause();
>+            newValue.then(dart.void, add, {onError: addError}).whenComplete(dart.bind(subscription, 'resume'));
>+          } else {
>+            controller.add(E._check(newValue));
>+          }
>+        }, TToNull()), {onError: addError, onDone: dart.bind(controller, 'close')});
>+      };
>+      dart.fn(onListen, VoidTovoid());
>+      if (dart.test(this.isBroadcast)) {
>+        controller = async._StreamControllerBase$(E)._check(async.StreamController$(E).broadcast({onListen: onListen, onCancel: dart.fn(() => {
>+            subscription.cancel();
>+          }, VoidToNull()), sync: true}));
>+      } else {
>+        controller = async._StreamControllerBase$(E)._check(async.StreamController$(E).new({onListen: onListen, onPause: dart.fn(() => {
>+            subscription.pause();
>+          }, VoidToNull()), onResume: dart.fn(() => {
>+            subscription.resume();
>+          }, VoidToNull()), onCancel: dart.fn(() => subscription.cancel(), VoidToFuture()), sync: true}));
>+      }
>+      return controller.stream;
>+    }
>+    asyncExpand(E, convert) {
>+      let controller = null;
>+      let subscription = null;
>+      const onListen = () => {
>+        if (!(async._StreamController.is(controller) || async._BroadcastStreamController.is(controller))) dart.assertFailed(null, "dart:async/stream.dart", 508, 14, "controller is _StreamController || controller is _BroadcastStreamController");
>+        subscription = this.listen(dart.fn(event => {
>+          let newStream = null;
>+          try {
>+            newStream = convert(event);
>+          } catch (e$) {
>+            let e = dart.getThrown(e$);
>+            let s = dart.stackTrace(e$);
>+            controller.addError(e, s);
>+            return;
>+          }
>+          if (newStream != null) {
>+            subscription.pause();
>+            controller.addStream(newStream).whenComplete(dart.bind(subscription, 'resume'));
>+          }
>+        }, TToNull()), {onError: dart.bind(controller, _addError), onDone: dart.bind(controller, 'close')});
>+      };
>+      dart.fn(onListen, VoidTovoid());
>+      if (dart.test(this.isBroadcast)) {
>+        controller = async._StreamControllerBase$(E)._check(async.StreamController$(E).broadcast({onListen: onListen, onCancel: dart.fn(() => {
>+            subscription.cancel();
>+          }, VoidToNull()), sync: true}));
>+      } else {
>+        controller = async._StreamControllerBase$(E)._check(async.StreamController$(E).new({onListen: onListen, onPause: dart.fn(() => {
>+            subscription.pause();
>+          }, VoidToNull()), onResume: dart.fn(() => {
>+            subscription.resume();
>+          }, VoidToNull()), onCancel: dart.fn(() => subscription.cancel(), VoidToFuture()), sync: true}));
>+      }
>+      return controller.stream;
>+    }
>+    handleError(onError, opts) {
>+      let test = opts && 'test' in opts ? opts.test : null;
>+      return new (_HandleErrorStreamOfT()).new(this, onError, test);
>+    }
>+    expand(S, convert) {
>+      return new (async._ExpandStream$(T, S)).new(this, convert);
>+    }
>+    pipe(streamConsumer) {
>+      StreamConsumerOfT()._check(streamConsumer);
>+      return streamConsumer.addStream(this).then(dart.dynamic, dart.fn(_ => streamConsumer.close(), dynamicToFuture()));
>+    }
>+    transform(S, streamTransformer) {
>+      async.StreamTransformer$(T, S)._check(streamTransformer);
>+      return streamTransformer.bind(this);
>+    }
>+    reduce(combine) {
>+      TAndTToT()._check(combine);
>+      let result = new (_FutureOfT()).new();
>+      let seenFirst = false;
>+      let value = null;
>+      let subscription = null;
>+      subscription = this.listen(dart.fn(element => {
>+        if (seenFirst) {
>+          async._runUserCode(T, dart.fn(() => combine(value, element), VoidToT()), dart.fn(newValue => {
>+            value = newValue;
>+          }, TToNull()), async._cancelAndErrorClosure(subscription, result));
>+        } else {
>+          value = element;
>+          seenFirst = true;
>+        }
>+      }, TToNull()), {onError: dart.bind(result, _completeError), onDone: dart.fn(() => {
>+          if (!seenFirst) {
>+            try {
>+              dart.throw(_internal.IterableElementError.noElement());
>+            } catch (e$) {
>+              let e = dart.getThrown(e$);
>+              let s = dart.stackTrace(e$);
>+              async._completeWithErrorCallback(result, e, s);
>+            }
>+          } else {
>+            result[_complete](value);
>+          }
>+        }, VoidToNull()), cancelOnError: true});
>+      return result;
>+    }
>+    fold(S, initialValue, combine) {
>+      let result = new (async._Future$(S)).new();
>+      let value = initialValue;
>+      let subscription = null;
>+      subscription = this.listen(dart.fn(element => {
>+        async._runUserCode(S, dart.fn(() => combine(value, element), dart.fnType(S, [])), dart.fn(newValue => {
>+          value = newValue;
>+        }, dart.fnType(core.Null, [S])), async._cancelAndErrorClosure(subscription, result));
>+      }, TToNull()), {onError: dart.bind(result, _completeError), onDone: dart.fn(() => {
>+          result[_complete](value);
>+        }, VoidToNull()), cancelOnError: true});
>+      return result;
>+    }
>+    join(separator) {
>+      if (separator === void 0) separator = "";
>+      let result = new (_FutureOfString()).new();
>+      let buffer = new core.StringBuffer.new();
>+      let subscription = null;
>+      let first = true;
>+      subscription = this.listen(dart.fn(element => {
>+        if (!first) {
>+          buffer.write(separator);
>+        }
>+        first = false;
>+        try {
>+          buffer.write(element);
>+        } catch (e$) {
>+          let e = dart.getThrown(e$);
>+          let s = dart.stackTrace(e$);
>+          async._cancelAndErrorWithReplacement(subscription, result, e, s);
>+        }
>+      }, TToNull()), {onError: dart.bind(result, _completeError), onDone: dart.fn(() => {
>+          result[_complete](buffer.toString());
>+        }, VoidToNull()), cancelOnError: true});
>+      return result;
>+    }
>+    contains(needle) {
>+      let future = new (_FutureOfbool()).new();
>+      let subscription = null;
>+      subscription = this.listen(dart.fn(element => {
>+        async._runUserCode(core.bool, dart.fn(() => dart.equals(element, needle), VoidTobool()), dart.fn(isMatch => {
>+          if (dart.test(isMatch)) {
>+            async._cancelAndValue(subscription, future, true);
>+          }
>+        }, boolToNull()), async._cancelAndErrorClosure(subscription, future));
>+      }, TToNull()), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
>+          future[_complete](false);
>+        }, VoidToNull()), cancelOnError: true});
>+      return future;
>+    }
>+    forEach(action) {
>+      let future = new async._Future.new();
>+      let subscription = null;
>+      subscription = this.listen(dart.fn(element => {
>+        async._runUserCode(dart.dynamic, dart.fn(() => action(element), VoidTovoid()), dart.fn(_ => {
>+        }, dynamicToNull()), async._cancelAndErrorClosure(subscription, future));
>+      }, TToNull()), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
>+          future[_complete](null);
>+        }, VoidToNull()), cancelOnError: true});
>+      return future;
>+    }
>+    every(test) {
>+      let future = new (_FutureOfbool()).new();
>+      let subscription = null;
>+      subscription = this.listen(dart.fn(element => {
>+        async._runUserCode(core.bool, dart.fn(() => test(element), VoidTobool()), dart.fn(isMatch => {
>+          if (!dart.test(isMatch)) {
>+            async._cancelAndValue(subscription, future, false);
>+          }
>+        }, boolToNull()), async._cancelAndErrorClosure(subscription, future));
>+      }, TToNull()), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
>+          future[_complete](true);
>+        }, VoidToNull()), cancelOnError: true});
>+      return future;
>+    }
>+    any(test) {
>+      let future = new (_FutureOfbool()).new();
>+      let subscription = null;
>+      subscription = this.listen(dart.fn(element => {
>+        async._runUserCode(core.bool, dart.fn(() => test(element), VoidTobool()), dart.fn(isMatch => {
>+          if (dart.test(isMatch)) {
>+            async._cancelAndValue(subscription, future, true);
>+          }
>+        }, boolToNull()), async._cancelAndErrorClosure(subscription, future));
>+      }, TToNull()), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
>+          future[_complete](false);
>+        }, VoidToNull()), cancelOnError: true});
>+      return future;
>+    }
>+    get length() {
>+      let future = new (_FutureOfint()).new();
>+      let count = 0;
>+      this.listen(dart.fn(_ => {
>+        count++;
>+      }, TToNull()), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
>+          future[_complete](count);
>+        }, VoidToNull()), cancelOnError: true});
>+      return future;
>+    }
>+    get isEmpty() {
>+      let future = new (_FutureOfbool()).new();
>+      let subscription = null;
>+      subscription = this.listen(dart.fn(_ => {
>+        async._cancelAndValue(subscription, future, false);
>+      }, TToNull()), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
>+          future[_complete](true);
>+        }, VoidToNull()), cancelOnError: true});
>+      return future;
>+    }
>+    cast(R) {
>+      return async.Stream.castFrom(T, R, this);
>+    }
>+    toList() {
>+      let result = JSArrayOfT().of([]);
>+      let future = new (_FutureOfListOfT()).new();
>+      this.listen(dart.fn(data => {
>+        result[$add](data);
>+      }, TToNull()), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
>+          future[_complete](result);
>+        }, VoidToNull()), cancelOnError: true});
>+      return future;
>+    }
>+    toSet() {
>+      let result = new (_HashSetOfT()).new();
>+      let future = new (_FutureOfSetOfT()).new();
>+      this.listen(dart.fn(data => {
>+        result.add(data);
>+      }, TToNull()), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
>+          future[_complete](result);
>+        }, VoidToNull()), cancelOnError: true});
>+      return future;
>+    }
>+    drain(E, futureValue) {
>+      if (futureValue === void 0) futureValue = null;
>+      return async.Future$(E)._check(this.listen(null, {cancelOnError: true}).asFuture(E, futureValue));
>+    }
>+    take(count) {
>+      return new (_TakeStreamOfT()).new(this, count);
>+    }
>+    takeWhile(test) {
>+      return new (_TakeWhileStreamOfT()).new(this, test);
>+    }
>+    skip(count) {
>+      return new (_SkipStreamOfT()).new(this, count);
>+    }
>+    skipWhile(test) {
>+      return new (_SkipWhileStreamOfT()).new(this, test);
>+    }
>+    distinct(equals) {
>+      if (equals === void 0) equals = null;
>+      return new (_DistinctStreamOfT()).new(this, equals);
>+    }
>+    get first() {
>+      let future = new (_FutureOfT()).new();
>+      let subscription = null;
>+      subscription = this.listen(dart.fn(value => {
>+        async._cancelAndValue(subscription, future, value);
>+      }, TToNull()), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
>+          try {
>+            dart.throw(_internal.IterableElementError.noElement());
>+          } catch (e$) {
>+            let e = dart.getThrown(e$);
>+            let s = dart.stackTrace(e$);
>+            async._completeWithErrorCallback(future, e, s);
>+          }
>+        }, VoidToNull()), cancelOnError: true});
>+      return future;
>+    }
>+    get last() {
>+      let future = new (_FutureOfT()).new();
>+      let result = null;
>+      let foundResult = false;
>+      this.listen(dart.fn(value => {
>+        foundResult = true;
>+        result = value;
>+      }, TToNull()), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
>+          if (foundResult) {
>+            future[_complete](result);
>+            return;
>+          }
>+          try {
>+            dart.throw(_internal.IterableElementError.noElement());
>+          } catch (e$) {
>+            let e = dart.getThrown(e$);
>+            let s = dart.stackTrace(e$);
>+            async._completeWithErrorCallback(future, e, s);
>+          }
>+        }, VoidToNull()), cancelOnError: true});
>+      return future;
>+    }
>+    get single() {
>+      let future = new (_FutureOfT()).new();
>+      let result = null;
>+      let foundResult = false;
>+      let subscription = null;
>+      subscription = this.listen(dart.fn(value => {
>+        if (foundResult) {
>+          try {
>+            dart.throw(_internal.IterableElementError.tooMany());
>+          } catch (e$) {
>+            let e = dart.getThrown(e$);
>+            let s = dart.stackTrace(e$);
>+            async._cancelAndErrorWithReplacement(subscription, future, e, s);
>+          }
>+          return;
>+        }
>+        foundResult = true;
>+        result = value;
>+      }, TToNull()), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
>+          if (foundResult) {
>+            future[_complete](result);
>+            return;
>+          }
>+          try {
>+            dart.throw(_internal.IterableElementError.noElement());
>+          } catch (e$) {
>+            let e = dart.getThrown(e$);
>+            let s = dart.stackTrace(e$);
>+            async._completeWithErrorCallback(future, e, s);
>+          }
>+        }, VoidToNull()), cancelOnError: true});
>+      return future;
>+    }
>+    firstWhere(test, opts) {
>+      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+      VoidToT()._check(orElse);
>+      let future = new (_FutureOfT()).new();
>+      let subscription = null;
>+      subscription = this.listen(dart.fn(value => {
>+        async._runUserCode(core.bool, dart.fn(() => test(value), VoidTobool()), dart.fn(isMatch => {
>+          if (dart.test(isMatch)) {
>+            async._cancelAndValue(subscription, future, value);
>+          }
>+        }, boolToNull()), async._cancelAndErrorClosure(subscription, future));
>+      }, TToNull()), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
>+          if (orElse != null) {
>+            async._runUserCode(T, orElse, dart.bind(future, _complete), dart.bind(future, _completeError));
>+            return;
>+          }
>+          try {
>+            dart.throw(_internal.IterableElementError.noElement());
>+          } catch (e$) {
>+            let e = dart.getThrown(e$);
>+            let s = dart.stackTrace(e$);
>+            async._completeWithErrorCallback(future, e, s);
>+          }
>+        }, VoidToNull()), cancelOnError: true});
>+      return future;
>+    }
>+    lastWhere(test, opts) {
>+      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+      VoidToT()._check(orElse);
>+      let future = new (_FutureOfT()).new();
>+      let result = null;
>+      let foundResult = false;
>+      let subscription = null;
>+      subscription = this.listen(dart.fn(value => {
>+        async._runUserCode(core.bool, dart.fn(() => true === test(value), VoidTobool()), dart.fn(isMatch => {
>+          if (dart.test(isMatch)) {
>+            foundResult = true;
>+            result = value;
>+          }
>+        }, boolToNull()), async._cancelAndErrorClosure(subscription, future));
>+      }, TToNull()), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
>+          if (foundResult) {
>+            future[_complete](result);
>+            return;
>+          }
>+          if (orElse != null) {
>+            async._runUserCode(T, orElse, dart.bind(future, _complete), dart.bind(future, _completeError));
>+            return;
>+          }
>+          try {
>+            dart.throw(_internal.IterableElementError.noElement());
>+          } catch (e$) {
>+            let e = dart.getThrown(e$);
>+            let s = dart.stackTrace(e$);
>+            async._completeWithErrorCallback(future, e, s);
>+          }
>+        }, VoidToNull()), cancelOnError: true});
>+      return future;
>+    }
>+    singleWhere(test, opts) {
>+      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+      VoidToT()._check(orElse);
>+      let future = new (_FutureOfT()).new();
>+      let result = null;
>+      let foundResult = false;
>+      let subscription = null;
>+      subscription = this.listen(dart.fn(value => {
>+        async._runUserCode(core.bool, dart.fn(() => true === test(value), VoidTobool()), dart.fn(isMatch => {
>+          if (dart.test(isMatch)) {
>+            if (foundResult) {
>+              try {
>+                dart.throw(_internal.IterableElementError.tooMany());
>+              } catch (e$) {
>+                let e = dart.getThrown(e$);
>+                let s = dart.stackTrace(e$);
>+                async._cancelAndErrorWithReplacement(subscription, future, e, s);
>+              }
>+              return;
>+            }
>+            foundResult = true;
>+            result = value;
>+          }
>+        }, boolToNull()), async._cancelAndErrorClosure(subscription, future));
>+      }, TToNull()), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
>+          if (foundResult) {
>+            future[_complete](result);
>+            return;
>+          }
>+          try {
>+            if (orElse != null) {
>+              async._runUserCode(T, orElse, dart.bind(future, _complete), dart.bind(future, _completeError));
>+              return;
>+            }
>+            dart.throw(_internal.IterableElementError.noElement());
>+          } catch (e$) {
>+            let e = dart.getThrown(e$);
>+            let s = dart.stackTrace(e$);
>+            async._completeWithErrorCallback(future, e, s);
>+          }
>+        }, VoidToNull()), cancelOnError: true});
>+      return future;
>+    }
>+    elementAt(index) {
>+      core.ArgumentError.checkNotNull(index, "index");
>+      core.RangeError.checkNotNegative(index, "index");
>+      let future = new (_FutureOfT()).new();
>+      let subscription = null;
>+      let elementIndex = 0;
>+      subscription = this.listen(dart.fn(value => {
>+        if (index === elementIndex) {
>+          async._cancelAndValue(subscription, future, value);
>+          return;
>+        }
>+        elementIndex = elementIndex + 1;
>+      }, TToNull()), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
>+          future[_completeError](core.RangeError.index(index, this, "index", null, elementIndex));
>+        }, VoidToNull()), cancelOnError: true});
>+      return future;
>+    }
>+    timeout(timeLimit, opts) {
>+      let onTimeout = opts && 'onTimeout' in opts ? opts.onTimeout : null;
>+      let controller = null;
>+      let subscription = null;
>+      let timer = null;
>+      let zone = null;
>+      let timeout = null;
>+      function onData(event) {
>+        timer.cancel();
>+        controller.add(event);
>+        timer = zone.createTimer(timeLimit, timeout);
>+      }
>+      dart.fn(onData, TTovoid());
>+      function onError(error, stackTrace) {
>+        timer.cancel();
>+        if (!(async._StreamController.is(controller) || async._BroadcastStreamController.is(controller))) dart.assertFailed(null, "dart:async/stream.dart", 1511, 14, "controller is _StreamController || controller is _BroadcastStreamController");
>+        controller[_addError](error, stackTrace);
>+        timer = zone.createTimer(timeLimit, timeout);
>+      }
>+      dart.fn(onError, dynamicAndStackTraceTovoid());
>+      function onDone() {
>+        timer.cancel();
>+        controller.close();
>+      }
>+      dart.fn(onDone, VoidTovoid());
>+      const onListen = () => {
>+        zone = async.Zone.current;
>+        if (onTimeout == null) {
>+          timeout = dart.fn(() => {
>+            controller.addError(new async.TimeoutException.new("No stream event", timeLimit), null);
>+          }, VoidToNull());
>+        } else {
>+          let registeredOnTimeout = zone.registerUnaryCallback(dart.dynamic, EventSinkOfT(), onTimeout);
>+          let wrapper = new (_ControllerEventSinkWrapperOfT()).new(null);
>+          timeout = dart.fn(() => {
>+            wrapper[_sink] = controller;
>+            zone.runUnaryGuarded(_ControllerEventSinkWrapperOfT(), registeredOnTimeout, wrapper);
>+            wrapper[_sink] = null;
>+          }, VoidToNull());
>+        }
>+        subscription = this.listen(onData, {onError: onError, onDone: onDone});
>+        timer = zone.createTimer(timeLimit, timeout);
>+      };
>+      dart.fn(onListen, VoidTovoid());
>+      function onCancel() {
>+        timer.cancel();
>+        let result = subscription.cancel();
>+        subscription = null;
>+        return result;
>+      }
>+      dart.fn(onCancel, VoidToFuture());
>+      controller = dart.test(this.isBroadcast) ? new (_SyncBroadcastStreamControllerOfT()).new(onListen, onCancel) : new (_SyncStreamControllerOfT()).new(onListen, dart.fn(() => {
>+        timer.cancel();
>+        subscription.pause();
>+      }, VoidToNull()), dart.fn(() => {
>+        subscription.resume();
>+        timer = zone.createTimer(timeLimit, timeout);
>+      }, VoidToNull()), onCancel);
>+      return controller.stream;
>+    }
>+  }
>+  (Stream.new = function() {
>+  }).prototype = Stream.prototype;
>+  (Stream._internal = function() {
>+  }).prototype = Stream.prototype;
>+  dart.addTypeTests(Stream);
>+  Stream.prototype[dart.isStream] = true;
>+  dart.setMethodSignature(Stream, () => ({
>+    __proto__: dart.getMethods(Stream.__proto__),
>+    asBroadcastStream: dart.fnType(async.Stream$(T), [], {onListen: dart.fnType(dart.void, [async.StreamSubscription$(T)]), onCancel: dart.fnType(dart.void, [async.StreamSubscription$(T)])}),
>+    where: dart.fnType(async.Stream$(T), [dart.fnType(core.bool, [T])]),
>+    map: dart.gFnType(S => [async.Stream$(S), [dart.fnType(S, [T])]]),
>+    asyncMap: dart.gFnType(E => [async.Stream$(E), [dart.fnType(async.FutureOr$(E), [T])]]),
>+    asyncExpand: dart.gFnType(E => [async.Stream$(E), [dart.fnType(async.Stream$(E), [T])]]),
>+    handleError: dart.fnType(async.Stream$(T), [core.Function], {test: dart.fnType(core.bool, [dart.dynamic])}),
>+    expand: dart.gFnType(S => [async.Stream$(S), [dart.fnType(core.Iterable$(S), [T])]]),
>+    pipe: dart.fnType(async.Future, [core.Object]),
>+    transform: dart.gFnType(S => [async.Stream$(S), [core.Object]]),
>+    reduce: dart.fnType(async.Future$(T), [core.Object]),
>+    fold: dart.gFnType(S => [async.Future$(S), [S, dart.fnType(S, [S, T])]]),
>+    join: dart.fnType(async.Future$(core.String), [], [core.String]),
>+    contains: dart.fnType(async.Future$(core.bool), [core.Object]),
>+    forEach: dart.fnType(async.Future, [dart.fnType(dart.void, [T])]),
>+    every: dart.fnType(async.Future$(core.bool), [dart.fnType(core.bool, [T])]),
>+    any: dart.fnType(async.Future$(core.bool), [dart.fnType(core.bool, [T])]),
>+    cast: dart.gFnType(R => [async.Stream$(R), []]),
>+    toList: dart.fnType(async.Future$(core.List$(T)), []),
>+    toSet: dart.fnType(async.Future$(core.Set$(T)), []),
>+    drain: dart.gFnType(E => [async.Future$(E), [], [E]]),
>+    take: dart.fnType(async.Stream$(T), [core.int]),
>+    takeWhile: dart.fnType(async.Stream$(T), [dart.fnType(core.bool, [T])]),
>+    skip: dart.fnType(async.Stream$(T), [core.int]),
>+    skipWhile: dart.fnType(async.Stream$(T), [dart.fnType(core.bool, [T])]),
>+    distinct: dart.fnType(async.Stream$(T), [], [dart.fnType(core.bool, [T, T])]),
>+    firstWhere: dart.fnType(async.Future$(T), [dart.fnType(core.bool, [T])], {orElse: core.Object}),
>+    lastWhere: dart.fnType(async.Future$(T), [dart.fnType(core.bool, [T])], {orElse: core.Object}),
>+    singleWhere: dart.fnType(async.Future$(T), [dart.fnType(core.bool, [T])], {orElse: core.Object}),
>+    elementAt: dart.fnType(async.Future$(T), [core.int]),
>+    timeout: dart.fnType(async.Stream$(T), [core.Duration], {onTimeout: dart.fnType(dart.void, [async.EventSink$(T)])})
>+  }));
>+  dart.setGetterSignature(Stream, () => ({
>+    __proto__: dart.getGetters(Stream.__proto__),
>+    isBroadcast: core.bool,
>+    length: async.Future$(core.int),
>+    isEmpty: async.Future$(core.bool),
>+    first: async.Future$(T),
>+    last: async.Future$(T),
>+    single: async.Future$(T)
>+  }));
>+  dart.setLibraryUri(Stream, "dart:async");
>+  return Stream;
>+});
>+async.Stream = async.Stream$();
>+dart.addTypeTests(async.Stream, dart.isStream);
>+const _is_CastStream_default = Symbol('_is_CastStream_default');
>+_internal.CastStream$ = dart.generic((S, T) => {
>+  let CastStreamSubscriptionOfS$T = () => (CastStreamSubscriptionOfS$T = dart.constFn(_internal.CastStreamSubscription$(S, T)))();
>+  let StreamOfS = () => (StreamOfS = dart.constFn(async.Stream$(S)))();
>+  class CastStream extends async.Stream$(T) {
>+    get isBroadcast() {
>+      return this[_source].isBroadcast;
>+    }
>+    listen(onData, opts) {
>+      let onError = opts && 'onError' in opts ? opts.onError : null;
>+      let onDone = opts && 'onDone' in opts ? opts.onDone : null;
>+      let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
>+      let _ = new (CastStreamSubscriptionOfS$T()).new(this[_source].listen(null, {onDone: onDone, cancelOnError: cancelOnError}));
>+      _.onData(onData);
>+      _.onError(onError);
>+      return _;
>+    }
>+    cast(R) {
>+      return new (_internal.CastStream$(S, R)).new(this[_source]);
>+    }
>+  }
>+  (CastStream.new = function(source) {
>+    this[_source] = source;
>+    CastStream.__proto__.new.call(this);
>+  }).prototype = CastStream.prototype;
>+  dart.addTypeTests(CastStream);
>+  CastStream.prototype[_is_CastStream_default] = true;
>+  dart.setMethodSignature(CastStream, () => ({
>+    __proto__: dart.getMethods(CastStream.__proto__),
>+    listen: dart.fnType(async.StreamSubscription$(T), [dart.fnType(dart.void, [T])], {onError: core.Function, onDone: dart.fnType(dart.void, []), cancelOnError: core.bool}),
>+    cast: dart.gFnType(R => [async.Stream$(R), []])
>+  }));
>+  dart.setGetterSignature(CastStream, () => ({
>+    __proto__: dart.getGetters(CastStream.__proto__),
>+    isBroadcast: core.bool
>+  }));
>+  dart.setLibraryUri(CastStream, "dart:_internal");
>+  dart.setFieldSignature(CastStream, () => ({
>+    __proto__: dart.getFields(CastStream.__proto__),
>+    [_source]: dart.finalFieldType(StreamOfS())
>+  }));
>+  return CastStream;
>+});
>+_internal.CastStream = _internal.CastStream$();
>+dart.addTypeTests(_internal.CastStream, _is_CastStream_default);
>+const _zone = dart.privateName(_internal, "_zone");
>+const _handleData = dart.privateName(_internal, "_handleData");
>+const _handleError = dart.privateName(_internal, "_handleError");
>+const _onData = dart.privateName(_internal, "_onData");
>+const _is_CastStreamSubscription_default = Symbol('_is_CastStreamSubscription_default');
>+_internal.CastStreamSubscription$ = dart.generic((S, T) => {
>+  let StreamSubscriptionOfS = () => (StreamSubscriptionOfS = dart.constFn(async.StreamSubscription$(S)))();
>+  let StreamSubscriptionOfT = () => (StreamSubscriptionOfT = dart.constFn(async.StreamSubscription$(T)))();
>+  let TTovoid = () => (TTovoid = dart.constFn(dart.fnType(dart.void, [T])))();
>+  class CastStreamSubscription extends core.Object {
>+    cancel() {
>+      return this[_source].cancel();
>+    }
>+    onData(handleData) {
>+      this[_handleData] = handleData == null ? null : this[_zone].registerUnaryCallback(dart.dynamic, T, handleData);
>+    }
>+    onError(handleError) {
>+      this[_source].onError(handleError);
>+      if (handleError == null) {
>+        this[_handleError] = null;
>+      } else if (NullAndNullTodynamic().is(handleError)) {
>+        this[_handleError] = this[_zone].registerBinaryCallback(dart.dynamic, core.Object, core.StackTrace, ObjectAndStackTraceTodynamic()._check(handleError));
>+      } else {
>+        this[_handleError] = this[_zone].registerUnaryCallback(dart.dynamic, core.Object, ObjectTodynamic()._check(handleError));
>+      }
>+    }
>+    onDone(handleDone) {
>+      this[_source].onDone(handleDone);
>+    }
>+    [_onData](data) {
>+      S._check(data);
>+      if (this[_handleData] == null) return;
>+      let targetData = null;
>+      try {
>+        targetData = T.as(data);
>+      } catch (e) {
>+        let error = dart.getThrown(e);
>+        let stack = dart.stackTrace(e);
>+        if (this[_handleError] == null) {
>+          this[_zone].handleUncaughtError(error, stack);
>+        } else if (NullAndNullTodynamic().is(this[_handleError])) {
>+          this[_zone].runBinaryGuarded(dart.dynamic, core.StackTrace, dynamicAndStackTraceTovoid()._check(this[_handleError]), error, stack);
>+        } else {
>+          this[_zone].runUnaryGuarded(dart.dynamic, dynamicTovoid()._check(this[_handleError]), error);
>+        }
>+        return;
>+      }
>+      this[_zone].runUnaryGuarded(T, this[_handleData], targetData);
>+    }
>+    pause(resumeSignal) {
>+      if (resumeSignal === void 0) resumeSignal = null;
>+      this[_source].pause(resumeSignal);
>+    }
>+    resume() {
>+      this[_source].resume();
>+    }
>+    get isPaused() {
>+      return this[_source].isPaused;
>+    }
>+    asFuture(E, futureValue) {
>+      if (futureValue === void 0) futureValue = null;
>+      return async.Future$(E)._check(this[_source].asFuture(E, futureValue));
>+    }
>+  }
>+  (CastStreamSubscription.new = function(source) {
>+    this[_zone] = async.Zone.current;
>+    this[_handleData] = null;
>+    this[_handleError] = null;
>+    this[_source] = source;
>+    this[_source].onData(dart.bind(this, _onData));
>+  }).prototype = CastStreamSubscription.prototype;
>+  CastStreamSubscription.prototype[dart.isStreamSubscription] = true;
>+  dart.addTypeTests(CastStreamSubscription);
>+  CastStreamSubscription.prototype[_is_CastStreamSubscription_default] = true;
>+  CastStreamSubscription[dart.implements] = () => [StreamSubscriptionOfT()];
>+  dart.setMethodSignature(CastStreamSubscription, () => ({
>+    __proto__: dart.getMethods(CastStreamSubscription.__proto__),
>+    cancel: dart.fnType(async.Future, []),
>+    onData: dart.fnType(dart.void, [dart.fnType(dart.void, [T])]),
>+    onError: dart.fnType(dart.void, [core.Function]),
>+    onDone: dart.fnType(dart.void, [dart.fnType(dart.void, [])]),
>+    [_onData]: dart.fnType(dart.void, [core.Object]),
>+    pause: dart.fnType(dart.void, [], [async.Future]),
>+    resume: dart.fnType(dart.void, []),
>+    asFuture: dart.gFnType(E => [async.Future$(E), [], [E]])
>+  }));
>+  dart.setGetterSignature(CastStreamSubscription, () => ({
>+    __proto__: dart.getGetters(CastStreamSubscription.__proto__),
>+    isPaused: core.bool
>+  }));
>+  dart.setLibraryUri(CastStreamSubscription, "dart:_internal");
>+  dart.setFieldSignature(CastStreamSubscription, () => ({
>+    __proto__: dart.getFields(CastStreamSubscription.__proto__),
>+    [_source]: dart.finalFieldType(StreamSubscriptionOfS()),
>+    [_zone]: dart.finalFieldType(async.Zone),
>+    [_handleData]: dart.fieldType(TTovoid()),
>+    [_handleError]: dart.fieldType(core.Function)
>+  }));
>+  return CastStreamSubscription;
>+});
>+_internal.CastStreamSubscription = _internal.CastStreamSubscription$();
>+dart.addTypeTests(_internal.CastStreamSubscription, _is_CastStreamSubscription_default);
>+const _is_StreamTransformerBase_default = Symbol('_is_StreamTransformerBase_default');
>+async.StreamTransformerBase$ = dart.generic((S, T) => {
>+  let StreamTransformerOfS$T = () => (StreamTransformerOfS$T = dart.constFn(async.StreamTransformer$(S, T)))();
>+  class StreamTransformerBase extends core.Object {
>+    cast(RS, RT) {
>+      return async.StreamTransformer.castFrom(S, T, RS, RT, this);
>+    }
>+  }
>+  (StreamTransformerBase.new = function() {
>+  }).prototype = StreamTransformerBase.prototype;
>+  dart.addTypeTests(StreamTransformerBase);
>+  StreamTransformerBase.prototype[_is_StreamTransformerBase_default] = true;
>+  StreamTransformerBase[dart.implements] = () => [StreamTransformerOfS$T()];
>+  dart.setMethodSignature(StreamTransformerBase, () => ({
>+    __proto__: dart.getMethods(StreamTransformerBase.__proto__),
>+    cast: dart.gFnType((RS, RT) => [async.StreamTransformer$(RS, RT), []])
>+  }));
>+  dart.setLibraryUri(StreamTransformerBase, "dart:async");
>+  return StreamTransformerBase;
>+});
>+async.StreamTransformerBase = async.StreamTransformerBase$();
>+dart.addTypeTests(async.StreamTransformerBase, _is_StreamTransformerBase_default);
>+const _is_CastStreamTransformer_default = Symbol('_is_CastStreamTransformer_default');
>+_internal.CastStreamTransformer$ = dart.generic((SS, ST, TS, TT) => {
>+  let StreamOfSS = () => (StreamOfSS = dart.constFn(async.Stream$(SS)))();
>+  let StreamTransformerOfSS$ST = () => (StreamTransformerOfSS$ST = dart.constFn(async.StreamTransformer$(SS, ST)))();
>+  let StreamOfTS = () => (StreamOfTS = dart.constFn(async.Stream$(TS)))();
>+  let StreamOfTT = () => (StreamOfTT = dart.constFn(async.Stream$(TT)))();
>+  class CastStreamTransformer extends async.StreamTransformerBase$(TS, TT) {
>+    cast(RS, RT) {
>+      return new (_internal.CastStreamTransformer$(SS, ST, RS, RT)).new(this[_source]);
>+    }
>+    bind(stream) {
>+      StreamOfTS()._check(stream);
>+      return StreamOfTT()._check(this[_source].bind(StreamOfSS()._check(stream.cast(SS))).cast(TT));
>+    }
>+  }
>+  (CastStreamTransformer.new = function(source) {
>+    this[_source] = source;
>+    CastStreamTransformer.__proto__.new.call(this);
>+  }).prototype = CastStreamTransformer.prototype;
>+  dart.addTypeTests(CastStreamTransformer);
>+  CastStreamTransformer.prototype[_is_CastStreamTransformer_default] = true;
>+  dart.setMethodSignature(CastStreamTransformer, () => ({
>+    __proto__: dart.getMethods(CastStreamTransformer.__proto__),
>+    cast: dart.gFnType((RS, RT) => [async.StreamTransformer$(RS, RT), []]),
>+    bind: dart.fnType(async.Stream$(TT), [core.Object])
>+  }));
>+  dart.setLibraryUri(CastStreamTransformer, "dart:_internal");
>+  dart.setFieldSignature(CastStreamTransformer, () => ({
>+    __proto__: dart.getFields(CastStreamTransformer.__proto__),
>+    [_source]: dart.finalFieldType(StreamTransformerOfSS$ST())
>+  }));
>+  return CastStreamTransformer;
>+});
>+_internal.CastStreamTransformer = _internal.CastStreamTransformer$();
>+dart.addTypeTests(_internal.CastStreamTransformer, _is_CastStreamTransformer_default);
>+const _is_Converter_default = Symbol('_is_Converter_default');
>+convert.Converter$ = dart.generic((S, T) => {
>+  let StreamOfS = () => (StreamOfS = dart.constFn(async.Stream$(S)))();
>+  let SinkOfT = () => (SinkOfT = dart.constFn(core.Sink$(T)))();
>+  let StreamOfT = () => (StreamOfT = dart.constFn(async.Stream$(T)))();
>+  class Converter extends async.StreamTransformerBase$(S, T) {
>+    static castFrom(SS, ST, TS, TT, source) {
>+      return new (_internal.CastConverter$(SS, ST, TS, TT)).new(source);
>+    }
>+    fuse(TT, other) {
>+      convert.Converter$(T, TT)._check(other);
>+      return new (convert._FusedConverter$(S, T, TT)).new(this, other);
>+    }
>+    startChunkedConversion(sink) {
>+      SinkOfT()._check(sink);
>+      dart.throw(new core.UnsupportedError.new("This converter does not support chunked conversions: " + dart.str(this)));
>+    }
>+    bind(stream) {
>+      StreamOfS()._check(stream);
>+      return StreamOfT().eventTransformed(stream, dart.fn(sink => new convert._ConverterStreamEventSink.new(this, sink), EventSinkTo_ConverterStreamEventSink()));
>+    }
>+    cast(RS, RT) {
>+      return convert.Converter.castFrom(S, T, RS, RT, this);
>+    }
>+  }
>+  (Converter.new = function() {
>+    Converter.__proto__.new.call(this);
>+  }).prototype = Converter.prototype;
>+  dart.addTypeTests(Converter);
>+  Converter.prototype[_is_Converter_default] = true;
>+  dart.setMethodSignature(Converter, () => ({
>+    __proto__: dart.getMethods(Converter.__proto__),
>+    fuse: dart.gFnType(TT => [convert.Converter$(S, TT), [core.Object]]),
>+    startChunkedConversion: dart.fnType(core.Sink$(S), [core.Object]),
>+    bind: dart.fnType(async.Stream$(T), [core.Object]),
>+    cast: dart.gFnType((RS, RT) => [convert.Converter$(RS, RT), []])
>+  }));
>+  dart.setLibraryUri(Converter, "dart:convert");
>+  return Converter;
>+});
>+convert.Converter = convert.Converter$();
>+dart.addTypeTests(convert.Converter, _is_Converter_default);
>+const _is_CastConverter_default = Symbol('_is_CastConverter_default');
>+_internal.CastConverter$ = dart.generic((SS, ST, TS, TT) => {
>+  let StreamOfSS = () => (StreamOfSS = dart.constFn(async.Stream$(SS)))();
>+  let ConverterOfSS$ST = () => (ConverterOfSS$ST = dart.constFn(convert.Converter$(SS, ST)))();
>+  let StreamOfTS = () => (StreamOfTS = dart.constFn(async.Stream$(TS)))();
>+  let StreamOfTT = () => (StreamOfTT = dart.constFn(async.Stream$(TT)))();
>+  class CastConverter extends convert.Converter$(TS, TT) {
>+    convert(input) {
>+      TS._check(input);
>+      return TT.as(this[_source].convert(SS.as(input)));
>+    }
>+    bind(stream) {
>+      StreamOfTS()._check(stream);
>+      return StreamOfTT()._check(this[_source].bind(StreamOfSS()._check(stream.cast(SS))).cast(TT));
>+    }
>+    cast(RS, RT) {
>+      return new (_internal.CastConverter$(SS, ST, RS, RT)).new(this[_source]);
>+    }
>+  }
>+  (CastConverter.new = function(source) {
>+    this[_source] = source;
>+    CastConverter.__proto__.new.call(this);
>+  }).prototype = CastConverter.prototype;
>+  dart.addTypeTests(CastConverter);
>+  CastConverter.prototype[_is_CastConverter_default] = true;
>+  dart.setMethodSignature(CastConverter, () => ({
>+    __proto__: dart.getMethods(CastConverter.__proto__),
>+    convert: dart.fnType(TT, [core.Object]),
>+    bind: dart.fnType(async.Stream$(TT), [core.Object]),
>+    cast: dart.gFnType((RS, RT) => [convert.Converter$(RS, RT), []])
>+  }));
>+  dart.setLibraryUri(CastConverter, "dart:_internal");
>+  dart.setFieldSignature(CastConverter, () => ({
>+    __proto__: dart.getFields(CastConverter.__proto__),
>+    [_source]: dart.finalFieldType(ConverterOfSS$ST())
>+  }));
>+  return CastConverter;
>+});
>+_internal.CastConverter = _internal.CastConverter$();
>+dart.addTypeTests(_internal.CastConverter, _is_CastConverter_default);
>+core.Iterable$ = dart.generic(E => {
>+  let EmptyIterableOfE = () => (EmptyIterableOfE = dart.constFn(_internal.EmptyIterable$(E)))();
>+  let _GeneratorIterableOfE = () => (_GeneratorIterableOfE = dart.constFn(core._GeneratorIterable$(E)))();
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  let EfficientLengthIterableOfE = () => (EfficientLengthIterableOfE = dart.constFn(_internal.EfficientLengthIterable$(E)))();
>+  let FollowedByIterableOfE = () => (FollowedByIterableOfE = dart.constFn(_internal.FollowedByIterable$(E)))();
>+  let WhereIterableOfE = () => (WhereIterableOfE = dart.constFn(_internal.WhereIterable$(E)))();
>+  let EAndEToE = () => (EAndEToE = dart.constFn(dart.fnType(E, [E, E])))();
>+  let ListOfE = () => (ListOfE = dart.constFn(core.List$(E)))();
>+  let SetOfE = () => (SetOfE = dart.constFn(core.Set$(E)))();
>+  let TakeIterableOfE = () => (TakeIterableOfE = dart.constFn(_internal.TakeIterable$(E)))();
>+  let TakeWhileIterableOfE = () => (TakeWhileIterableOfE = dart.constFn(_internal.TakeWhileIterable$(E)))();
>+  let SkipIterableOfE = () => (SkipIterableOfE = dart.constFn(_internal.SkipIterable$(E)))();
>+  let SkipWhileIterableOfE = () => (SkipWhileIterableOfE = dart.constFn(_internal.SkipWhileIterable$(E)))();
>+  let VoidToE = () => (VoidToE = dart.constFn(dart.fnType(E, [])))();
>+  class Iterable extends core.Object {
>+    static generate(count, generator) {
>+      if (generator === void 0) generator = null;
>+      if (dart.notNull(count) <= 0) return new (EmptyIterableOfE()).new();
>+      return new (_GeneratorIterableOfE()).new(count, generator);
>+    }
>+    static empty() {
>+      return new (EmptyIterableOfE()).new();
>+    }
>+    static castFrom(S, T, source) {
>+      return _internal.CastIterable$(S, T).new(source);
>+    }
>+    [Symbol.iterator]() {
>+      return new dart.JsIterator(this[$iterator]);
>+    }
>+    cast(R) {
>+      return core.Iterable.castFrom(E, R, this);
>+    }
>+    followedBy(other) {
>+      IterableOfE()._check(other);
>+      if (EfficientLengthIterableOfE().is(this)) {
>+        return FollowedByIterableOfE().firstEfficient(EfficientLengthIterableOfE()._check(this), other);
>+      }
>+      return new (FollowedByIterableOfE()).new(this, other);
>+    }
>+    map(T, f) {
>+      return _internal.MappedIterable$(E, T).new(this, f);
>+    }
>+    where(test) {
>+      return new (WhereIterableOfE()).new(this, test);
>+    }
>+    whereType(T) {
>+      return new (_internal.WhereTypeIterable$(T)).new(this);
>+    }
>+    expand(T, f) {
>+      return new (_internal.ExpandIterable$(E, T)).new(this, f);
>+    }
>+    contains(element) {
>+      for (let e of this) {
>+        if (dart.equals(e, element)) return true;
>+      }
>+      return false;
>+    }
>+    forEach(f) {
>+      for (let element of this)
>+        f(element);
>+    }
>+    reduce(combine) {
>+      EAndEToE()._check(combine);
>+      let iterator = this[$iterator];
>+      if (!dart.test(iterator.moveNext())) {
>+        dart.throw(_internal.IterableElementError.noElement());
>+      }
>+      let value = iterator.current;
>+      while (dart.test(iterator.moveNext())) {
>+        value = combine(value, iterator.current);
>+      }
>+      return value;
>+    }
>+    fold(T, initialValue, combine) {
>+      let value = initialValue;
>+      for (let element of this)
>+        value = combine(value, element);
>+      return value;
>+    }
>+    every(test) {
>+      for (let element of this) {
>+        if (!dart.test(test(element))) return false;
>+      }
>+      return true;
>+    }
>+    join(separator) {
>+      if (separator === void 0) separator = "";
>+      let iterator = this[$iterator];
>+      if (!dart.test(iterator.moveNext())) return "";
>+      let buffer = new core.StringBuffer.new();
>+      if (separator == null || separator === "") {
>+        do {
>+          buffer.write(dart.str(iterator.current));
>+        } while (dart.test(iterator.moveNext()));
>+      } else {
>+        buffer.write(dart.str(iterator.current));
>+        while (dart.test(iterator.moveNext())) {
>+          buffer.write(separator);
>+          buffer.write(dart.str(iterator.current));
>+        }
>+      }
>+      return buffer.toString();
>+    }
>+    any(test) {
>+      for (let element of this) {
>+        if (dart.test(test(element))) return true;
>+      }
>+      return false;
>+    }
>+    toList(opts) {
>+      let growable = opts && 'growable' in opts ? opts.growable : true;
>+      return ListOfE().from(this, {growable: growable});
>+    }
>+    toSet() {
>+      return SetOfE().from(this);
>+    }
>+    get length() {
>+      if (!!_internal.EfficientLengthIterable.is(this)) dart.assertFailed(null, "dart:core/iterable.dart", 420, 12, "this is! EfficientLengthIterable");
>+      let count = 0;
>+      let it = this[$iterator];
>+      while (dart.test(it.moveNext())) {
>+        count++;
>+      }
>+      return count;
>+    }
>+    get isEmpty() {
>+      return !dart.test(this[$iterator].moveNext());
>+    }
>+    get isNotEmpty() {
>+      return !dart.test(this[$isEmpty]);
>+    }
>+    take(count) {
>+      return TakeIterableOfE().new(this, count);
>+    }
>+    takeWhile(test) {
>+      return new (TakeWhileIterableOfE()).new(this, test);
>+    }
>+    skip(count) {
>+      return SkipIterableOfE().new(this, count);
>+    }
>+    skipWhile(test) {
>+      return new (SkipWhileIterableOfE()).new(this, test);
>+    }
>+    get first() {
>+      let it = this[$iterator];
>+      if (!dart.test(it.moveNext())) {
>+        dart.throw(_internal.IterableElementError.noElement());
>+      }
>+      return it.current;
>+    }
>+    get last() {
>+      let it = this[$iterator];
>+      if (!dart.test(it.moveNext())) {
>+        dart.throw(_internal.IterableElementError.noElement());
>+      }
>+      let result = null;
>+      do {
>+        result = it.current;
>+      } while (dart.test(it.moveNext()));
>+      return result;
>+    }
>+    get single() {
>+      let it = this[$iterator];
>+      if (!dart.test(it.moveNext())) dart.throw(_internal.IterableElementError.noElement());
>+      let result = it.current;
>+      if (dart.test(it.moveNext())) dart.throw(_internal.IterableElementError.tooMany());
>+      return result;
>+    }
>+    firstWhere(test, opts) {
>+      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+      VoidToE()._check(orElse);
>+      for (let element of this) {
>+        if (dart.test(test(element))) return element;
>+      }
>+      if (orElse != null) return orElse();
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    lastWhere(test, opts) {
>+      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+      VoidToE()._check(orElse);
>+      let result = null;
>+      let foundMatching = false;
>+      for (let element of this) {
>+        if (dart.test(test(element))) {
>+          result = element;
>+          foundMatching = true;
>+        }
>+      }
>+      if (foundMatching) return result;
>+      if (orElse != null) return orElse();
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    singleWhere(test, opts) {
>+      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+      VoidToE()._check(orElse);
>+      let result = null;
>+      let foundMatching = false;
>+      for (let element of this) {
>+        if (dart.test(test(element))) {
>+          if (foundMatching) {
>+            dart.throw(_internal.IterableElementError.tooMany());
>+          }
>+          result = element;
>+          foundMatching = true;
>+        }
>+      }
>+      if (foundMatching) return result;
>+      if (orElse != null) return orElse();
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    elementAt(index) {
>+      core.ArgumentError.checkNotNull(index, "index");
>+      core.RangeError.checkNotNegative(index, "index");
>+      let elementIndex = 0;
>+      for (let element of this) {
>+        if (index === elementIndex) return element;
>+        elementIndex++;
>+      }
>+      dart.throw(core.RangeError.index(index, this, "index", null, elementIndex));
>+    }
>+    toString() {
>+      return collection.IterableBase.iterableToShortString(this, "(", ")");
>+    }
>+  }
>+  (Iterable.new = function() {
>+  }).prototype = Iterable.prototype;
>+  dart.addTypeTests(Iterable);
>+  Iterable.prototype[dart.isIterable] = true;
>+  dart.setMethodSignature(Iterable, () => ({
>+    __proto__: dart.getMethods(Iterable.__proto__),
>+    cast: dart.gFnType(R => [core.Iterable$(R), []]),
>+    [$cast]: dart.gFnType(R => [core.Iterable$(R), []]),
>+    followedBy: dart.fnType(core.Iterable$(E), [core.Object]),
>+    [$followedBy]: dart.fnType(core.Iterable$(E), [core.Object]),
>+    map: dart.gFnType(T => [core.Iterable$(T), [dart.fnType(T, [E])]]),
>+    [$map]: dart.gFnType(T => [core.Iterable$(T), [dart.fnType(T, [E])]]),
>+    where: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    [$where]: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    whereType: dart.gFnType(T => [core.Iterable$(T), []]),
>+    [$whereType]: dart.gFnType(T => [core.Iterable$(T), []]),
>+    expand: dart.gFnType(T => [core.Iterable$(T), [dart.fnType(core.Iterable$(T), [E])]]),
>+    [$expand]: dart.gFnType(T => [core.Iterable$(T), [dart.fnType(core.Iterable$(T), [E])]]),
>+    contains: dart.fnType(core.bool, [core.Object]),
>+    [$contains]: dart.fnType(core.bool, [core.Object]),
>+    forEach: dart.fnType(dart.void, [dart.fnType(dart.void, [E])]),
>+    [$forEach]: dart.fnType(dart.void, [dart.fnType(dart.void, [E])]),
>+    reduce: dart.fnType(E, [core.Object]),
>+    [$reduce]: dart.fnType(E, [core.Object]),
>+    fold: dart.gFnType(T => [T, [T, dart.fnType(T, [T, E])]]),
>+    [$fold]: dart.gFnType(T => [T, [T, dart.fnType(T, [T, E])]]),
>+    every: dart.fnType(core.bool, [dart.fnType(core.bool, [E])]),
>+    [$every]: dart.fnType(core.bool, [dart.fnType(core.bool, [E])]),
>+    join: dart.fnType(core.String, [], [core.String]),
>+    [$join]: dart.fnType(core.String, [], [core.String]),
>+    any: dart.fnType(core.bool, [dart.fnType(core.bool, [E])]),
>+    [$any]: dart.fnType(core.bool, [dart.fnType(core.bool, [E])]),
>+    toList: dart.fnType(core.List$(E), [], {growable: core.bool}),
>+    [$toList]: dart.fnType(core.List$(E), [], {growable: core.bool}),
>+    toSet: dart.fnType(core.Set$(E), []),
>+    [$toSet]: dart.fnType(core.Set$(E), []),
>+    take: dart.fnType(core.Iterable$(E), [core.int]),
>+    [$take]: dart.fnType(core.Iterable$(E), [core.int]),
>+    takeWhile: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    [$takeWhile]: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    skip: dart.fnType(core.Iterable$(E), [core.int]),
>+    [$skip]: dart.fnType(core.Iterable$(E), [core.int]),
>+    skipWhile: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    [$skipWhile]: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    firstWhere: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    [$firstWhere]: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    lastWhere: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    [$lastWhere]: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    singleWhere: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    [$singleWhere]: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    elementAt: dart.fnType(E, [core.int]),
>+    [$elementAt]: dart.fnType(E, [core.int]),
>+    toString: dart.fnType(core.String, []),
>+    [$toString]: dart.fnType(core.String, [])
>+  }));
>+  dart.setGetterSignature(Iterable, () => ({
>+    __proto__: dart.getGetters(Iterable.__proto__),
>+    length: core.int,
>+    [$length]: core.int,
>+    isEmpty: core.bool,
>+    [$isEmpty]: core.bool,
>+    isNotEmpty: core.bool,
>+    [$isNotEmpty]: core.bool,
>+    first: E,
>+    [$first]: E,
>+    last: E,
>+    [$last]: E,
>+    single: E,
>+    [$single]: E
>+  }));
>+  dart.setLibraryUri(Iterable, "dart:core");
>+  dart.defineExtensionMethods(Iterable, [
>+    'cast',
>+    'followedBy',
>+    'map',
>+    'where',
>+    'whereType',
>+    'expand',
>+    'contains',
>+    'forEach',
>+    'reduce',
>+    'fold',
>+    'every',
>+    'join',
>+    'any',
>+    'toList',
>+    'toSet',
>+    'take',
>+    'takeWhile',
>+    'skip',
>+    'skipWhile',
>+    'firstWhere',
>+    'lastWhere',
>+    'singleWhere',
>+    'elementAt',
>+    'toString'
>+  ]);
>+  dart.defineExtensionAccessors(Iterable, [
>+    'length',
>+    'isEmpty',
>+    'isNotEmpty',
>+    'first',
>+    'last',
>+    'single'
>+  ]);
>+  return Iterable;
>+});
>+core.Iterable = core.Iterable$();
>+dart.addTypeTests(core.Iterable, dart.isIterable);
>+const _is__CastIterableBase_default = Symbol('_is__CastIterableBase_default');
>+_internal._CastIterableBase$ = dart.generic((S, T) => {
>+  let CastIteratorOfS$T = () => (CastIteratorOfS$T = dart.constFn(_internal.CastIterator$(S, T)))();
>+  let CastIterableOfS$T = () => (CastIterableOfS$T = dart.constFn(_internal.CastIterable$(S, T)))();
>+  let STobool = () => (STobool = dart.constFn(dart.fnType(core.bool, [S])))();
>+  let VoidToS = () => (VoidToS = dart.constFn(dart.fnType(S, [])))();
>+  let VoidToT = () => (VoidToT = dart.constFn(dart.fnType(T, [])))();
>+  class _CastIterableBase extends core.Iterable$(T) {
>+    get iterator() {
>+      return new (CastIteratorOfS$T()).new(this[_source][$iterator]);
>+    }
>+    get length() {
>+      return this[_source][$length];
>+    }
>+    get isEmpty() {
>+      return this[_source][$isEmpty];
>+    }
>+    get isNotEmpty() {
>+      return this[_source][$isNotEmpty];
>+    }
>+    skip(count) {
>+      return CastIterableOfS$T().new(this[_source][$skip](count));
>+    }
>+    take(count) {
>+      return CastIterableOfS$T().new(this[_source][$take](count));
>+    }
>+    elementAt(index) {
>+      return T.as(this[_source][$elementAt](index));
>+    }
>+    get first() {
>+      return T.as(this[_source][$first]);
>+    }
>+    get last() {
>+      return T.as(this[_source][$last]);
>+    }
>+    get single() {
>+      return T.as(this[_source][$single]);
>+    }
>+    contains(other) {
>+      return this[_source][$contains](other);
>+    }
>+    lastWhere(test, opts) {
>+      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+      VoidToT()._check(orElse);
>+      return T.as(this[_source][$lastWhere](dart.fn(element => test(T.as(element)), STobool()), {orElse: orElse == null ? null : dart.fn(() => S.as(orElse()), VoidToS())}));
>+    }
>+    toString() {
>+      return dart.toString(this[_source]);
>+    }
>+  }
>+  (_CastIterableBase.new = function() {
>+    _CastIterableBase.__proto__.new.call(this);
>+  }).prototype = _CastIterableBase.prototype;
>+  dart.addTypeTests(_CastIterableBase);
>+  _CastIterableBase.prototype[_is__CastIterableBase_default] = true;
>+  dart.setMethodSignature(_CastIterableBase, () => ({
>+    __proto__: dart.getMethods(_CastIterableBase.__proto__),
>+    skip: dart.fnType(core.Iterable$(T), [core.int]),
>+    [$skip]: dart.fnType(core.Iterable$(T), [core.int]),
>+    take: dart.fnType(core.Iterable$(T), [core.int]),
>+    [$take]: dart.fnType(core.Iterable$(T), [core.int]),
>+    elementAt: dart.fnType(T, [core.int]),
>+    [$elementAt]: dart.fnType(T, [core.int]),
>+    contains: dart.fnType(core.bool, [core.Object]),
>+    [$contains]: dart.fnType(core.bool, [core.Object]),
>+    lastWhere: dart.fnType(T, [dart.fnType(core.bool, [T])], {orElse: core.Object}),
>+    [$lastWhere]: dart.fnType(T, [dart.fnType(core.bool, [T])], {orElse: core.Object}),
>+    toString: dart.fnType(core.String, []),
>+    [$toString]: dart.fnType(core.String, [])
>+  }));
>+  dart.setGetterSignature(_CastIterableBase, () => ({
>+    __proto__: dart.getGetters(_CastIterableBase.__proto__),
>+    iterator: core.Iterator$(T),
>+    [$iterator]: core.Iterator$(T),
>+    length: core.int,
>+    [$length]: core.int,
>+    isEmpty: core.bool,
>+    [$isEmpty]: core.bool,
>+    isNotEmpty: core.bool,
>+    [$isNotEmpty]: core.bool,
>+    first: T,
>+    [$first]: T,
>+    last: T,
>+    [$last]: T,
>+    single: T,
>+    [$single]: T
>+  }));
>+  dart.setLibraryUri(_CastIterableBase, "dart:_internal");
>+  dart.defineExtensionMethods(_CastIterableBase, [
>+    'skip',
>+    'take',
>+    'elementAt',
>+    'contains',
>+    'lastWhere',
>+    'toString'
>+  ]);
>+  dart.defineExtensionAccessors(_CastIterableBase, [
>+    'iterator',
>+    'length',
>+    'isEmpty',
>+    'isNotEmpty',
>+    'first',
>+    'last',
>+    'single'
>+  ]);
>+  return _CastIterableBase;
>+});
>+_internal._CastIterableBase = _internal._CastIterableBase$();
>+dart.addTypeTests(_internal._CastIterableBase, _is__CastIterableBase_default);
>+const _is_CastIterator_default = Symbol('_is_CastIterator_default');
>+_internal.CastIterator$ = dart.generic((S, T) => {
>+  let IteratorOfS = () => (IteratorOfS = dart.constFn(core.Iterator$(S)))();
>+  let IteratorOfT = () => (IteratorOfT = dart.constFn(core.Iterator$(T)))();
>+  class CastIterator extends core.Object {
>+    moveNext() {
>+      return this[_source].moveNext();
>+    }
>+    get current() {
>+      return T.as(this[_source].current);
>+    }
>+  }
>+  (CastIterator.new = function(source) {
>+    this[_source] = source;
>+  }).prototype = CastIterator.prototype;
>+  dart.addTypeTests(CastIterator);
>+  CastIterator.prototype[_is_CastIterator_default] = true;
>+  CastIterator[dart.implements] = () => [IteratorOfT()];
>+  dart.setMethodSignature(CastIterator, () => ({
>+    __proto__: dart.getMethods(CastIterator.__proto__),
>+    moveNext: dart.fnType(core.bool, [])
>+  }));
>+  dart.setGetterSignature(CastIterator, () => ({
>+    __proto__: dart.getGetters(CastIterator.__proto__),
>+    current: T
>+  }));
>+  dart.setLibraryUri(CastIterator, "dart:_internal");
>+  dart.setFieldSignature(CastIterator, () => ({
>+    __proto__: dart.getFields(CastIterator.__proto__),
>+    [_source]: dart.fieldType(IteratorOfS())
>+  }));
>+  return CastIterator;
>+});
>+_internal.CastIterator = _internal.CastIterator$();
>+dart.addTypeTests(_internal.CastIterator, _is_CastIterator_default);
>+const _is_CastIterable_default = Symbol('_is_CastIterable_default');
>+_internal.CastIterable$ = dart.generic((S, T) => {
>+  let EfficientLengthIterableOfS = () => (EfficientLengthIterableOfS = dart.constFn(_internal.EfficientLengthIterable$(S)))();
>+  let _EfficientLengthCastIterableOfS$T = () => (_EfficientLengthCastIterableOfS$T = dart.constFn(_internal._EfficientLengthCastIterable$(S, T)))();
>+  let CastIterableOfS$T = () => (CastIterableOfS$T = dart.constFn(_internal.CastIterable$(S, T)))();
>+  let IterableOfS = () => (IterableOfS = dart.constFn(core.Iterable$(S)))();
>+  class CastIterable extends _internal._CastIterableBase$(S, T) {
>+    static new(source) {
>+      if (EfficientLengthIterableOfS().is(source)) {
>+        return new (_EfficientLengthCastIterableOfS$T()).new(source);
>+      }
>+      return new (CastIterableOfS$T()).__(source);
>+    }
>+    cast(R) {
>+      return _internal.CastIterable$(S, R).new(this[_source]);
>+    }
>+  }
>+  (CastIterable.__ = function(source) {
>+    this[_source] = source;
>+    CastIterable.__proto__.new.call(this);
>+  }).prototype = CastIterable.prototype;
>+  dart.addTypeTests(CastIterable);
>+  CastIterable.prototype[_is_CastIterable_default] = true;
>+  dart.setMethodSignature(CastIterable, () => ({
>+    __proto__: dart.getMethods(CastIterable.__proto__),
>+    cast: dart.gFnType(R => [core.Iterable$(R), []]),
>+    [$cast]: dart.gFnType(R => [core.Iterable$(R), []])
>+  }));
>+  dart.setLibraryUri(CastIterable, "dart:_internal");
>+  dart.setFieldSignature(CastIterable, () => ({
>+    __proto__: dart.getFields(CastIterable.__proto__),
>+    [_source]: dart.finalFieldType(IterableOfS())
>+  }));
>+  dart.defineExtensionMethods(CastIterable, ['cast']);
>+  return CastIterable;
>+});
>+_internal.CastIterable = _internal.CastIterable$();
>+dart.addTypeTests(_internal.CastIterable, _is_CastIterable_default);
>+const _is__EfficientLengthCastIterable_default = Symbol('_is__EfficientLengthCastIterable_default');
>+_internal._EfficientLengthCastIterable$ = dart.generic((S, T) => {
>+  let EfficientLengthIterableOfT = () => (EfficientLengthIterableOfT = dart.constFn(_internal.EfficientLengthIterable$(T)))();
>+  class _EfficientLengthCastIterable extends _internal.CastIterable$(S, T) {}
>+  (_EfficientLengthCastIterable.new = function(source) {
>+    _EfficientLengthCastIterable.__proto__.__.call(this, source);
>+  }).prototype = _EfficientLengthCastIterable.prototype;
>+  dart.addTypeTests(_EfficientLengthCastIterable);
>+  _EfficientLengthCastIterable.prototype[_is__EfficientLengthCastIterable_default] = true;
>+  _EfficientLengthCastIterable[dart.implements] = () => [EfficientLengthIterableOfT()];
>+  dart.setLibraryUri(_EfficientLengthCastIterable, "dart:_internal");
>+  return _EfficientLengthCastIterable;
>+});
>+_internal._EfficientLengthCastIterable = _internal._EfficientLengthCastIterable$();
>+dart.addTypeTests(_internal._EfficientLengthCastIterable, _is__EfficientLengthCastIterable_default);
>+const _is__CastListBase_default = Symbol('_is__CastListBase_default');
>+_internal._CastListBase$ = dart.generic((S, T) => {
>+  let CastIterableOfT$S = () => (CastIterableOfT$S = dart.constFn(_internal.CastIterable$(T, S)))();
>+  let SAndSToint = () => (SAndSToint = dart.constFn(dart.fnType(core.int, [S, S])))();
>+  let STobool = () => (STobool = dart.constFn(dart.fnType(core.bool, [S])))();
>+  let CastIterableOfS$T = () => (CastIterableOfS$T = dart.constFn(_internal.CastIterable$(S, T)))();
>+  let IterableOfT = () => (IterableOfT = dart.constFn(core.Iterable$(T)))();
>+  const _CastIterableBase_ListMixin$ = class _CastIterableBase_ListMixin extends _internal._CastIterableBase$(S, T) {};
>+  (_CastIterableBase_ListMixin$.new = function() {
>+    _CastIterableBase_ListMixin$.__proto__.new.call(this);
>+  }).prototype = _CastIterableBase_ListMixin$.prototype;
>+  dart.applyMixin(_CastIterableBase_ListMixin$, collection.ListMixin$(T));
>+  class _CastListBase extends _CastIterableBase_ListMixin$ {
>+    _get(index) {
>+      return T.as(this[_source][$_get](index));
>+    }
>+    _set(index, value) {
>+      T._check(value);
>+      this[_source][$_set](index, S.as(value));
>+      return value;
>+    }
>+    set length(length) {
>+      this[_source][$length] = length;
>+    }
>+    get length() {
>+      return super.length;
>+    }
>+    add(value) {
>+      T._check(value);
>+      this[_source][$add](S.as(value));
>+    }
>+    addAll(values) {
>+      IterableOfT()._check(values);
>+      this[_source][$addAll](CastIterableOfT$S().new(values));
>+    }
>+    sort(compare) {
>+      if (compare === void 0) compare = null;
>+      this[_source][$sort](compare == null ? null : dart.fn((v1, v2) => compare(T.as(v1), T.as(v2)), SAndSToint()));
>+    }
>+    shuffle(random) {
>+      if (random === void 0) random = null;
>+      this[_source][$shuffle](random);
>+    }
>+    insert(index, element) {
>+      T._check(element);
>+      this[_source][$insert](index, S.as(element));
>+    }
>+    insertAll(index, elements) {
>+      IterableOfT()._check(elements);
>+      this[_source][$insertAll](index, CastIterableOfT$S().new(elements));
>+    }
>+    setAll(index, elements) {
>+      IterableOfT()._check(elements);
>+      this[_source][$setAll](index, CastIterableOfT$S().new(elements));
>+    }
>+    remove(value) {
>+      return this[_source][$remove](value);
>+    }
>+    removeAt(index) {
>+      return T.as(this[_source][$removeAt](index));
>+    }
>+    removeLast() {
>+      return T.as(this[_source][$removeLast]());
>+    }
>+    removeWhere(test) {
>+      this[_source][$removeWhere](dart.fn(element => test(T.as(element)), STobool()));
>+    }
>+    retainWhere(test) {
>+      this[_source][$retainWhere](dart.fn(element => test(T.as(element)), STobool()));
>+    }
>+    getRange(start, end) {
>+      return CastIterableOfS$T().new(this[_source][$getRange](start, end));
>+    }
>+    setRange(start, end, iterable, skipCount) {
>+      IterableOfT()._check(iterable);
>+      if (skipCount === void 0) skipCount = 0;
>+      this[_source][$setRange](start, end, CastIterableOfT$S().new(iterable), skipCount);
>+    }
>+    removeRange(start, end) {
>+      this[_source][$removeRange](start, end);
>+    }
>+    fillRange(start, end, fillValue) {
>+      if (fillValue === void 0) fillValue = null;
>+      T._check(fillValue);
>+      this[_source][$fillRange](start, end, S.as(fillValue));
>+    }
>+    replaceRange(start, end, replacement) {
>+      IterableOfT()._check(replacement);
>+      this[_source][$replaceRange](start, end, CastIterableOfT$S().new(replacement));
>+    }
>+  }
>+  (_CastListBase.new = function() {
>+    _CastListBase.__proto__.new.call(this);
>+  }).prototype = _CastListBase.prototype;
>+  dart.addTypeTests(_CastListBase);
>+  _CastListBase.prototype[_is__CastListBase_default] = true;
>+  dart.setMethodSignature(_CastListBase, () => ({
>+    __proto__: dart.getMethods(_CastListBase.__proto__),
>+    _get: dart.fnType(T, [core.int]),
>+    [$_get]: dart.fnType(T, [core.int]),
>+    _set: dart.fnType(dart.void, [core.int, core.Object]),
>+    [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+    add: dart.fnType(dart.void, [core.Object]),
>+    [$add]: dart.fnType(dart.void, [core.Object]),
>+    addAll: dart.fnType(dart.void, [core.Object]),
>+    [$addAll]: dart.fnType(dart.void, [core.Object]),
>+    sort: dart.fnType(dart.void, [], [dart.fnType(core.int, [T, T])]),
>+    [$sort]: dart.fnType(dart.void, [], [dart.fnType(core.int, [T, T])]),
>+    shuffle: dart.fnType(dart.void, [], [math.Random]),
>+    [$shuffle]: dart.fnType(dart.void, [], [math.Random]),
>+    insert: dart.fnType(dart.void, [core.int, core.Object]),
>+    [$insert]: dart.fnType(dart.void, [core.int, core.Object]),
>+    insertAll: dart.fnType(dart.void, [core.int, core.Object]),
>+    [$insertAll]: dart.fnType(dart.void, [core.int, core.Object]),
>+    setAll: dart.fnType(dart.void, [core.int, core.Object]),
>+    [$setAll]: dart.fnType(dart.void, [core.int, core.Object]),
>+    remove: dart.fnType(core.bool, [core.Object]),
>+    [$remove]: dart.fnType(core.bool, [core.Object]),
>+    removeAt: dart.fnType(T, [core.int]),
>+    [$removeAt]: dart.fnType(T, [core.int]),
>+    removeLast: dart.fnType(T, []),
>+    [$removeLast]: dart.fnType(T, []),
>+    removeWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [T])]),
>+    [$removeWhere]: dart.fnType(dart.void, [dart.fnType(core.bool, [T])]),
>+    retainWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [T])]),
>+    [$retainWhere]: dart.fnType(dart.void, [dart.fnType(core.bool, [T])]),
>+    getRange: dart.fnType(core.Iterable$(T), [core.int, core.int]),
>+    [$getRange]: dart.fnType(core.Iterable$(T), [core.int, core.int]),
>+    setRange: dart.fnType(dart.void, [core.int, core.int, core.Object], [core.int]),
>+    [$setRange]: dart.fnType(dart.void, [core.int, core.int, core.Object], [core.int]),
>+    removeRange: dart.fnType(dart.void, [core.int, core.int]),
>+    [$removeRange]: dart.fnType(dart.void, [core.int, core.int]),
>+    fillRange: dart.fnType(dart.void, [core.int, core.int], [core.Object]),
>+    [$fillRange]: dart.fnType(dart.void, [core.int, core.int], [core.Object]),
>+    replaceRange: dart.fnType(dart.void, [core.int, core.int, core.Object]),
>+    [$replaceRange]: dart.fnType(dart.void, [core.int, core.int, core.Object])
>+  }));
>+  dart.setSetterSignature(_CastListBase, () => ({
>+    __proto__: dart.getSetters(_CastListBase.__proto__),
>+    length: core.int,
>+    [$length]: core.int
>+  }));
>+  dart.setLibraryUri(_CastListBase, "dart:_internal");
>+  dart.defineExtensionMethods(_CastListBase, [
>+    '_get',
>+    '_set',
>+    'add',
>+    'addAll',
>+    'sort',
>+    'shuffle',
>+    'insert',
>+    'insertAll',
>+    'setAll',
>+    'remove',
>+    'removeAt',
>+    'removeLast',
>+    'removeWhere',
>+    'retainWhere',
>+    'getRange',
>+    'setRange',
>+    'removeRange',
>+    'fillRange',
>+    'replaceRange'
>+  ]);
>+  dart.defineExtensionAccessors(_CastListBase, ['length']);
>+  return _CastListBase;
>+});
>+_internal._CastListBase = _internal._CastListBase$();
>+dart.addTypeTests(_internal._CastListBase, _is__CastListBase_default);
>+const _is_CastList_default = Symbol('_is_CastList_default');
>+_internal.CastList$ = dart.generic((S, T) => {
>+  let ListOfS = () => (ListOfS = dart.constFn(core.List$(S)))();
>+  class CastList extends _internal._CastListBase$(S, T) {
>+    cast(R) {
>+      return new (_internal.CastList$(S, R)).new(this[_source]);
>+    }
>+  }
>+  (CastList.new = function(source) {
>+    this[_source] = source;
>+    CastList.__proto__.new.call(this);
>+  }).prototype = CastList.prototype;
>+  dart.addTypeTests(CastList);
>+  CastList.prototype[_is_CastList_default] = true;
>+  dart.setMethodSignature(CastList, () => ({
>+    __proto__: dart.getMethods(CastList.__proto__),
>+    cast: dart.gFnType(R => [core.List$(R), []]),
>+    [$cast]: dart.gFnType(R => [core.List$(R), []])
>+  }));
>+  dart.setLibraryUri(CastList, "dart:_internal");
>+  dart.setFieldSignature(CastList, () => ({
>+    __proto__: dart.getFields(CastList.__proto__),
>+    [_source]: dart.finalFieldType(ListOfS())
>+  }));
>+  dart.defineExtensionMethods(CastList, ['cast']);
>+  return CastList;
>+});
>+_internal.CastList = _internal.CastList$();
>+dart.addTypeTests(_internal.CastList, _is_CastList_default);
>+const _emptySet = dart.privateName(_internal, "_emptySet");
>+const _conditionalAdd = dart.privateName(_internal, "_conditionalAdd");
>+const _clone = dart.privateName(_internal, "_clone");
>+const _is_CastSet_default = Symbol('_is_CastSet_default');
>+_internal.CastSet$ = dart.generic((S, T) => {
>+  let CastIterableOfT$S = () => (CastIterableOfT$S = dart.constFn(_internal.CastIterable$(T, S)))();
>+  let STobool = () => (STobool = dart.constFn(dart.fnType(core.bool, [S])))();
>+  let CastSetOfS$T = () => (CastSetOfS$T = dart.constFn(_internal.CastSet$(S, T)))();
>+  let SetOfS = () => (SetOfS = dart.constFn(core.Set$(S)))();
>+  let IterableOfT = () => (IterableOfT = dart.constFn(core.Iterable$(T)))();
>+  let _HashSetOfT = () => (_HashSetOfT = dart.constFn(collection._HashSet$(T)))();
>+  let SetOfT = () => (SetOfT = dart.constFn(core.Set$(T)))();
>+  class CastSet extends _internal._CastIterableBase$(S, T) {
>+    static _defaultEmptySet(R) {
>+      return new (collection._HashSet$(R)).new();
>+    }
>+    cast(R) {
>+      return new (_internal.CastSet$(S, R)).new(this[_source], this[_emptySet]);
>+    }
>+    add(value) {
>+      T._check(value);
>+      return this[_source].add(S.as(value));
>+    }
>+    addAll(elements) {
>+      IterableOfT()._check(elements);
>+      this[_source].addAll(CastIterableOfT$S().new(elements));
>+    }
>+    remove(object) {
>+      return this[_source].remove(object);
>+    }
>+    removeAll(objects) {
>+      this[_source].removeAll(objects);
>+    }
>+    retainAll(objects) {
>+      this[_source].retainAll(objects);
>+    }
>+    removeWhere(test) {
>+      this[_source].removeWhere(dart.fn(element => test(T.as(element)), STobool()));
>+    }
>+    retainWhere(test) {
>+      this[_source].retainWhere(dart.fn(element => test(T.as(element)), STobool()));
>+    }
>+    containsAll(objects) {
>+      return this[_source].containsAll(objects);
>+    }
>+    intersection(other) {
>+      if (this[_emptySet] != null) return this[_conditionalAdd](other, true);
>+      return new (CastSetOfS$T()).new(this[_source].intersection(other), null);
>+    }
>+    difference(other) {
>+      if (this[_emptySet] != null) return this[_conditionalAdd](other, false);
>+      return new (CastSetOfS$T()).new(this[_source].difference(other), null);
>+    }
>+    [_conditionalAdd](other, otherContains) {
>+      let result = this[_emptySet] == null ? new (_HashSetOfT()).new() : this[_emptySet](T);
>+      for (let element of this[_source]) {
>+        let castElement = T.as(element);
>+        if (otherContains == other.contains(castElement)) result.add(castElement);
>+      }
>+      return result;
>+    }
>+    union(other) {
>+      SetOfT()._check(other);
>+      let _ = this[_clone]();
>+      _.addAll(other);
>+      return _;
>+    }
>+    clear() {
>+      this[_source].clear();
>+    }
>+    [_clone]() {
>+      let result = this[_emptySet] == null ? new (_HashSetOfT()).new() : this[_emptySet](T);
>+      result.addAll(this);
>+      return result;
>+    }
>+    toSet() {
>+      return this[_clone]();
>+    }
>+    lookup(key) {
>+      return T.as(this[_source].lookup(key));
>+    }
>+  }
>+  (CastSet.new = function(source, emptySet) {
>+    this[_source] = source;
>+    this[_emptySet] = emptySet;
>+    CastSet.__proto__.new.call(this);
>+  }).prototype = CastSet.prototype;
>+  dart.addTypeTests(CastSet);
>+  CastSet.prototype[_is_CastSet_default] = true;
>+  CastSet[dart.implements] = () => [SetOfT()];
>+  dart.setMethodSignature(CastSet, () => ({
>+    __proto__: dart.getMethods(CastSet.__proto__),
>+    cast: dart.gFnType(R => [core.Set$(R), []]),
>+    [$cast]: dart.gFnType(R => [core.Set$(R), []]),
>+    add: dart.fnType(core.bool, [core.Object]),
>+    addAll: dart.fnType(dart.void, [core.Object]),
>+    remove: dart.fnType(core.bool, [core.Object]),
>+    removeAll: dart.fnType(dart.void, [core.Iterable$(core.Object)]),
>+    retainAll: dart.fnType(dart.void, [core.Iterable$(core.Object)]),
>+    removeWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [T])]),
>+    retainWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [T])]),
>+    containsAll: dart.fnType(core.bool, [core.Iterable$(core.Object)]),
>+    intersection: dart.fnType(core.Set$(T), [core.Set$(core.Object)]),
>+    difference: dart.fnType(core.Set$(T), [core.Set$(core.Object)]),
>+    [_conditionalAdd]: dart.fnType(core.Set$(T), [core.Set$(core.Object), core.bool]),
>+    union: dart.fnType(core.Set$(T), [core.Object]),
>+    clear: dart.fnType(dart.void, []),
>+    [_clone]: dart.fnType(core.Set$(T), []),
>+    toSet: dart.fnType(core.Set$(T), []),
>+    [$toSet]: dart.fnType(core.Set$(T), []),
>+    lookup: dart.fnType(T, [core.Object])
>+  }));
>+  dart.setLibraryUri(CastSet, "dart:_internal");
>+  dart.setFieldSignature(CastSet, () => ({
>+    __proto__: dart.getFields(CastSet.__proto__),
>+    [_source]: dart.finalFieldType(SetOfS()),
>+    [_emptySet]: dart.finalFieldType(VoidToSetOfR())
>+  }));
>+  dart.defineExtensionMethods(CastSet, ['cast', 'toSet']);
>+  return CastSet;
>+});
>+_internal.CastSet = _internal.CastSet$();
>+dart.addTypeTests(_internal.CastSet, _is_CastSet_default);
>+const _is_MapMixin_default = Symbol('_is_MapMixin_default');
>+collection.MapMixin$ = dart.generic((K, V) => {
>+  let MapOfK$V = () => (MapOfK$V = dart.constFn(core.Map$(K, V)))();
>+  let KAndVToV = () => (KAndVToV = dart.constFn(dart.fnType(V, [K, V])))();
>+  let MapEntryOfK$V = () => (MapEntryOfK$V = dart.constFn(core.MapEntry$(K, V)))();
>+  let KToMapEntryOfK$V = () => (KToMapEntryOfK$V = dart.constFn(dart.fnType(MapEntryOfK$V(), [K])))();
>+  let IterableOfMapEntryOfK$V = () => (IterableOfMapEntryOfK$V = dart.constFn(core.Iterable$(MapEntryOfK$V())))();
>+  let JSArrayOfK = () => (JSArrayOfK = dart.constFn(_interceptors.JSArray$(K)))();
>+  let _MapBaseValueIterableOfK$V = () => (_MapBaseValueIterableOfK$V = dart.constFn(collection._MapBaseValueIterable$(K, V)))();
>+  let VoidToV = () => (VoidToV = dart.constFn(dart.fnType(V, [])))();
>+  let VToV = () => (VToV = dart.constFn(dart.fnType(V, [V])))();
>+  class MapMixin extends core.Object {
>+    cast(RK, RV) {
>+      return core.Map.castFrom(K, V, RK, RV, this);
>+    }
>+    forEach(action) {
>+      for (let key of this[$keys]) {
>+        action(key, this[$_get](key));
>+      }
>+    }
>+    addAll(other) {
>+      MapOfK$V()._check(other);
>+      for (let key of other[$keys]) {
>+        this[$_set](key, other[$_get](key));
>+      }
>+    }
>+    containsValue(value) {
>+      for (let key of this[$keys]) {
>+        if (dart.equals(this[$_get](key), value)) return true;
>+      }
>+      return false;
>+    }
>+    putIfAbsent(key, ifAbsent) {
>+      K._check(key);
>+      VoidToV()._check(ifAbsent);
>+      if (dart.test(this[$containsKey](key))) {
>+        return this[$_get](key);
>+      }
>+      return this[$_set](key, ifAbsent());
>+    }
>+    update(key, update, opts) {
>+      K._check(key);
>+      VToV()._check(update);
>+      let ifAbsent = opts && 'ifAbsent' in opts ? opts.ifAbsent : null;
>+      VoidToV()._check(ifAbsent);
>+      if (dart.test(this[$containsKey](key))) {
>+        return this[$_set](key, update(this[$_get](key)));
>+      }
>+      if (ifAbsent != null) {
>+        return this[$_set](key, ifAbsent());
>+      }
>+      dart.throw(new core.ArgumentError.value(key, "key", "Key not in map."));
>+    }
>+    updateAll(update) {
>+      KAndVToV()._check(update);
>+      for (let key of this[$keys]) {
>+        this[$_set](key, update(key, this[$_get](key)));
>+      }
>+    }
>+    get entries() {
>+      return IterableOfMapEntryOfK$V()._check(this[$keys][$map](MapEntryOfK$V(), dart.fn(key => MapEntryOfK$V().new(key, this[$_get](key)), KToMapEntryOfK$V())));
>+    }
>+    map(K2, V2, transform) {
>+      let result = new (_js_helper.LinkedMap$(K2, V2)).new();
>+      for (let key of this[$keys]) {
>+        let entry = transform(key, this[$_get](key));
>+        result[$_set](entry.key, entry.value);
>+      }
>+      return result;
>+    }
>+    addEntries(newEntries) {
>+      IterableOfMapEntryOfK$V()._check(newEntries);
>+      for (let entry of newEntries) {
>+        this[$_set](entry.key, entry.value);
>+      }
>+    }
>+    removeWhere(test) {
>+      let keysToRemove = JSArrayOfK().of([]);
>+      for (let key of this[$keys]) {
>+        if (dart.test(test(key, this[$_get](key)))) keysToRemove[$add](key);
>+      }
>+      for (let key of keysToRemove) {
>+        this[$remove](key);
>+      }
>+    }
>+    containsKey(key) {
>+      return this[$keys][$contains](key);
>+    }
>+    get length() {
>+      return this[$keys][$length];
>+    }
>+    get isEmpty() {
>+      return this[$keys][$isEmpty];
>+    }
>+    get isNotEmpty() {
>+      return this[$keys][$isNotEmpty];
>+    }
>+    get values() {
>+      return new (_MapBaseValueIterableOfK$V()).new(this);
>+    }
>+    toString() {
>+      return collection.MapBase.mapToString(this);
>+    }
>+  }
>+  (MapMixin.new = function() {
>+  }).prototype = MapMixin.prototype;
>+  MapMixin.prototype[dart.isMap] = true;
>+  dart.addTypeTests(MapMixin);
>+  MapMixin.prototype[_is_MapMixin_default] = true;
>+  MapMixin[dart.implements] = () => [MapOfK$V()];
>+  dart.setMethodSignature(MapMixin, () => ({
>+    __proto__: dart.getMethods(MapMixin.__proto__),
>+    cast: dart.gFnType((RK, RV) => [core.Map$(RK, RV), []]),
>+    [$cast]: dart.gFnType((RK, RV) => [core.Map$(RK, RV), []]),
>+    forEach: dart.fnType(dart.void, [dart.fnType(dart.void, [K, V])]),
>+    [$forEach]: dart.fnType(dart.void, [dart.fnType(dart.void, [K, V])]),
>+    addAll: dart.fnType(dart.void, [core.Object]),
>+    [$addAll]: dart.fnType(dart.void, [core.Object]),
>+    containsValue: dart.fnType(core.bool, [core.Object]),
>+    [$containsValue]: dart.fnType(core.bool, [core.Object]),
>+    putIfAbsent: dart.fnType(V, [core.Object, core.Object]),
>+    [$putIfAbsent]: dart.fnType(V, [core.Object, core.Object]),
>+    update: dart.fnType(V, [core.Object, core.Object], {ifAbsent: core.Object}),
>+    [$update]: dart.fnType(V, [core.Object, core.Object], {ifAbsent: core.Object}),
>+    updateAll: dart.fnType(dart.void, [core.Object]),
>+    [$updateAll]: dart.fnType(dart.void, [core.Object]),
>+    map: dart.gFnType((K2, V2) => [core.Map$(K2, V2), [dart.fnType(core.MapEntry$(K2, V2), [K, V])]]),
>+    [$map]: dart.gFnType((K2, V2) => [core.Map$(K2, V2), [dart.fnType(core.MapEntry$(K2, V2), [K, V])]]),
>+    addEntries: dart.fnType(dart.void, [core.Object]),
>+    [$addEntries]: dart.fnType(dart.void, [core.Object]),
>+    removeWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [K, V])]),
>+    [$removeWhere]: dart.fnType(dart.void, [dart.fnType(core.bool, [K, V])]),
>+    containsKey: dart.fnType(core.bool, [core.Object]),
>+    [$containsKey]: dart.fnType(core.bool, [core.Object]),
>+    toString: dart.fnType(core.String, []),
>+    [$toString]: dart.fnType(core.String, [])
>+  }));
>+  dart.setGetterSignature(MapMixin, () => ({
>+    __proto__: dart.getGetters(MapMixin.__proto__),
>+    entries: core.Iterable$(core.MapEntry$(K, V)),
>+    [$entries]: core.Iterable$(core.MapEntry$(K, V)),
>+    length: core.int,
>+    [$length]: core.int,
>+    isEmpty: core.bool,
>+    [$isEmpty]: core.bool,
>+    isNotEmpty: core.bool,
>+    [$isNotEmpty]: core.bool,
>+    values: core.Iterable$(V),
>+    [$values]: core.Iterable$(V)
>+  }));
>+  dart.setLibraryUri(MapMixin, "dart:collection");
>+  dart.defineExtensionMethods(MapMixin, [
>+    'cast',
>+    'forEach',
>+    'addAll',
>+    'containsValue',
>+    'putIfAbsent',
>+    'update',
>+    'updateAll',
>+    'map',
>+    'addEntries',
>+    'removeWhere',
>+    'containsKey',
>+    'toString'
>+  ]);
>+  dart.defineExtensionAccessors(MapMixin, [
>+    'entries',
>+    'length',
>+    'isEmpty',
>+    'isNotEmpty',
>+    'values'
>+  ]);
>+  return MapMixin;
>+});
>+collection.MapMixin = collection.MapMixin$();
>+dart.addTypeTests(collection.MapMixin, _is_MapMixin_default);
>+const _is_MapBase_default = Symbol('_is_MapBase_default');
>+collection.MapBase$ = dart.generic((K, V) => {
>+  class MapBase extends collection.MapMixin$(K, V) {
>+    static mapToString(m) {
>+      if (dart.test(collection._isToStringVisiting(m))) {
>+        return "{...}";
>+      }
>+      let result = new core.StringBuffer.new();
>+      try {
>+        collection._toStringVisiting[$add](m);
>+        result.write("{");
>+        let first = true;
>+        m[$forEach](dart.fn((k, v) => {
>+          if (!first) {
>+            result.write(", ");
>+          }
>+          first = false;
>+          result.write(k);
>+          result.write(": ");
>+          result.write(v);
>+        }, dynamicAnddynamicToNull()));
>+        result.write("}");
>+      } finally {
>+        if (!core.identical(collection._toStringVisiting[$last], m)) dart.assertFailed(null, "dart:collection/maps.dart", 44, 14, "identical(_toStringVisiting.last, m)");
>+        collection._toStringVisiting[$removeLast]();
>+      }
>+      return result.toString();
>+    }
>+    static _id(x) {
>+      return x;
>+    }
>+    static _fillMapWithMappedIterable(map, iterable, key, value) {
>+      let t = key;
>+      t == null ? key = dart.fn(collection.MapBase._id, dynamicTodynamic()) : t;
>+      let t$ = value;
>+      t$ == null ? value = dart.fn(collection.MapBase._id, dynamicTodynamic()) : t$;
>+      for (let element of iterable) {
>+        map[$_set](key(element), value(element));
>+      }
>+    }
>+    static _fillMapWithIterables(map, keys, values) {
>+      let keyIterator = keys[$iterator];
>+      let valueIterator = values[$iterator];
>+      let hasNextKey = keyIterator.moveNext();
>+      let hasNextValue = valueIterator.moveNext();
>+      while (dart.test(hasNextKey) && dart.test(hasNextValue)) {
>+        map[$_set](keyIterator.current, valueIterator.current);
>+        hasNextKey = keyIterator.moveNext();
>+        hasNextValue = valueIterator.moveNext();
>+      }
>+      if (dart.test(hasNextKey) || dart.test(hasNextValue)) {
>+        dart.throw(new core.ArgumentError.new("Iterables do not have same length."));
>+      }
>+    }
>+  }
>+  (MapBase.new = function() {
>+  }).prototype = MapBase.prototype;
>+  dart.addTypeTests(MapBase);
>+  MapBase.prototype[_is_MapBase_default] = true;
>+  dart.setLibraryUri(MapBase, "dart:collection");
>+  return MapBase;
>+});
>+collection.MapBase = collection.MapBase$();
>+dart.addTypeTests(collection.MapBase, _is_MapBase_default);
>+const _is_CastMap_default = Symbol('_is_CastMap_default');
>+_internal.CastMap$ = dart.generic((SK, SV, K, V) => {
>+  let CastMapOfK$V$SK$SV = () => (CastMapOfK$V$SK$SV = dart.constFn(_internal.CastMap$(K, V, SK, SV)))();
>+  let SKAndSVToNull = () => (SKAndSVToNull = dart.constFn(dart.fnType(core.Null, [SK, SV])))();
>+  let CastIterableOfSK$K = () => (CastIterableOfSK$K = dart.constFn(_internal.CastIterable$(SK, K)))();
>+  let SKAndSVToSV = () => (SKAndSVToSV = dart.constFn(dart.fnType(SV, [SK, SV])))();
>+  let MapEntryOfSK$SV = () => (MapEntryOfSK$SV = dart.constFn(core.MapEntry$(SK, SV)))();
>+  let MapEntryOfSK$SVToMapEntryOfK$V = () => (MapEntryOfSK$SVToMapEntryOfK$V = dart.constFn(dart.fnType(MapEntryOfK$V(), [MapEntryOfSK$SV()])))();
>+  let SKAndSVTobool = () => (SKAndSVTobool = dart.constFn(dart.fnType(core.bool, [SK, SV])))();
>+  let MapOfSK$SV = () => (MapOfSK$SV = dart.constFn(core.Map$(SK, SV)))();
>+  let VoidToSV = () => (VoidToSV = dart.constFn(dart.fnType(SV, [])))();
>+  let CastIterableOfSV$V = () => (CastIterableOfSV$V = dart.constFn(_internal.CastIterable$(SV, V)))();
>+  let SVToSV = () => (SVToSV = dart.constFn(dart.fnType(SV, [SV])))();
>+  let MapOfK$V = () => (MapOfK$V = dart.constFn(core.Map$(K, V)))();
>+  let KAndVToV = () => (KAndVToV = dart.constFn(dart.fnType(V, [K, V])))();
>+  let MapEntryOfK$V = () => (MapEntryOfK$V = dart.constFn(core.MapEntry$(K, V)))();
>+  let IterableOfMapEntryOfK$V = () => (IterableOfMapEntryOfK$V = dart.constFn(core.Iterable$(MapEntryOfK$V())))();
>+  let VoidToV = () => (VoidToV = dart.constFn(dart.fnType(V, [])))();
>+  let VToV = () => (VToV = dart.constFn(dart.fnType(V, [V])))();
>+  class CastMap extends collection.MapBase$(K, V) {
>+    cast(RK, RV) {
>+      return new (_internal.CastMap$(SK, SV, RK, RV)).new(this[_source]);
>+    }
>+    containsValue(value) {
>+      return this[_source][$containsValue](value);
>+    }
>+    containsKey(key) {
>+      return this[_source][$containsKey](key);
>+    }
>+    _get(key) {
>+      return V.as(this[_source][$_get](key));
>+    }
>+    _set(key, value) {
>+      K._check(key);
>+      V._check(value);
>+      this[_source][$_set](SK.as(key), SV.as(value));
>+      return value;
>+    }
>+    putIfAbsent(key, ifAbsent) {
>+      K._check(key);
>+      VoidToV()._check(ifAbsent);
>+      return V.as(this[_source][$putIfAbsent](SK.as(key), ifAbsent == null ? null : dart.fn(() => SV.as(ifAbsent()), VoidToSV())));
>+    }
>+    addAll(other) {
>+      MapOfK$V()._check(other);
>+      this[_source][$addAll](new (CastMapOfK$V$SK$SV()).new(other));
>+    }
>+    remove(key) {
>+      return V.as(this[_source][$remove](key));
>+    }
>+    clear() {
>+      this[_source][$clear]();
>+    }
>+    forEach(f) {
>+      this[_source][$forEach](dart.fn((key, value) => {
>+        f(K.as(key), V.as(value));
>+      }, SKAndSVToNull()));
>+    }
>+    get keys() {
>+      return CastIterableOfSK$K().new(this[_source][$keys]);
>+    }
>+    get values() {
>+      return CastIterableOfSV$V().new(this[_source][$values]);
>+    }
>+    get length() {
>+      return this[_source][$length];
>+    }
>+    get isEmpty() {
>+      return this[_source][$isEmpty];
>+    }
>+    get isNotEmpty() {
>+      return this[_source][$isNotEmpty];
>+    }
>+    update(key, update, opts) {
>+      K._check(key);
>+      VToV()._check(update);
>+      let ifAbsent = opts && 'ifAbsent' in opts ? opts.ifAbsent : null;
>+      VoidToV()._check(ifAbsent);
>+      return V.as(this[_source][$update](SK.as(key), dart.fn(value => SV.as(update(V.as(value))), SVToSV()), {ifAbsent: ifAbsent == null ? null : dart.fn(() => SV.as(ifAbsent()), VoidToSV())}));
>+    }
>+    updateAll(update) {
>+      KAndVToV()._check(update);
>+      this[_source][$updateAll](dart.fn((key, value) => SV.as(update(K.as(key), V.as(value))), SKAndSVToSV()));
>+    }
>+    get entries() {
>+      return IterableOfMapEntryOfK$V()._check(this[_source][$entries][$map](MapEntryOfK$V(), dart.fn(e => MapEntryOfK$V().new(K.as(e.key), V.as(e.value)), MapEntryOfSK$SVToMapEntryOfK$V())));
>+    }
>+    addEntries(entries) {
>+      IterableOfMapEntryOfK$V()._check(entries);
>+      for (let entry of entries) {
>+        this[_source][$_set](SK.as(entry.key), SV.as(entry.value));
>+      }
>+    }
>+    removeWhere(test) {
>+      this[_source][$removeWhere](dart.fn((key, value) => test(K.as(key), V.as(value)), SKAndSVTobool()));
>+    }
>+  }
>+  (CastMap.new = function(source) {
>+    this[_source] = source;
>+  }).prototype = CastMap.prototype;
>+  dart.addTypeTests(CastMap);
>+  CastMap.prototype[_is_CastMap_default] = true;
>+  dart.setMethodSignature(CastMap, () => ({
>+    __proto__: dart.getMethods(CastMap.__proto__),
>+    cast: dart.gFnType((RK, RV) => [core.Map$(RK, RV), []]),
>+    [$cast]: dart.gFnType((RK, RV) => [core.Map$(RK, RV), []]),
>+    containsValue: dart.fnType(core.bool, [core.Object]),
>+    [$containsValue]: dart.fnType(core.bool, [core.Object]),
>+    containsKey: dart.fnType(core.bool, [core.Object]),
>+    [$containsKey]: dart.fnType(core.bool, [core.Object]),
>+    _get: dart.fnType(V, [core.Object]),
>+    [$_get]: dart.fnType(V, [core.Object]),
>+    _set: dart.fnType(dart.void, [core.Object, core.Object]),
>+    [$_set]: dart.fnType(dart.void, [core.Object, core.Object]),
>+    putIfAbsent: dart.fnType(V, [core.Object, core.Object]),
>+    [$putIfAbsent]: dart.fnType(V, [core.Object, core.Object]),
>+    addAll: dart.fnType(dart.void, [core.Object]),
>+    [$addAll]: dart.fnType(dart.void, [core.Object]),
>+    remove: dart.fnType(V, [core.Object]),
>+    [$remove]: dart.fnType(V, [core.Object]),
>+    clear: dart.fnType(dart.void, []),
>+    [$clear]: dart.fnType(dart.void, []),
>+    forEach: dart.fnType(dart.void, [dart.fnType(dart.void, [K, V])]),
>+    [$forEach]: dart.fnType(dart.void, [dart.fnType(dart.void, [K, V])]),
>+    update: dart.fnType(V, [core.Object, core.Object], {ifAbsent: core.Object}),
>+    [$update]: dart.fnType(V, [core.Object, core.Object], {ifAbsent: core.Object}),
>+    updateAll: dart.fnType(dart.void, [core.Object]),
>+    [$updateAll]: dart.fnType(dart.void, [core.Object]),
>+    addEntries: dart.fnType(dart.void, [core.Object]),
>+    [$addEntries]: dart.fnType(dart.void, [core.Object]),
>+    removeWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [K, V])]),
>+    [$removeWhere]: dart.fnType(dart.void, [dart.fnType(core.bool, [K, V])])
>+  }));
>+  dart.setGetterSignature(CastMap, () => ({
>+    __proto__: dart.getGetters(CastMap.__proto__),
>+    keys: core.Iterable$(K),
>+    [$keys]: core.Iterable$(K),
>+    values: core.Iterable$(V),
>+    [$values]: core.Iterable$(V),
>+    length: core.int,
>+    [$length]: core.int,
>+    isEmpty: core.bool,
>+    [$isEmpty]: core.bool,
>+    isNotEmpty: core.bool,
>+    [$isNotEmpty]: core.bool,
>+    entries: core.Iterable$(core.MapEntry$(K, V)),
>+    [$entries]: core.Iterable$(core.MapEntry$(K, V))
>+  }));
>+  dart.setLibraryUri(CastMap, "dart:_internal");
>+  dart.setFieldSignature(CastMap, () => ({
>+    __proto__: dart.getFields(CastMap.__proto__),
>+    [_source]: dart.finalFieldType(MapOfSK$SV())
>+  }));
>+  dart.defineExtensionMethods(CastMap, [
>+    'cast',
>+    'containsValue',
>+    'containsKey',
>+    '_get',
>+    '_set',
>+    'putIfAbsent',
>+    'addAll',
>+    'remove',
>+    'clear',
>+    'forEach',
>+    'update',
>+    'updateAll',
>+    'addEntries',
>+    'removeWhere'
>+  ]);
>+  dart.defineExtensionAccessors(CastMap, [
>+    'keys',
>+    'values',
>+    'length',
>+    'isEmpty',
>+    'isNotEmpty',
>+    'entries'
>+  ]);
>+  return CastMap;
>+});
>+_internal.CastMap = _internal.CastMap$();
>+dart.addTypeTests(_internal.CastMap, _is_CastMap_default);
>+const _is_CastQueue_default = Symbol('_is_CastQueue_default');
>+_internal.CastQueue$ = dart.generic((S, T) => {
>+  let CastIterableOfT$S = () => (CastIterableOfT$S = dart.constFn(_internal.CastIterable$(T, S)))();
>+  let STobool = () => (STobool = dart.constFn(dart.fnType(core.bool, [S])))();
>+  let QueueOfS = () => (QueueOfS = dart.constFn(collection.Queue$(S)))();
>+  let IterableOfT = () => (IterableOfT = dart.constFn(core.Iterable$(T)))();
>+  let QueueOfT = () => (QueueOfT = dart.constFn(collection.Queue$(T)))();
>+  class CastQueue extends _internal._CastIterableBase$(S, T) {
>+    cast(R) {
>+      return new (_internal.CastQueue$(S, R)).new(this[_source]);
>+    }
>+    removeFirst() {
>+      return T.as(this[_source].removeFirst());
>+    }
>+    removeLast() {
>+      return T.as(this[_source].removeLast());
>+    }
>+    add(value) {
>+      T._check(value);
>+      this[_source].add(S.as(value));
>+    }
>+    addFirst(value) {
>+      T._check(value);
>+      this[_source].addFirst(S.as(value));
>+    }
>+    addLast(value) {
>+      T._check(value);
>+      this[_source].addLast(S.as(value));
>+    }
>+    remove(other) {
>+      return this[_source].remove(other);
>+    }
>+    addAll(elements) {
>+      IterableOfT()._check(elements);
>+      this[_source].addAll(CastIterableOfT$S().new(elements));
>+    }
>+    removeWhere(test) {
>+      this[_source].removeWhere(dart.fn(element => test(T.as(element)), STobool()));
>+    }
>+    retainWhere(test) {
>+      this[_source].retainWhere(dart.fn(element => test(T.as(element)), STobool()));
>+    }
>+    clear() {
>+      this[_source].clear();
>+    }
>+  }
>+  (CastQueue.new = function(source) {
>+    this[_source] = source;
>+    CastQueue.__proto__.new.call(this);
>+  }).prototype = CastQueue.prototype;
>+  dart.addTypeTests(CastQueue);
>+  CastQueue.prototype[_is_CastQueue_default] = true;
>+  CastQueue[dart.implements] = () => [QueueOfT()];
>+  dart.setMethodSignature(CastQueue, () => ({
>+    __proto__: dart.getMethods(CastQueue.__proto__),
>+    cast: dart.gFnType(R => [collection.Queue$(R), []]),
>+    [$cast]: dart.gFnType(R => [collection.Queue$(R), []]),
>+    removeFirst: dart.fnType(T, []),
>+    removeLast: dart.fnType(T, []),
>+    add: dart.fnType(dart.void, [core.Object]),
>+    addFirst: dart.fnType(dart.void, [core.Object]),
>+    addLast: dart.fnType(dart.void, [core.Object]),
>+    remove: dart.fnType(core.bool, [core.Object]),
>+    addAll: dart.fnType(dart.void, [core.Object]),
>+    removeWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [T])]),
>+    retainWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [T])]),
>+    clear: dart.fnType(dart.void, [])
>+  }));
>+  dart.setLibraryUri(CastQueue, "dart:_internal");
>+  dart.setFieldSignature(CastQueue, () => ({
>+    __proto__: dart.getFields(CastQueue.__proto__),
>+    [_source]: dart.finalFieldType(QueueOfS())
>+  }));
>+  dart.defineExtensionMethods(CastQueue, ['cast']);
>+  return CastQueue;
>+});
>+_internal.CastQueue = _internal.CastQueue$();
>+dart.addTypeTests(_internal.CastQueue, _is_CastQueue_default);
>+const _is_EfficientLengthIterable_default = Symbol('_is_EfficientLengthIterable_default');
>+_internal.EfficientLengthIterable$ = dart.generic(T => {
>+  class EfficientLengthIterable extends core.Iterable$(T) {}
>+  (EfficientLengthIterable.new = function() {
>+    EfficientLengthIterable.__proto__.new.call(this);
>+  }).prototype = EfficientLengthIterable.prototype;
>+  dart.addTypeTests(EfficientLengthIterable);
>+  EfficientLengthIterable.prototype[_is_EfficientLengthIterable_default] = true;
>+  dart.setLibraryUri(EfficientLengthIterable, "dart:_internal");
>+  return EfficientLengthIterable;
>+});
>+_internal.EfficientLengthIterable = _internal.EfficientLengthIterable$();
>+dart.addTypeTests(_internal.EfficientLengthIterable, _is_EfficientLengthIterable_default);
>+const _is_ListIterable_default = Symbol('_is_ListIterable_default');
>+_internal.ListIterable$ = dart.generic(E => {
>+  let ListIteratorOfE = () => (ListIteratorOfE = dart.constFn(_internal.ListIterator$(E)))();
>+  let VoidToE = () => (VoidToE = dart.constFn(dart.fnType(E, [])))();
>+  let EAndEToE = () => (EAndEToE = dart.constFn(dart.fnType(E, [E, E])))();
>+  let SubListIterableOfE = () => (SubListIterableOfE = dart.constFn(_internal.SubListIterable$(E)))();
>+  let JSArrayOfE = () => (JSArrayOfE = dart.constFn(_interceptors.JSArray$(E)))();
>+  let ListOfE = () => (ListOfE = dart.constFn(core.List$(E)))();
>+  let _HashSetOfE = () => (_HashSetOfE = dart.constFn(collection._HashSet$(E)))();
>+  class ListIterable extends _internal.EfficientLengthIterable$(E) {
>+    get iterator() {
>+      return new (ListIteratorOfE()).new(this);
>+    }
>+    forEach(action) {
>+      let length = this.length;
>+      for (let i = 0; i < dart.notNull(length); i++) {
>+        action(this.elementAt(i));
>+        if (length != this.length) {
>+          dart.throw(new core.ConcurrentModificationError.new(this));
>+        }
>+      }
>+    }
>+    get isEmpty() {
>+      return this.length === 0;
>+    }
>+    get first() {
>+      if (this.length === 0) dart.throw(_internal.IterableElementError.noElement());
>+      return this.elementAt(0);
>+    }
>+    get last() {
>+      if (this.length === 0) dart.throw(_internal.IterableElementError.noElement());
>+      return this.elementAt(dart.notNull(this.length) - 1);
>+    }
>+    get single() {
>+      if (this.length === 0) dart.throw(_internal.IterableElementError.noElement());
>+      if (dart.notNull(this.length) > 1) dart.throw(_internal.IterableElementError.tooMany());
>+      return this.elementAt(0);
>+    }
>+    contains(element) {
>+      let length = this.length;
>+      for (let i = 0; i < dart.notNull(length); i++) {
>+        if (dart.equals(this.elementAt(i), element)) return true;
>+        if (length != this.length) {
>+          dart.throw(new core.ConcurrentModificationError.new(this));
>+        }
>+      }
>+      return false;
>+    }
>+    every(test) {
>+      let length = this.length;
>+      for (let i = 0; i < dart.notNull(length); i++) {
>+        if (!dart.test(test(this.elementAt(i)))) return false;
>+        if (length != this.length) {
>+          dart.throw(new core.ConcurrentModificationError.new(this));
>+        }
>+      }
>+      return true;
>+    }
>+    any(test) {
>+      let length = this.length;
>+      for (let i = 0; i < dart.notNull(length); i++) {
>+        if (dart.test(test(this.elementAt(i)))) return true;
>+        if (length != this.length) {
>+          dart.throw(new core.ConcurrentModificationError.new(this));
>+        }
>+      }
>+      return false;
>+    }
>+    firstWhere(test, opts) {
>+      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+      VoidToE()._check(orElse);
>+      let length = this.length;
>+      for (let i = 0; i < dart.notNull(length); i++) {
>+        let element = this.elementAt(i);
>+        if (dart.test(test(element))) return element;
>+        if (length != this.length) {
>+          dart.throw(new core.ConcurrentModificationError.new(this));
>+        }
>+      }
>+      if (orElse != null) return orElse();
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    lastWhere(test, opts) {
>+      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+      VoidToE()._check(orElse);
>+      let length = this.length;
>+      for (let i = dart.notNull(length) - 1; i >= 0; i--) {
>+        let element = this.elementAt(i);
>+        if (dart.test(test(element))) return element;
>+        if (length != this.length) {
>+          dart.throw(new core.ConcurrentModificationError.new(this));
>+        }
>+      }
>+      if (orElse != null) return orElse();
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    singleWhere(test, opts) {
>+      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+      VoidToE()._check(orElse);
>+      let length = this.length;
>+      let match = null;
>+      let matchFound = false;
>+      for (let i = 0; i < dart.notNull(length); i++) {
>+        let element = this.elementAt(i);
>+        if (dart.test(test(element))) {
>+          if (matchFound) {
>+            dart.throw(_internal.IterableElementError.tooMany());
>+          }
>+          matchFound = true;
>+          match = element;
>+        }
>+        if (length != this.length) {
>+          dart.throw(new core.ConcurrentModificationError.new(this));
>+        }
>+      }
>+      if (matchFound) return match;
>+      if (orElse != null) return orElse();
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    join(separator) {
>+      if (separator === void 0) separator = "";
>+      let length = this.length;
>+      if (!separator[$isEmpty]) {
>+        if (length === 0) return "";
>+        let first = dart.str(this.elementAt(0));
>+        if (length != this.length) {
>+          dart.throw(new core.ConcurrentModificationError.new(this));
>+        }
>+        let buffer = new core.StringBuffer.new(first);
>+        for (let i = 1; i < dart.notNull(length); i++) {
>+          buffer.write(separator);
>+          buffer.write(this.elementAt(i));
>+          if (length != this.length) {
>+            dart.throw(new core.ConcurrentModificationError.new(this));
>+          }
>+        }
>+        return buffer.toString();
>+      } else {
>+        let buffer = new core.StringBuffer.new();
>+        for (let i = 0; i < dart.notNull(length); i++) {
>+          buffer.write(this.elementAt(i));
>+          if (length != this.length) {
>+            dart.throw(new core.ConcurrentModificationError.new(this));
>+          }
>+        }
>+        return buffer.toString();
>+      }
>+    }
>+    where(test) {
>+      return super.where(test);
>+    }
>+    map(T, f) {
>+      return new (_internal.MappedListIterable$(E, T)).new(this, f);
>+    }
>+    reduce(combine) {
>+      EAndEToE()._check(combine);
>+      let length = this.length;
>+      if (length === 0) dart.throw(_internal.IterableElementError.noElement());
>+      let value = this.elementAt(0);
>+      for (let i = 1; i < dart.notNull(length); i++) {
>+        value = combine(value, this.elementAt(i));
>+        if (length != this.length) {
>+          dart.throw(new core.ConcurrentModificationError.new(this));
>+        }
>+      }
>+      return value;
>+    }
>+    fold(T, initialValue, combine) {
>+      let value = initialValue;
>+      let length = this.length;
>+      for (let i = 0; i < dart.notNull(length); i++) {
>+        value = combine(value, this.elementAt(i));
>+        if (length != this.length) {
>+          dart.throw(new core.ConcurrentModificationError.new(this));
>+        }
>+      }
>+      return value;
>+    }
>+    skip(count) {
>+      return new (SubListIterableOfE()).new(this, count, null);
>+    }
>+    skipWhile(test) {
>+      return super.skipWhile(test);
>+    }
>+    take(count) {
>+      return new (SubListIterableOfE()).new(this, 0, count);
>+    }
>+    takeWhile(test) {
>+      return super.takeWhile(test);
>+    }
>+    toList(opts) {
>+      let growable = opts && 'growable' in opts ? opts.growable : true;
>+      let result = null;
>+      if (dart.test(growable)) {
>+        result = JSArrayOfE().of([]);
>+        result[$length] = this.length;
>+      } else {
>+        result = ListOfE().new(this.length);
>+      }
>+      for (let i = 0; i < dart.notNull(this.length); i++) {
>+        result[$_set](i, this.elementAt(i));
>+      }
>+      return result;
>+    }
>+    toSet() {
>+      let result = new (_HashSetOfE()).new();
>+      for (let i = 0; i < dart.notNull(this.length); i++) {
>+        result.add(this.elementAt(i));
>+      }
>+      return result;
>+    }
>+  }
>+  (ListIterable.new = function() {
>+    ListIterable.__proto__.new.call(this);
>+  }).prototype = ListIterable.prototype;
>+  dart.addTypeTests(ListIterable);
>+  ListIterable.prototype[_is_ListIterable_default] = true;
>+  dart.setMethodSignature(ListIterable, () => ({
>+    __proto__: dart.getMethods(ListIterable.__proto__),
>+    firstWhere: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    [$firstWhere]: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    lastWhere: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    [$lastWhere]: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    singleWhere: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    [$singleWhere]: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    reduce: dart.fnType(E, [core.Object]),
>+    [$reduce]: dart.fnType(E, [core.Object])
>+  }));
>+  dart.setGetterSignature(ListIterable, () => ({
>+    __proto__: dart.getGetters(ListIterable.__proto__),
>+    iterator: core.Iterator$(E),
>+    [$iterator]: core.Iterator$(E)
>+  }));
>+  dart.setLibraryUri(ListIterable, "dart:_internal");
>+  dart.defineExtensionMethods(ListIterable, [
>+    'forEach',
>+    'contains',
>+    'every',
>+    'any',
>+    'firstWhere',
>+    'lastWhere',
>+    'singleWhere',
>+    'join',
>+    'where',
>+    'map',
>+    'reduce',
>+    'fold',
>+    'skip',
>+    'skipWhile',
>+    'take',
>+    'takeWhile',
>+    'toList',
>+    'toSet'
>+  ]);
>+  dart.defineExtensionAccessors(ListIterable, [
>+    'iterator',
>+    'isEmpty',
>+    'first',
>+    'last',
>+    'single'
>+  ]);
>+  return ListIterable;
>+});
>+_internal.ListIterable = _internal.ListIterable$();
>+dart.addTypeTests(_internal.ListIterable, _is_ListIterable_default);
>+const _iterable$ = dart.privateName(_internal, "_iterable");
>+const _start = dart.privateName(_internal, "_start");
>+const _endOrLength = dart.privateName(_internal, "_endOrLength");
>+const _endIndex = dart.privateName(_internal, "_endIndex");
>+const _startIndex = dart.privateName(_internal, "_startIndex");
>+const _is_SubListIterable_default = Symbol('_is_SubListIterable_default');
>+_internal.SubListIterable$ = dart.generic(E => {
>+  let EmptyIterableOfE = () => (EmptyIterableOfE = dart.constFn(_internal.EmptyIterable$(E)))();
>+  let SubListIterableOfE = () => (SubListIterableOfE = dart.constFn(_internal.SubListIterable$(E)))();
>+  let JSArrayOfE = () => (JSArrayOfE = dart.constFn(_interceptors.JSArray$(E)))();
>+  let ListOfE = () => (ListOfE = dart.constFn(core.List$(E)))();
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  class SubListIterable extends _internal.ListIterable$(E) {
>+    get [_endIndex]() {
>+      let length = this[_iterable$][$length];
>+      if (this[_endOrLength] == null || dart.notNull(this[_endOrLength]) > dart.notNull(length)) return length;
>+      return this[_endOrLength];
>+    }
>+    get [_startIndex]() {
>+      let length = this[_iterable$][$length];
>+      if (dart.notNull(this[_start]) > dart.notNull(length)) return length;
>+      return this[_start];
>+    }
>+    get length() {
>+      let length = this[_iterable$][$length];
>+      if (dart.notNull(this[_start]) >= dart.notNull(length)) return 0;
>+      if (this[_endOrLength] == null || dart.notNull(this[_endOrLength]) >= dart.notNull(length)) {
>+        return dart.notNull(length) - dart.notNull(this[_start]);
>+      }
>+      return dart.notNull(this[_endOrLength]) - dart.notNull(this[_start]);
>+    }
>+    elementAt(index) {
>+      let realIndex = dart.notNull(this[_startIndex]) + dart.notNull(index);
>+      if (dart.notNull(index) < 0 || realIndex >= dart.notNull(this[_endIndex])) {
>+        dart.throw(core.RangeError.index(index, this, "index"));
>+      }
>+      return this[_iterable$][$elementAt](realIndex);
>+    }
>+    skip(count) {
>+      core.RangeError.checkNotNegative(count, "count");
>+      let newStart = dart.notNull(this[_start]) + dart.notNull(count);
>+      if (this[_endOrLength] != null && newStart >= dart.notNull(this[_endOrLength])) {
>+        return new (EmptyIterableOfE()).new();
>+      }
>+      return new (SubListIterableOfE()).new(this[_iterable$], newStart, this[_endOrLength]);
>+    }
>+    take(count) {
>+      core.RangeError.checkNotNegative(count, "count");
>+      if (this[_endOrLength] == null) {
>+        return new (SubListIterableOfE()).new(this[_iterable$], this[_start], dart.notNull(this[_start]) + dart.notNull(count));
>+      } else {
>+        let newEnd = dart.notNull(this[_start]) + dart.notNull(count);
>+        if (dart.notNull(this[_endOrLength]) < newEnd) return this;
>+        return new (SubListIterableOfE()).new(this[_iterable$], this[_start], newEnd);
>+      }
>+    }
>+    toList(opts) {
>+      let growable = opts && 'growable' in opts ? opts.growable : true;
>+      let start = this[_start];
>+      let end = this[_iterable$][$length];
>+      if (this[_endOrLength] != null && dart.notNull(this[_endOrLength]) < dart.notNull(end)) end = this[_endOrLength];
>+      let length = dart.notNull(end) - dart.notNull(start);
>+      if (length < 0) length = 0;
>+      let result = dart.test(growable) ? (() => {
>+        let _ = JSArrayOfE().of([]);
>+        _[$length] = length;
>+        return _;
>+      })() : ListOfE().new(length);
>+      for (let i = 0; i < length; i++) {
>+        result[$_set](i, this[_iterable$][$elementAt](dart.notNull(start) + i));
>+        if (dart.notNull(this[_iterable$][$length]) < dart.notNull(end)) dart.throw(new core.ConcurrentModificationError.new(this));
>+      }
>+      return result;
>+    }
>+  }
>+  (SubListIterable.new = function(iterable, start, endOrLength) {
>+    this[_iterable$] = iterable;
>+    this[_start] = start;
>+    this[_endOrLength] = endOrLength;
>+    SubListIterable.__proto__.new.call(this);
>+    core.RangeError.checkNotNegative(this[_start], "start");
>+    if (this[_endOrLength] != null) {
>+      core.RangeError.checkNotNegative(this[_endOrLength], "end");
>+      if (dart.notNull(this[_start]) > dart.notNull(this[_endOrLength])) {
>+        dart.throw(new core.RangeError.range(this[_start], 0, this[_endOrLength], "start"));
>+      }
>+    }
>+  }).prototype = SubListIterable.prototype;
>+  dart.addTypeTests(SubListIterable);
>+  SubListIterable.prototype[_is_SubListIterable_default] = true;
>+  dart.setMethodSignature(SubListIterable, () => ({
>+    __proto__: dart.getMethods(SubListIterable.__proto__),
>+    elementAt: dart.fnType(E, [core.int]),
>+    [$elementAt]: dart.fnType(E, [core.int])
>+  }));
>+  dart.setGetterSignature(SubListIterable, () => ({
>+    __proto__: dart.getGetters(SubListIterable.__proto__),
>+    [_endIndex]: core.int,
>+    [_startIndex]: core.int,
>+    length: core.int,
>+    [$length]: core.int
>+  }));
>+  dart.setLibraryUri(SubListIterable, "dart:_internal");
>+  dart.setFieldSignature(SubListIterable, () => ({
>+    __proto__: dart.getFields(SubListIterable.__proto__),
>+    [_iterable$]: dart.finalFieldType(IterableOfE()),
>+    [_start]: dart.finalFieldType(core.int),
>+    [_endOrLength]: dart.finalFieldType(core.int)
>+  }));
>+  dart.defineExtensionMethods(SubListIterable, ['elementAt', 'skip', 'take', 'toList']);
>+  dart.defineExtensionAccessors(SubListIterable, ['length']);
>+  return SubListIterable;
>+});
>+_internal.SubListIterable = _internal.SubListIterable$();
>+dart.addTypeTests(_internal.SubListIterable, _is_SubListIterable_default);
>+const _length$ = dart.privateName(_internal, "_length");
>+const _index$ = dart.privateName(_internal, "_index");
>+const _current$ = dart.privateName(_internal, "_current");
>+const _is_ListIterator_default = Symbol('_is_ListIterator_default');
>+_internal.ListIterator$ = dart.generic(E => {
>+  let IteratorOfE = () => (IteratorOfE = dart.constFn(core.Iterator$(E)))();
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  class ListIterator extends core.Object {
>+    get current() {
>+      return this[_current$];
>+    }
>+    moveNext() {
>+      let length = this[_iterable$][$length];
>+      if (this[_length$] != length) {
>+        dart.throw(new core.ConcurrentModificationError.new(this[_iterable$]));
>+      }
>+      if (dart.notNull(this[_index$]) >= dart.notNull(length)) {
>+        this[_current$] = null;
>+        return false;
>+      }
>+      this[_current$] = this[_iterable$][$elementAt](this[_index$]);
>+      this[_index$] = dart.notNull(this[_index$]) + 1;
>+      return true;
>+    }
>+  }
>+  (ListIterator.new = function(iterable) {
>+    this[_current$] = null;
>+    this[_iterable$] = iterable;
>+    this[_length$] = iterable[$length];
>+    this[_index$] = 0;
>+  }).prototype = ListIterator.prototype;
>+  dart.addTypeTests(ListIterator);
>+  ListIterator.prototype[_is_ListIterator_default] = true;
>+  ListIterator[dart.implements] = () => [IteratorOfE()];
>+  dart.setMethodSignature(ListIterator, () => ({
>+    __proto__: dart.getMethods(ListIterator.__proto__),
>+    moveNext: dart.fnType(core.bool, [])
>+  }));
>+  dart.setGetterSignature(ListIterator, () => ({
>+    __proto__: dart.getGetters(ListIterator.__proto__),
>+    current: E
>+  }));
>+  dart.setLibraryUri(ListIterator, "dart:_internal");
>+  dart.setFieldSignature(ListIterator, () => ({
>+    __proto__: dart.getFields(ListIterator.__proto__),
>+    [_iterable$]: dart.finalFieldType(IterableOfE()),
>+    [_length$]: dart.finalFieldType(core.int),
>+    [_index$]: dart.fieldType(core.int),
>+    [_current$]: dart.fieldType(E)
>+  }));
>+  return ListIterator;
>+});
>+_internal.ListIterator = _internal.ListIterator$();
>+dart.addTypeTests(_internal.ListIterator, _is_ListIterator_default);
>+const _f = dart.privateName(_internal, "_f");
>+const _is_MappedIterable_default = Symbol('_is_MappedIterable_default');
>+_internal.MappedIterable$ = dart.generic((S, T) => {
>+  let EfficientLengthMappedIterableOfS$T = () => (EfficientLengthMappedIterableOfS$T = dart.constFn(_internal.EfficientLengthMappedIterable$(S, T)))();
>+  let MappedIterableOfS$T = () => (MappedIterableOfS$T = dart.constFn(_internal.MappedIterable$(S, T)))();
>+  let MappedIteratorOfS$T = () => (MappedIteratorOfS$T = dart.constFn(_internal.MappedIterator$(S, T)))();
>+  let IterableOfS = () => (IterableOfS = dart.constFn(core.Iterable$(S)))();
>+  let SToT = () => (SToT = dart.constFn(dart.fnType(T, [S])))();
>+  class MappedIterable extends core.Iterable$(T) {
>+    static new(iterable, func) {
>+      if (_internal.EfficientLengthIterable.is(iterable)) {
>+        return new (EfficientLengthMappedIterableOfS$T()).new(iterable, func);
>+      }
>+      return new (MappedIterableOfS$T()).__(iterable, func);
>+    }
>+    get iterator() {
>+      return new (MappedIteratorOfS$T()).new(this[_iterable$][$iterator], this[_f]);
>+    }
>+    get length() {
>+      return this[_iterable$][$length];
>+    }
>+    get isEmpty() {
>+      return this[_iterable$][$isEmpty];
>+    }
>+    get first() {
>+      return this[_f](this[_iterable$][$first]);
>+    }
>+    get last() {
>+      return this[_f](this[_iterable$][$last]);
>+    }
>+    get single() {
>+      return this[_f](this[_iterable$][$single]);
>+    }
>+    elementAt(index) {
>+      return this[_f](this[_iterable$][$elementAt](index));
>+    }
>+  }
>+  (MappedIterable.__ = function(iterable, f) {
>+    this[_iterable$] = iterable;
>+    this[_f] = f;
>+    MappedIterable.__proto__.new.call(this);
>+  }).prototype = MappedIterable.prototype;
>+  dart.addTypeTests(MappedIterable);
>+  MappedIterable.prototype[_is_MappedIterable_default] = true;
>+  dart.setMethodSignature(MappedIterable, () => ({
>+    __proto__: dart.getMethods(MappedIterable.__proto__),
>+    elementAt: dart.fnType(T, [core.int]),
>+    [$elementAt]: dart.fnType(T, [core.int])
>+  }));
>+  dart.setGetterSignature(MappedIterable, () => ({
>+    __proto__: dart.getGetters(MappedIterable.__proto__),
>+    iterator: core.Iterator$(T),
>+    [$iterator]: core.Iterator$(T),
>+    length: core.int,
>+    [$length]: core.int,
>+    isEmpty: core.bool,
>+    [$isEmpty]: core.bool,
>+    first: T,
>+    [$first]: T,
>+    last: T,
>+    [$last]: T,
>+    single: T,
>+    [$single]: T
>+  }));
>+  dart.setLibraryUri(MappedIterable, "dart:_internal");
>+  dart.setFieldSignature(MappedIterable, () => ({
>+    __proto__: dart.getFields(MappedIterable.__proto__),
>+    [_iterable$]: dart.finalFieldType(IterableOfS()),
>+    [_f]: dart.finalFieldType(SToT())
>+  }));
>+  dart.defineExtensionMethods(MappedIterable, ['elementAt']);
>+  dart.defineExtensionAccessors(MappedIterable, [
>+    'iterator',
>+    'length',
>+    'isEmpty',
>+    'first',
>+    'last',
>+    'single'
>+  ]);
>+  return MappedIterable;
>+});
>+_internal.MappedIterable = _internal.MappedIterable$();
>+dart.addTypeTests(_internal.MappedIterable, _is_MappedIterable_default);
>+const _is_EfficientLengthMappedIterable_default = Symbol('_is_EfficientLengthMappedIterable_default');
>+_internal.EfficientLengthMappedIterable$ = dart.generic((S, T) => {
>+  let EfficientLengthIterableOfT = () => (EfficientLengthIterableOfT = dart.constFn(_internal.EfficientLengthIterable$(T)))();
>+  class EfficientLengthMappedIterable extends _internal.MappedIterable$(S, T) {}
>+  (EfficientLengthMappedIterable.new = function(iterable, func) {
>+    EfficientLengthMappedIterable.__proto__.__.call(this, iterable, func);
>+  }).prototype = EfficientLengthMappedIterable.prototype;
>+  dart.addTypeTests(EfficientLengthMappedIterable);
>+  EfficientLengthMappedIterable.prototype[_is_EfficientLengthMappedIterable_default] = true;
>+  EfficientLengthMappedIterable[dart.implements] = () => [EfficientLengthIterableOfT()];
>+  dart.setLibraryUri(EfficientLengthMappedIterable, "dart:_internal");
>+  return EfficientLengthMappedIterable;
>+});
>+_internal.EfficientLengthMappedIterable = _internal.EfficientLengthMappedIterable$();
>+dart.addTypeTests(_internal.EfficientLengthMappedIterable, _is_EfficientLengthMappedIterable_default);
>+const _iterator = dart.privateName(_internal, "_iterator");
>+const _is_Iterator_default = Symbol('_is_Iterator_default');
>+core.Iterator$ = dart.generic(E => {
>+  class Iterator extends core.Object {}
>+  (Iterator.new = function() {
>+  }).prototype = Iterator.prototype;
>+  dart.addTypeTests(Iterator);
>+  Iterator.prototype[_is_Iterator_default] = true;
>+  dart.setLibraryUri(Iterator, "dart:core");
>+  return Iterator;
>+});
>+core.Iterator = core.Iterator$();
>+dart.addTypeTests(core.Iterator, _is_Iterator_default);
>+const _is_MappedIterator_default = Symbol('_is_MappedIterator_default');
>+_internal.MappedIterator$ = dart.generic((S, T) => {
>+  let IteratorOfS = () => (IteratorOfS = dart.constFn(core.Iterator$(S)))();
>+  let SToT = () => (SToT = dart.constFn(dart.fnType(T, [S])))();
>+  class MappedIterator extends core.Iterator$(T) {
>+    moveNext() {
>+      if (dart.test(this[_iterator].moveNext())) {
>+        this[_current$] = this[_f](this[_iterator].current);
>+        return true;
>+      }
>+      this[_current$] = null;
>+      return false;
>+    }
>+    get current() {
>+      return this[_current$];
>+    }
>+  }
>+  (MappedIterator.new = function(iterator, f) {
>+    this[_current$] = null;
>+    this[_iterator] = iterator;
>+    this[_f] = f;
>+  }).prototype = MappedIterator.prototype;
>+  dart.addTypeTests(MappedIterator);
>+  MappedIterator.prototype[_is_MappedIterator_default] = true;
>+  dart.setMethodSignature(MappedIterator, () => ({
>+    __proto__: dart.getMethods(MappedIterator.__proto__),
>+    moveNext: dart.fnType(core.bool, [])
>+  }));
>+  dart.setGetterSignature(MappedIterator, () => ({
>+    __proto__: dart.getGetters(MappedIterator.__proto__),
>+    current: T
>+  }));
>+  dart.setLibraryUri(MappedIterator, "dart:_internal");
>+  dart.setFieldSignature(MappedIterator, () => ({
>+    __proto__: dart.getFields(MappedIterator.__proto__),
>+    [_current$]: dart.fieldType(T),
>+    [_iterator]: dart.finalFieldType(IteratorOfS()),
>+    [_f]: dart.finalFieldType(SToT())
>+  }));
>+  return MappedIterator;
>+});
>+_internal.MappedIterator = _internal.MappedIterator$();
>+dart.addTypeTests(_internal.MappedIterator, _is_MappedIterator_default);
>+const _is_MappedListIterable_default = Symbol('_is_MappedListIterable_default');
>+_internal.MappedListIterable$ = dart.generic((S, T) => {
>+  let IterableOfS = () => (IterableOfS = dart.constFn(core.Iterable$(S)))();
>+  let SToT = () => (SToT = dart.constFn(dart.fnType(T, [S])))();
>+  class MappedListIterable extends _internal.ListIterable$(T) {
>+    get length() {
>+      return this[_source][$length];
>+    }
>+    elementAt(index) {
>+      return this[_f](this[_source][$elementAt](index));
>+    }
>+  }
>+  (MappedListIterable.new = function(source, f) {
>+    this[_source] = source;
>+    this[_f] = f;
>+    MappedListIterable.__proto__.new.call(this);
>+  }).prototype = MappedListIterable.prototype;
>+  dart.addTypeTests(MappedListIterable);
>+  MappedListIterable.prototype[_is_MappedListIterable_default] = true;
>+  dart.setMethodSignature(MappedListIterable, () => ({
>+    __proto__: dart.getMethods(MappedListIterable.__proto__),
>+    elementAt: dart.fnType(T, [core.int]),
>+    [$elementAt]: dart.fnType(T, [core.int])
>+  }));
>+  dart.setGetterSignature(MappedListIterable, () => ({
>+    __proto__: dart.getGetters(MappedListIterable.__proto__),
>+    length: core.int,
>+    [$length]: core.int
>+  }));
>+  dart.setLibraryUri(MappedListIterable, "dart:_internal");
>+  dart.setFieldSignature(MappedListIterable, () => ({
>+    __proto__: dart.getFields(MappedListIterable.__proto__),
>+    [_source]: dart.finalFieldType(IterableOfS()),
>+    [_f]: dart.finalFieldType(SToT())
>+  }));
>+  dart.defineExtensionMethods(MappedListIterable, ['elementAt']);
>+  dart.defineExtensionAccessors(MappedListIterable, ['length']);
>+  return MappedListIterable;
>+});
>+_internal.MappedListIterable = _internal.MappedListIterable$();
>+dart.addTypeTests(_internal.MappedListIterable, _is_MappedListIterable_default);
>+const _is_WhereIterable_default = Symbol('_is_WhereIterable_default');
>+_internal.WhereIterable$ = dart.generic(E => {
>+  let WhereIteratorOfE = () => (WhereIteratorOfE = dart.constFn(_internal.WhereIterator$(E)))();
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  let ETobool = () => (ETobool = dart.constFn(dart.fnType(core.bool, [E])))();
>+  class WhereIterable extends core.Iterable$(E) {
>+    get iterator() {
>+      return new (WhereIteratorOfE()).new(this[_iterable$][$iterator], this[_f]);
>+    }
>+    map(T, f) {
>+      return new (_internal.MappedIterable$(E, T)).__(this, f);
>+    }
>+  }
>+  (WhereIterable.new = function(iterable, f) {
>+    this[_iterable$] = iterable;
>+    this[_f] = f;
>+    WhereIterable.__proto__.new.call(this);
>+  }).prototype = WhereIterable.prototype;
>+  dart.addTypeTests(WhereIterable);
>+  WhereIterable.prototype[_is_WhereIterable_default] = true;
>+  dart.setGetterSignature(WhereIterable, () => ({
>+    __proto__: dart.getGetters(WhereIterable.__proto__),
>+    iterator: core.Iterator$(E),
>+    [$iterator]: core.Iterator$(E)
>+  }));
>+  dart.setLibraryUri(WhereIterable, "dart:_internal");
>+  dart.setFieldSignature(WhereIterable, () => ({
>+    __proto__: dart.getFields(WhereIterable.__proto__),
>+    [_iterable$]: dart.finalFieldType(IterableOfE()),
>+    [_f]: dart.finalFieldType(ETobool())
>+  }));
>+  dart.defineExtensionMethods(WhereIterable, ['map']);
>+  dart.defineExtensionAccessors(WhereIterable, ['iterator']);
>+  return WhereIterable;
>+});
>+_internal.WhereIterable = _internal.WhereIterable$();
>+dart.addTypeTests(_internal.WhereIterable, _is_WhereIterable_default);
>+const _is_WhereIterator_default = Symbol('_is_WhereIterator_default');
>+_internal.WhereIterator$ = dart.generic(E => {
>+  let IteratorOfE = () => (IteratorOfE = dart.constFn(core.Iterator$(E)))();
>+  let ETobool = () => (ETobool = dart.constFn(dart.fnType(core.bool, [E])))();
>+  class WhereIterator extends core.Iterator$(E) {
>+    moveNext() {
>+      while (dart.test(this[_iterator].moveNext())) {
>+        if (dart.test(this[_f](this[_iterator].current))) {
>+          return true;
>+        }
>+      }
>+      return false;
>+    }
>+    get current() {
>+      return this[_iterator].current;
>+    }
>+  }
>+  (WhereIterator.new = function(iterator, f) {
>+    this[_iterator] = iterator;
>+    this[_f] = f;
>+  }).prototype = WhereIterator.prototype;
>+  dart.addTypeTests(WhereIterator);
>+  WhereIterator.prototype[_is_WhereIterator_default] = true;
>+  dart.setMethodSignature(WhereIterator, () => ({
>+    __proto__: dart.getMethods(WhereIterator.__proto__),
>+    moveNext: dart.fnType(core.bool, [])
>+  }));
>+  dart.setGetterSignature(WhereIterator, () => ({
>+    __proto__: dart.getGetters(WhereIterator.__proto__),
>+    current: E
>+  }));
>+  dart.setLibraryUri(WhereIterator, "dart:_internal");
>+  dart.setFieldSignature(WhereIterator, () => ({
>+    __proto__: dart.getFields(WhereIterator.__proto__),
>+    [_iterator]: dart.finalFieldType(IteratorOfE()),
>+    [_f]: dart.finalFieldType(ETobool())
>+  }));
>+  return WhereIterator;
>+});
>+_internal.WhereIterator = _internal.WhereIterator$();
>+dart.addTypeTests(_internal.WhereIterator, _is_WhereIterator_default);
>+const _is_ExpandIterable_default = Symbol('_is_ExpandIterable_default');
>+_internal.ExpandIterable$ = dart.generic((S, T) => {
>+  let ExpandIteratorOfS$T = () => (ExpandIteratorOfS$T = dart.constFn(_internal.ExpandIterator$(S, T)))();
>+  let IterableOfS = () => (IterableOfS = dart.constFn(core.Iterable$(S)))();
>+  let SToIterableOfT = () => (SToIterableOfT = dart.constFn(dart.fnType(IterableOfT(), [S])))();
>+  let IterableOfT = () => (IterableOfT = dart.constFn(core.Iterable$(T)))();
>+  class ExpandIterable extends core.Iterable$(T) {
>+    get iterator() {
>+      return new (ExpandIteratorOfS$T()).new(this[_iterable$][$iterator], this[_f]);
>+    }
>+  }
>+  (ExpandIterable.new = function(iterable, f) {
>+    this[_iterable$] = iterable;
>+    this[_f] = f;
>+    ExpandIterable.__proto__.new.call(this);
>+  }).prototype = ExpandIterable.prototype;
>+  dart.addTypeTests(ExpandIterable);
>+  ExpandIterable.prototype[_is_ExpandIterable_default] = true;
>+  dart.setGetterSignature(ExpandIterable, () => ({
>+    __proto__: dart.getGetters(ExpandIterable.__proto__),
>+    iterator: core.Iterator$(T),
>+    [$iterator]: core.Iterator$(T)
>+  }));
>+  dart.setLibraryUri(ExpandIterable, "dart:_internal");
>+  dart.setFieldSignature(ExpandIterable, () => ({
>+    __proto__: dart.getFields(ExpandIterable.__proto__),
>+    [_iterable$]: dart.finalFieldType(IterableOfS()),
>+    [_f]: dart.finalFieldType(SToIterableOfT())
>+  }));
>+  dart.defineExtensionAccessors(ExpandIterable, ['iterator']);
>+  return ExpandIterable;
>+});
>+_internal.ExpandIterable = _internal.ExpandIterable$();
>+dart.addTypeTests(_internal.ExpandIterable, _is_ExpandIterable_default);
>+const _currentExpansion = dart.privateName(_internal, "_currentExpansion");
>+let const$3;
>+const _is_ExpandIterator_default = Symbol('_is_ExpandIterator_default');
>+_internal.ExpandIterator$ = dart.generic((S, T) => {
>+  let IteratorOfS = () => (IteratorOfS = dart.constFn(core.Iterator$(S)))();
>+  let SToIterableOfT = () => (SToIterableOfT = dart.constFn(dart.fnType(IterableOfT(), [S])))();
>+  let IteratorOfT = () => (IteratorOfT = dart.constFn(core.Iterator$(T)))();
>+  let IterableOfT = () => (IterableOfT = dart.constFn(core.Iterable$(T)))();
>+  class ExpandIterator extends core.Object {
>+    get current() {
>+      return this[_current$];
>+    }
>+    moveNext() {
>+      if (this[_currentExpansion] == null) return false;
>+      while (!dart.test(this[_currentExpansion].moveNext())) {
>+        this[_current$] = null;
>+        if (dart.test(this[_iterator].moveNext())) {
>+          this[_currentExpansion] = null;
>+          this[_currentExpansion] = this[_f](this[_iterator].current)[$iterator];
>+        } else {
>+          return false;
>+        }
>+      }
>+      this[_current$] = this[_currentExpansion].current;
>+      return true;
>+    }
>+  }
>+  (ExpandIterator.new = function(iterator, f) {
>+    this[_currentExpansion] = const$3 || (const$3 = dart.const(new (EmptyIteratorOfNull()).new()));
>+    this[_current$] = null;
>+    this[_iterator] = iterator;
>+    this[_f] = f;
>+  }).prototype = ExpandIterator.prototype;
>+  dart.addTypeTests(ExpandIterator);
>+  ExpandIterator.prototype[_is_ExpandIterator_default] = true;
>+  ExpandIterator[dart.implements] = () => [IteratorOfT()];
>+  dart.setMethodSignature(ExpandIterator, () => ({
>+    __proto__: dart.getMethods(ExpandIterator.__proto__),
>+    moveNext: dart.fnType(core.bool, [])
>+  }));
>+  dart.setGetterSignature(ExpandIterator, () => ({
>+    __proto__: dart.getGetters(ExpandIterator.__proto__),
>+    current: T
>+  }));
>+  dart.setLibraryUri(ExpandIterator, "dart:_internal");
>+  dart.setFieldSignature(ExpandIterator, () => ({
>+    __proto__: dart.getFields(ExpandIterator.__proto__),
>+    [_iterator]: dart.finalFieldType(IteratorOfS()),
>+    [_f]: dart.finalFieldType(SToIterableOfT()),
>+    [_currentExpansion]: dart.fieldType(IteratorOfT()),
>+    [_current$]: dart.fieldType(T)
>+  }));
>+  return ExpandIterator;
>+});
>+_internal.ExpandIterator = _internal.ExpandIterator$();
>+dart.addTypeTests(_internal.ExpandIterator, _is_ExpandIterator_default);
>+const _takeCount = dart.privateName(_internal, "_takeCount");
>+const _is_TakeIterable_default = Symbol('_is_TakeIterable_default');
>+_internal.TakeIterable$ = dart.generic(E => {
>+  let EfficientLengthTakeIterableOfE = () => (EfficientLengthTakeIterableOfE = dart.constFn(_internal.EfficientLengthTakeIterable$(E)))();
>+  let TakeIterableOfE = () => (TakeIterableOfE = dart.constFn(_internal.TakeIterable$(E)))();
>+  let TakeIteratorOfE = () => (TakeIteratorOfE = dart.constFn(_internal.TakeIterator$(E)))();
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  class TakeIterable extends core.Iterable$(E) {
>+    static new(iterable, takeCount) {
>+      core.ArgumentError.checkNotNull(takeCount, "takeCount");
>+      core.RangeError.checkNotNegative(takeCount, "takeCount");
>+      if (_internal.EfficientLengthIterable.is(iterable)) {
>+        return new (EfficientLengthTakeIterableOfE()).new(iterable, takeCount);
>+      }
>+      return new (TakeIterableOfE()).__(iterable, takeCount);
>+    }
>+    get iterator() {
>+      return new (TakeIteratorOfE()).new(this[_iterable$][$iterator], this[_takeCount]);
>+    }
>+  }
>+  (TakeIterable.__ = function(iterable, takeCount) {
>+    this[_iterable$] = iterable;
>+    this[_takeCount] = takeCount;
>+    TakeIterable.__proto__.new.call(this);
>+  }).prototype = TakeIterable.prototype;
>+  dart.addTypeTests(TakeIterable);
>+  TakeIterable.prototype[_is_TakeIterable_default] = true;
>+  dart.setGetterSignature(TakeIterable, () => ({
>+    __proto__: dart.getGetters(TakeIterable.__proto__),
>+    iterator: core.Iterator$(E),
>+    [$iterator]: core.Iterator$(E)
>+  }));
>+  dart.setLibraryUri(TakeIterable, "dart:_internal");
>+  dart.setFieldSignature(TakeIterable, () => ({
>+    __proto__: dart.getFields(TakeIterable.__proto__),
>+    [_iterable$]: dart.finalFieldType(IterableOfE()),
>+    [_takeCount]: dart.finalFieldType(core.int)
>+  }));
>+  dart.defineExtensionAccessors(TakeIterable, ['iterator']);
>+  return TakeIterable;
>+});
>+_internal.TakeIterable = _internal.TakeIterable$();
>+dart.addTypeTests(_internal.TakeIterable, _is_TakeIterable_default);
>+const _is_EfficientLengthTakeIterable_default = Symbol('_is_EfficientLengthTakeIterable_default');
>+_internal.EfficientLengthTakeIterable$ = dart.generic(E => {
>+  let EfficientLengthIterableOfE = () => (EfficientLengthIterableOfE = dart.constFn(_internal.EfficientLengthIterable$(E)))();
>+  class EfficientLengthTakeIterable extends _internal.TakeIterable$(E) {
>+    get length() {
>+      let iterableLength = this[_iterable$][$length];
>+      if (dart.notNull(iterableLength) > dart.notNull(this[_takeCount])) return this[_takeCount];
>+      return iterableLength;
>+    }
>+  }
>+  (EfficientLengthTakeIterable.new = function(iterable, takeCount) {
>+    EfficientLengthTakeIterable.__proto__.__.call(this, iterable, takeCount);
>+  }).prototype = EfficientLengthTakeIterable.prototype;
>+  dart.addTypeTests(EfficientLengthTakeIterable);
>+  EfficientLengthTakeIterable.prototype[_is_EfficientLengthTakeIterable_default] = true;
>+  EfficientLengthTakeIterable[dart.implements] = () => [EfficientLengthIterableOfE()];
>+  dart.setLibraryUri(EfficientLengthTakeIterable, "dart:_internal");
>+  dart.defineExtensionAccessors(EfficientLengthTakeIterable, ['length']);
>+  return EfficientLengthTakeIterable;
>+});
>+_internal.EfficientLengthTakeIterable = _internal.EfficientLengthTakeIterable$();
>+dart.addTypeTests(_internal.EfficientLengthTakeIterable, _is_EfficientLengthTakeIterable_default);
>+const _remaining = dart.privateName(_internal, "_remaining");
>+const _is_TakeIterator_default = Symbol('_is_TakeIterator_default');
>+_internal.TakeIterator$ = dart.generic(E => {
>+  let IteratorOfE = () => (IteratorOfE = dart.constFn(core.Iterator$(E)))();
>+  class TakeIterator extends core.Iterator$(E) {
>+    moveNext() {
>+      this[_remaining] = dart.notNull(this[_remaining]) - 1;
>+      if (dart.notNull(this[_remaining]) >= 0) {
>+        return this[_iterator].moveNext();
>+      }
>+      this[_remaining] = -1;
>+      return false;
>+    }
>+    get current() {
>+      if (dart.notNull(this[_remaining]) < 0) return null;
>+      return this[_iterator].current;
>+    }
>+  }
>+  (TakeIterator.new = function(iterator, remaining) {
>+    this[_iterator] = iterator;
>+    this[_remaining] = remaining;
>+    if (!(dart.notNull(this[_remaining]) >= 0)) dart.assertFailed(null, "dart:_internal/iterable.dart", 528, 12, "_remaining >= 0");
>+  }).prototype = TakeIterator.prototype;
>+  dart.addTypeTests(TakeIterator);
>+  TakeIterator.prototype[_is_TakeIterator_default] = true;
>+  dart.setMethodSignature(TakeIterator, () => ({
>+    __proto__: dart.getMethods(TakeIterator.__proto__),
>+    moveNext: dart.fnType(core.bool, [])
>+  }));
>+  dart.setGetterSignature(TakeIterator, () => ({
>+    __proto__: dart.getGetters(TakeIterator.__proto__),
>+    current: E
>+  }));
>+  dart.setLibraryUri(TakeIterator, "dart:_internal");
>+  dart.setFieldSignature(TakeIterator, () => ({
>+    __proto__: dart.getFields(TakeIterator.__proto__),
>+    [_iterator]: dart.finalFieldType(IteratorOfE()),
>+    [_remaining]: dart.fieldType(core.int)
>+  }));
>+  return TakeIterator;
>+});
>+_internal.TakeIterator = _internal.TakeIterator$();
>+dart.addTypeTests(_internal.TakeIterator, _is_TakeIterator_default);
>+const _is_TakeWhileIterable_default = Symbol('_is_TakeWhileIterable_default');
>+_internal.TakeWhileIterable$ = dart.generic(E => {
>+  let TakeWhileIteratorOfE = () => (TakeWhileIteratorOfE = dart.constFn(_internal.TakeWhileIterator$(E)))();
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  let ETobool = () => (ETobool = dart.constFn(dart.fnType(core.bool, [E])))();
>+  class TakeWhileIterable extends core.Iterable$(E) {
>+    get iterator() {
>+      return new (TakeWhileIteratorOfE()).new(this[_iterable$][$iterator], this[_f]);
>+    }
>+  }
>+  (TakeWhileIterable.new = function(iterable, f) {
>+    this[_iterable$] = iterable;
>+    this[_f] = f;
>+    TakeWhileIterable.__proto__.new.call(this);
>+  }).prototype = TakeWhileIterable.prototype;
>+  dart.addTypeTests(TakeWhileIterable);
>+  TakeWhileIterable.prototype[_is_TakeWhileIterable_default] = true;
>+  dart.setGetterSignature(TakeWhileIterable, () => ({
>+    __proto__: dart.getGetters(TakeWhileIterable.__proto__),
>+    iterator: core.Iterator$(E),
>+    [$iterator]: core.Iterator$(E)
>+  }));
>+  dart.setLibraryUri(TakeWhileIterable, "dart:_internal");
>+  dart.setFieldSignature(TakeWhileIterable, () => ({
>+    __proto__: dart.getFields(TakeWhileIterable.__proto__),
>+    [_iterable$]: dart.finalFieldType(IterableOfE()),
>+    [_f]: dart.finalFieldType(ETobool())
>+  }));
>+  dart.defineExtensionAccessors(TakeWhileIterable, ['iterator']);
>+  return TakeWhileIterable;
>+});
>+_internal.TakeWhileIterable = _internal.TakeWhileIterable$();
>+dart.addTypeTests(_internal.TakeWhileIterable, _is_TakeWhileIterable_default);
>+const _isFinished = dart.privateName(_internal, "_isFinished");
>+const _is_TakeWhileIterator_default = Symbol('_is_TakeWhileIterator_default');
>+_internal.TakeWhileIterator$ = dart.generic(E => {
>+  let IteratorOfE = () => (IteratorOfE = dart.constFn(core.Iterator$(E)))();
>+  let ETobool = () => (ETobool = dart.constFn(dart.fnType(core.bool, [E])))();
>+  class TakeWhileIterator extends core.Iterator$(E) {
>+    moveNext() {
>+      if (dart.test(this[_isFinished])) return false;
>+      if (!dart.test(this[_iterator].moveNext()) || !dart.test(this[_f](this[_iterator].current))) {
>+        this[_isFinished] = true;
>+        return false;
>+      }
>+      return true;
>+    }
>+    get current() {
>+      if (dart.test(this[_isFinished])) return null;
>+      return this[_iterator].current;
>+    }
>+  }
>+  (TakeWhileIterator.new = function(iterator, f) {
>+    this[_isFinished] = false;
>+    this[_iterator] = iterator;
>+    this[_f] = f;
>+  }).prototype = TakeWhileIterator.prototype;
>+  dart.addTypeTests(TakeWhileIterator);
>+  TakeWhileIterator.prototype[_is_TakeWhileIterator_default] = true;
>+  dart.setMethodSignature(TakeWhileIterator, () => ({
>+    __proto__: dart.getMethods(TakeWhileIterator.__proto__),
>+    moveNext: dart.fnType(core.bool, [])
>+  }));
>+  dart.setGetterSignature(TakeWhileIterator, () => ({
>+    __proto__: dart.getGetters(TakeWhileIterator.__proto__),
>+    current: E
>+  }));
>+  dart.setLibraryUri(TakeWhileIterator, "dart:_internal");
>+  dart.setFieldSignature(TakeWhileIterator, () => ({
>+    __proto__: dart.getFields(TakeWhileIterator.__proto__),
>+    [_iterator]: dart.finalFieldType(IteratorOfE()),
>+    [_f]: dart.finalFieldType(ETobool()),
>+    [_isFinished]: dart.fieldType(core.bool)
>+  }));
>+  return TakeWhileIterator;
>+});
>+_internal.TakeWhileIterator = _internal.TakeWhileIterator$();
>+dart.addTypeTests(_internal.TakeWhileIterator, _is_TakeWhileIterator_default);
>+const _skipCount = dart.privateName(_internal, "_skipCount");
>+const _is_SkipIterable_default = Symbol('_is_SkipIterable_default');
>+_internal.SkipIterable$ = dart.generic(E => {
>+  let EfficientLengthSkipIterableOfE = () => (EfficientLengthSkipIterableOfE = dart.constFn(_internal.EfficientLengthSkipIterable$(E)))();
>+  let SkipIterableOfE = () => (SkipIterableOfE = dart.constFn(_internal.SkipIterable$(E)))();
>+  let SkipIteratorOfE = () => (SkipIteratorOfE = dart.constFn(_internal.SkipIterator$(E)))();
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  class SkipIterable extends core.Iterable$(E) {
>+    static new(iterable, count) {
>+      if (_internal.EfficientLengthIterable.is(iterable)) {
>+        return EfficientLengthSkipIterableOfE().new(iterable, count);
>+      }
>+      return new (SkipIterableOfE()).__(iterable, _internal._checkCount(count));
>+    }
>+    skip(count) {
>+      return new (SkipIterableOfE()).__(this[_iterable$], dart.notNull(this[_skipCount]) + dart.notNull(_internal._checkCount(count)));
>+    }
>+    get iterator() {
>+      return new (SkipIteratorOfE()).new(this[_iterable$][$iterator], this[_skipCount]);
>+    }
>+  }
>+  (SkipIterable.__ = function(iterable, skipCount) {
>+    this[_iterable$] = iterable;
>+    this[_skipCount] = skipCount;
>+    SkipIterable.__proto__.new.call(this);
>+  }).prototype = SkipIterable.prototype;
>+  dart.addTypeTests(SkipIterable);
>+  SkipIterable.prototype[_is_SkipIterable_default] = true;
>+  dart.setGetterSignature(SkipIterable, () => ({
>+    __proto__: dart.getGetters(SkipIterable.__proto__),
>+    iterator: core.Iterator$(E),
>+    [$iterator]: core.Iterator$(E)
>+  }));
>+  dart.setLibraryUri(SkipIterable, "dart:_internal");
>+  dart.setFieldSignature(SkipIterable, () => ({
>+    __proto__: dart.getFields(SkipIterable.__proto__),
>+    [_iterable$]: dart.finalFieldType(IterableOfE()),
>+    [_skipCount]: dart.finalFieldType(core.int)
>+  }));
>+  dart.defineExtensionMethods(SkipIterable, ['skip']);
>+  dart.defineExtensionAccessors(SkipIterable, ['iterator']);
>+  return SkipIterable;
>+});
>+_internal.SkipIterable = _internal.SkipIterable$();
>+dart.addTypeTests(_internal.SkipIterable, _is_SkipIterable_default);
>+const _is_EfficientLengthSkipIterable_default = Symbol('_is_EfficientLengthSkipIterable_default');
>+_internal.EfficientLengthSkipIterable$ = dart.generic(E => {
>+  let EfficientLengthSkipIterableOfE = () => (EfficientLengthSkipIterableOfE = dart.constFn(_internal.EfficientLengthSkipIterable$(E)))();
>+  let EfficientLengthIterableOfE = () => (EfficientLengthIterableOfE = dart.constFn(_internal.EfficientLengthIterable$(E)))();
>+  class EfficientLengthSkipIterable extends _internal.SkipIterable$(E) {
>+    static new(iterable, count) {
>+      return new (EfficientLengthSkipIterableOfE()).__(iterable, _internal._checkCount(count));
>+    }
>+    get length() {
>+      let length = dart.notNull(this[_iterable$][$length]) - dart.notNull(this[_skipCount]);
>+      if (length >= 0) return length;
>+      return 0;
>+    }
>+    skip(count) {
>+      return new (EfficientLengthSkipIterableOfE()).__(this[_iterable$], dart.notNull(this[_skipCount]) + dart.notNull(_internal._checkCount(count)));
>+    }
>+  }
>+  (EfficientLengthSkipIterable.__ = function(iterable, count) {
>+    EfficientLengthSkipIterable.__proto__.__.call(this, iterable, count);
>+  }).prototype = EfficientLengthSkipIterable.prototype;
>+  dart.addTypeTests(EfficientLengthSkipIterable);
>+  EfficientLengthSkipIterable.prototype[_is_EfficientLengthSkipIterable_default] = true;
>+  EfficientLengthSkipIterable[dart.implements] = () => [EfficientLengthIterableOfE()];
>+  dart.setLibraryUri(EfficientLengthSkipIterable, "dart:_internal");
>+  dart.defineExtensionMethods(EfficientLengthSkipIterable, ['skip']);
>+  dart.defineExtensionAccessors(EfficientLengthSkipIterable, ['length']);
>+  return EfficientLengthSkipIterable;
>+});
>+_internal.EfficientLengthSkipIterable = _internal.EfficientLengthSkipIterable$();
>+dart.addTypeTests(_internal.EfficientLengthSkipIterable, _is_EfficientLengthSkipIterable_default);
>+_internal._checkCount = function(count) {
>+  core.ArgumentError.checkNotNull(count, "count");
>+  core.RangeError.checkNotNegative(count, "count");
>+  return count;
>+};
>+const _is_SkipIterator_default = Symbol('_is_SkipIterator_default');
>+_internal.SkipIterator$ = dart.generic(E => {
>+  let IteratorOfE = () => (IteratorOfE = dart.constFn(core.Iterator$(E)))();
>+  class SkipIterator extends core.Iterator$(E) {
>+    moveNext() {
>+      for (let i = 0; i < dart.notNull(this[_skipCount]); i++)
>+        this[_iterator].moveNext();
>+      this[_skipCount] = 0;
>+      return this[_iterator].moveNext();
>+    }
>+    get current() {
>+      return this[_iterator].current;
>+    }
>+  }
>+  (SkipIterator.new = function(iterator, skipCount) {
>+    this[_iterator] = iterator;
>+    this[_skipCount] = skipCount;
>+    if (!(dart.notNull(this[_skipCount]) >= 0)) dart.assertFailed(null, "dart:_internal/iterable.dart", 633, 12, "_skipCount >= 0");
>+  }).prototype = SkipIterator.prototype;
>+  dart.addTypeTests(SkipIterator);
>+  SkipIterator.prototype[_is_SkipIterator_default] = true;
>+  dart.setMethodSignature(SkipIterator, () => ({
>+    __proto__: dart.getMethods(SkipIterator.__proto__),
>+    moveNext: dart.fnType(core.bool, [])
>+  }));
>+  dart.setGetterSignature(SkipIterator, () => ({
>+    __proto__: dart.getGetters(SkipIterator.__proto__),
>+    current: E
>+  }));
>+  dart.setLibraryUri(SkipIterator, "dart:_internal");
>+  dart.setFieldSignature(SkipIterator, () => ({
>+    __proto__: dart.getFields(SkipIterator.__proto__),
>+    [_iterator]: dart.finalFieldType(IteratorOfE()),
>+    [_skipCount]: dart.fieldType(core.int)
>+  }));
>+  return SkipIterator;
>+});
>+_internal.SkipIterator = _internal.SkipIterator$();
>+dart.addTypeTests(_internal.SkipIterator, _is_SkipIterator_default);
>+const _is_SkipWhileIterable_default = Symbol('_is_SkipWhileIterable_default');
>+_internal.SkipWhileIterable$ = dart.generic(E => {
>+  let SkipWhileIteratorOfE = () => (SkipWhileIteratorOfE = dart.constFn(_internal.SkipWhileIterator$(E)))();
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  let ETobool = () => (ETobool = dart.constFn(dart.fnType(core.bool, [E])))();
>+  class SkipWhileIterable extends core.Iterable$(E) {
>+    get iterator() {
>+      return new (SkipWhileIteratorOfE()).new(this[_iterable$][$iterator], this[_f]);
>+    }
>+  }
>+  (SkipWhileIterable.new = function(iterable, f) {
>+    this[_iterable$] = iterable;
>+    this[_f] = f;
>+    SkipWhileIterable.__proto__.new.call(this);
>+  }).prototype = SkipWhileIterable.prototype;
>+  dart.addTypeTests(SkipWhileIterable);
>+  SkipWhileIterable.prototype[_is_SkipWhileIterable_default] = true;
>+  dart.setGetterSignature(SkipWhileIterable, () => ({
>+    __proto__: dart.getGetters(SkipWhileIterable.__proto__),
>+    iterator: core.Iterator$(E),
>+    [$iterator]: core.Iterator$(E)
>+  }));
>+  dart.setLibraryUri(SkipWhileIterable, "dart:_internal");
>+  dart.setFieldSignature(SkipWhileIterable, () => ({
>+    __proto__: dart.getFields(SkipWhileIterable.__proto__),
>+    [_iterable$]: dart.finalFieldType(IterableOfE()),
>+    [_f]: dart.finalFieldType(ETobool())
>+  }));
>+  dart.defineExtensionAccessors(SkipWhileIterable, ['iterator']);
>+  return SkipWhileIterable;
>+});
>+_internal.SkipWhileIterable = _internal.SkipWhileIterable$();
>+dart.addTypeTests(_internal.SkipWhileIterable, _is_SkipWhileIterable_default);
>+const _hasSkipped = dart.privateName(_internal, "_hasSkipped");
>+const _is_SkipWhileIterator_default = Symbol('_is_SkipWhileIterator_default');
>+_internal.SkipWhileIterator$ = dart.generic(E => {
>+  let IteratorOfE = () => (IteratorOfE = dart.constFn(core.Iterator$(E)))();
>+  let ETobool = () => (ETobool = dart.constFn(dart.fnType(core.bool, [E])))();
>+  class SkipWhileIterator extends core.Iterator$(E) {
>+    moveNext() {
>+      if (!dart.test(this[_hasSkipped])) {
>+        this[_hasSkipped] = true;
>+        while (dart.test(this[_iterator].moveNext())) {
>+          if (!dart.test(this[_f](this[_iterator].current))) return true;
>+        }
>+      }
>+      return this[_iterator].moveNext();
>+    }
>+    get current() {
>+      return this[_iterator].current;
>+    }
>+  }
>+  (SkipWhileIterator.new = function(iterator, f) {
>+    this[_hasSkipped] = false;
>+    this[_iterator] = iterator;
>+    this[_f] = f;
>+  }).prototype = SkipWhileIterator.prototype;
>+  dart.addTypeTests(SkipWhileIterator);
>+  SkipWhileIterator.prototype[_is_SkipWhileIterator_default] = true;
>+  dart.setMethodSignature(SkipWhileIterator, () => ({
>+    __proto__: dart.getMethods(SkipWhileIterator.__proto__),
>+    moveNext: dart.fnType(core.bool, [])
>+  }));
>+  dart.setGetterSignature(SkipWhileIterator, () => ({
>+    __proto__: dart.getGetters(SkipWhileIterator.__proto__),
>+    current: E
>+  }));
>+  dart.setLibraryUri(SkipWhileIterator, "dart:_internal");
>+  dart.setFieldSignature(SkipWhileIterator, () => ({
>+    __proto__: dart.getFields(SkipWhileIterator.__proto__),
>+    [_iterator]: dart.finalFieldType(IteratorOfE()),
>+    [_f]: dart.finalFieldType(ETobool()),
>+    [_hasSkipped]: dart.fieldType(core.bool)
>+  }));
>+  return SkipWhileIterator;
>+});
>+_internal.SkipWhileIterator = _internal.SkipWhileIterator$();
>+dart.addTypeTests(_internal.SkipWhileIterator, _is_SkipWhileIterator_default);
>+let const$4;
>+const _is_EmptyIterable_default = Symbol('_is_EmptyIterable_default');
>+_internal.EmptyIterable$ = dart.generic(E => {
>+  let VoidToE = () => (VoidToE = dart.constFn(dart.fnType(E, [])))();
>+  let EAndEToE = () => (EAndEToE = dart.constFn(dart.fnType(E, [E, E])))();
>+  let JSArrayOfE = () => (JSArrayOfE = dart.constFn(_interceptors.JSArray$(E)))();
>+  let ListOfE = () => (ListOfE = dart.constFn(core.List$(E)))();
>+  let _HashSetOfE = () => (_HashSetOfE = dart.constFn(collection._HashSet$(E)))();
>+  class EmptyIterable extends _internal.EfficientLengthIterable$(E) {
>+    get iterator() {
>+      return const$4 || (const$4 = dart.const(new (EmptyIteratorOfNull()).new()));
>+    }
>+    forEach(action) {}
>+    get isEmpty() {
>+      return true;
>+    }
>+    get length() {
>+      return 0;
>+    }
>+    get first() {
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    get last() {
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    get single() {
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    elementAt(index) {
>+      dart.throw(new core.RangeError.range(index, 0, 0, "index"));
>+    }
>+    contains(element) {
>+      return false;
>+    }
>+    every(test) {
>+      return true;
>+    }
>+    any(test) {
>+      return false;
>+    }
>+    firstWhere(test, opts) {
>+      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+      VoidToE()._check(orElse);
>+      if (orElse != null) return orElse();
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    lastWhere(test, opts) {
>+      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+      VoidToE()._check(orElse);
>+      if (orElse != null) return orElse();
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    singleWhere(test, opts) {
>+      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+      VoidToE()._check(orElse);
>+      if (orElse != null) return orElse();
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    join(separator) {
>+      if (separator === void 0) separator = "";
>+      return "";
>+    }
>+    where(test) {
>+      return this;
>+    }
>+    map(T, f) {
>+      return new (_internal.EmptyIterable$(T)).new();
>+    }
>+    reduce(combine) {
>+      EAndEToE()._check(combine);
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    fold(T, initialValue, combine) {
>+      return initialValue;
>+    }
>+    skip(count) {
>+      core.RangeError.checkNotNegative(count, "count");
>+      return this;
>+    }
>+    skipWhile(test) {
>+      return this;
>+    }
>+    take(count) {
>+      core.RangeError.checkNotNegative(count, "count");
>+      return this;
>+    }
>+    takeWhile(test) {
>+      return this;
>+    }
>+    toList(opts) {
>+      let growable = opts && 'growable' in opts ? opts.growable : true;
>+      return dart.test(growable) ? JSArrayOfE().of([]) : ListOfE().new(0);
>+    }
>+    toSet() {
>+      return new (_HashSetOfE()).new();
>+    }
>+  }
>+  (EmptyIterable.new = function() {
>+    EmptyIterable.__proto__.new.call(this);
>+  }).prototype = EmptyIterable.prototype;
>+  dart.addTypeTests(EmptyIterable);
>+  EmptyIterable.prototype[_is_EmptyIterable_default] = true;
>+  dart.setMethodSignature(EmptyIterable, () => ({
>+    __proto__: dart.getMethods(EmptyIterable.__proto__),
>+    firstWhere: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    [$firstWhere]: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    lastWhere: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    [$lastWhere]: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    singleWhere: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    [$singleWhere]: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    reduce: dart.fnType(E, [core.Object]),
>+    [$reduce]: dart.fnType(E, [core.Object])
>+  }));
>+  dart.setGetterSignature(EmptyIterable, () => ({
>+    __proto__: dart.getGetters(EmptyIterable.__proto__),
>+    iterator: core.Iterator$(E),
>+    [$iterator]: core.Iterator$(E),
>+    length: core.int,
>+    [$length]: core.int
>+  }));
>+  dart.setLibraryUri(EmptyIterable, "dart:_internal");
>+  dart.defineExtensionMethods(EmptyIterable, [
>+    'forEach',
>+    'elementAt',
>+    'contains',
>+    'every',
>+    'any',
>+    'firstWhere',
>+    'lastWhere',
>+    'singleWhere',
>+    'join',
>+    'where',
>+    'map',
>+    'reduce',
>+    'fold',
>+    'skip',
>+    'skipWhile',
>+    'take',
>+    'takeWhile',
>+    'toList',
>+    'toSet'
>+  ]);
>+  dart.defineExtensionAccessors(EmptyIterable, [
>+    'iterator',
>+    'isEmpty',
>+    'length',
>+    'first',
>+    'last',
>+    'single'
>+  ]);
>+  return EmptyIterable;
>+});
>+_internal.EmptyIterable = _internal.EmptyIterable$();
>+dart.addTypeTests(_internal.EmptyIterable, _is_EmptyIterable_default);
>+const _is_EmptyIterator_default = Symbol('_is_EmptyIterator_default');
>+_internal.EmptyIterator$ = dart.generic(E => {
>+  let IteratorOfE = () => (IteratorOfE = dart.constFn(core.Iterator$(E)))();
>+  class EmptyIterator extends core.Object {
>+    moveNext() {
>+      return false;
>+    }
>+    get current() {
>+      return null;
>+    }
>+  }
>+  (EmptyIterator.new = function() {
>+  }).prototype = EmptyIterator.prototype;
>+  dart.addTypeTests(EmptyIterator);
>+  EmptyIterator.prototype[_is_EmptyIterator_default] = true;
>+  EmptyIterator[dart.implements] = () => [IteratorOfE()];
>+  dart.setMethodSignature(EmptyIterator, () => ({
>+    __proto__: dart.getMethods(EmptyIterator.__proto__),
>+    moveNext: dart.fnType(core.bool, [])
>+  }));
>+  dart.setGetterSignature(EmptyIterator, () => ({
>+    __proto__: dart.getGetters(EmptyIterator.__proto__),
>+    current: E
>+  }));
>+  dart.setLibraryUri(EmptyIterator, "dart:_internal");
>+  return EmptyIterator;
>+});
>+_internal.EmptyIterator = _internal.EmptyIterator$();
>+dart.addTypeTests(_internal.EmptyIterator, _is_EmptyIterator_default);
>+const _first = dart.privateName(_internal, "_first");
>+const _second = dart.privateName(_internal, "_second");
>+const _is_FollowedByIterable_default = Symbol('_is_FollowedByIterable_default');
>+_internal.FollowedByIterable$ = dart.generic(E => {
>+  let EfficientLengthIterableOfE = () => (EfficientLengthIterableOfE = dart.constFn(_internal.EfficientLengthIterable$(E)))();
>+  let EfficientLengthFollowedByIterableOfE = () => (EfficientLengthFollowedByIterableOfE = dart.constFn(_internal.EfficientLengthFollowedByIterable$(E)))();
>+  let FollowedByIterableOfE = () => (FollowedByIterableOfE = dart.constFn(_internal.FollowedByIterable$(E)))();
>+  let FollowedByIteratorOfE = () => (FollowedByIteratorOfE = dart.constFn(_internal.FollowedByIterator$(E)))();
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  class FollowedByIterable extends core.Iterable$(E) {
>+    static firstEfficient(first, second) {
>+      if (EfficientLengthIterableOfE().is(second)) {
>+        return new (EfficientLengthFollowedByIterableOfE()).new(first, second);
>+      }
>+      return new (FollowedByIterableOfE()).new(first, second);
>+    }
>+    get iterator() {
>+      return new (FollowedByIteratorOfE()).new(this[_first], this[_second]);
>+    }
>+    get length() {
>+      return dart.notNull(this[_first][$length]) + dart.notNull(this[_second][$length]);
>+    }
>+    get isEmpty() {
>+      return dart.test(this[_first][$isEmpty]) && dart.test(this[_second][$isEmpty]);
>+    }
>+    get isNotEmpty() {
>+      return dart.test(this[_first][$isNotEmpty]) || dart.test(this[_second][$isNotEmpty]);
>+    }
>+    contains(value) {
>+      return dart.test(this[_first][$contains](value)) || dart.test(this[_second][$contains](value));
>+    }
>+    get first() {
>+      let iterator = this[_first][$iterator];
>+      if (dart.test(iterator.moveNext())) return iterator.current;
>+      return this[_second][$first];
>+    }
>+    get last() {
>+      let iterator = this[_second][$iterator];
>+      if (dart.test(iterator.moveNext())) {
>+        let last = iterator.current;
>+        while (dart.test(iterator.moveNext()))
>+          last = iterator.current;
>+        return last;
>+      }
>+      return this[_first][$last];
>+    }
>+  }
>+  (FollowedByIterable.new = function(first, second) {
>+    this[_first] = first;
>+    this[_second] = second;
>+    FollowedByIterable.__proto__.new.call(this);
>+  }).prototype = FollowedByIterable.prototype;
>+  dart.addTypeTests(FollowedByIterable);
>+  FollowedByIterable.prototype[_is_FollowedByIterable_default] = true;
>+  dart.setGetterSignature(FollowedByIterable, () => ({
>+    __proto__: dart.getGetters(FollowedByIterable.__proto__),
>+    iterator: core.Iterator$(E),
>+    [$iterator]: core.Iterator$(E)
>+  }));
>+  dart.setLibraryUri(FollowedByIterable, "dart:_internal");
>+  dart.setFieldSignature(FollowedByIterable, () => ({
>+    __proto__: dart.getFields(FollowedByIterable.__proto__),
>+    [_first]: dart.finalFieldType(IterableOfE()),
>+    [_second]: dart.finalFieldType(IterableOfE())
>+  }));
>+  dart.defineExtensionMethods(FollowedByIterable, ['contains']);
>+  dart.defineExtensionAccessors(FollowedByIterable, [
>+    'iterator',
>+    'length',
>+    'isEmpty',
>+    'isNotEmpty',
>+    'first',
>+    'last'
>+  ]);
>+  return FollowedByIterable;
>+});
>+_internal.FollowedByIterable = _internal.FollowedByIterable$();
>+dart.addTypeTests(_internal.FollowedByIterable, _is_FollowedByIterable_default);
>+const _is_EfficientLengthFollowedByIterable_default = Symbol('_is_EfficientLengthFollowedByIterable_default');
>+_internal.EfficientLengthFollowedByIterable$ = dart.generic(E => {
>+  let EfficientLengthIterableOfE = () => (EfficientLengthIterableOfE = dart.constFn(_internal.EfficientLengthIterable$(E)))();
>+  let EfficientLengthFollowedByIterableOfE = () => (EfficientLengthFollowedByIterableOfE = dart.constFn(_internal.EfficientLengthFollowedByIterable$(E)))();
>+  class EfficientLengthFollowedByIterable extends _internal.FollowedByIterable$(E) {
>+    skip(count) {
>+      let firstLength = this[_first][$length];
>+      if (dart.notNull(count) >= dart.notNull(firstLength)) return this[_second][$skip](dart.notNull(count) - dart.notNull(firstLength));
>+      return new (EfficientLengthFollowedByIterableOfE()).new(EfficientLengthIterableOfE()._check(this[_first][$skip](count)), EfficientLengthIterableOfE()._check(this[_second]));
>+    }
>+    take(count) {
>+      let firstLength = this[_first][$length];
>+      if (dart.notNull(count) <= dart.notNull(firstLength)) return this[_first][$take](count);
>+      return new (EfficientLengthFollowedByIterableOfE()).new(EfficientLengthIterableOfE()._check(this[_first]), EfficientLengthIterableOfE()._check(this[_second][$take](dart.notNull(count) - dart.notNull(firstLength))));
>+    }
>+    elementAt(index) {
>+      let firstLength = this[_first][$length];
>+      if (dart.notNull(index) < dart.notNull(firstLength)) return this[_first][$elementAt](index);
>+      return this[_second][$elementAt](dart.notNull(index) - dart.notNull(firstLength));
>+    }
>+    get first() {
>+      if (dart.test(this[_first][$isNotEmpty])) return this[_first][$first];
>+      return this[_second][$first];
>+    }
>+    get last() {
>+      if (dart.test(this[_second][$isNotEmpty])) return this[_second][$last];
>+      return this[_first][$last];
>+    }
>+  }
>+  (EfficientLengthFollowedByIterable.new = function(first, second) {
>+    EfficientLengthFollowedByIterable.__proto__.new.call(this, first, second);
>+  }).prototype = EfficientLengthFollowedByIterable.prototype;
>+  dart.addTypeTests(EfficientLengthFollowedByIterable);
>+  EfficientLengthFollowedByIterable.prototype[_is_EfficientLengthFollowedByIterable_default] = true;
>+  EfficientLengthFollowedByIterable[dart.implements] = () => [EfficientLengthIterableOfE()];
>+  dart.setLibraryUri(EfficientLengthFollowedByIterable, "dart:_internal");
>+  dart.defineExtensionMethods(EfficientLengthFollowedByIterable, ['skip', 'take', 'elementAt']);
>+  dart.defineExtensionAccessors(EfficientLengthFollowedByIterable, ['first', 'last']);
>+  return EfficientLengthFollowedByIterable;
>+});
>+_internal.EfficientLengthFollowedByIterable = _internal.EfficientLengthFollowedByIterable$();
>+dart.addTypeTests(_internal.EfficientLengthFollowedByIterable, _is_EfficientLengthFollowedByIterable_default);
>+const _nextIterable = dart.privateName(_internal, "_nextIterable");
>+const _currentIterator = dart.privateName(_internal, "_currentIterator");
>+const _is_FollowedByIterator_default = Symbol('_is_FollowedByIterator_default');
>+_internal.FollowedByIterator$ = dart.generic(E => {
>+  let IteratorOfE = () => (IteratorOfE = dart.constFn(core.Iterator$(E)))();
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  class FollowedByIterator extends core.Object {
>+    moveNext() {
>+      if (dart.test(this[_currentIterator].moveNext())) return true;
>+      if (this[_nextIterable] != null) {
>+        this[_currentIterator] = this[_nextIterable][$iterator];
>+        this[_nextIterable] = null;
>+        return this[_currentIterator].moveNext();
>+      }
>+      return false;
>+    }
>+    get current() {
>+      return this[_currentIterator].current;
>+    }
>+  }
>+  (FollowedByIterator.new = function(first, nextIterable) {
>+    this[_nextIterable] = nextIterable;
>+    this[_currentIterator] = first[$iterator];
>+  }).prototype = FollowedByIterator.prototype;
>+  dart.addTypeTests(FollowedByIterator);
>+  FollowedByIterator.prototype[_is_FollowedByIterator_default] = true;
>+  FollowedByIterator[dart.implements] = () => [IteratorOfE()];
>+  dart.setMethodSignature(FollowedByIterator, () => ({
>+    __proto__: dart.getMethods(FollowedByIterator.__proto__),
>+    moveNext: dart.fnType(core.bool, [])
>+  }));
>+  dart.setGetterSignature(FollowedByIterator, () => ({
>+    __proto__: dart.getGetters(FollowedByIterator.__proto__),
>+    current: E
>+  }));
>+  dart.setLibraryUri(FollowedByIterator, "dart:_internal");
>+  dart.setFieldSignature(FollowedByIterator, () => ({
>+    __proto__: dart.getFields(FollowedByIterator.__proto__),
>+    [_currentIterator]: dart.fieldType(IteratorOfE()),
>+    [_nextIterable]: dart.fieldType(IterableOfE())
>+  }));
>+  return FollowedByIterator;
>+});
>+_internal.FollowedByIterator = _internal.FollowedByIterator$();
>+dart.addTypeTests(_internal.FollowedByIterator, _is_FollowedByIterator_default);
>+const _is_WhereTypeIterable_default = Symbol('_is_WhereTypeIterable_default');
>+_internal.WhereTypeIterable$ = dart.generic(T => {
>+  let WhereTypeIteratorOfT = () => (WhereTypeIteratorOfT = dart.constFn(_internal.WhereTypeIterator$(T)))();
>+  class WhereTypeIterable extends core.Iterable$(T) {
>+    get iterator() {
>+      return new (WhereTypeIteratorOfT()).new(this[_source][$iterator]);
>+    }
>+  }
>+  (WhereTypeIterable.new = function(source) {
>+    this[_source] = source;
>+    WhereTypeIterable.__proto__.new.call(this);
>+  }).prototype = WhereTypeIterable.prototype;
>+  dart.addTypeTests(WhereTypeIterable);
>+  WhereTypeIterable.prototype[_is_WhereTypeIterable_default] = true;
>+  dart.setGetterSignature(WhereTypeIterable, () => ({
>+    __proto__: dart.getGetters(WhereTypeIterable.__proto__),
>+    iterator: core.Iterator$(T),
>+    [$iterator]: core.Iterator$(T)
>+  }));
>+  dart.setLibraryUri(WhereTypeIterable, "dart:_internal");
>+  dart.setFieldSignature(WhereTypeIterable, () => ({
>+    __proto__: dart.getFields(WhereTypeIterable.__proto__),
>+    [_source]: dart.finalFieldType(IterableOfObject())
>+  }));
>+  dart.defineExtensionAccessors(WhereTypeIterable, ['iterator']);
>+  return WhereTypeIterable;
>+});
>+_internal.WhereTypeIterable = _internal.WhereTypeIterable$();
>+dart.addTypeTests(_internal.WhereTypeIterable, _is_WhereTypeIterable_default);
>+const _is_WhereTypeIterator_default = Symbol('_is_WhereTypeIterator_default');
>+_internal.WhereTypeIterator$ = dart.generic(T => {
>+  let IteratorOfT = () => (IteratorOfT = dart.constFn(core.Iterator$(T)))();
>+  class WhereTypeIterator extends core.Object {
>+    moveNext() {
>+      while (dart.test(this[_source].moveNext())) {
>+        if (T.is(this[_source].current)) return true;
>+      }
>+      return false;
>+    }
>+    get current() {
>+      return T._check(this[_source].current);
>+    }
>+  }
>+  (WhereTypeIterator.new = function(source) {
>+    this[_source] = source;
>+  }).prototype = WhereTypeIterator.prototype;
>+  dart.addTypeTests(WhereTypeIterator);
>+  WhereTypeIterator.prototype[_is_WhereTypeIterator_default] = true;
>+  WhereTypeIterator[dart.implements] = () => [IteratorOfT()];
>+  dart.setMethodSignature(WhereTypeIterator, () => ({
>+    __proto__: dart.getMethods(WhereTypeIterator.__proto__),
>+    moveNext: dart.fnType(core.bool, [])
>+  }));
>+  dart.setGetterSignature(WhereTypeIterator, () => ({
>+    __proto__: dart.getGetters(WhereTypeIterator.__proto__),
>+    current: T
>+  }));
>+  dart.setLibraryUri(WhereTypeIterator, "dart:_internal");
>+  dart.setFieldSignature(WhereTypeIterator, () => ({
>+    __proto__: dart.getFields(WhereTypeIterator.__proto__),
>+    [_source]: dart.finalFieldType(IteratorOfObject())
>+  }));
>+  return WhereTypeIterator;
>+});
>+_internal.WhereTypeIterator = _internal.WhereTypeIterator$();
>+dart.addTypeTests(_internal.WhereTypeIterator, _is_WhereTypeIterator_default);
>+_internal.IterableElementError = class IterableElementError extends core.Object {
>+  static noElement() {
>+    return new core.StateError.new("No element");
>+  }
>+  static tooMany() {
>+    return new core.StateError.new("Too many elements");
>+  }
>+  static tooFew() {
>+    return new core.StateError.new("Too few elements");
>+  }
>+};
>+(_internal.IterableElementError.new = function() {
>+}).prototype = _internal.IterableElementError.prototype;
>+dart.addTypeTests(_internal.IterableElementError);
>+dart.setLibraryUri(_internal.IterableElementError, "dart:_internal");
>+const _is_FixedLengthListMixin_default = Symbol('_is_FixedLengthListMixin_default');
>+_internal.FixedLengthListMixin$ = dart.generic(E => {
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  class FixedLengthListMixin extends core.Object {
>+    set length(newLength) {
>+      dart.throw(new core.UnsupportedError.new("Cannot change the length of a fixed-length list"));
>+    }
>+    add(value) {
>+      E._check(value);
>+      dart.throw(new core.UnsupportedError.new("Cannot add to a fixed-length list"));
>+    }
>+    insert(index, value) {
>+      E._check(value);
>+      dart.throw(new core.UnsupportedError.new("Cannot add to a fixed-length list"));
>+    }
>+    insertAll(at, iterable) {
>+      IterableOfE()._check(iterable);
>+      dart.throw(new core.UnsupportedError.new("Cannot add to a fixed-length list"));
>+    }
>+    addAll(iterable) {
>+      IterableOfE()._check(iterable);
>+      dart.throw(new core.UnsupportedError.new("Cannot add to a fixed-length list"));
>+    }
>+    remove(element) {
>+      dart.throw(new core.UnsupportedError.new("Cannot remove from a fixed-length list"));
>+    }
>+    removeWhere(test) {
>+      dart.throw(new core.UnsupportedError.new("Cannot remove from a fixed-length list"));
>+    }
>+    retainWhere(test) {
>+      dart.throw(new core.UnsupportedError.new("Cannot remove from a fixed-length list"));
>+    }
>+    clear() {
>+      dart.throw(new core.UnsupportedError.new("Cannot clear a fixed-length list"));
>+    }
>+    removeAt(index) {
>+      dart.throw(new core.UnsupportedError.new("Cannot remove from a fixed-length list"));
>+    }
>+    removeLast() {
>+      dart.throw(new core.UnsupportedError.new("Cannot remove from a fixed-length list"));
>+    }
>+    removeRange(start, end) {
>+      dart.throw(new core.UnsupportedError.new("Cannot remove from a fixed-length list"));
>+    }
>+    replaceRange(start, end, iterable) {
>+      IterableOfE()._check(iterable);
>+      dart.throw(new core.UnsupportedError.new("Cannot remove from a fixed-length list"));
>+    }
>+  }
>+  (FixedLengthListMixin.new = function() {
>+  }).prototype = FixedLengthListMixin.prototype;
>+  dart.addTypeTests(FixedLengthListMixin);
>+  FixedLengthListMixin.prototype[_is_FixedLengthListMixin_default] = true;
>+  dart.setMethodSignature(FixedLengthListMixin, () => ({
>+    __proto__: dart.getMethods(FixedLengthListMixin.__proto__),
>+    add: dart.fnType(dart.void, [core.Object]),
>+    [$add]: dart.fnType(dart.void, [core.Object]),
>+    insert: dart.fnType(dart.void, [core.int, core.Object]),
>+    [$insert]: dart.fnType(dart.void, [core.int, core.Object]),
>+    insertAll: dart.fnType(dart.void, [core.int, core.Object]),
>+    [$insertAll]: dart.fnType(dart.void, [core.int, core.Object]),
>+    addAll: dart.fnType(dart.void, [core.Object]),
>+    [$addAll]: dart.fnType(dart.void, [core.Object]),
>+    remove: dart.fnType(core.bool, [core.Object]),
>+    [$remove]: dart.fnType(core.bool, [core.Object]),
>+    removeWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [E])]),
>+    [$removeWhere]: dart.fnType(dart.void, [dart.fnType(core.bool, [E])]),
>+    retainWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [E])]),
>+    [$retainWhere]: dart.fnType(dart.void, [dart.fnType(core.bool, [E])]),
>+    clear: dart.fnType(dart.void, []),
>+    [$clear]: dart.fnType(dart.void, []),
>+    removeAt: dart.fnType(E, [core.int]),
>+    [$removeAt]: dart.fnType(E, [core.int]),
>+    removeLast: dart.fnType(E, []),
>+    [$removeLast]: dart.fnType(E, []),
>+    removeRange: dart.fnType(dart.void, [core.int, core.int]),
>+    [$removeRange]: dart.fnType(dart.void, [core.int, core.int]),
>+    replaceRange: dart.fnType(dart.void, [core.int, core.int, core.Object]),
>+    [$replaceRange]: dart.fnType(dart.void, [core.int, core.int, core.Object])
>+  }));
>+  dart.setSetterSignature(FixedLengthListMixin, () => ({
>+    __proto__: dart.getSetters(FixedLengthListMixin.__proto__),
>+    length: core.int,
>+    [$length]: core.int
>+  }));
>+  dart.setLibraryUri(FixedLengthListMixin, "dart:_internal");
>+  dart.defineExtensionMethods(FixedLengthListMixin, [
>+    'add',
>+    'insert',
>+    'insertAll',
>+    'addAll',
>+    'remove',
>+    'removeWhere',
>+    'retainWhere',
>+    'clear',
>+    'removeAt',
>+    'removeLast',
>+    'removeRange',
>+    'replaceRange'
>+  ]);
>+  dart.defineExtensionAccessors(FixedLengthListMixin, ['length']);
>+  return FixedLengthListMixin;
>+});
>+_internal.FixedLengthListMixin = _internal.FixedLengthListMixin$();
>+dart.addTypeTests(_internal.FixedLengthListMixin, _is_FixedLengthListMixin_default);
>+const _is_FixedLengthListBase_default = Symbol('_is_FixedLengthListBase_default');
>+_internal.FixedLengthListBase$ = dart.generic(E => {
>+  const ListBase_FixedLengthListMixin$ = class ListBase_FixedLengthListMixin extends collection.ListBase$(E) {};
>+  (ListBase_FixedLengthListMixin$.new = function() {
>+  }).prototype = ListBase_FixedLengthListMixin$.prototype;
>+  dart.applyMixin(ListBase_FixedLengthListMixin$, _internal.FixedLengthListMixin$(E));
>+  class FixedLengthListBase extends ListBase_FixedLengthListMixin$ {}
>+  (FixedLengthListBase.new = function() {
>+  }).prototype = FixedLengthListBase.prototype;
>+  dart.addTypeTests(FixedLengthListBase);
>+  FixedLengthListBase.prototype[_is_FixedLengthListBase_default] = true;
>+  dart.setLibraryUri(FixedLengthListBase, "dart:_internal");
>+  return FixedLengthListBase;
>+});
>+_internal.FixedLengthListBase = _internal.FixedLengthListBase$();
>+dart.addTypeTests(_internal.FixedLengthListBase, _is_FixedLengthListBase_default);
>+const _backedList = dart.privateName(_internal, "_backedList");
>+_internal._ListIndicesIterable = class _ListIndicesIterable extends _internal.ListIterable$(core.int) {
>+  get length() {
>+    return this[_backedList][$length];
>+  }
>+  elementAt(index) {
>+    core.RangeError.checkValidIndex(index, this);
>+    return index;
>+  }
>+};
>+(_internal._ListIndicesIterable.new = function(backedList) {
>+  this[_backedList] = backedList;
>+  _internal._ListIndicesIterable.__proto__.new.call(this);
>+}).prototype = _internal._ListIndicesIterable.prototype;
>+dart.addTypeTests(_internal._ListIndicesIterable);
>+dart.setMethodSignature(_internal._ListIndicesIterable, () => ({
>+  __proto__: dart.getMethods(_internal._ListIndicesIterable.__proto__),
>+  elementAt: dart.fnType(core.int, [core.int]),
>+  [$elementAt]: dart.fnType(core.int, [core.int])
>+}));
>+dart.setGetterSignature(_internal._ListIndicesIterable, () => ({
>+  __proto__: dart.getGetters(_internal._ListIndicesIterable.__proto__),
>+  length: core.int,
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(_internal._ListIndicesIterable, "dart:_internal");
>+dart.setFieldSignature(_internal._ListIndicesIterable, () => ({
>+  __proto__: dart.getFields(_internal._ListIndicesIterable.__proto__),
>+  [_backedList]: dart.fieldType(core.List)
>+}));
>+dart.defineExtensionMethods(_internal._ListIndicesIterable, ['elementAt']);
>+dart.defineExtensionAccessors(_internal._ListIndicesIterable, ['length']);
>+const _values = dart.privateName(_internal, "_values");
>+const _is__UnmodifiableMapMixin_default = Symbol('_is__UnmodifiableMapMixin_default');
>+collection._UnmodifiableMapMixin$ = dart.generic((K, V) => {
>+  let MapOfK$V = () => (MapOfK$V = dart.constFn(core.Map$(K, V)))();
>+  let MapEntryOfK$V = () => (MapEntryOfK$V = dart.constFn(core.MapEntry$(K, V)))();
>+  let IterableOfMapEntryOfK$V = () => (IterableOfMapEntryOfK$V = dart.constFn(core.Iterable$(MapEntryOfK$V())))();
>+  let KAndVToV = () => (KAndVToV = dart.constFn(dart.fnType(V, [K, V])))();
>+  let VoidToV = () => (VoidToV = dart.constFn(dart.fnType(V, [])))();
>+  let VToV = () => (VToV = dart.constFn(dart.fnType(V, [V])))();
>+  class _UnmodifiableMapMixin extends core.Object {
>+    _set(key, value) {
>+      K._check(key);
>+      V._check(value);
>+      dart.throw(new core.UnsupportedError.new("Cannot modify unmodifiable map"));
>+      return value;
>+    }
>+    addAll(other) {
>+      MapOfK$V()._check(other);
>+      dart.throw(new core.UnsupportedError.new("Cannot modify unmodifiable map"));
>+    }
>+    addEntries(entries) {
>+      IterableOfMapEntryOfK$V()._check(entries);
>+      dart.throw(new core.UnsupportedError.new("Cannot modify unmodifiable map"));
>+    }
>+    clear() {
>+      dart.throw(new core.UnsupportedError.new("Cannot modify unmodifiable map"));
>+    }
>+    remove(key) {
>+      dart.throw(new core.UnsupportedError.new("Cannot modify unmodifiable map"));
>+    }
>+    removeWhere(test) {
>+      dart.throw(new core.UnsupportedError.new("Cannot modify unmodifiable map"));
>+    }
>+    putIfAbsent(key, ifAbsent) {
>+      K._check(key);
>+      VoidToV()._check(ifAbsent);
>+      dart.throw(new core.UnsupportedError.new("Cannot modify unmodifiable map"));
>+    }
>+    update(key, update, opts) {
>+      K._check(key);
>+      VToV()._check(update);
>+      let ifAbsent = opts && 'ifAbsent' in opts ? opts.ifAbsent : null;
>+      VoidToV()._check(ifAbsent);
>+      dart.throw(new core.UnsupportedError.new("Cannot modify unmodifiable map"));
>+    }
>+    updateAll(update) {
>+      KAndVToV()._check(update);
>+      dart.throw(new core.UnsupportedError.new("Cannot modify unmodifiable map"));
>+    }
>+  }
>+  (_UnmodifiableMapMixin.new = function() {
>+  }).prototype = _UnmodifiableMapMixin.prototype;
>+  _UnmodifiableMapMixin.prototype[dart.isMap] = true;
>+  dart.addTypeTests(_UnmodifiableMapMixin);
>+  _UnmodifiableMapMixin.prototype[_is__UnmodifiableMapMixin_default] = true;
>+  _UnmodifiableMapMixin[dart.implements] = () => [MapOfK$V()];
>+  dart.setMethodSignature(_UnmodifiableMapMixin, () => ({
>+    __proto__: dart.getMethods(_UnmodifiableMapMixin.__proto__),
>+    _set: dart.fnType(dart.void, [core.Object, core.Object]),
>+    [$_set]: dart.fnType(dart.void, [core.Object, core.Object]),
>+    addAll: dart.fnType(dart.void, [core.Object]),
>+    [$addAll]: dart.fnType(dart.void, [core.Object]),
>+    addEntries: dart.fnType(dart.void, [core.Object]),
>+    [$addEntries]: dart.fnType(dart.void, [core.Object]),
>+    clear: dart.fnType(dart.void, []),
>+    [$clear]: dart.fnType(dart.void, []),
>+    remove: dart.fnType(V, [core.Object]),
>+    [$remove]: dart.fnType(V, [core.Object]),
>+    removeWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [K, V])]),
>+    [$removeWhere]: dart.fnType(dart.void, [dart.fnType(core.bool, [K, V])]),
>+    putIfAbsent: dart.fnType(V, [core.Object, core.Object]),
>+    [$putIfAbsent]: dart.fnType(V, [core.Object, core.Object]),
>+    update: dart.fnType(V, [core.Object, core.Object], {ifAbsent: core.Object}),
>+    [$update]: dart.fnType(V, [core.Object, core.Object], {ifAbsent: core.Object}),
>+    updateAll: dart.fnType(dart.void, [core.Object]),
>+    [$updateAll]: dart.fnType(dart.void, [core.Object])
>+  }));
>+  dart.setLibraryUri(_UnmodifiableMapMixin, "dart:collection");
>+  dart.defineExtensionMethods(_UnmodifiableMapMixin, [
>+    '_set',
>+    'addAll',
>+    'addEntries',
>+    'clear',
>+    'remove',
>+    'removeWhere',
>+    'putIfAbsent',
>+    'update',
>+    'updateAll'
>+  ]);
>+  return _UnmodifiableMapMixin;
>+});
>+collection._UnmodifiableMapMixin = collection._UnmodifiableMapMixin$();
>+dart.addTypeTests(collection._UnmodifiableMapMixin, _is__UnmodifiableMapMixin_default);
>+const _is_UnmodifiableMapBase_default = Symbol('_is_UnmodifiableMapBase_default');
>+collection.UnmodifiableMapBase$ = dart.generic((K, V) => {
>+  const MapBase__UnmodifiableMapMixin$ = class MapBase__UnmodifiableMapMixin extends collection.MapBase$(K, V) {};
>+  (MapBase__UnmodifiableMapMixin$.new = function() {
>+  }).prototype = MapBase__UnmodifiableMapMixin$.prototype;
>+  dart.applyMixin(MapBase__UnmodifiableMapMixin$, collection._UnmodifiableMapMixin$(K, V));
>+  class UnmodifiableMapBase extends MapBase__UnmodifiableMapMixin$ {}
>+  (UnmodifiableMapBase.new = function() {
>+  }).prototype = UnmodifiableMapBase.prototype;
>+  dart.addTypeTests(UnmodifiableMapBase);
>+  UnmodifiableMapBase.prototype[_is_UnmodifiableMapBase_default] = true;
>+  dart.setLibraryUri(UnmodifiableMapBase, "dart:collection");
>+  return UnmodifiableMapBase;
>+});
>+collection.UnmodifiableMapBase = collection.UnmodifiableMapBase$();
>+dart.addTypeTests(collection.UnmodifiableMapBase, _is_UnmodifiableMapBase_default);
>+const _is_ListMapView_default = Symbol('_is_ListMapView_default');
>+_internal.ListMapView$ = dart.generic(E => {
>+  let SubListIterableOfE = () => (SubListIterableOfE = dart.constFn(_internal.SubListIterable$(E)))();
>+  let ListOfE = () => (ListOfE = dart.constFn(core.List$(E)))();
>+  class ListMapView extends collection.UnmodifiableMapBase$(core.int, E) {
>+    _get(key) {
>+      return dart.test(this.containsKey(key)) ? this[_values][$_get](core.int._check(key)) : null;
>+    }
>+    get length() {
>+      return this[_values][$length];
>+    }
>+    get values() {
>+      return new (SubListIterableOfE()).new(this[_values], 0, null);
>+    }
>+    get keys() {
>+      return new _internal._ListIndicesIterable.new(this[_values]);
>+    }
>+    get isEmpty() {
>+      return this[_values][$isEmpty];
>+    }
>+    get isNotEmpty() {
>+      return this[_values][$isNotEmpty];
>+    }
>+    containsValue(value) {
>+      return this[_values][$contains](value);
>+    }
>+    containsKey(key) {
>+      return core.int.is(key) && dart.notNull(key) >= 0 && dart.notNull(key) < dart.notNull(this.length);
>+    }
>+    forEach(f) {
>+      let length = this[_values][$length];
>+      for (let i = 0; i < dart.notNull(length); i++) {
>+        f(i, this[_values][$_get](i));
>+        if (length != this[_values][$length]) {
>+          dart.throw(new core.ConcurrentModificationError.new(this[_values]));
>+        }
>+      }
>+    }
>+  }
>+  (ListMapView.new = function(values) {
>+    this[_values] = values;
>+  }).prototype = ListMapView.prototype;
>+  dart.addTypeTests(ListMapView);
>+  ListMapView.prototype[_is_ListMapView_default] = true;
>+  dart.setMethodSignature(ListMapView, () => ({
>+    __proto__: dart.getMethods(ListMapView.__proto__),
>+    _get: dart.fnType(E, [core.Object]),
>+    [$_get]: dart.fnType(E, [core.Object]),
>+    containsValue: dart.fnType(core.bool, [core.Object]),
>+    [$containsValue]: dart.fnType(core.bool, [core.Object]),
>+    containsKey: dart.fnType(core.bool, [core.Object]),
>+    [$containsKey]: dart.fnType(core.bool, [core.Object]),
>+    forEach: dart.fnType(dart.void, [dart.fnType(dart.void, [core.int, E])]),
>+    [$forEach]: dart.fnType(dart.void, [dart.fnType(dart.void, [core.int, E])])
>+  }));
>+  dart.setGetterSignature(ListMapView, () => ({
>+    __proto__: dart.getGetters(ListMapView.__proto__),
>+    length: core.int,
>+    [$length]: core.int,
>+    values: core.Iterable$(E),
>+    [$values]: core.Iterable$(E),
>+    keys: core.Iterable$(core.int),
>+    [$keys]: core.Iterable$(core.int),
>+    isEmpty: core.bool,
>+    [$isEmpty]: core.bool,
>+    isNotEmpty: core.bool,
>+    [$isNotEmpty]: core.bool
>+  }));
>+  dart.setLibraryUri(ListMapView, "dart:_internal");
>+  dart.setFieldSignature(ListMapView, () => ({
>+    __proto__: dart.getFields(ListMapView.__proto__),
>+    [_values]: dart.fieldType(ListOfE())
>+  }));
>+  dart.defineExtensionMethods(ListMapView, ['_get', 'containsValue', 'containsKey', 'forEach']);
>+  dart.defineExtensionAccessors(ListMapView, [
>+    'length',
>+    'values',
>+    'keys',
>+    'isEmpty',
>+    'isNotEmpty'
>+  ]);
>+  return ListMapView;
>+});
>+_internal.ListMapView = _internal.ListMapView$();
>+dart.addTypeTests(_internal.ListMapView, _is_ListMapView_default);
>+const _is_ReversedListIterable_default = Symbol('_is_ReversedListIterable_default');
>+_internal.ReversedListIterable$ = dart.generic(E => {
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  class ReversedListIterable extends _internal.ListIterable$(E) {
>+    get length() {
>+      return this[_source][$length];
>+    }
>+    elementAt(index) {
>+      return this[_source][$elementAt](dart.notNull(this[_source][$length]) - 1 - dart.notNull(index));
>+    }
>+  }
>+  (ReversedListIterable.new = function(source) {
>+    this[_source] = source;
>+    ReversedListIterable.__proto__.new.call(this);
>+  }).prototype = ReversedListIterable.prototype;
>+  dart.addTypeTests(ReversedListIterable);
>+  ReversedListIterable.prototype[_is_ReversedListIterable_default] = true;
>+  dart.setMethodSignature(ReversedListIterable, () => ({
>+    __proto__: dart.getMethods(ReversedListIterable.__proto__),
>+    elementAt: dart.fnType(E, [core.int]),
>+    [$elementAt]: dart.fnType(E, [core.int])
>+  }));
>+  dart.setGetterSignature(ReversedListIterable, () => ({
>+    __proto__: dart.getGetters(ReversedListIterable.__proto__),
>+    length: core.int,
>+    [$length]: core.int
>+  }));
>+  dart.setLibraryUri(ReversedListIterable, "dart:_internal");
>+  dart.setFieldSignature(ReversedListIterable, () => ({
>+    __proto__: dart.getFields(ReversedListIterable.__proto__),
>+    [_source]: dart.fieldType(IterableOfE())
>+  }));
>+  dart.defineExtensionMethods(ReversedListIterable, ['elementAt']);
>+  dart.defineExtensionAccessors(ReversedListIterable, ['length']);
>+  return ReversedListIterable;
>+});
>+_internal.ReversedListIterable = _internal.ReversedListIterable$();
>+dart.addTypeTests(_internal.ReversedListIterable, _is_ReversedListIterable_default);
>+_internal.UnmodifiableListError = class UnmodifiableListError extends core.Object {
>+  static add() {
>+    return new core.UnsupportedError.new("Cannot add to unmodifiable List");
>+  }
>+  static change() {
>+    return new core.UnsupportedError.new("Cannot change the content of an unmodifiable List");
>+  }
>+  static length() {
>+    return new core.UnsupportedError.new("Cannot change length of unmodifiable List");
>+  }
>+  static remove() {
>+    return new core.UnsupportedError.new("Cannot remove from unmodifiable List");
>+  }
>+};
>+(_internal.UnmodifiableListError.new = function() {
>+}).prototype = _internal.UnmodifiableListError.prototype;
>+dart.addTypeTests(_internal.UnmodifiableListError);
>+dart.setLibraryUri(_internal.UnmodifiableListError, "dart:_internal");
>+_internal.NonGrowableListError = class NonGrowableListError extends core.Object {
>+  static add() {
>+    return new core.UnsupportedError.new("Cannot add to non-growable List");
>+  }
>+  static length() {
>+    return new core.UnsupportedError.new("Cannot change length of non-growable List");
>+  }
>+  static remove() {
>+    return new core.UnsupportedError.new("Cannot remove from non-growable List");
>+  }
>+};
>+(_internal.NonGrowableListError.new = function() {
>+}).prototype = _internal.NonGrowableListError.prototype;
>+dart.addTypeTests(_internal.NonGrowableListError);
>+dart.setLibraryUri(_internal.NonGrowableListError, "dart:_internal");
>+_internal.makeListFixedLength = function(E, growableList) {
>+  _interceptors.JSArray.markFixedList(growableList);
>+  return growableList;
>+};
>+_internal.makeFixedListUnmodifiable = function(E, fixedLengthList) {
>+  _interceptors.JSArray.markUnmodifiableList(fixedLengthList);
>+  return fixedLengthList;
>+};
>+dart.defineLazy(_internal, {
>+  /*_internal.printToZone*/get printToZone() {
>+    return null;
>+  },
>+  set printToZone(_) {}
>+});
>+_internal.printToConsole = function(line) {
>+  _js_primitives.printString(dart.str(line));
>+};
>+_internal.Sort = class Sort extends core.Object {
>+  static sort(E, a, compare) {
>+    _internal.Sort._doSort(E, a, 0, dart.notNull(a[$length]) - 1, compare);
>+  }
>+  static sortRange(E, a, from, to, compare) {
>+    if (dart.notNull(from) < 0 || dart.notNull(to) > dart.notNull(a[$length]) || dart.notNull(to) < dart.notNull(from)) {
>+      dart.throw("OutOfRange");
>+    }
>+    _internal.Sort._doSort(E, a, from, dart.notNull(to) - 1, compare);
>+  }
>+  static _doSort(E, a, left, right, compare) {
>+    if (dart.notNull(right) - dart.notNull(left) <= 32) {
>+      _internal.Sort._insertionSort(E, a, left, right, compare);
>+    } else {
>+      _internal.Sort._dualPivotQuicksort(E, a, left, right, compare);
>+    }
>+  }
>+  static _insertionSort(E, a, left, right, compare) {
>+    for (let i = dart.notNull(left) + 1; i <= dart.notNull(right); i++) {
>+      let el = a[$_get](i);
>+      let j = i;
>+      while (j > dart.notNull(left) && dart.notNull(compare(a[$_get](j - 1), el)) > 0) {
>+        a[$_set](j, a[$_get](j - 1));
>+        j--;
>+      }
>+      a[$_set](j, el);
>+    }
>+  }
>+  static _dualPivotQuicksort(E, a, left, right, compare) {
>+    if (!(dart.notNull(right) - dart.notNull(left) > 32)) dart.assertFailed(null, "dart:_internal/sort.dart", 79, 12, "right - left > _INSERTION_SORT_THRESHOLD");
>+    let sixth = ((dart.notNull(right) - dart.notNull(left) + 1) / 6)[$truncate]();
>+    let index1 = dart.notNull(left) + sixth;
>+    let index5 = dart.notNull(right) - sixth;
>+    let index3 = ((dart.notNull(left) + dart.notNull(right)) / 2)[$truncate]();
>+    let index2 = index3 - sixth;
>+    let index4 = index3 + sixth;
>+    let el1 = a[$_get](index1);
>+    let el2 = a[$_get](index2);
>+    let el3 = a[$_get](index3);
>+    let el4 = a[$_get](index4);
>+    let el5 = a[$_get](index5);
>+    if (dart.notNull(compare(el1, el2)) > 0) {
>+      let t = el1;
>+      el1 = el2;
>+      el2 = t;
>+    }
>+    if (dart.notNull(compare(el4, el5)) > 0) {
>+      let t = el4;
>+      el4 = el5;
>+      el5 = t;
>+    }
>+    if (dart.notNull(compare(el1, el3)) > 0) {
>+      let t = el1;
>+      el1 = el3;
>+      el3 = t;
>+    }
>+    if (dart.notNull(compare(el2, el3)) > 0) {
>+      let t = el2;
>+      el2 = el3;
>+      el3 = t;
>+    }
>+    if (dart.notNull(compare(el1, el4)) > 0) {
>+      let t = el1;
>+      el1 = el4;
>+      el4 = t;
>+    }
>+    if (dart.notNull(compare(el3, el4)) > 0) {
>+      let t = el3;
>+      el3 = el4;
>+      el4 = t;
>+    }
>+    if (dart.notNull(compare(el2, el5)) > 0) {
>+      let t = el2;
>+      el2 = el5;
>+      el5 = t;
>+    }
>+    if (dart.notNull(compare(el2, el3)) > 0) {
>+      let t = el2;
>+      el2 = el3;
>+      el3 = t;
>+    }
>+    if (dart.notNull(compare(el4, el5)) > 0) {
>+      let t = el4;
>+      el4 = el5;
>+      el5 = t;
>+    }
>+    let pivot1 = el2;
>+    let pivot2 = el4;
>+    a[$_set](index1, el1);
>+    a[$_set](index3, el3);
>+    a[$_set](index5, el5);
>+    a[$_set](index2, a[$_get](left));
>+    a[$_set](index4, a[$_get](right));
>+    let less = dart.notNull(left) + 1;
>+    let great = dart.notNull(right) - 1;
>+    let pivots_are_equal = compare(pivot1, pivot2) === 0;
>+    if (pivots_are_equal) {
>+      let pivot = pivot1;
>+      for (let k = less; k <= great; k++) {
>+        let ak = a[$_get](k);
>+        let comp = compare(ak, pivot);
>+        if (comp === 0) continue;
>+        if (dart.notNull(comp) < 0) {
>+          if (k !== less) {
>+            a[$_set](k, a[$_get](less));
>+            a[$_set](less, ak);
>+          }
>+          less++;
>+        } else {
>+          while (true) {
>+            comp = compare(a[$_get](great), pivot);
>+            if (dart.notNull(comp) > 0) {
>+              great--;
>+              continue;
>+            } else if (dart.notNull(comp) < 0) {
>+              a[$_set](k, a[$_get](less));
>+              a[$_set](less++, a[$_get](great));
>+              a[$_set](great--, ak);
>+              break;
>+            } else {
>+              a[$_set](k, a[$_get](great));
>+              a[$_set](great--, ak);
>+              break;
>+            }
>+          }
>+        }
>+      }
>+    } else {
>+      for (let k = less; k <= great; k++) {
>+        let ak = a[$_get](k);
>+        let comp_pivot1 = compare(ak, pivot1);
>+        if (dart.notNull(comp_pivot1) < 0) {
>+          if (k !== less) {
>+            a[$_set](k, a[$_get](less));
>+            a[$_set](less, ak);
>+          }
>+          less++;
>+        } else {
>+          let comp_pivot2 = compare(ak, pivot2);
>+          if (dart.notNull(comp_pivot2) > 0) {
>+            while (true) {
>+              let comp = compare(a[$_get](great), pivot2);
>+              if (dart.notNull(comp) > 0) {
>+                great--;
>+                if (great < k) break;
>+                continue;
>+              } else {
>+                comp = compare(a[$_get](great), pivot1);
>+                if (dart.notNull(comp) < 0) {
>+                  a[$_set](k, a[$_get](less));
>+                  a[$_set](less++, a[$_get](great));
>+                  a[$_set](great--, ak);
>+                } else {
>+                  a[$_set](k, a[$_get](great));
>+                  a[$_set](great--, ak);
>+                }
>+                break;
>+              }
>+            }
>+          }
>+        }
>+      }
>+    }
>+    a[$_set](left, a[$_get](less - 1));
>+    a[$_set](less - 1, pivot1);
>+    a[$_set](right, a[$_get](great + 1));
>+    a[$_set](great + 1, pivot2);
>+    _internal.Sort._doSort(E, a, left, less - 2, compare);
>+    _internal.Sort._doSort(E, a, great + 2, right, compare);
>+    if (pivots_are_equal) {
>+      return;
>+    }
>+    if (less < index1 && great > index5) {
>+      while (compare(a[$_get](less), pivot1) === 0) {
>+        less++;
>+      }
>+      while (compare(a[$_get](great), pivot2) === 0) {
>+        great--;
>+      }
>+      for (let k = less; k <= great; k++) {
>+        let ak = a[$_get](k);
>+        let comp_pivot1 = compare(ak, pivot1);
>+        if (comp_pivot1 === 0) {
>+          if (k !== less) {
>+            a[$_set](k, a[$_get](less));
>+            a[$_set](less, ak);
>+          }
>+          less++;
>+        } else {
>+          let comp_pivot2 = compare(ak, pivot2);
>+          if (comp_pivot2 === 0) {
>+            while (true) {
>+              let comp = compare(a[$_get](great), pivot2);
>+              if (comp === 0) {
>+                great--;
>+                if (great < k) break;
>+                continue;
>+              } else {
>+                comp = compare(a[$_get](great), pivot1);
>+                if (dart.notNull(comp) < 0) {
>+                  a[$_set](k, a[$_get](less));
>+                  a[$_set](less++, a[$_get](great));
>+                  a[$_set](great--, ak);
>+                } else {
>+                  a[$_set](k, a[$_get](great));
>+                  a[$_set](great--, ak);
>+                }
>+                break;
>+              }
>+            }
>+          }
>+        }
>+      }
>+      _internal.Sort._doSort(E, a, less, great, compare);
>+    } else {
>+      _internal.Sort._doSort(E, a, less, great, compare);
>+    }
>+  }
>+};
>+(_internal.Sort.new = function() {
>+}).prototype = _internal.Sort.prototype;
>+dart.addTypeTests(_internal.Sort);
>+dart.setLibraryUri(_internal.Sort, "dart:_internal");
>+dart.defineLazy(_internal.Sort, {
>+  /*_internal.Sort._INSERTION_SORT_THRESHOLD*/get _INSERTION_SORT_THRESHOLD() {
>+    return 32;
>+  }
>+});
>+const _name = dart.privateName(_internal, "_name");
>+_internal.Symbol = class Symbol extends core.Object {
>+  _equals(other) {
>+    return _internal.Symbol.is(other) && this[_name] == other[_name];
>+  }
>+  get hashCode() {
>+    let hash = this._hashCode;
>+    if (hash != null) return hash;
>+    let arbitraryPrime = 664597;
>+    hash = 536870911 & arbitraryPrime * dart.hashCode(this[_name]);
>+    this._hashCode = hash;
>+    return hash;
>+  }
>+  toString() {
>+    return "Symbol(\"" + dart.str(this[_name]) + "\")";
>+  }
>+  static getName(symbol) {
>+    return symbol[_name];
>+  }
>+  static validatePublicSymbol(name) {
>+    if (name[$isEmpty] || dart.test(_internal.Symbol.publicSymbolPattern.hasMatch(name))) return name;
>+    if (name[$startsWith]("_")) {
>+      dart.throw(new core.ArgumentError.new("\"" + dart.str(name) + "\" is a private identifier"));
>+    }
>+    dart.throw(new core.ArgumentError.new("\"" + dart.str(name) + "\" is not a valid (qualified) symbol name"));
>+  }
>+  static isValidSymbol(name) {
>+    return name[$isEmpty] || dart.test(_internal.Symbol.symbolPattern.hasMatch(name));
>+  }
>+  static computeUnmangledName(symbol) {
>+    return symbol[_name];
>+  }
>+};
>+(_internal.Symbol.new = function(name) {
>+  this[_name] = name;
>+}).prototype = _internal.Symbol.prototype;
>+(_internal.Symbol.unvalidated = function(name) {
>+  this[_name] = name;
>+}).prototype = _internal.Symbol.prototype;
>+(_internal.Symbol.validated = function(name) {
>+  this[_name] = _internal.Symbol.validatePublicSymbol(name);
>+}).prototype = _internal.Symbol.prototype;
>+dart.addTypeTests(_internal.Symbol);
>+_internal.Symbol[dart.implements] = () => [core.Symbol];
>+dart.setLibraryUri(_internal.Symbol, "dart:_internal");
>+dart.setFieldSignature(_internal.Symbol, () => ({
>+  __proto__: dart.getFields(_internal.Symbol.__proto__),
>+  [_name]: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionMethods(_internal.Symbol, ['_equals', 'toString']);
>+dart.defineExtensionAccessors(_internal.Symbol, ['hashCode']);
>+dart.defineLazy(_internal.Symbol, {
>+  /*_internal.Symbol.reservedWordRE*/get reservedWordRE() {
>+    return "(?:assert|break|c(?:a(?:se|tch)|lass|on(?:st|tinue))|d(?:efault|o)|" + "e(?:lse|num|xtends)|f(?:alse|inal(?:ly)?|or)|i[fns]|n(?:ew|ull)|" + "ret(?:hrow|urn)|s(?:uper|witch)|t(?:h(?:is|row)|r(?:ue|y))|" + "v(?:ar|oid)|w(?:hile|ith))";
>+  },
>+  /*_internal.Symbol.publicIdentifierRE*/get publicIdentifierRE() {
>+    return "(?!" + "(?:assert|break|c(?:a(?:se|tch)|lass|on(?:st|tinue))|d(?:efault|o)|e(?:lse|num|xtends)|f(?:alse|inal(?:ly)?|or)|i[fns]|n(?:ew|ull)|ret(?:hrow|urn)|s(?:uper|witch)|t(?:h(?:is|row)|r(?:ue|y))|v(?:ar|oid)|w(?:hile|ith))" + "\\b(?!\\$))[a-zA-Z$][\\w$]*";
>+  },
>+  /*_internal.Symbol.identifierRE*/get identifierRE() {
>+    return "(?!" + "(?:assert|break|c(?:a(?:se|tch)|lass|on(?:st|tinue))|d(?:efault|o)|e(?:lse|num|xtends)|f(?:alse|inal(?:ly)?|or)|i[fns]|n(?:ew|ull)|ret(?:hrow|urn)|s(?:uper|witch)|t(?:h(?:is|row)|r(?:ue|y))|v(?:ar|oid)|w(?:hile|ith))" + "\\b(?!\\$))[a-zA-Z$_][\\w$]*";
>+  },
>+  /*_internal.Symbol.operatorRE*/get operatorRE() {
>+    return "(?:[\\-+*/%&|^]|\\[\\]=?|==|~/?|<[<=]?|>[>=]?|unary-)";
>+  },
>+  /*_internal.Symbol.publicSymbolPattern*/get publicSymbolPattern() {
>+    return core.RegExp.new("^(?:" + "(?:[\\-+*/%&|^]|\\[\\]=?|==|~/?|<[<=]?|>[>=]?|unary-)" + "$|" + "(?!(?:assert|break|c(?:a(?:se|tch)|lass|on(?:st|tinue))|d(?:efault|o)|e(?:lse|num|xtends)|f(?:alse|inal(?:ly)?|or)|i[fns]|n(?:ew|ull)|ret(?:hrow|urn)|s(?:uper|witch)|t(?:h(?:is|row)|r(?:ue|y))|v(?:ar|oid)|w(?:hile|ith))\\b(?!\\$))[a-zA-Z$][\\w$]*" + "(?:=?$|[.](?!$)))+?$");
>+  },
>+  /*_internal.Symbol.symbolPattern*/get symbolPattern() {
>+    return core.RegExp.new("^(?:" + "(?:[\\-+*/%&|^]|\\[\\]=?|==|~/?|<[<=]?|>[>=]?|unary-)" + "$|" + "(?!(?:assert|break|c(?:a(?:se|tch)|lass|on(?:st|tinue))|d(?:efault|o)|e(?:lse|num|xtends)|f(?:alse|inal(?:ly)?|or)|i[fns]|n(?:ew|ull)|ret(?:hrow|urn)|s(?:uper|witch)|t(?:h(?:is|row)|r(?:ue|y))|v(?:ar|oid)|w(?:hile|ith))\\b(?!\\$))[a-zA-Z$_][\\w$]*" + "(?:=?$|[.](?!$)))+?$");
>+  }
>+});
>+const _next = dart.privateName(_internal, "_next");
>+const _previous = dart.privateName(_internal, "_previous");
>+const _list = dart.privateName(_internal, "_list");
>+const _is_IterableBase_default = Symbol('_is_IterableBase_default');
>+collection.IterableBase$ = dart.generic(E => {
>+  class IterableBase extends core.Iterable$(E) {
>+    static iterableToShortString(iterable, leftDelimiter, rightDelimiter) {
>+      if (leftDelimiter === void 0) leftDelimiter = "(";
>+      if (rightDelimiter === void 0) rightDelimiter = ")";
>+      if (dart.test(collection._isToStringVisiting(iterable))) {
>+        if (leftDelimiter === "(" && rightDelimiter === ")") {
>+          return "(...)";
>+        }
>+        return dart.str(leftDelimiter) + "..." + dart.str(rightDelimiter);
>+      }
>+      let parts = JSArrayOfString().of([]);
>+      collection._toStringVisiting[$add](iterable);
>+      try {
>+        collection._iterablePartsToStrings(iterable, parts);
>+      } finally {
>+        if (!core.identical(collection._toStringVisiting[$last], iterable)) dart.assertFailed(null, "dart:collection/iterable.dart", 240, 14, "identical(_toStringVisiting.last, iterable)");
>+        collection._toStringVisiting[$removeLast]();
>+      }
>+      return (() => {
>+        let _ = new core.StringBuffer.new(leftDelimiter);
>+        _.writeAll(parts, ", ");
>+        _.write(rightDelimiter);
>+        return _;
>+      })().toString();
>+    }
>+    static iterableToFullString(iterable, leftDelimiter, rightDelimiter) {
>+      if (leftDelimiter === void 0) leftDelimiter = "(";
>+      if (rightDelimiter === void 0) rightDelimiter = ")";
>+      if (dart.test(collection._isToStringVisiting(iterable))) {
>+        return dart.str(leftDelimiter) + "..." + dart.str(rightDelimiter);
>+      }
>+      let buffer = new core.StringBuffer.new(leftDelimiter);
>+      collection._toStringVisiting[$add](iterable);
>+      try {
>+        buffer.writeAll(iterable, ", ");
>+      } finally {
>+        if (!core.identical(collection._toStringVisiting[$last], iterable)) dart.assertFailed(null, "dart:collection/iterable.dart", 269, 14, "identical(_toStringVisiting.last, iterable)");
>+        collection._toStringVisiting[$removeLast]();
>+      }
>+      buffer.write(rightDelimiter);
>+      return buffer.toString();
>+    }
>+  }
>+  (IterableBase.new = function() {
>+    IterableBase.__proto__.new.call(this);
>+  }).prototype = IterableBase.prototype;
>+  dart.addTypeTests(IterableBase);
>+  IterableBase.prototype[_is_IterableBase_default] = true;
>+  dart.setLibraryUri(IterableBase, "dart:collection");
>+  return IterableBase;
>+});
>+collection.IterableBase = collection.IterableBase$();
>+dart.addTypeTests(collection.IterableBase, _is_IterableBase_default);
>+const _is_LinkedList_default = Symbol('_is_LinkedList_default');
>+_internal.LinkedList$ = dart.generic(T => {
>+  let _LinkedListIteratorOfT = () => (_LinkedListIteratorOfT = dart.constFn(_internal._LinkedListIterator$(T)))();
>+  class LinkedList extends collection.IterableBase$(T) {
>+    get first() {
>+      return this[first];
>+    }
>+    set first(value) {
>+      this[first] = T._check(value);
>+    }
>+    get last() {
>+      return this[last];
>+    }
>+    set last(value) {
>+      this[last] = T._check(value);
>+    }
>+    get length() {
>+      return this[length];
>+    }
>+    set length(value) {
>+      this[length] = value;
>+    }
>+    get isEmpty() {
>+      return this.length === 0;
>+    }
>+    add(newLast) {
>+      T._check(newLast);
>+      if (!(newLast[_next] == null && newLast[_previous] == null)) dart.assertFailed(null, "dart:_internal/linked_list.dart", 19, 12, "newLast._next == null && newLast._previous == null");
>+      if (this.last != null) {
>+        if (!(this.last[_next] == null)) dart.assertFailed(null, "dart:_internal/linked_list.dart", 21, 14, "last._next == null");
>+        this.last[_next] = newLast;
>+      } else {
>+        this.first = newLast;
>+      }
>+      newLast[_previous] = this.last;
>+      this.last = newLast;
>+      this.last[_list] = this;
>+      this.length = dart.notNull(this.length) + 1;
>+    }
>+    addFirst(newFirst) {
>+      T._check(newFirst);
>+      if (this.first != null) {
>+        if (!(this.first[_previous] == null)) dart.assertFailed(null, "dart:_internal/linked_list.dart", 37, 14, "first._previous == null");
>+        this.first[_previous] = newFirst;
>+      } else {
>+        this.last = newFirst;
>+      }
>+      newFirst[_next] = this.first;
>+      this.first = newFirst;
>+      this.first[_list] = this;
>+      this.length = dart.notNull(this.length) + 1;
>+    }
>+    remove(node) {
>+      T._check(node);
>+      if (!dart.equals(node[_list], this)) return;
>+      this.length = dart.notNull(this.length) - 1;
>+      if (node[_previous] == null) {
>+        if (!(node == this.first)) dart.assertFailed(null, "dart:_internal/linked_list.dart", 59, 14, "identical(node, first)");
>+        this.first = node[_next];
>+      } else {
>+        node[_previous][_next] = node[_next];
>+      }
>+      if (node[_next] == null) {
>+        if (!(node == this.last)) dart.assertFailed(null, "dart:_internal/linked_list.dart", 65, 14, "identical(node, last)");
>+        this.last = node[_previous];
>+      } else {
>+        node[_next][_previous] = node[_previous];
>+      }
>+      node[_next] = node[_previous] = null;
>+      node[_list] = null;
>+    }
>+    get iterator() {
>+      return new (_LinkedListIteratorOfT()).new(this);
>+    }
>+  }
>+  (LinkedList.new = function() {
>+    this[first] = null;
>+    this[last] = null;
>+    this[length] = 0;
>+    LinkedList.__proto__.new.call(this);
>+  }).prototype = LinkedList.prototype;
>+  dart.addTypeTests(LinkedList);
>+  LinkedList.prototype[_is_LinkedList_default] = true;
>+  const first = Symbol("LinkedList.first");
>+  const last = Symbol("LinkedList.last");
>+  const length = Symbol("LinkedList.length");
>+  dart.setMethodSignature(LinkedList, () => ({
>+    __proto__: dart.getMethods(LinkedList.__proto__),
>+    add: dart.fnType(dart.void, [core.Object]),
>+    addFirst: dart.fnType(dart.void, [core.Object]),
>+    remove: dart.fnType(dart.void, [core.Object])
>+  }));
>+  dart.setGetterSignature(LinkedList, () => ({
>+    __proto__: dart.getGetters(LinkedList.__proto__),
>+    iterator: core.Iterator$(T),
>+    [$iterator]: core.Iterator$(T)
>+  }));
>+  dart.setLibraryUri(LinkedList, "dart:_internal");
>+  dart.setFieldSignature(LinkedList, () => ({
>+    __proto__: dart.getFields(LinkedList.__proto__),
>+    first: dart.fieldType(T),
>+    last: dart.fieldType(T),
>+    length: dart.fieldType(core.int)
>+  }));
>+  dart.defineExtensionAccessors(LinkedList, [
>+    'isEmpty',
>+    'iterator',
>+    'first',
>+    'last',
>+    'length'
>+  ]);
>+  return LinkedList;
>+});
>+_internal.LinkedList = _internal.LinkedList$();
>+dart.addTypeTests(_internal.LinkedList, _is_LinkedList_default);
>+const _is_LinkedListEntry_default = Symbol('_is_LinkedListEntry_default');
>+_internal.LinkedListEntry$ = dart.generic(T => {
>+  let LinkedListOfT = () => (LinkedListOfT = dart.constFn(_internal.LinkedList$(T)))();
>+  class LinkedListEntry extends core.Object {
>+    unlink() {
>+      if (this[_list] == null) return;
>+      this[_list].remove(T._check(this));
>+    }
>+  }
>+  (LinkedListEntry.new = function() {
>+    this[_next] = null;
>+    this[_previous] = null;
>+    this[_list] = null;
>+  }).prototype = LinkedListEntry.prototype;
>+  dart.addTypeTests(LinkedListEntry);
>+  LinkedListEntry.prototype[_is_LinkedListEntry_default] = true;
>+  dart.setMethodSignature(LinkedListEntry, () => ({
>+    __proto__: dart.getMethods(LinkedListEntry.__proto__),
>+    unlink: dart.fnType(dart.void, [])
>+  }));
>+  dart.setLibraryUri(LinkedListEntry, "dart:_internal");
>+  dart.setFieldSignature(LinkedListEntry, () => ({
>+    __proto__: dart.getFields(LinkedListEntry.__proto__),
>+    [_next]: dart.fieldType(T),
>+    [_previous]: dart.fieldType(T),
>+    [_list]: dart.fieldType(LinkedListOfT())
>+  }));
>+  return LinkedListEntry;
>+});
>+_internal.LinkedListEntry = _internal.LinkedListEntry$();
>+dart.addTypeTests(_internal.LinkedListEntry, _is_LinkedListEntry_default);
>+const _is__LinkedListIterator_default = Symbol('_is__LinkedListIterator_default');
>+_internal._LinkedListIterator$ = dart.generic(T => {
>+  let IteratorOfT = () => (IteratorOfT = dart.constFn(core.Iterator$(T)))();
>+  let LinkedListOfT = () => (LinkedListOfT = dart.constFn(_internal.LinkedList$(T)))();
>+  class _LinkedListIterator extends core.Object {
>+    moveNext() {
>+      if (this.current == null) {
>+        if (this[_list] == null) return false;
>+        if (!(dart.notNull(this[_list].length) > 0)) dart.assertFailed(null, "dart:_internal/linked_list.dart", 118, 14, "_list.length > 0");
>+        this.current = this[_list].first;
>+        this[_list] = null;
>+        return true;
>+      }
>+      this.current = this.current[_next];
>+      return this.current != null;
>+    }
>+  }
>+  (_LinkedListIterator.new = function(list) {
>+    this.current = null;
>+    this[_list] = list;
>+    if (this[_list].length === 0) this[_list] = null;
>+  }).prototype = _LinkedListIterator.prototype;
>+  dart.addTypeTests(_LinkedListIterator);
>+  _LinkedListIterator.prototype[_is__LinkedListIterator_default] = true;
>+  _LinkedListIterator[dart.implements] = () => [IteratorOfT()];
>+  dart.setMethodSignature(_LinkedListIterator, () => ({
>+    __proto__: dart.getMethods(_LinkedListIterator.__proto__),
>+    moveNext: dart.fnType(core.bool, [])
>+  }));
>+  dart.setLibraryUri(_LinkedListIterator, "dart:_internal");
>+  dart.setFieldSignature(_LinkedListIterator, () => ({
>+    __proto__: dart.getFields(_LinkedListIterator.__proto__),
>+    current: dart.fieldType(T),
>+    [_list]: dart.fieldType(LinkedListOfT())
>+  }));
>+  return _LinkedListIterator;
>+});
>+_internal._LinkedListIterator = _internal._LinkedListIterator$();
>+dart.addTypeTests(_internal._LinkedListIterator, _is__LinkedListIterator_default);
>+_isolate_helper.startRootIsolate = function(main, args) {
>+  if (args == null) args = JSArrayOfString().of([]);
>+  if (core.List.is(args)) {
>+    if (!ListOfString().is(args)) args = ListOfString().from(core.Iterable._check(args));
>+    if (typeof main == "function") {
>+      main(args, null);
>+    } else {
>+      dart.dcall(main, [args]);
>+    }
>+  } else {
>+    dart.throw(new core.ArgumentError.new("Arguments to main must be a List: " + dart.str(args)));
>+  }
>+};
>+dart.defineLazy(_isolate_helper, {
>+  /*_isolate_helper.global*/get global() {
>+    return dart.global;
>+  }
>+});
>+const _once = dart.privateName(_isolate_helper, "_once");
>+const _handle = dart.privateName(_isolate_helper, "_handle");
>+const _tick = dart.privateName(_isolate_helper, "_tick");
>+_isolate_helper.TimerImpl = class TimerImpl extends core.Object {
>+  get tick() {
>+    return this[_tick];
>+  }
>+  cancel() {
>+    if (dart.test(_isolate_helper.hasTimer())) {
>+      if (this[_handle] == null) return;
>+      dart.removeAsyncCallback();
>+      if (dart.test(this[_once])) {
>+        _isolate_helper.global.clearTimeout(this[_handle]);
>+      } else {
>+        _isolate_helper.global.clearInterval(this[_handle]);
>+      }
>+      this[_handle] = null;
>+    } else {
>+      dart.throw(new core.UnsupportedError.new("Canceling a timer."));
>+    }
>+  }
>+  get isActive() {
>+    return this[_handle] != null;
>+  }
>+};
>+(_isolate_helper.TimerImpl.new = function(milliseconds, callback) {
>+  this[_handle] = null;
>+  this[_tick] = 0;
>+  this[_once] = true;
>+  if (dart.test(_isolate_helper.hasTimer())) {
>+    const internalCallback = () => {
>+      this[_handle] = null;
>+      dart.removeAsyncCallback();
>+      this[_tick] = 1;
>+      callback();
>+    };
>+    dart.fn(internalCallback, VoidTovoid());
>+    dart.addAsyncCallback();
>+    this[_handle] = _isolate_helper.global.setTimeout(internalCallback, milliseconds);
>+  } else {
>+    dart.throw(new core.UnsupportedError.new("`setTimeout()` not found."));
>+  }
>+}).prototype = _isolate_helper.TimerImpl.prototype;
>+(_isolate_helper.TimerImpl.periodic = function(milliseconds, callback) {
>+  this[_handle] = null;
>+  this[_tick] = 0;
>+  this[_once] = false;
>+  if (dart.test(_isolate_helper.hasTimer())) {
>+    dart.addAsyncCallback();
>+    let start = Date.now();
>+    this[_handle] = _isolate_helper.global.setInterval(dart.fn(() => {
>+      let tick = dart.notNull(this[_tick]) + 1;
>+      if (dart.notNull(milliseconds) > 0) {
>+        let duration = Date.now() - start;
>+        if (duration > (tick + 1) * dart.notNull(milliseconds)) {
>+          tick = (duration / dart.notNull(milliseconds))[$truncate]();
>+        }
>+      }
>+      this[_tick] = tick;
>+      callback(this);
>+    }, VoidToNull()), milliseconds);
>+  } else {
>+    dart.throw(new core.UnsupportedError.new("Periodic timer."));
>+  }
>+}).prototype = _isolate_helper.TimerImpl.prototype;
>+dart.addTypeTests(_isolate_helper.TimerImpl);
>+_isolate_helper.TimerImpl[dart.implements] = () => [async.Timer];
>+dart.setMethodSignature(_isolate_helper.TimerImpl, () => ({
>+  __proto__: dart.getMethods(_isolate_helper.TimerImpl.__proto__),
>+  cancel: dart.fnType(dart.void, [])
>+}));
>+dart.setGetterSignature(_isolate_helper.TimerImpl, () => ({
>+  __proto__: dart.getGetters(_isolate_helper.TimerImpl.__proto__),
>+  tick: core.int,
>+  isActive: core.bool
>+}));
>+dart.setLibraryUri(_isolate_helper.TimerImpl, "dart:_isolate_helper");
>+dart.setFieldSignature(_isolate_helper.TimerImpl, () => ({
>+  __proto__: dart.getFields(_isolate_helper.TimerImpl.__proto__),
>+  [_once]: dart.finalFieldType(core.bool),
>+  [_handle]: dart.fieldType(core.int),
>+  [_tick]: dart.fieldType(core.int)
>+}));
>+_isolate_helper.hasTimer = function() {
>+  return _isolate_helper.global.setTimeout != null;
>+};
>+_js_helper._Patch = class _Patch extends core.Object {};
>+(_js_helper._Patch.new = function() {
>+}).prototype = _js_helper._Patch.prototype;
>+dart.addTypeTests(_js_helper._Patch);
>+dart.setLibraryUri(_js_helper._Patch, "dart:_js_helper");
>+dart.defineLazy(_js_helper, {
>+  /*_js_helper.patch*/get patch() {
>+    return dart.const(new _js_helper._Patch.new());
>+  }
>+});
>+const _jsIterator = dart.privateName(_js_helper, "_jsIterator");
>+const _current$0 = dart.privateName(_js_helper, "_current");
>+const _is_DartIterator_default = Symbol('_is_DartIterator_default');
>+_js_helper.DartIterator$ = dart.generic(E => {
>+  let IteratorOfE = () => (IteratorOfE = dart.constFn(core.Iterator$(E)))();
>+  class DartIterator extends core.Object {
>+    get current() {
>+      return this[_current$0];
>+    }
>+    moveNext() {
>+      let ret = this[_jsIterator].next();
>+      this[_current$0] = ret.value;
>+      return !ret.done;
>+    }
>+  }
>+  (DartIterator.new = function(jsIterator) {
>+    this[_current$0] = null;
>+    this[_jsIterator] = jsIterator;
>+  }).prototype = DartIterator.prototype;
>+  dart.addTypeTests(DartIterator);
>+  DartIterator.prototype[_is_DartIterator_default] = true;
>+  DartIterator[dart.implements] = () => [IteratorOfE()];
>+  dart.setMethodSignature(DartIterator, () => ({
>+    __proto__: dart.getMethods(DartIterator.__proto__),
>+    moveNext: dart.fnType(core.bool, [])
>+  }));
>+  dart.setGetterSignature(DartIterator, () => ({
>+    __proto__: dart.getGetters(DartIterator.__proto__),
>+    current: E
>+  }));
>+  dart.setLibraryUri(DartIterator, "dart:_js_helper");
>+  dart.setFieldSignature(DartIterator, () => ({
>+    __proto__: dart.getFields(DartIterator.__proto__),
>+    [_jsIterator]: dart.finalFieldType(dart.dynamic),
>+    [_current$0]: dart.fieldType(E)
>+  }));
>+  return DartIterator;
>+});
>+_js_helper.DartIterator = _js_helper.DartIterator$();
>+dart.addTypeTests(_js_helper.DartIterator, _is_DartIterator_default);
>+const _initGenerator = dart.privateName(_js_helper, "_initGenerator");
>+const _is_SyncIterable_default = Symbol('_is_SyncIterable_default');
>+_js_helper.SyncIterable$ = dart.generic(E => {
>+  let DartIteratorOfE = () => (DartIteratorOfE = dart.constFn(_js_helper.DartIterator$(E)))();
>+  class SyncIterable extends collection.IterableBase$(E) {
>+    [Symbol.iterator]() {
>+      return this[_initGenerator]();
>+    }
>+    get iterator() {
>+      return new (DartIteratorOfE()).new(this[_initGenerator]());
>+    }
>+  }
>+  (SyncIterable.new = function(initGenerator) {
>+    this[_initGenerator] = initGenerator;
>+    SyncIterable.__proto__.new.call(this);
>+  }).prototype = SyncIterable.prototype;
>+  dart.addTypeTests(SyncIterable);
>+  SyncIterable.prototype[_is_SyncIterable_default] = true;
>+  dart.setMethodSignature(SyncIterable, () => ({
>+    __proto__: dart.getMethods(SyncIterable.__proto__),
>+    [Symbol.iterator]: dart.fnType(dart.dynamic, [])
>+  }));
>+  dart.setGetterSignature(SyncIterable, () => ({
>+    __proto__: dart.getGetters(SyncIterable.__proto__),
>+    iterator: core.Iterator$(E),
>+    [$iterator]: core.Iterator$(E)
>+  }));
>+  dart.setLibraryUri(SyncIterable, "dart:_js_helper");
>+  dart.setFieldSignature(SyncIterable, () => ({
>+    __proto__: dart.getFields(SyncIterable.__proto__),
>+    [_initGenerator]: dart.finalFieldType(VoidTodynamic())
>+  }));
>+  dart.defineExtensionAccessors(SyncIterable, ['iterator']);
>+  return SyncIterable;
>+});
>+_js_helper.SyncIterable = _js_helper.SyncIterable$();
>+dart.addTypeTests(_js_helper.SyncIterable, _is_SyncIterable_default);
>+_js_helper.Primitives = class Primitives extends core.Object {
>+  static _parseIntError(source, handleError) {
>+    if (handleError == null) dart.throw(new core.FormatException.new(source));
>+    return handleError(source);
>+  }
>+  static parseInt(source, _radix, handleError) {
>+    if (source == null) dart.argumentError(source);
>+    let re = /^\s*[+-]?((0x[a-f0-9]+)|(\d+)|([a-z0-9]+))\s*$/i;
>+    let match = re.exec(source);
>+    let digitsIndex = 1;
>+    let hexIndex = 2;
>+    let decimalIndex = 3;
>+    if (match == null) {
>+      return _js_helper.Primitives._parseIntError(source, handleError);
>+    }
>+    let decimalMatch = match[$_get](decimalIndex);
>+    if (_radix == null) {
>+      if (decimalMatch != null) {
>+        return parseInt(source, 10);
>+      }
>+      if (match[$_get](hexIndex) != null) {
>+        return parseInt(source, 16);
>+      }
>+      return _js_helper.Primitives._parseIntError(source, handleError);
>+    }
>+    let radix = _radix;
>+    if (radix < 2 || radix > 36) {
>+      dart.throw(new core.RangeError.range(radix, 2, 36, "radix"));
>+    }
>+    if (radix === 10 && decimalMatch != null) {
>+      return parseInt(source, 10);
>+    }
>+    if (radix < 10 || decimalMatch == null) {
>+      let maxCharCode = null;
>+      if (radix <= 10) {
>+        maxCharCode = 48 - 1 + radix;
>+      } else {
>+        maxCharCode = 97 - 10 - 1 + radix;
>+      }
>+      if (!(typeof match[$_get](digitsIndex) == 'string')) dart.assertFailed(null, "dart:_js_helper", 134, 14, "match[digitsIndex] is String");
>+      let digitsPart = match[digitsIndex];
>+      for (let i = 0; i < digitsPart.length; i++) {
>+        let characterCode = (digitsPart[$codeUnitAt](i) | 32) >>> 0;
>+        if (characterCode > dart.notNull(maxCharCode)) {
>+          return _js_helper.Primitives._parseIntError(source, handleError);
>+        }
>+      }
>+    }
>+    return parseInt(source, radix);
>+  }
>+  static _parseDoubleError(source, handleError) {
>+    if (handleError == null) {
>+      dart.throw(new core.FormatException.new("Invalid double", source));
>+    }
>+    return handleError(source);
>+  }
>+  static parseDouble(source, handleError) {
>+    if (source == null) dart.argumentError(source);
>+    if (!/^\s*[+-]?(?:Infinity|NaN|(?:\.\d+|\d+(?:\.\d*)?)(?:[eE][+-]?\d+)?)\s*$/.test(source)) {
>+      return _js_helper.Primitives._parseDoubleError(source, handleError);
>+    }
>+    let result = parseFloat(source);
>+    if (result[$isNaN]) {
>+      let trimmed = source[$trim]();
>+      if (trimmed === "NaN" || trimmed === "+NaN" || trimmed === "-NaN") {
>+        return result;
>+      }
>+      return _js_helper.Primitives._parseDoubleError(source, handleError);
>+    }
>+    return result;
>+  }
>+  static dateNow() {
>+    return Date.now();
>+  }
>+  static initTicker() {
>+    if (_js_helper.Primitives.timerFrequency != null) return;
>+    _js_helper.Primitives.timerFrequency = 1000;
>+    _js_helper.Primitives.timerTicks = dart.fn(_js_helper.Primitives.dateNow, VoidToint());
>+    if (typeof window == "undefined") return;
>+    let jsWindow = window;
>+    if (jsWindow == null) return;
>+    let performance = jsWindow.performance;
>+    if (performance == null) return;
>+    if (typeof performance.now != "function") return;
>+    _js_helper.Primitives.timerFrequency = 1000000;
>+    _js_helper.Primitives.timerTicks = dart.fn(() => (1000 * performance.now())[$floor](), VoidToint());
>+  }
>+  static get isD8() {
>+    return typeof version == "function" && typeof os == "object" && "system" in os;
>+  }
>+  static get isJsshell() {
>+    return typeof version == "function" && typeof system == "function";
>+  }
>+  static currentUri() {
>+    if (!!dart.global.location) {
>+      return dart.global.location.href;
>+    }
>+    return "";
>+  }
>+  static _fromCharCodeApply(array) {
>+    let kMaxApply = 500;
>+    let end = dart.notNull(array[$length]);
>+    if (end <= kMaxApply) {
>+      return String.fromCharCode.apply(null, array);
>+    }
>+    let result = "";
>+    for (let i = 0; i < end; i = i + kMaxApply) {
>+      let chunkEnd = i + kMaxApply < end ? i + kMaxApply : end;
>+      result = result + String.fromCharCode.apply(null, array.slice(i, chunkEnd));
>+    }
>+    return result;
>+  }
>+  static stringFromCodePoints(codePoints) {
>+    let a = JSArrayOfint().of([]);
>+    for (let i of codePoints) {
>+      if (i == null) dart.argumentError(i);
>+      {
>+        if (i <= 65535) {
>+          a[$add](i);
>+        } else if (i <= 1114111) {
>+          a[$add](55296 + (i - 65536 >> 10 & 1023));
>+          a[$add](56320 + (i & 1023));
>+        } else {
>+          dart.throw(_js_helper.argumentErrorValue(i));
>+        }
>+      }
>+    }
>+    return _js_helper.Primitives._fromCharCodeApply(a);
>+  }
>+  static stringFromCharCodes(charCodes) {
>+    for (let i of charCodes) {
>+      if (i == null) dart.argumentError(i);
>+      {
>+        if (i < 0) dart.throw(_js_helper.argumentErrorValue(i));
>+        if (i > 65535) return _js_helper.Primitives.stringFromCodePoints(charCodes);
>+      }
>+    }
>+    return _js_helper.Primitives._fromCharCodeApply(charCodes);
>+  }
>+  static stringFromNativeUint8List(charCodes, start, end) {
>+    if (start == null) dart.argumentError(start);
>+    if (end == null) dart.argumentError(end);
>+    let kMaxApply = 500;
>+    if (end <= kMaxApply && start === 0 && end === charCodes[$length]) {
>+      return String.fromCharCode.apply(null, charCodes);
>+    }
>+    let result = "";
>+    for (let i = start; i < end; i = i + kMaxApply) {
>+      let chunkEnd = i + kMaxApply < end ? i + kMaxApply : end;
>+      result = result + String.fromCharCode.apply(null, charCodes.subarray(i, chunkEnd));
>+    }
>+    return result;
>+  }
>+  static stringFromCharCode(charCode) {
>+    if (charCode == null) dart.argumentError(charCode);
>+    if (0 <= charCode) {
>+      if (charCode <= 65535) {
>+        return String.fromCharCode(charCode);
>+      }
>+      if (charCode <= 1114111) {
>+        let bits = charCode - 65536;
>+        let low = 56320 | bits & 1023;
>+        let high = (55296 | bits[$rightShift](10)) >>> 0;
>+        return String.fromCharCode(high, low);
>+      }
>+    }
>+    dart.throw(new core.RangeError.range(charCode, 0, 1114111));
>+  }
>+  static stringConcatUnchecked(string1, string2) {
>+    return _foreign_helper.JS_STRING_CONCAT(string1, string2);
>+  }
>+  static flattenString(str) {
>+    return str.charCodeAt(0) == 0 ? str : str;
>+  }
>+  static getTimeZoneName(receiver) {
>+    let d = _js_helper.Primitives.lazyAsJsDate(receiver);
>+    let match = /$(.*)$/.exec(d.toString());
>+    if (match != null) return core.String._check(match[$_get](1));
>+    match = /^[A-Z,a-z]{3}\s[A-Z,a-z]{3}\s\d+\s\d{2}:\d{2}:\d{2}\s([A-Z]{3,5})\s\d{4}$/.exec(d.toString());
>+    if (match != null) return core.String._check(match[$_get](1));
>+    match = /(?:GMT|UTC)[+-]\d{4}/.exec(d.toString());
>+    if (match != null) return core.String._check(match[$_get](0));
>+    return "";
>+  }
>+  static getTimeZoneOffsetInMinutes(receiver) {
>+    return -_js_helper.Primitives.lazyAsJsDate(receiver).getTimezoneOffset();
>+  }
>+  static valueFromDecomposedDate(years, month, day, hours, minutes, seconds, milliseconds, isUtc) {
>+    if (years == null) dart.argumentError(years);
>+    if (month == null) dart.argumentError(month);
>+    if (day == null) dart.argumentError(day);
>+    if (hours == null) dart.argumentError(hours);
>+    if (minutes == null) dart.argumentError(minutes);
>+    if (seconds == null) dart.argumentError(seconds);
>+    if (milliseconds == null) dart.argumentError(milliseconds);
>+    if (isUtc == null) dart.argumentError(isUtc);
>+    let MAX_MILLISECONDS_SINCE_EPOCH = 8640000000000000;
>+    let jsMonth = month - 1;
>+    let value = null;
>+    if (isUtc) {
>+      value = Date.UTC(years, jsMonth, day, hours, minutes, seconds, milliseconds);
>+    } else {
>+      value = new Date(years, jsMonth, day, hours, minutes, seconds, milliseconds).valueOf();
>+    }
>+    if (value[$isNaN] || dart.notNull(value) < -MAX_MILLISECONDS_SINCE_EPOCH || dart.notNull(value) > MAX_MILLISECONDS_SINCE_EPOCH) {
>+      return null;
>+    }
>+    if (years <= 0 || years < 100) return _js_helper.Primitives.patchUpY2K(value, years, isUtc);
>+    return value;
>+  }
>+  static patchUpY2K(value, years, isUtc) {
>+    let date = new Date(value);
>+    if (dart.dtest(isUtc)) {
>+      date.setUTCFullYear(years);
>+    } else {
>+      date.setFullYear(years);
>+    }
>+    return date.valueOf();
>+  }
>+  static lazyAsJsDate(receiver) {
>+    if (receiver.date === void 0) {
>+      receiver.date = new Date(receiver.millisecondsSinceEpoch);
>+    }
>+    return receiver.date;
>+  }
>+  static getYear(receiver) {
>+    return dart.test(receiver.isUtc) ? _js_helper.Primitives.lazyAsJsDate(receiver).getUTCFullYear() + 0 : _js_helper.Primitives.lazyAsJsDate(receiver).getFullYear() + 0;
>+  }
>+  static getMonth(receiver) {
>+    return dart.test(receiver.isUtc) ? _js_helper.Primitives.lazyAsJsDate(receiver).getUTCMonth() + 1 : _js_helper.Primitives.lazyAsJsDate(receiver).getMonth() + 1;
>+  }
>+  static getDay(receiver) {
>+    return dart.test(receiver.isUtc) ? _js_helper.Primitives.lazyAsJsDate(receiver).getUTCDate() + 0 : _js_helper.Primitives.lazyAsJsDate(receiver).getDate() + 0;
>+  }
>+  static getHours(receiver) {
>+    return dart.test(receiver.isUtc) ? _js_helper.Primitives.lazyAsJsDate(receiver).getUTCHours() + 0 : _js_helper.Primitives.lazyAsJsDate(receiver).getHours() + 0;
>+  }
>+  static getMinutes(receiver) {
>+    return dart.test(receiver.isUtc) ? _js_helper.Primitives.lazyAsJsDate(receiver).getUTCMinutes() + 0 : _js_helper.Primitives.lazyAsJsDate(receiver).getMinutes() + 0;
>+  }
>+  static getSeconds(receiver) {
>+    return dart.test(receiver.isUtc) ? _js_helper.Primitives.lazyAsJsDate(receiver).getUTCSeconds() + 0 : _js_helper.Primitives.lazyAsJsDate(receiver).getSeconds() + 0;
>+  }
>+  static getMilliseconds(receiver) {
>+    return dart.test(receiver.isUtc) ? _js_helper.Primitives.lazyAsJsDate(receiver).getUTCMilliseconds() + 0 : _js_helper.Primitives.lazyAsJsDate(receiver).getMilliseconds() + 0;
>+  }
>+  static getWeekday(receiver) {
>+    let weekday = dart.test(receiver.isUtc) ? _js_helper.Primitives.lazyAsJsDate(receiver).getUTCDay() + 0 : _js_helper.Primitives.lazyAsJsDate(receiver).getDay() + 0;
>+    return (weekday + 6)[$modulo](7) + 1;
>+  }
>+  static valueFromDateString(str) {
>+    if (!(typeof str == 'string')) dart.throw(_js_helper.argumentErrorValue(str));
>+    let value = Date.parse(str);
>+    if (value[$isNaN]) dart.throw(_js_helper.argumentErrorValue(str));
>+    return value;
>+  }
>+  static getProperty(object, key) {
>+    if (object == null || typeof object == 'boolean' || typeof object == 'number' || typeof object == 'string') {
>+      dart.throw(_js_helper.argumentErrorValue(object));
>+    }
>+    return object[key];
>+  }
>+  static setProperty(object, key, value) {
>+    if (object == null || typeof object == 'boolean' || typeof object == 'number' || typeof object == 'string') {
>+      dart.throw(_js_helper.argumentErrorValue(object));
>+    }
>+    object[key] = value;
>+  }
>+};
>+(_js_helper.Primitives.new = function() {
>+}).prototype = _js_helper.Primitives.prototype;
>+dart.addTypeTests(_js_helper.Primitives);
>+dart.setLibraryUri(_js_helper.Primitives, "dart:_js_helper");
>+dart.defineLazy(_js_helper.Primitives, {
>+  /*_js_helper.Primitives.DOLLAR_CHAR_VALUE*/get DOLLAR_CHAR_VALUE() {
>+    return 36;
>+  },
>+  /*_js_helper.Primitives.timerFrequency*/get timerFrequency() {
>+    return null;
>+  },
>+  set timerFrequency(_) {},
>+  /*_js_helper.Primitives.timerTicks*/get timerTicks() {
>+    return null;
>+  },
>+  set timerTicks(_) {}
>+});
>+_js_helper.diagnoseIndexError = function(indexable, index) {
>+  let length = core.int._check(dart.dload(indexable, 'length'));
>+  if (dart.notNull(index) < 0 || dart.notNull(index) >= dart.notNull(length)) {
>+    return core.RangeError.index(index, indexable, "index", null, length);
>+  }
>+  return new core.RangeError.value(index, "index");
>+};
>+_js_helper.diagnoseRangeError = function(start, end, length) {
>+  if (start == null) {
>+    return new core.ArgumentError.value(start, "start");
>+  }
>+  if (dart.notNull(start) < 0 || dart.notNull(start) > dart.notNull(length)) {
>+    return new core.RangeError.range(start, 0, length, "start");
>+  }
>+  if (end != null) {
>+    if (dart.notNull(end) < dart.notNull(start) || dart.notNull(end) > dart.notNull(length)) {
>+      return new core.RangeError.range(end, start, length, "end");
>+    }
>+  }
>+  return new core.ArgumentError.value(end, "end");
>+};
>+_js_helper.stringLastIndexOfUnchecked = function(receiver, element, start) {
>+  return receiver.lastIndexOf(element, start);
>+};
>+_js_helper.argumentErrorValue = function(object) {
>+  return new core.ArgumentError.value(object);
>+};
>+_js_helper.throwArgumentErrorValue = function(value) {
>+  dart.throw(_js_helper.argumentErrorValue(value));
>+};
>+_js_helper.checkInt = function(value) {
>+  if (!core.int.is(value)) dart.throw(_js_helper.argumentErrorValue(value));
>+  return value;
>+};
>+_js_helper.throwRuntimeError = function(message) {
>+  dart.throw(new _js_helper.RuntimeError.new(message));
>+};
>+_js_helper.throwAbstractClassInstantiationError = function(className) {
>+  dart.throw(new core.AbstractClassInstantiationError.new(core.String._check(className)));
>+};
>+_js_helper.throwConcurrentModificationError = function(collection) {
>+  dart.throw(new core.ConcurrentModificationError.new(collection));
>+};
>+const _message = dart.privateName(_js_helper, "_message");
>+const _method = dart.privateName(_js_helper, "_method");
>+const _receiver = dart.privateName(_js_helper, "_receiver");
>+core.Error = class Error extends core.Object {
>+  static safeToString(object) {
>+    if (typeof object == 'number' || typeof object == 'boolean' || null == object) {
>+      return dart.toString(object);
>+    }
>+    if (typeof object == 'string') {
>+      return core.Error._stringToSafeString(object);
>+    }
>+    return core.Error._objectToString(object);
>+  }
>+  static _stringToSafeString(string) {
>+    return JSON.stringify(string);
>+  }
>+  static _objectToString(object) {
>+    return "Instance of '" + dart.typeName(dart.getReifiedType(object)) + "'";
>+  }
>+  get stackTrace() {
>+    return dart.stackTraceForError(this);
>+  }
>+};
>+(core.Error.new = function() {
>+}).prototype = core.Error.prototype;
>+dart.addTypeTests(core.Error);
>+dart.setGetterSignature(core.Error, () => ({
>+  __proto__: dart.getGetters(core.Error.__proto__),
>+  stackTrace: core.StackTrace,
>+  [$stackTrace]: core.StackTrace
>+}));
>+dart.setLibraryUri(core.Error, "dart:core");
>+dart.defineExtensionAccessors(core.Error, ['stackTrace']);
>+_js_helper.JsNoSuchMethodError = class JsNoSuchMethodError extends core.Error {
>+  toString() {
>+    if (this[_method] == null) return "NoSuchMethodError: " + dart.str(this[_message]);
>+    if (this[_receiver] == null) {
>+      return "NoSuchMethodError: method not found: '" + dart.str(this[_method]) + "' (" + dart.str(this[_message]) + ")";
>+    }
>+    return "NoSuchMethodError: " + ("method not found: '" + dart.str(this[_method]) + "' on '" + dart.str(this[_receiver]) + "' (" + dart.str(this[_message]) + ")");
>+  }
>+};
>+(_js_helper.JsNoSuchMethodError.new = function(message, match) {
>+  this[_message] = message;
>+  this[_method] = match == null ? null : match.method;
>+  this[_receiver] = match == null ? null : match.receiver;
>+  _js_helper.JsNoSuchMethodError.__proto__.new.call(this);
>+}).prototype = _js_helper.JsNoSuchMethodError.prototype;
>+dart.addTypeTests(_js_helper.JsNoSuchMethodError);
>+_js_helper.JsNoSuchMethodError[dart.implements] = () => [core.NoSuchMethodError];
>+dart.setLibraryUri(_js_helper.JsNoSuchMethodError, "dart:_js_helper");
>+dart.setFieldSignature(_js_helper.JsNoSuchMethodError, () => ({
>+  __proto__: dart.getFields(_js_helper.JsNoSuchMethodError.__proto__),
>+  [_message]: dart.finalFieldType(core.String),
>+  [_method]: dart.finalFieldType(core.String),
>+  [_receiver]: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionMethods(_js_helper.JsNoSuchMethodError, ['toString']);
>+_js_helper.UnknownJsTypeError = class UnknownJsTypeError extends core.Error {
>+  toString() {
>+    return this[_message][$isEmpty] ? "Error" : "Error: " + dart.str(this[_message]);
>+  }
>+};
>+(_js_helper.UnknownJsTypeError.new = function(message) {
>+  this[_message] = message;
>+  _js_helper.UnknownJsTypeError.__proto__.new.call(this);
>+}).prototype = _js_helper.UnknownJsTypeError.prototype;
>+dart.addTypeTests(_js_helper.UnknownJsTypeError);
>+dart.setLibraryUri(_js_helper.UnknownJsTypeError, "dart:_js_helper");
>+dart.setFieldSignature(_js_helper.UnknownJsTypeError, () => ({
>+  __proto__: dart.getFields(_js_helper.UnknownJsTypeError.__proto__),
>+  [_message]: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionMethods(_js_helper.UnknownJsTypeError, ['toString']);
>+_js_helper.fillLiteralMap = function(keyValuePairs, result) {
>+  let index = 0;
>+  let length = _js_helper.getLength(keyValuePairs);
>+  while (index < dart.notNull(length)) {
>+    let key = _js_helper.getIndex(keyValuePairs, index++);
>+    let value = _js_helper.getIndex(keyValuePairs, index++);
>+    result[$_set](key, value);
>+  }
>+  return result;
>+};
>+_js_helper.jsHasOwnProperty = function(jsObject, property) {
>+  return jsObject.hasOwnProperty(property);
>+};
>+_js_helper.jsPropertyAccess = function(jsObject, property) {
>+  return jsObject[property];
>+};
>+_js_helper.getFallThroughError = function() {
>+  return new _js_helper.FallThroughErrorImplementation.new();
>+};
>+_js_helper.Creates = class Creates extends core.Object {};
>+(_js_helper.Creates.new = function(types) {
>+  this.types = types;
>+}).prototype = _js_helper.Creates.prototype;
>+dart.addTypeTests(_js_helper.Creates);
>+dart.setLibraryUri(_js_helper.Creates, "dart:_js_helper");
>+dart.setFieldSignature(_js_helper.Creates, () => ({
>+  __proto__: dart.getFields(_js_helper.Creates.__proto__),
>+  types: dart.finalFieldType(core.String)
>+}));
>+_js_helper.Returns = class Returns extends core.Object {};
>+(_js_helper.Returns.new = function(types) {
>+  this.types = types;
>+}).prototype = _js_helper.Returns.prototype;
>+dart.addTypeTests(_js_helper.Returns);
>+dart.setLibraryUri(_js_helper.Returns, "dart:_js_helper");
>+dart.setFieldSignature(_js_helper.Returns, () => ({
>+  __proto__: dart.getFields(_js_helper.Returns.__proto__),
>+  types: dart.finalFieldType(core.String)
>+}));
>+_js_helper.JSName = class JSName extends core.Object {};
>+(_js_helper.JSName.new = function(name) {
>+  this.name = name;
>+}).prototype = _js_helper.JSName.prototype;
>+dart.addTypeTests(_js_helper.JSName);
>+dart.setLibraryUri(_js_helper.JSName, "dart:_js_helper");
>+dart.setFieldSignature(_js_helper.JSName, () => ({
>+  __proto__: dart.getFields(_js_helper.JSName.__proto__),
>+  name: dart.finalFieldType(core.String)
>+}));
>+const _is_JavaScriptIndexingBehavior_default = Symbol('_is_JavaScriptIndexingBehavior_default');
>+_js_helper.JavaScriptIndexingBehavior$ = dart.generic(E => {
>+  class JavaScriptIndexingBehavior extends core.Object {}
>+  (JavaScriptIndexingBehavior.new = function() {
>+  }).prototype = JavaScriptIndexingBehavior.prototype;
>+  dart.addTypeTests(JavaScriptIndexingBehavior);
>+  JavaScriptIndexingBehavior.prototype[_is_JavaScriptIndexingBehavior_default] = true;
>+  dart.setLibraryUri(JavaScriptIndexingBehavior, "dart:_js_helper");
>+  return JavaScriptIndexingBehavior;
>+});
>+_js_helper.JavaScriptIndexingBehavior = _js_helper.JavaScriptIndexingBehavior$();
>+dart.addTypeTests(_js_helper.JavaScriptIndexingBehavior, _is_JavaScriptIndexingBehavior_default);
>+_js_helper.TypeErrorImpl = class TypeErrorImpl extends core.Error {
>+  toString() {
>+    return this.message;
>+  }
>+};
>+(_js_helper.TypeErrorImpl.new = function(message) {
>+  this.message = message;
>+  _js_helper.TypeErrorImpl.__proto__.new.call(this);
>+}).prototype = _js_helper.TypeErrorImpl.prototype;
>+dart.addTypeTests(_js_helper.TypeErrorImpl);
>+_js_helper.TypeErrorImpl[dart.implements] = () => [core.TypeError];
>+dart.setLibraryUri(_js_helper.TypeErrorImpl, "dart:_js_helper");
>+dart.setFieldSignature(_js_helper.TypeErrorImpl, () => ({
>+  __proto__: dart.getFields(_js_helper.TypeErrorImpl.__proto__),
>+  message: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionMethods(_js_helper.TypeErrorImpl, ['toString']);
>+_js_helper.CastErrorImpl = class CastErrorImpl extends core.Error {
>+  toString() {
>+    return this.message;
>+  }
>+};
>+(_js_helper.CastErrorImpl.new = function(message) {
>+  this.message = message;
>+  _js_helper.CastErrorImpl.__proto__.new.call(this);
>+}).prototype = _js_helper.CastErrorImpl.prototype;
>+dart.addTypeTests(_js_helper.CastErrorImpl);
>+_js_helper.CastErrorImpl[dart.implements] = () => [core.CastError];
>+dart.setLibraryUri(_js_helper.CastErrorImpl, "dart:_js_helper");
>+dart.setFieldSignature(_js_helper.CastErrorImpl, () => ({
>+  __proto__: dart.getFields(_js_helper.CastErrorImpl.__proto__),
>+  message: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionMethods(_js_helper.CastErrorImpl, ['toString']);
>+core.FallThroughError = class FallThroughError extends core.Error {
>+  toString() {
>+    return super.toString();
>+  }
>+};
>+(core.FallThroughError.new = function() {
>+  core.FallThroughError.__proto__.new.call(this);
>+}).prototype = core.FallThroughError.prototype;
>+(core.FallThroughError._create = function(url, line) {
>+  core.FallThroughError.__proto__.new.call(this);
>+}).prototype = core.FallThroughError.prototype;
>+dart.addTypeTests(core.FallThroughError);
>+dart.setLibraryUri(core.FallThroughError, "dart:core");
>+dart.defineExtensionMethods(core.FallThroughError, ['toString']);
>+_js_helper.FallThroughErrorImplementation = class FallThroughErrorImplementation extends core.FallThroughError {
>+  toString() {
>+    return "Switch case fall-through.";
>+  }
>+};
>+(_js_helper.FallThroughErrorImplementation.new = function() {
>+  _js_helper.FallThroughErrorImplementation.__proto__.new.call(this);
>+}).prototype = _js_helper.FallThroughErrorImplementation.prototype;
>+dart.addTypeTests(_js_helper.FallThroughErrorImplementation);
>+dart.setLibraryUri(_js_helper.FallThroughErrorImplementation, "dart:_js_helper");
>+dart.defineExtensionMethods(_js_helper.FallThroughErrorImplementation, ['toString']);
>+_js_helper.RuntimeError = class RuntimeError extends core.Error {
>+  toString() {
>+    return "RuntimeError: " + dart.str(this.message);
>+  }
>+};
>+(_js_helper.RuntimeError.new = function(message) {
>+  this.message = message;
>+  _js_helper.RuntimeError.__proto__.new.call(this);
>+}).prototype = _js_helper.RuntimeError.prototype;
>+dart.addTypeTests(_js_helper.RuntimeError);
>+dart.setLibraryUri(_js_helper.RuntimeError, "dart:_js_helper");
>+dart.setFieldSignature(_js_helper.RuntimeError, () => ({
>+  __proto__: dart.getFields(_js_helper.RuntimeError.__proto__),
>+  message: dart.finalFieldType(dart.dynamic)
>+}));
>+dart.defineExtensionMethods(_js_helper.RuntimeError, ['toString']);
>+const _fileUri = dart.privateName(_js_helper, "_fileUri");
>+const _line = dart.privateName(_js_helper, "_line");
>+const _column = dart.privateName(_js_helper, "_column");
>+const _conditionSource = dart.privateName(_js_helper, "_conditionSource");
>+core.AssertionError = class AssertionError extends core.Error {
>+  get message() {
>+    return this[message$];
>+  }
>+  set message(value) {
>+    super.message = value;
>+  }
>+  toString() {
>+    return "Assertion failed";
>+  }
>+};
>+(core.AssertionError.new = function(message) {
>+  if (message === void 0) message = null;
>+  this[message$] = message;
>+  core.AssertionError.__proto__.new.call(this);
>+}).prototype = core.AssertionError.prototype;
>+dart.addTypeTests(core.AssertionError);
>+const message$ = Symbol("AssertionError.message");
>+dart.setLibraryUri(core.AssertionError, "dart:core");
>+dart.setFieldSignature(core.AssertionError, () => ({
>+  __proto__: dart.getFields(core.AssertionError.__proto__),
>+  message: dart.finalFieldType(core.Object)
>+}));
>+dart.defineExtensionMethods(core.AssertionError, ['toString']);
>+_js_helper.AssertionErrorImpl = class AssertionErrorImpl extends core.AssertionError {
>+  toString() {
>+    let failureMessage = "";
>+    if (this[_fileUri] != null && this[_line] != null && this[_column] != null && this[_conditionSource] != null) {
>+      failureMessage = failureMessage + (dart.str(this[_fileUri]) + ":" + dart.str(this[_line]) + ":" + dart.str(this[_column]) + "\n" + dart.str(this[_conditionSource]) + "\n");
>+    }
>+    failureMessage = failureMessage + dart.notNull(this.message != null ? core.Error.safeToString(this.message) : "is not true");
>+    return "Assertion failed: " + failureMessage;
>+  }
>+};
>+(_js_helper.AssertionErrorImpl.new = function(message, fileUri, line, column, conditionSource) {
>+  if (fileUri === void 0) fileUri = null;
>+  if (line === void 0) line = null;
>+  if (column === void 0) column = null;
>+  if (conditionSource === void 0) conditionSource = null;
>+  this[_fileUri] = fileUri;
>+  this[_line] = line;
>+  this[_column] = column;
>+  this[_conditionSource] = conditionSource;
>+  _js_helper.AssertionErrorImpl.__proto__.new.call(this, message);
>+}).prototype = _js_helper.AssertionErrorImpl.prototype;
>+dart.addTypeTests(_js_helper.AssertionErrorImpl);
>+dart.setLibraryUri(_js_helper.AssertionErrorImpl, "dart:_js_helper");
>+dart.setFieldSignature(_js_helper.AssertionErrorImpl, () => ({
>+  __proto__: dart.getFields(_js_helper.AssertionErrorImpl.__proto__),
>+  [_fileUri]: dart.finalFieldType(core.String),
>+  [_line]: dart.finalFieldType(core.int),
>+  [_column]: dart.finalFieldType(core.int),
>+  [_conditionSource]: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionMethods(_js_helper.AssertionErrorImpl, ['toString']);
>+_js_helper.random64 = function() {
>+  let int32a = Math.random() * 0x100000000 >>> 0;
>+  let int32b = Math.random() * 0x100000000 >>> 0;
>+  return int32a + int32b * 4294967296;
>+};
>+_js_helper.BooleanConversionAssertionError = class BooleanConversionAssertionError extends core.AssertionError {
>+  toString() {
>+    return "Failed assertion: boolean expression must not be null";
>+  }
>+};
>+(_js_helper.BooleanConversionAssertionError.new = function() {
>+  _js_helper.BooleanConversionAssertionError.__proto__.new.call(this);
>+}).prototype = _js_helper.BooleanConversionAssertionError.prototype;
>+dart.addTypeTests(_js_helper.BooleanConversionAssertionError);
>+dart.setLibraryUri(_js_helper.BooleanConversionAssertionError, "dart:_js_helper");
>+dart.defineExtensionMethods(_js_helper.BooleanConversionAssertionError, ['toString']);
>+_js_helper.registerGlobalObject = function(object) {
>+  try {
>+    if (dart.test(dart.polyfill(object))) {
>+      dart.applyAllExtensions(object);
>+    }
>+  } catch (e$) {
>+    let e = dart.getThrown(e$);
>+  }
>+};
>+_js_helper.applyExtension = function(name, nativeObject) {
>+  dart.applyExtension(name, nativeObject);
>+};
>+const _name$ = dart.privateName(_js_helper, "_name");
>+const _nativeSymbol = dart.privateName(_js_helper, "_nativeSymbol");
>+_js_helper.PrivateSymbol = class PrivateSymbol extends core.Object {
>+  static getName(symbol) {
>+    return _js_helper.PrivateSymbol.as(symbol)[_name$];
>+  }
>+  static getNativeSymbol(symbol) {
>+    if (_js_helper.PrivateSymbol.is(symbol)) return symbol[_nativeSymbol];
>+    return null;
>+  }
>+  _equals(other) {
>+    return _js_helper.PrivateSymbol.is(other) && this[_name$] == other[_name$] && core.identical(this[_nativeSymbol], other[_nativeSymbol]);
>+  }
>+  get hashCode() {
>+    return dart.hashCode(this[_name$]);
>+  }
>+  toString() {
>+    return "Symbol(\"" + dart.str(this[_name$]) + "\")";
>+  }
>+};
>+(_js_helper.PrivateSymbol.new = function(name, nativeSymbol) {
>+  this[_name$] = name;
>+  this[_nativeSymbol] = nativeSymbol;
>+}).prototype = _js_helper.PrivateSymbol.prototype;
>+dart.addTypeTests(_js_helper.PrivateSymbol);
>+_js_helper.PrivateSymbol[dart.implements] = () => [core.Symbol];
>+dart.setLibraryUri(_js_helper.PrivateSymbol, "dart:_js_helper");
>+dart.setFieldSignature(_js_helper.PrivateSymbol, () => ({
>+  __proto__: dart.getFields(_js_helper.PrivateSymbol.__proto__),
>+  [_name$]: dart.finalFieldType(core.String),
>+  [_nativeSymbol]: dart.finalFieldType(core.Object)
>+}));
>+dart.defineExtensionMethods(_js_helper.PrivateSymbol, ['_equals', 'toString']);
>+dart.defineExtensionAccessors(_js_helper.PrivateSymbol, ['hashCode']);
>+_js_helper.ForceInline = class ForceInline extends core.Object {};
>+(_js_helper.ForceInline.new = function() {
>+}).prototype = _js_helper.ForceInline.prototype;
>+dart.addTypeTests(_js_helper.ForceInline);
>+dart.setLibraryUri(_js_helper.ForceInline, "dart:_js_helper");
>+_js_helper._NotNull = class _NotNull extends core.Object {};
>+(_js_helper._NotNull.new = function() {
>+}).prototype = _js_helper._NotNull.prototype;
>+dart.addTypeTests(_js_helper._NotNull);
>+dart.setLibraryUri(_js_helper._NotNull, "dart:_js_helper");
>+dart.defineLazy(_js_helper, {
>+  /*_js_helper.notNull*/get notNull() {
>+    return dart.const(new _js_helper._NotNull.new());
>+  }
>+});
>+_js_helper.NoReifyGeneric = class NoReifyGeneric extends core.Object {};
>+(_js_helper.NoReifyGeneric.new = function() {
>+}).prototype = _js_helper.NoReifyGeneric.prototype;
>+dart.addTypeTests(_js_helper.NoReifyGeneric);
>+dart.setLibraryUri(_js_helper.NoReifyGeneric, "dart:_js_helper");
>+_js_helper.ReifyFunctionTypes = class ReifyFunctionTypes extends core.Object {};
>+(_js_helper.ReifyFunctionTypes.new = function(value) {
>+  this.value = value;
>+}).prototype = _js_helper.ReifyFunctionTypes.prototype;
>+dart.addTypeTests(_js_helper.ReifyFunctionTypes);
>+dart.setLibraryUri(_js_helper.ReifyFunctionTypes, "dart:_js_helper");
>+dart.setFieldSignature(_js_helper.ReifyFunctionTypes, () => ({
>+  __proto__: dart.getFields(_js_helper.ReifyFunctionTypes.__proto__),
>+  value: dart.finalFieldType(core.bool)
>+}));
>+_js_helper._NullCheck = class _NullCheck extends core.Object {};
>+(_js_helper._NullCheck.new = function() {
>+}).prototype = _js_helper._NullCheck.prototype;
>+dart.addTypeTests(_js_helper._NullCheck);
>+dart.setLibraryUri(_js_helper._NullCheck, "dart:_js_helper");
>+dart.defineLazy(_js_helper, {
>+  /*_js_helper.undefined*/get undefined() {
>+    return dart.const(new _js_helper._Undefined.new());
>+  }
>+});
>+_js_helper._Undefined = class _Undefined extends core.Object {};
>+(_js_helper._Undefined.new = function() {
>+}).prototype = _js_helper._Undefined.prototype;
>+dart.addTypeTests(_js_helper._Undefined);
>+dart.setLibraryUri(_js_helper._Undefined, "dart:_js_helper");
>+dart.defineLazy(_js_helper, {
>+  /*_js_helper.nullCheck*/get nullCheck() {
>+    return dart.const(new _js_helper._NullCheck.new());
>+  }
>+});
>+_js_helper.NoThrows = class NoThrows extends core.Object {};
>+(_js_helper.NoThrows.new = function() {
>+}).prototype = _js_helper.NoThrows.prototype;
>+dart.addTypeTests(_js_helper.NoThrows);
>+dart.setLibraryUri(_js_helper.NoThrows, "dart:_js_helper");
>+_js_helper.NoInline = class NoInline extends core.Object {};
>+(_js_helper.NoInline.new = function() {
>+}).prototype = _js_helper.NoInline.prototype;
>+dart.addTypeTests(_js_helper.NoInline);
>+dart.setLibraryUri(_js_helper.NoInline, "dart:_js_helper");
>+_js_helper.Native = class Native extends core.Object {};
>+(_js_helper.Native.new = function(name) {
>+  this.name = name;
>+}).prototype = _js_helper.Native.prototype;
>+dart.addTypeTests(_js_helper.Native);
>+dart.setLibraryUri(_js_helper.Native, "dart:_js_helper");
>+dart.setFieldSignature(_js_helper.Native, () => ({
>+  __proto__: dart.getFields(_js_helper.Native.__proto__),
>+  name: dart.finalFieldType(core.String)
>+}));
>+_js_helper.JsPeerInterface = class JsPeerInterface extends core.Object {};
>+(_js_helper.JsPeerInterface.new = function(opts) {
>+  let name = opts && 'name' in opts ? opts.name : null;
>+  this.name = name;
>+}).prototype = _js_helper.JsPeerInterface.prototype;
>+dart.addTypeTests(_js_helper.JsPeerInterface);
>+dart.setLibraryUri(_js_helper.JsPeerInterface, "dart:_js_helper");
>+dart.setFieldSignature(_js_helper.JsPeerInterface, () => ({
>+  __proto__: dart.getFields(_js_helper.JsPeerInterface.__proto__),
>+  name: dart.finalFieldType(core.String)
>+}));
>+_js_helper.SupportJsExtensionMethods = class SupportJsExtensionMethods extends core.Object {};
>+(_js_helper.SupportJsExtensionMethods.new = function() {
>+}).prototype = _js_helper.SupportJsExtensionMethods.prototype;
>+dart.addTypeTests(_js_helper.SupportJsExtensionMethods);
>+dart.setLibraryUri(_js_helper.SupportJsExtensionMethods, "dart:_js_helper");
>+const _modifications = dart.privateName(_js_helper, "_modifications");
>+const _map = dart.privateName(_js_helper, "_map");
>+const _is_InternalMap_default = Symbol('_is_InternalMap_default');
>+_js_helper.InternalMap$ = dart.generic((K, V) => {
>+  let LinkedHashMapOfK$V = () => (LinkedHashMapOfK$V = dart.constFn(collection.LinkedHashMap$(K, V)))();
>+  let HashMapOfK$V = () => (HashMapOfK$V = dart.constFn(collection.HashMap$(K, V)))();
>+  class InternalMap extends collection.MapBase$(K, V) {
>+    forEach(action) {
>+      let modifications = this[_modifications];
>+      for (let entry of this[_map].entries()) {
>+        action(entry[0], entry[1]);
>+        if (modifications !== this[_modifications]) {
>+          dart.throw(new core.ConcurrentModificationError.new(this));
>+        }
>+      }
>+    }
>+  }
>+  (InternalMap.new = function() {
>+  }).prototype = InternalMap.prototype;
>+  dart.addTypeTests(InternalMap);
>+  InternalMap.prototype[_is_InternalMap_default] = true;
>+  InternalMap[dart.implements] = () => [LinkedHashMapOfK$V(), HashMapOfK$V()];
>+  dart.setLibraryUri(InternalMap, "dart:_js_helper");
>+  dart.defineExtensionMethods(InternalMap, ['forEach']);
>+  return InternalMap;
>+});
>+_js_helper.InternalMap = _js_helper.InternalMap$();
>+dart.addTypeTests(_js_helper.InternalMap, _is_InternalMap_default);
>+const _keyMap = dart.privateName(_js_helper, "_keyMap");
>+const _is_LinkedMap_default = Symbol('_is_LinkedMap_default');
>+_js_helper.LinkedMap$ = dart.generic((K, V) => {
>+  let _JSMapIterableOfK = () => (_JSMapIterableOfK = dart.constFn(_js_helper._JSMapIterable$(K)))();
>+  let MapOfK$V = () => (MapOfK$V = dart.constFn(core.Map$(K, V)))();
>+  let KAndVToNull = () => (KAndVToNull = dart.constFn(dart.fnType(core.Null, [K, V])))();
>+  let _JSMapIterableOfV = () => (_JSMapIterableOfV = dart.constFn(_js_helper._JSMapIterable$(V)))();
>+  let VoidToV = () => (VoidToV = dart.constFn(dart.fnType(V, [])))();
>+  class LinkedMap extends _js_helper.InternalMap$(K, V) {
>+    get length() {
>+      return this[_map].size;
>+    }
>+    get isEmpty() {
>+      return this[_map].size == 0;
>+    }
>+    get isNotEmpty() {
>+      return this[_map].size != 0;
>+    }
>+    get keys() {
>+      return new (_JSMapIterableOfK()).new(this, true);
>+    }
>+    get values() {
>+      return new (_JSMapIterableOfV()).new(this, false);
>+    }
>+    containsKey(key) {
>+      if (key == null) {
>+        key = null;
>+      } else if (key[$_equals] !== dart.identityEquals) {
>+        let k = key;
>+        let buckets = this[_keyMap].get(k[$hashCode] & 0x3ffffff);
>+        if (buckets != null) {
>+          for (let i = 0, n = buckets.length; i < n; i++) {
>+            k = buckets[i];
>+            if (k[$_equals](key)) return true;
>+          }
>+        }
>+        return false;
>+      }
>+      return this[_map].has(key);
>+    }
>+    containsValue(value) {
>+      for (let v of this[_map].values()) {
>+        if (dart.equals(v, value)) return true;
>+      }
>+      return false;
>+    }
>+    addAll(other) {
>+      MapOfK$V()._check(other);
>+      let map = this[_map];
>+      let length = map.size;
>+      other[$forEach](dart.fn((key, value) => {
>+        if (key == null) {
>+          key = null;
>+        } else if (key[$_equals] !== dart.identityEquals) {
>+          key = _js_helper.putLinkedMapKey(key, this[_keyMap]);
>+        }
>+        this[_map].set(key, value);
>+      }, KAndVToNull()));
>+      if (length !== map.size) {
>+        this[_modifications] = this[_modifications] + 1 & 67108863;
>+      }
>+    }
>+    _get(key) {
>+      if (key == null) {
>+        key = null;
>+      } else if (key[$_equals] !== dart.identityEquals) {
>+        let k = key;
>+        let buckets = this[_keyMap].get(k[$hashCode] & 0x3ffffff);
>+        if (buckets != null) {
>+          for (let i = 0, n = buckets.length; i < n; i++) {
>+            k = buckets[i];
>+            if (k[$_equals](key)) return this[_map].get(k);
>+          }
>+        }
>+        return null;
>+      }
>+      let value = this[_map].get(key);
>+      return value == null ? null : value;
>+    }
>+    _set(key, value) {
>+      K._check(key);
>+      V._check(value);
>+      if (key == null) {
>+        key = null;
>+      } else if (key[$_equals] !== dart.identityEquals) {
>+        key = _js_helper.putLinkedMapKey(key, this[_keyMap]);
>+      }
>+      let map = this[_map];
>+      let length = map.size;
>+      map.set(key, value);
>+      if (length !== map.size) {
>+        this[_modifications] = this[_modifications] + 1 & 67108863;
>+      }
>+      return value;
>+    }
>+    putIfAbsent(key, ifAbsent) {
>+      K._check(key);
>+      VoidToV()._check(ifAbsent);
>+      let map = this[_map];
>+      if (key == null) {
>+        key = null;
>+        if (map.has(null)) return map.get(null);
>+      } else if (key[$_equals] !== dart.identityEquals) {
>+        let k = key;
>+        let hash = k[$hashCode] & 0x3ffffff;
>+        let buckets = this[_keyMap].get(hash);
>+        if (buckets == null) {
>+          this[_keyMap].set(hash, [key]);
>+        } else {
>+          for (let i = 0, n = buckets.length; i < n; i++) {
>+            k = buckets[i];
>+            if (k[$_equals](key)) return map.get(k);
>+          }
>+          buckets.push(key);
>+        }
>+      } else if (map.has(key)) {
>+        return map.get(key);
>+      }
>+      let value = ifAbsent();
>+      if (value == null) value = null;
>+      map.set(key, value);
>+      this[_modifications] = this[_modifications] + 1 & 67108863;
>+      return value;
>+    }
>+    remove(key) {
>+      if (key == null) {
>+        key = null;
>+      } else if (key[$_equals] !== dart.identityEquals) {
>+        let k = key;
>+        let hash = k[$hashCode] & 0x3ffffff;
>+        let buckets = this[_keyMap].get(hash);
>+        if (buckets == null) return null;
>+        for (let i = 0, n = buckets.length;;) {
>+          k = buckets[i];
>+          if (k[$_equals](key)) {
>+            key = k;
>+            if (n === 1) {
>+              this[_keyMap].delete(hash);
>+            } else {
>+              buckets.splice(i, 1);
>+            }
>+            break;
>+          }
>+          if (++i >= n) return null;
>+        }
>+      }
>+      let map = this[_map];
>+      let value = map.get(key);
>+      if (map.delete(key)) {
>+        this[_modifications] = this[_modifications] + 1 & 67108863;
>+      }
>+      return value == null ? null : value;
>+    }
>+    clear() {
>+      let map = this[_map];
>+      if (map.size > 0) {
>+        map.clear();
>+        this[_keyMap].clear();
>+        this[_modifications] = this[_modifications] + 1 & 67108863;
>+      }
>+    }
>+  }
>+  (LinkedMap.new = function() {
>+    this[_map] = new Map();
>+    this[_keyMap] = new Map();
>+    this[_modifications] = 0;
>+  }).prototype = LinkedMap.prototype;
>+  (LinkedMap.from = function(entries) {
>+    this[_map] = new Map();
>+    this[_keyMap] = new Map();
>+    this[_modifications] = 0;
>+    let map = this[_map];
>+    let keyMap = this[_keyMap];
>+    for (let i = 0, n = entries.length; i < n; i = i + 2) {
>+      let key = entries[i];
>+      let value = entries[i + 1];
>+      if (key == null) {
>+        key = null;
>+      } else if (key[$_equals] !== dart.identityEquals) {
>+        key = _js_helper.putLinkedMapKey(key, keyMap);
>+      }
>+      map.set(key, value);
>+    }
>+  }).prototype = LinkedMap.prototype;
>+  dart.addTypeTests(LinkedMap);
>+  LinkedMap.prototype[_is_LinkedMap_default] = true;
>+  dart.setMethodSignature(LinkedMap, () => ({
>+    __proto__: dart.getMethods(LinkedMap.__proto__),
>+    addAll: dart.fnType(dart.void, [core.Object]),
>+    [$addAll]: dart.fnType(dart.void, [core.Object]),
>+    _get: dart.fnType(V, [core.Object]),
>+    [$_get]: dart.fnType(V, [core.Object]),
>+    _set: dart.fnType(dart.void, [core.Object, core.Object]),
>+    [$_set]: dart.fnType(dart.void, [core.Object, core.Object]),
>+    putIfAbsent: dart.fnType(V, [core.Object, core.Object]),
>+    [$putIfAbsent]: dart.fnType(V, [core.Object, core.Object]),
>+    remove: dart.fnType(V, [core.Object]),
>+    [$remove]: dart.fnType(V, [core.Object]),
>+    clear: dart.fnType(dart.void, []),
>+    [$clear]: dart.fnType(dart.void, [])
>+  }));
>+  dart.setGetterSignature(LinkedMap, () => ({
>+    __proto__: dart.getGetters(LinkedMap.__proto__),
>+    keys: core.Iterable$(K),
>+    [$keys]: core.Iterable$(K)
>+  }));
>+  dart.setLibraryUri(LinkedMap, "dart:_js_helper");
>+  dart.setFieldSignature(LinkedMap, () => ({
>+    __proto__: dart.getFields(LinkedMap.__proto__),
>+    [_map]: dart.finalFieldType(dart.dynamic),
>+    [_keyMap]: dart.finalFieldType(dart.dynamic),
>+    [_modifications]: dart.fieldType(core.int)
>+  }));
>+  dart.defineExtensionMethods(LinkedMap, [
>+    'containsKey',
>+    'containsValue',
>+    'addAll',
>+    '_get',
>+    '_set',
>+    'putIfAbsent',
>+    'remove',
>+    'clear'
>+  ]);
>+  dart.defineExtensionAccessors(LinkedMap, [
>+    'length',
>+    'isEmpty',
>+    'isNotEmpty',
>+    'keys',
>+    'values'
>+  ]);
>+  return LinkedMap;
>+});
>+_js_helper.LinkedMap = _js_helper.LinkedMap$();
>+dart.addTypeTests(_js_helper.LinkedMap, _is_LinkedMap_default);
>+_js_helper.putLinkedMapKey = function(key, keyMap) {
>+  let hash = key[$hashCode] & 0x3ffffff;
>+  let buckets = keyMap.get(hash);
>+  if (buckets == null) {
>+    keyMap.set(hash, [key]);
>+    return key;
>+  }
>+  for (let i = 0, n = buckets.length; i < n; i++) {
>+    let k = buckets[i];
>+    if (k[$_equals](key)) return k;
>+  }
>+  buckets.push(key);
>+  return key;
>+};
>+const _is_ImmutableMap_default = Symbol('_is_ImmutableMap_default');
>+_js_helper.ImmutableMap$ = dart.generic((K, V) => {
>+  class ImmutableMap extends _js_helper.LinkedMap$(K, V) {
>+    _set(key, value) {
>+      dart.throw(_js_helper.ImmutableMap._unsupported());
>+      return value;
>+    }
>+    addAll(other) {
>+      return dart.throw(_js_helper.ImmutableMap._unsupported());
>+    }
>+    clear() {
>+      return dart.throw(_js_helper.ImmutableMap._unsupported());
>+    }
>+    remove(key) {
>+      return dart.throw(_js_helper.ImmutableMap._unsupported());
>+    }
>+    putIfAbsent(key, ifAbsent) {
>+      return dart.throw(_js_helper.ImmutableMap._unsupported());
>+    }
>+    static _unsupported() {
>+      return new core.UnsupportedError.new("Cannot modify unmodifiable map");
>+    }
>+  }
>+  (ImmutableMap.from = function(entries) {
>+    ImmutableMap.__proto__.from.call(this, entries);
>+  }).prototype = ImmutableMap.prototype;
>+  dart.addTypeTests(ImmutableMap);
>+  ImmutableMap.prototype[_is_ImmutableMap_default] = true;
>+  dart.setMethodSignature(ImmutableMap, () => ({
>+    __proto__: dart.getMethods(ImmutableMap.__proto__),
>+    _set: dart.fnType(dart.void, [core.Object, core.Object]),
>+    [$_set]: dart.fnType(dart.void, [core.Object, core.Object]),
>+    addAll: dart.fnType(dart.void, [core.Object]),
>+    [$addAll]: dart.fnType(dart.void, [core.Object]),
>+    putIfAbsent: dart.fnType(V, [core.Object, dart.fnType(core.Object, [])]),
>+    [$putIfAbsent]: dart.fnType(V, [core.Object, dart.fnType(core.Object, [])])
>+  }));
>+  dart.setLibraryUri(ImmutableMap, "dart:_js_helper");
>+  dart.defineExtensionMethods(ImmutableMap, [
>+    '_set',
>+    'addAll',
>+    'clear',
>+    'remove',
>+    'putIfAbsent'
>+  ]);
>+  return ImmutableMap;
>+});
>+_js_helper.ImmutableMap = _js_helper.ImmutableMap$();
>+dart.addTypeTests(_js_helper.ImmutableMap, _is_ImmutableMap_default);
>+const _is_IdentityMap_default = Symbol('_is_IdentityMap_default');
>+_js_helper.IdentityMap$ = dart.generic((K, V) => {
>+  let _JSMapIterableOfK = () => (_JSMapIterableOfK = dart.constFn(_js_helper._JSMapIterable$(K)))();
>+  let MapOfK$V = () => (MapOfK$V = dart.constFn(core.Map$(K, V)))();
>+  let KAndVToNull = () => (KAndVToNull = dart.constFn(dart.fnType(core.Null, [K, V])))();
>+  let _JSMapIterableOfV = () => (_JSMapIterableOfV = dart.constFn(_js_helper._JSMapIterable$(V)))();
>+  let VoidToV = () => (VoidToV = dart.constFn(dart.fnType(V, [])))();
>+  class IdentityMap extends _js_helper.InternalMap$(K, V) {
>+    get length() {
>+      return this[_map].size;
>+    }
>+    get isEmpty() {
>+      return this[_map].size == 0;
>+    }
>+    get isNotEmpty() {
>+      return this[_map].size != 0;
>+    }
>+    get keys() {
>+      return new (_JSMapIterableOfK()).new(this, true);
>+    }
>+    get values() {
>+      return new (_JSMapIterableOfV()).new(this, false);
>+    }
>+    containsKey(key) {
>+      return this[_map].has(key);
>+    }
>+    containsValue(value) {
>+      for (let v of this[_map].values()) {
>+        if (dart.equals(v, value)) return true;
>+      }
>+      return false;
>+    }
>+    addAll(other) {
>+      MapOfK$V()._check(other);
>+      if (dart.test(other[$isNotEmpty])) {
>+        let map = this[_map];
>+        other[$forEach](dart.fn((key, value) => {
>+          map.set(key, value);
>+        }, KAndVToNull()));
>+        this[_modifications] = this[_modifications] + 1 & 67108863;
>+      }
>+    }
>+    _get(key) {
>+      let value = this[_map].get(key);
>+      return value == null ? null : value;
>+    }
>+    _set(key, value) {
>+      K._check(key);
>+      V._check(value);
>+      let map = this[_map];
>+      let length = map.size;
>+      map.set(key, value);
>+      if (length !== map.size) {
>+        this[_modifications] = this[_modifications] + 1 & 67108863;
>+      }
>+      return value;
>+    }
>+    putIfAbsent(key, ifAbsent) {
>+      K._check(key);
>+      VoidToV()._check(ifAbsent);
>+      if (this[_map].has(key)) return this[_map].get(key);
>+      let value = ifAbsent();
>+      if (value == null) value = null;
>+      this[_map].set(key, value);
>+      this[_modifications] = this[_modifications] + 1 & 67108863;
>+      return value;
>+    }
>+    remove(key) {
>+      let value = this[_map].get(key);
>+      if (this[_map].delete(key)) {
>+        this[_modifications] = this[_modifications] + 1 & 67108863;
>+      }
>+      return value == null ? null : value;
>+    }
>+    clear() {
>+      if (this[_map].size > 0) {
>+        this[_map].clear();
>+        this[_modifications] = this[_modifications] + 1 & 67108863;
>+      }
>+    }
>+  }
>+  (IdentityMap.new = function() {
>+    this[_map] = new Map();
>+    this[_modifications] = 0;
>+  }).prototype = IdentityMap.prototype;
>+  (IdentityMap.from = function(entries) {
>+    this[_map] = new Map();
>+    this[_modifications] = 0;
>+    let map = this[_map];
>+    for (let i = 0, n = entries.length; i < n; i = i + 2) {
>+      map.set(entries[i], entries[i + 1]);
>+    }
>+  }).prototype = IdentityMap.prototype;
>+  dart.addTypeTests(IdentityMap);
>+  IdentityMap.prototype[_is_IdentityMap_default] = true;
>+  dart.setMethodSignature(IdentityMap, () => ({
>+    __proto__: dart.getMethods(IdentityMap.__proto__),
>+    addAll: dart.fnType(dart.void, [core.Object]),
>+    [$addAll]: dart.fnType(dart.void, [core.Object]),
>+    _get: dart.fnType(V, [core.Object]),
>+    [$_get]: dart.fnType(V, [core.Object]),
>+    _set: dart.fnType(dart.void, [core.Object, core.Object]),
>+    [$_set]: dart.fnType(dart.void, [core.Object, core.Object]),
>+    putIfAbsent: dart.fnType(V, [core.Object, core.Object]),
>+    [$putIfAbsent]: dart.fnType(V, [core.Object, core.Object]),
>+    remove: dart.fnType(V, [core.Object]),
>+    [$remove]: dart.fnType(V, [core.Object]),
>+    clear: dart.fnType(dart.void, []),
>+    [$clear]: dart.fnType(dart.void, [])
>+  }));
>+  dart.setGetterSignature(IdentityMap, () => ({
>+    __proto__: dart.getGetters(IdentityMap.__proto__),
>+    keys: core.Iterable$(K),
>+    [$keys]: core.Iterable$(K)
>+  }));
>+  dart.setLibraryUri(IdentityMap, "dart:_js_helper");
>+  dart.setFieldSignature(IdentityMap, () => ({
>+    __proto__: dart.getFields(IdentityMap.__proto__),
>+    [_map]: dart.finalFieldType(dart.dynamic),
>+    [_modifications]: dart.fieldType(core.int)
>+  }));
>+  dart.defineExtensionMethods(IdentityMap, [
>+    'containsKey',
>+    'containsValue',
>+    'addAll',
>+    '_get',
>+    '_set',
>+    'putIfAbsent',
>+    'remove',
>+    'clear'
>+  ]);
>+  dart.defineExtensionAccessors(IdentityMap, [
>+    'length',
>+    'isEmpty',
>+    'isNotEmpty',
>+    'keys',
>+    'values'
>+  ]);
>+  return IdentityMap;
>+});
>+_js_helper.IdentityMap = _js_helper.IdentityMap$();
>+dart.addTypeTests(_js_helper.IdentityMap, _is_IdentityMap_default);
>+const _isKeys = dart.privateName(_js_helper, "_isKeys");
>+const _is__JSMapIterable_default = Symbol('_is__JSMapIterable_default');
>+_js_helper._JSMapIterable$ = dart.generic(E => {
>+  let DartIteratorOfE = () => (DartIteratorOfE = dart.constFn(_js_helper.DartIterator$(E)))();
>+  class _JSMapIterable extends _internal.EfficientLengthIterable$(E) {
>+    get length() {
>+      return this[_map].length;
>+    }
>+    get isEmpty() {
>+      return this[_map].isEmpty;
>+    }
>+    [Symbol.iterator]() {
>+      let map = this[_map];
>+      let iterator = this[_isKeys] ? map[_map].keys() : map[_map].values();
>+      let modifications = map[_modifications];
>+      return {
>+        next() {
>+          if (modifications != map[_modifications]) {
>+            throw new core.ConcurrentModificationError.new(map);
>+          }
>+          return iterator.next();
>+        }
>+      };
>+    }
>+    get iterator() {
>+      return new (DartIteratorOfE()).new(this[Symbol.iterator]());
>+    }
>+    contains(element) {
>+      return this[_isKeys] ? this[_map].containsKey(element) : this[_map].containsValue(element);
>+    }
>+    forEach(f) {
>+      for (let entry of this)
>+        f(entry);
>+    }
>+  }
>+  (_JSMapIterable.new = function(map, isKeys) {
>+    this[_map] = map;
>+    this[_isKeys] = isKeys;
>+    _JSMapIterable.__proto__.new.call(this);
>+  }).prototype = _JSMapIterable.prototype;
>+  dart.addTypeTests(_JSMapIterable);
>+  _JSMapIterable.prototype[_is__JSMapIterable_default] = true;
>+  dart.setMethodSignature(_JSMapIterable, () => ({
>+    __proto__: dart.getMethods(_JSMapIterable.__proto__),
>+    [Symbol.iterator]: dart.fnType(dart.dynamic, [])
>+  }));
>+  dart.setGetterSignature(_JSMapIterable, () => ({
>+    __proto__: dart.getGetters(_JSMapIterable.__proto__),
>+    length: core.int,
>+    [$length]: core.int,
>+    iterator: core.Iterator$(E),
>+    [$iterator]: core.Iterator$(E)
>+  }));
>+  dart.setLibraryUri(_JSMapIterable, "dart:_js_helper");
>+  dart.setFieldSignature(_JSMapIterable, () => ({
>+    __proto__: dart.getFields(_JSMapIterable.__proto__),
>+    [_map]: dart.finalFieldType(_js_helper.InternalMap),
>+    [_isKeys]: dart.finalFieldType(core.bool)
>+  }));
>+  dart.defineExtensionMethods(_JSMapIterable, ['contains', 'forEach']);
>+  dart.defineExtensionAccessors(_JSMapIterable, ['length', 'isEmpty', 'iterator']);
>+  return _JSMapIterable;
>+});
>+_js_helper._JSMapIterable = _js_helper._JSMapIterable$();
>+dart.addTypeTests(_js_helper._JSMapIterable, _is__JSMapIterable_default);
>+const _validKey = dart.privateName(_js_helper, "_validKey");
>+const _equals = dart.privateName(_js_helper, "_equals");
>+const _hashCode = dart.privateName(_js_helper, "_hashCode");
>+const _is_CustomHashMap_default = Symbol('_is_CustomHashMap_default');
>+_js_helper.CustomHashMap$ = dart.generic((K, V) => {
>+  let _JSMapIterableOfK = () => (_JSMapIterableOfK = dart.constFn(_js_helper._JSMapIterable$(K)))();
>+  let MapOfK$V = () => (MapOfK$V = dart.constFn(core.Map$(K, V)))();
>+  let KAndVToNull = () => (KAndVToNull = dart.constFn(dart.fnType(core.Null, [K, V])))();
>+  let KAndKTobool = () => (KAndKTobool = dart.constFn(dart.fnType(core.bool, [K, K])))();
>+  let KToint = () => (KToint = dart.constFn(dart.fnType(core.int, [K])))();
>+  let _JSMapIterableOfV = () => (_JSMapIterableOfV = dart.constFn(_js_helper._JSMapIterable$(V)))();
>+  let VoidToV = () => (VoidToV = dart.constFn(dart.fnType(V, [])))();
>+  class CustomHashMap extends _js_helper.InternalMap$(K, V) {
>+    get length() {
>+      return this[_map].size;
>+    }
>+    get isEmpty() {
>+      return this[_map].size == 0;
>+    }
>+    get isNotEmpty() {
>+      return this[_map].size != 0;
>+    }
>+    get keys() {
>+      return new (_JSMapIterableOfK()).new(this, true);
>+    }
>+    get values() {
>+      return new (_JSMapIterableOfV()).new(this, false);
>+    }
>+    containsKey(key) {
>+      if (K.is(key)) {
>+        let buckets = this[_keyMap].get(this[_hashCode](key) & 0x3ffffff);
>+        if (buckets != null) {
>+          let equals = this[_equals];
>+          for (let i = 0, n = buckets.length; i < n; i++) {
>+            let k = buckets[i];
>+            if (dart.test(equals(k, key))) return true;
>+          }
>+        }
>+      }
>+      return false;
>+    }
>+    containsValue(value) {
>+      for (let v of this[_map].values()) {
>+        if (dart.equals(value, v)) return true;
>+      }
>+      return false;
>+    }
>+    addAll(other) {
>+      MapOfK$V()._check(other);
>+      other[$forEach](dart.fn((key, value) => {
>+        this._set(key, value);
>+      }, KAndVToNull()));
>+    }
>+    _get(key) {
>+      if (K.is(key)) {
>+        let buckets = this[_keyMap].get(this[_hashCode](key) & 0x3ffffff);
>+        if (buckets != null) {
>+          let equals = this[_equals];
>+          for (let i = 0, n = buckets.length; i < n; i++) {
>+            let k = buckets[i];
>+            if (dart.test(equals(k, key))) {
>+              let value = this[_map].get(k);
>+              return value == null ? null : value;
>+            }
>+          }
>+        }
>+      }
>+      return null;
>+    }
>+    _set(key, value) {
>+      K._check(key);
>+      V._check(value);
>+      let keyMap = this[_keyMap];
>+      let hash = this[_hashCode](key) & 0x3ffffff;
>+      let buckets = keyMap.get(hash);
>+      if (buckets == null) {
>+        keyMap.set(hash, [key]);
>+      } else {
>+        let equals = this[_equals];
>+        for (let i = 0, n = buckets.length;;) {
>+          let k = buckets[i];
>+          if (dart.test(equals(k, key))) {
>+            key = k;
>+            break;
>+          }
>+          if (++i >= n) {
>+            buckets.push(key);
>+            break;
>+          }
>+        }
>+      }
>+      this[_map].set(key, value);
>+      this[_modifications] = this[_modifications] + 1 & 67108863;
>+      return value;
>+    }
>+    putIfAbsent(key, ifAbsent) {
>+      K._check(key);
>+      VoidToV()._check(ifAbsent);
>+      let keyMap = this[_keyMap];
>+      let hash = this[_hashCode](key) & 0x3ffffff;
>+      let buckets = keyMap.get(hash);
>+      if (buckets == null) {
>+        keyMap.set(hash, [key]);
>+      } else {
>+        let equals = this[_equals];
>+        for (let i = 0, n = buckets.length; i < n; i++) {
>+          let k = buckets[i];
>+          if (dart.test(equals(k, key))) return this[_map].get(k);
>+        }
>+        buckets.push(key);
>+      }
>+      let value = ifAbsent();
>+      if (value == null) value = null;
>+      this[_map].set(key, value);
>+      this[_modifications] = this[_modifications] + 1 & 67108863;
>+      return value;
>+    }
>+    remove(key) {
>+      if (K.is(key)) {
>+        let hash = this[_hashCode](key) & 0x3ffffff;
>+        let keyMap = this[_keyMap];
>+        let buckets = keyMap.get(hash);
>+        if (buckets == null) return null;
>+        let equals = this[_equals];
>+        for (let i = 0, n = buckets.length; i < n; i++) {
>+          let k = buckets[i];
>+          if (dart.test(equals(k, key))) {
>+            if (n === 1) {
>+              keyMap.delete(hash);
>+            } else {
>+              buckets.splice(i, 1);
>+            }
>+            let map = this[_map];
>+            let value = map.get(k);
>+            map.delete(k);
>+            this[_modifications] = this[_modifications] + 1 & 67108863;
>+            return value == null ? null : value;
>+          }
>+        }
>+      }
>+      return null;
>+    }
>+    clear() {
>+      let map = this[_map];
>+      if (map.size > 0) {
>+        map.clear();
>+        this[_keyMap].clear();
>+        this[_modifications] = this[_modifications] + 1 & 67108863;
>+      }
>+    }
>+  }
>+  (CustomHashMap.new = function(equals, hashCode) {
>+    this[_map] = new Map();
>+    this[_keyMap] = new Map();
>+    this[_modifications] = 0;
>+    this[_equals] = equals;
>+    this[_hashCode] = hashCode;
>+  }).prototype = CustomHashMap.prototype;
>+  dart.addTypeTests(CustomHashMap);
>+  CustomHashMap.prototype[_is_CustomHashMap_default] = true;
>+  dart.setMethodSignature(CustomHashMap, () => ({
>+    __proto__: dart.getMethods(CustomHashMap.__proto__),
>+    addAll: dart.fnType(dart.void, [core.Object]),
>+    [$addAll]: dart.fnType(dart.void, [core.Object]),
>+    _get: dart.fnType(V, [core.Object]),
>+    [$_get]: dart.fnType(V, [core.Object]),
>+    _set: dart.fnType(dart.void, [core.Object, core.Object]),
>+    [$_set]: dart.fnType(dart.void, [core.Object, core.Object]),
>+    putIfAbsent: dart.fnType(V, [core.Object, core.Object]),
>+    [$putIfAbsent]: dart.fnType(V, [core.Object, core.Object]),
>+    remove: dart.fnType(V, [core.Object]),
>+    [$remove]: dart.fnType(V, [core.Object]),
>+    clear: dart.fnType(dart.void, []),
>+    [$clear]: dart.fnType(dart.void, [])
>+  }));
>+  dart.setGetterSignature(CustomHashMap, () => ({
>+    __proto__: dart.getGetters(CustomHashMap.__proto__),
>+    keys: core.Iterable$(K),
>+    [$keys]: core.Iterable$(K)
>+  }));
>+  dart.setLibraryUri(CustomHashMap, "dart:_js_helper");
>+  dart.setFieldSignature(CustomHashMap, () => ({
>+    __proto__: dart.getFields(CustomHashMap.__proto__),
>+    [_map]: dart.finalFieldType(dart.dynamic),
>+    [_keyMap]: dart.finalFieldType(dart.dynamic),
>+    [_modifications]: dart.fieldType(core.int),
>+    [_equals]: dart.finalFieldType(KAndKTobool()),
>+    [_hashCode]: dart.finalFieldType(KToint())
>+  }));
>+  dart.defineExtensionMethods(CustomHashMap, [
>+    'containsKey',
>+    'containsValue',
>+    'addAll',
>+    '_get',
>+    '_set',
>+    'putIfAbsent',
>+    'remove',
>+    'clear'
>+  ]);
>+  dart.defineExtensionAccessors(CustomHashMap, [
>+    'length',
>+    'isEmpty',
>+    'isNotEmpty',
>+    'keys',
>+    'values'
>+  ]);
>+  return CustomHashMap;
>+});
>+_js_helper.CustomHashMap = _js_helper.CustomHashMap$();
>+dart.addTypeTests(_js_helper.CustomHashMap, _is_CustomHashMap_default);
>+const _is_CustomKeyHashMap_default = Symbol('_is_CustomKeyHashMap_default');
>+_js_helper.CustomKeyHashMap$ = dart.generic((K, V) => {
>+  class CustomKeyHashMap extends _js_helper.CustomHashMap$(K, V) {
>+    containsKey(key) {
>+      if (!dart.test(this[_validKey](key))) return false;
>+      return super.containsKey(key);
>+    }
>+    _get(key) {
>+      if (!dart.test(this[_validKey](key))) return null;
>+      return super._get(key);
>+    }
>+    remove(key) {
>+      if (!dart.test(this[_validKey](key))) return null;
>+      return super.remove(key);
>+    }
>+  }
>+  (CustomKeyHashMap.new = function(equals, hashCode, validKey) {
>+    this[_validKey] = validKey;
>+    CustomKeyHashMap.__proto__.new.call(this, equals, hashCode);
>+  }).prototype = CustomKeyHashMap.prototype;
>+  dart.addTypeTests(CustomKeyHashMap);
>+  CustomKeyHashMap.prototype[_is_CustomKeyHashMap_default] = true;
>+  dart.setLibraryUri(CustomKeyHashMap, "dart:_js_helper");
>+  dart.setFieldSignature(CustomKeyHashMap, () => ({
>+    __proto__: dart.getFields(CustomKeyHashMap.__proto__),
>+    [_validKey]: dart.finalFieldType(ObjectTobool())
>+  }));
>+  dart.defineExtensionMethods(CustomKeyHashMap, ['containsKey', '_get', 'remove']);
>+  return CustomKeyHashMap;
>+});
>+_js_helper.CustomKeyHashMap = _js_helper.CustomKeyHashMap$();
>+dart.addTypeTests(_js_helper.CustomKeyHashMap, _is_CustomKeyHashMap_default);
>+_js_helper.convertDartClosureToJS = function(F, closure, arity) {
>+  return closure;
>+};
>+_js_helper.setNativeSubclassDispatchRecord = function(proto, interceptor) {
>+};
>+_js_helper.findDispatchTagForInterceptorClass = function(interceptorClassConstructor) {
>+};
>+_js_helper.makeLeafDispatchRecord = function(interceptor) {
>+};
>+const _nativeRegExp = dart.privateName(_js_helper, "_nativeRegExp");
>+_js_helper.regExpGetNative = function(regexp) {
>+  return regexp[_nativeRegExp];
>+};
>+const _nativeGlobalVersion = dart.privateName(_js_helper, "_nativeGlobalVersion");
>+_js_helper.regExpGetGlobalNative = function(regexp) {
>+  let nativeRegexp = regexp[_nativeGlobalVersion];
>+  nativeRegexp.lastIndex = 0;
>+  return nativeRegexp;
>+};
>+const _nativeAnchoredVersion = dart.privateName(_js_helper, "_nativeAnchoredVersion");
>+_js_helper.regExpCaptureCount = function(regexp) {
>+  let nativeAnchoredRegExp = regexp[_nativeAnchoredVersion];
>+  let match = nativeAnchoredRegExp.exec('');
>+  return match.length - 2;
>+};
>+const _nativeGlobalRegExp = dart.privateName(_js_helper, "_nativeGlobalRegExp");
>+const _nativeAnchoredRegExp = dart.privateName(_js_helper, "_nativeAnchoredRegExp");
>+const _isMultiLine = dart.privateName(_js_helper, "_isMultiLine");
>+const _isCaseSensitive = dart.privateName(_js_helper, "_isCaseSensitive");
>+const _isUnicode = dart.privateName(_js_helper, "_isUnicode");
>+const _isDotAll = dart.privateName(_js_helper, "_isDotAll");
>+const _execGlobal = dart.privateName(_js_helper, "_execGlobal");
>+const _execAnchored = dart.privateName(_js_helper, "_execAnchored");
>+_js_helper.JSSyntaxRegExp = class JSSyntaxRegExp extends core.Object {
>+  toString() {
>+    return "RegExp/" + dart.str(this.pattern) + "/" + this[_nativeRegExp].flags;
>+  }
>+  get [_nativeGlobalVersion]() {
>+    if (this[_nativeGlobalRegExp] != null) return this[_nativeGlobalRegExp];
>+    return this[_nativeGlobalRegExp] = _js_helper.JSSyntaxRegExp.makeNative(this.pattern, this[_isMultiLine], this[_isCaseSensitive], this[_isUnicode], this[_isDotAll], true);
>+  }
>+  get [_nativeAnchoredVersion]() {
>+    if (this[_nativeAnchoredRegExp] != null) return this[_nativeAnchoredRegExp];
>+    return this[_nativeAnchoredRegExp] = _js_helper.JSSyntaxRegExp.makeNative(dart.str(this.pattern) + "|()", this[_isMultiLine], this[_isCaseSensitive], this[_isUnicode], this[_isDotAll], true);
>+  }
>+  get [_isMultiLine]() {
>+    return this[_nativeRegExp].multiline;
>+  }
>+  get [_isCaseSensitive]() {
>+    return !this[_nativeRegExp].ignoreCase;
>+  }
>+  get [_isUnicode]() {
>+    return this[_nativeRegExp].unicode;
>+  }
>+  get [_isDotAll]() {
>+    return this[_nativeRegExp].dotAll;
>+  }
>+  static makeNative(source, multiLine, caseSensitive, unicode, dotAll, global) {
>+    if (source == null) dart.argumentError(source);
>+    let m = dart.test(multiLine) ? "m" : "";
>+    let i = dart.test(caseSensitive) ? "" : "i";
>+    let u = dart.test(unicode) ? "u" : "";
>+    let s = dart.test(dotAll) ? "s" : "";
>+    let g = dart.test(global) ? "g" : "";
>+    let regexp = (function() {
>+      try {
>+        return new RegExp(source, m + i + u + s + g);
>+      } catch (e) {
>+        return e;
>+      }
>+    })();
>+    if (regexp instanceof RegExp) return regexp;
>+    let errorMessage = String(regexp);
>+    dart.throw(new core.FormatException.new("Illegal RegExp pattern: " + source + ", " + errorMessage));
>+  }
>+  firstMatch(string) {
>+    if (string == null) dart.argumentError(string);
>+    let m = this[_nativeRegExp].exec(string);
>+    if (m == null) return null;
>+    return new _js_helper._MatchImplementation.new(this, JSArrayOfString().of(m));
>+  }
>+  hasMatch(string) {
>+    if (string == null) dart.argumentError(string);
>+    return this[_nativeRegExp].test(string);
>+  }
>+  stringMatch(string) {
>+    let match = this.firstMatch(string);
>+    if (match != null) return match.group(0);
>+    return null;
>+  }
>+  allMatches(string, start) {
>+    if (string == null) dart.argumentError(string);
>+    if (start === void 0) start = 0;
>+    if (start == null) dart.argumentError(start);
>+    if (start < 0 || start > string.length) {
>+      dart.throw(new core.RangeError.range(start, 0, string.length));
>+    }
>+    return new _js_helper._AllMatchesIterable.new(this, string, start);
>+  }
>+  [_execGlobal](string, start) {
>+    let regexp = this[_nativeGlobalVersion];
>+    regexp.lastIndex = start;
>+    let match = regexp.exec(string);
>+    if (match == null) return null;
>+    return new _js_helper._MatchImplementation.new(this, JSArrayOfString().of(match));
>+  }
>+  [_execAnchored](string, start) {
>+    let regexp = this[_nativeAnchoredVersion];
>+    regexp.lastIndex = start;
>+    let match = regexp.exec(string);
>+    if (match == null) return null;
>+    if (match[$_get](dart.notNull(match[$length]) - 1) != null) return null;
>+    match[$length] = dart.notNull(match[$length]) - 1;
>+    return new _js_helper._MatchImplementation.new(this, JSArrayOfString().of(match));
>+  }
>+  matchAsPrefix(string, start) {
>+    if (start === void 0) start = 0;
>+    if (dart.notNull(start) < 0 || dart.notNull(start) > string.length) {
>+      dart.throw(new core.RangeError.range(start, 0, string.length));
>+    }
>+    return this[_execAnchored](string, start);
>+  }
>+  get isMultiLine() {
>+    return this[_isMultiLine];
>+  }
>+  get isCaseSensitive() {
>+    return this[_isCaseSensitive];
>+  }
>+  get isUnicode() {
>+    return this[_isUnicode];
>+  }
>+  get isDotAll() {
>+    return this[_isDotAll];
>+  }
>+};
>+(_js_helper.JSSyntaxRegExp.new = function(source, opts) {
>+  let multiLine = opts && 'multiLine' in opts ? opts.multiLine : false;
>+  let caseSensitive = opts && 'caseSensitive' in opts ? opts.caseSensitive : true;
>+  let unicode = opts && 'unicode' in opts ? opts.unicode : false;
>+  let dotAll = opts && 'dotAll' in opts ? opts.dotAll : false;
>+  this[_nativeGlobalRegExp] = null;
>+  this[_nativeAnchoredRegExp] = null;
>+  this.pattern = source;
>+  this[_nativeRegExp] = _js_helper.JSSyntaxRegExp.makeNative(source, multiLine, caseSensitive, unicode, dotAll, false);
>+}).prototype = _js_helper.JSSyntaxRegExp.prototype;
>+dart.addTypeTests(_js_helper.JSSyntaxRegExp);
>+_js_helper.JSSyntaxRegExp[dart.implements] = () => [core.RegExp];
>+dart.setMethodSignature(_js_helper.JSSyntaxRegExp, () => ({
>+  __proto__: dart.getMethods(_js_helper.JSSyntaxRegExp.__proto__),
>+  firstMatch: dart.fnType(core.RegExpMatch, [core.String]),
>+  hasMatch: dart.fnType(core.bool, [core.String]),
>+  stringMatch: dart.fnType(core.String, [core.String]),
>+  allMatches: dart.fnType(core.Iterable$(core.RegExpMatch), [core.String], [core.int]),
>+  [$allMatches]: dart.fnType(core.Iterable$(core.RegExpMatch), [core.String], [core.int]),
>+  [_execGlobal]: dart.fnType(core.RegExpMatch, [core.String, core.int]),
>+  [_execAnchored]: dart.fnType(core.RegExpMatch, [core.String, core.int]),
>+  matchAsPrefix: dart.fnType(core.RegExpMatch, [core.String], [core.int]),
>+  [$matchAsPrefix]: dart.fnType(core.RegExpMatch, [core.String], [core.int])
>+}));
>+dart.setGetterSignature(_js_helper.JSSyntaxRegExp, () => ({
>+  __proto__: dart.getGetters(_js_helper.JSSyntaxRegExp.__proto__),
>+  [_nativeGlobalVersion]: dart.dynamic,
>+  [_nativeAnchoredVersion]: dart.dynamic,
>+  [_isMultiLine]: core.bool,
>+  [_isCaseSensitive]: core.bool,
>+  [_isUnicode]: core.bool,
>+  [_isDotAll]: core.bool,
>+  isMultiLine: core.bool,
>+  isCaseSensitive: core.bool,
>+  isUnicode: core.bool,
>+  isDotAll: core.bool
>+}));
>+dart.setLibraryUri(_js_helper.JSSyntaxRegExp, "dart:_js_helper");
>+dart.setFieldSignature(_js_helper.JSSyntaxRegExp, () => ({
>+  __proto__: dart.getFields(_js_helper.JSSyntaxRegExp.__proto__),
>+  pattern: dart.finalFieldType(core.String),
>+  [_nativeRegExp]: dart.finalFieldType(dart.dynamic),
>+  [_nativeGlobalRegExp]: dart.fieldType(dart.dynamic),
>+  [_nativeAnchoredRegExp]: dart.fieldType(dart.dynamic)
>+}));
>+dart.defineExtensionMethods(_js_helper.JSSyntaxRegExp, ['toString', 'allMatches', 'matchAsPrefix']);
>+const _match = dart.privateName(_js_helper, "_match");
>+_js_helper._MatchImplementation = class _MatchImplementation extends core.Object {
>+  get input() {
>+    return this[_match].input;
>+  }
>+  get start() {
>+    return this[_match].index;
>+  }
>+  get end() {
>+    return dart.notNull(this.start) + this[_match][$_get](0).length;
>+  }
>+  group(index) {
>+    return this[_match][$_get](index);
>+  }
>+  _get(index) {
>+    return this.group(index);
>+  }
>+  get groupCount() {
>+    return dart.notNull(this[_match][$length]) - 1;
>+  }
>+  groups(groups) {
>+    let out = JSArrayOfString().of([]);
>+    for (let i of groups) {
>+      out[$add](this.group(i));
>+    }
>+    return out;
>+  }
>+  namedGroup(name) {
>+    let groups = this[_match].groups;
>+    if (groups !== null) {
>+      let result = groups[name];
>+      if (result != null || name in groups) {
>+        return result;
>+      }
>+    }
>+    dart.throw(new core.ArgumentError.value(name, "name", "Not a capture group name"));
>+  }
>+  get groupNames() {
>+    let groups = this[_match].groups;
>+    if (groups !== null) {
>+      let keys = JSArrayOfString().of(Object.keys(groups));
>+      return new (SubListIterableOfString()).new(keys, 0, null);
>+    }
>+    return IterableOfString().empty();
>+  }
>+};
>+(_js_helper._MatchImplementation.new = function(pattern, match) {
>+  this.pattern = pattern;
>+  this[_match] = match;
>+  if (!(typeof this[_match].input == 'string')) dart.assertFailed(null, "dart:_js_helper/regexp_helper.dart", 181, 12, "JS(\"var\", \"#.input\", _match) is String");
>+  if (!core.int.is(this[_match].index)) dart.assertFailed(null, "dart:_js_helper/regexp_helper.dart", 182, 12, "JS(\"var\", \"#.index\", _match) is int");
>+}).prototype = _js_helper._MatchImplementation.prototype;
>+dart.addTypeTests(_js_helper._MatchImplementation);
>+_js_helper._MatchImplementation[dart.implements] = () => [core.RegExpMatch];
>+dart.setMethodSignature(_js_helper._MatchImplementation, () => ({
>+  __proto__: dart.getMethods(_js_helper._MatchImplementation.__proto__),
>+  group: dart.fnType(core.String, [core.int]),
>+  _get: dart.fnType(core.String, [core.int]),
>+  groups: dart.fnType(core.List$(core.String), [core.List$(core.int)]),
>+  namedGroup: dart.fnType(core.String, [core.String])
>+}));
>+dart.setGetterSignature(_js_helper._MatchImplementation, () => ({
>+  __proto__: dart.getGetters(_js_helper._MatchImplementation.__proto__),
>+  input: core.String,
>+  start: core.int,
>+  end: core.int,
>+  groupCount: core.int,
>+  groupNames: core.Iterable$(core.String)
>+}));
>+dart.setLibraryUri(_js_helper._MatchImplementation, "dart:_js_helper");
>+dart.setFieldSignature(_js_helper._MatchImplementation, () => ({
>+  __proto__: dart.getFields(_js_helper._MatchImplementation.__proto__),
>+  pattern: dart.finalFieldType(core.Pattern),
>+  [_match]: dart.finalFieldType(ListOfString())
>+}));
>+const _re = dart.privateName(_js_helper, "_re");
>+const _string$ = dart.privateName(_js_helper, "_string");
>+const _start$ = dart.privateName(_js_helper, "_start");
>+core.RegExpMatch = class RegExpMatch extends core.Object {};
>+(core.RegExpMatch.new = function() {
>+}).prototype = core.RegExpMatch.prototype;
>+dart.addTypeTests(core.RegExpMatch);
>+core.RegExpMatch[dart.implements] = () => [core.Match];
>+dart.setLibraryUri(core.RegExpMatch, "dart:core");
>+_js_helper._AllMatchesIterable = class _AllMatchesIterable extends collection.IterableBase$(core.RegExpMatch) {
>+  get iterator() {
>+    return new _js_helper._AllMatchesIterator.new(this[_re], this[_string$], this[_start$]);
>+  }
>+};
>+(_js_helper._AllMatchesIterable.new = function(re, string, start) {
>+  this[_re] = re;
>+  this[_string$] = string;
>+  this[_start$] = start;
>+  _js_helper._AllMatchesIterable.__proto__.new.call(this);
>+}).prototype = _js_helper._AllMatchesIterable.prototype;
>+dart.addTypeTests(_js_helper._AllMatchesIterable);
>+dart.setGetterSignature(_js_helper._AllMatchesIterable, () => ({
>+  __proto__: dart.getGetters(_js_helper._AllMatchesIterable.__proto__),
>+  iterator: core.Iterator$(core.RegExpMatch),
>+  [$iterator]: core.Iterator$(core.RegExpMatch)
>+}));
>+dart.setLibraryUri(_js_helper._AllMatchesIterable, "dart:_js_helper");
>+dart.setFieldSignature(_js_helper._AllMatchesIterable, () => ({
>+  __proto__: dart.getFields(_js_helper._AllMatchesIterable.__proto__),
>+  [_re]: dart.finalFieldType(_js_helper.JSSyntaxRegExp),
>+  [_string$]: dart.finalFieldType(core.String),
>+  [_start$]: dart.finalFieldType(core.int)
>+}));
>+dart.defineExtensionAccessors(_js_helper._AllMatchesIterable, ['iterator']);
>+const _regExp = dart.privateName(_js_helper, "_regExp");
>+const _nextIndex = dart.privateName(_js_helper, "_nextIndex");
>+_js_helper._AllMatchesIterator = class _AllMatchesIterator extends core.Object {
>+  get current() {
>+    return this[_current$0];
>+  }
>+  static _isLeadSurrogate(c) {
>+    return dart.notNull(c) >= 55296 && dart.notNull(c) <= 56319;
>+  }
>+  static _isTrailSurrogate(c) {
>+    return dart.notNull(c) >= 56320 && dart.notNull(c) <= 57343;
>+  }
>+  moveNext() {
>+    if (this[_string$] == null) return false;
>+    if (dart.notNull(this[_nextIndex]) <= this[_string$].length) {
>+      let match = this[_regExp][_execGlobal](this[_string$], this[_nextIndex]);
>+      if (match != null) {
>+        this[_current$0] = match;
>+        let nextIndex = match.end;
>+        if (match.start == nextIndex) {
>+          if (dart.test(this[_regExp].isUnicode) && dart.notNull(this[_nextIndex]) + 1 < this[_string$].length && dart.test(_js_helper._AllMatchesIterator._isLeadSurrogate(this[_string$][$codeUnitAt](this[_nextIndex]))) && dart.test(_js_helper._AllMatchesIterator._isTrailSurrogate(this[_string$][$codeUnitAt](dart.notNull(this[_nextIndex]) + 1)))) {
>+            nextIndex = dart.notNull(nextIndex) + 1;
>+          }
>+          nextIndex = dart.notNull(nextIndex) + 1;
>+        }
>+        this[_nextIndex] = nextIndex;
>+        return true;
>+      }
>+    }
>+    this[_current$0] = null;
>+    this[_string$] = null;
>+    return false;
>+  }
>+};
>+(_js_helper._AllMatchesIterator.new = function(regExp, string, nextIndex) {
>+  this[_current$0] = null;
>+  this[_regExp] = regExp;
>+  this[_string$] = string;
>+  this[_nextIndex] = nextIndex;
>+}).prototype = _js_helper._AllMatchesIterator.prototype;
>+dart.addTypeTests(_js_helper._AllMatchesIterator);
>+_js_helper._AllMatchesIterator[dart.implements] = () => [IteratorOfRegExpMatch()];
>+dart.setMethodSignature(_js_helper._AllMatchesIterator, () => ({
>+  __proto__: dart.getMethods(_js_helper._AllMatchesIterator.__proto__),
>+  moveNext: dart.fnType(core.bool, [])
>+}));
>+dart.setGetterSignature(_js_helper._AllMatchesIterator, () => ({
>+  __proto__: dart.getGetters(_js_helper._AllMatchesIterator.__proto__),
>+  current: core.RegExpMatch
>+}));
>+dart.setLibraryUri(_js_helper._AllMatchesIterator, "dart:_js_helper");
>+dart.setFieldSignature(_js_helper._AllMatchesIterator, () => ({
>+  __proto__: dart.getFields(_js_helper._AllMatchesIterator.__proto__),
>+  [_regExp]: dart.finalFieldType(_js_helper.JSSyntaxRegExp),
>+  [_string$]: dart.fieldType(core.String),
>+  [_nextIndex]: dart.fieldType(core.int),
>+  [_current$0]: dart.fieldType(core.RegExpMatch)
>+}));
>+_js_helper.firstMatchAfter = function(regExp, string, start) {
>+  return regExp[_execGlobal](string, start);
>+};
>+_js_helper.stringIndexOfStringUnchecked = function(receiver, other, startIndex) {
>+  return receiver.indexOf(other, startIndex);
>+};
>+_js_helper.substring1Unchecked = function(receiver, startIndex) {
>+  return receiver.substring(startIndex);
>+};
>+_js_helper.substring2Unchecked = function(receiver, startIndex, endIndex) {
>+  return receiver.substring(startIndex, endIndex);
>+};
>+_js_helper.stringContainsStringUnchecked = function(receiver, other, startIndex) {
>+  return _js_helper.stringIndexOfStringUnchecked(receiver, other, startIndex) >= 0;
>+};
>+_js_helper.StringMatch = class StringMatch extends core.Object {
>+  get end() {
>+    return dart.notNull(this.start) + this.pattern.length;
>+  }
>+  _get(g) {
>+    return this.group(g);
>+  }
>+  get groupCount() {
>+    return 0;
>+  }
>+  group(group_) {
>+    if (group_ !== 0) {
>+      dart.throw(new core.RangeError.value(group_));
>+    }
>+    return this.pattern;
>+  }
>+  groups(groups_) {
>+    let result = JSArrayOfString().of([]);
>+    for (let g of groups_) {
>+      result[$add](this.group(g));
>+    }
>+    return result;
>+  }
>+};
>+(_js_helper.StringMatch.new = function(start, input, pattern) {
>+  this.start = start;
>+  this.input = input;
>+  this.pattern = pattern;
>+}).prototype = _js_helper.StringMatch.prototype;
>+dart.addTypeTests(_js_helper.StringMatch);
>+_js_helper.StringMatch[dart.implements] = () => [core.Match];
>+dart.setMethodSignature(_js_helper.StringMatch, () => ({
>+  __proto__: dart.getMethods(_js_helper.StringMatch.__proto__),
>+  _get: dart.fnType(core.String, [core.int]),
>+  group: dart.fnType(core.String, [core.int]),
>+  groups: dart.fnType(core.List$(core.String), [core.List$(core.int)])
>+}));
>+dart.setGetterSignature(_js_helper.StringMatch, () => ({
>+  __proto__: dart.getGetters(_js_helper.StringMatch.__proto__),
>+  end: core.int,
>+  groupCount: core.int
>+}));
>+dart.setLibraryUri(_js_helper.StringMatch, "dart:_js_helper");
>+dart.setFieldSignature(_js_helper.StringMatch, () => ({
>+  __proto__: dart.getFields(_js_helper.StringMatch.__proto__),
>+  start: dart.finalFieldType(core.int),
>+  input: dart.finalFieldType(core.String),
>+  pattern: dart.finalFieldType(core.String)
>+}));
>+_js_helper.allMatchesInStringUnchecked = function(pattern, string, startIndex) {
>+  return new _js_helper._StringAllMatchesIterable.new(string, pattern, startIndex);
>+};
>+const _input = dart.privateName(_js_helper, "_input");
>+const _pattern = dart.privateName(_js_helper, "_pattern");
>+const _index$0 = dart.privateName(_js_helper, "_index");
>+core.Match = class Match extends core.Object {};
>+(core.Match.new = function() {
>+}).prototype = core.Match.prototype;
>+dart.addTypeTests(core.Match);
>+dart.setLibraryUri(core.Match, "dart:core");
>+_js_helper._StringAllMatchesIterable = class _StringAllMatchesIterable extends core.Iterable$(core.Match) {
>+  get iterator() {
>+    return new _js_helper._StringAllMatchesIterator.new(this[_input], this[_pattern], this[_index$0]);
>+  }
>+  get first() {
>+    let index = _js_helper.stringIndexOfStringUnchecked(this[_input], this[_pattern], this[_index$0]);
>+    if (index >= 0) {
>+      return new _js_helper.StringMatch.new(index, this[_input], this[_pattern]);
>+    }
>+    dart.throw(_internal.IterableElementError.noElement());
>+  }
>+};
>+(_js_helper._StringAllMatchesIterable.new = function(input, pattern, index) {
>+  this[_input] = input;
>+  this[_pattern] = pattern;
>+  this[_index$0] = index;
>+  _js_helper._StringAllMatchesIterable.__proto__.new.call(this);
>+}).prototype = _js_helper._StringAllMatchesIterable.prototype;
>+dart.addTypeTests(_js_helper._StringAllMatchesIterable);
>+dart.setGetterSignature(_js_helper._StringAllMatchesIterable, () => ({
>+  __proto__: dart.getGetters(_js_helper._StringAllMatchesIterable.__proto__),
>+  iterator: core.Iterator$(core.Match),
>+  [$iterator]: core.Iterator$(core.Match),
>+  first: core.Match,
>+  [$first]: core.Match
>+}));
>+dart.setLibraryUri(_js_helper._StringAllMatchesIterable, "dart:_js_helper");
>+dart.setFieldSignature(_js_helper._StringAllMatchesIterable, () => ({
>+  __proto__: dart.getFields(_js_helper._StringAllMatchesIterable.__proto__),
>+  [_input]: dart.finalFieldType(core.String),
>+  [_pattern]: dart.finalFieldType(core.String),
>+  [_index$0]: dart.finalFieldType(core.int)
>+}));
>+dart.defineExtensionAccessors(_js_helper._StringAllMatchesIterable, ['iterator', 'first']);
>+_js_helper._StringAllMatchesIterator = class _StringAllMatchesIterator extends core.Object {
>+  moveNext() {
>+    if (dart.notNull(this[_index$0]) + this[_pattern].length > this[_input].length) {
>+      this[_current$0] = null;
>+      return false;
>+    }
>+    let index = _js_helper.stringIndexOfStringUnchecked(this[_input], this[_pattern], this[_index$0]);
>+    if (index < 0) {
>+      this[_index$0] = this[_input].length + 1;
>+      this[_current$0] = null;
>+      return false;
>+    }
>+    let end = index + this[_pattern].length;
>+    this[_current$0] = new _js_helper.StringMatch.new(index, this[_input], this[_pattern]);
>+    if (end === this[_index$0]) end++;
>+    this[_index$0] = end;
>+    return true;
>+  }
>+  get current() {
>+    return this[_current$0];
>+  }
>+};
>+(_js_helper._StringAllMatchesIterator.new = function(input, pattern, index) {
>+  this[_current$0] = null;
>+  this[_input] = input;
>+  this[_pattern] = pattern;
>+  this[_index$0] = index;
>+}).prototype = _js_helper._StringAllMatchesIterator.prototype;
>+dart.addTypeTests(_js_helper._StringAllMatchesIterator);
>+_js_helper._StringAllMatchesIterator[dart.implements] = () => [IteratorOfMatch()];
>+dart.setMethodSignature(_js_helper._StringAllMatchesIterator, () => ({
>+  __proto__: dart.getMethods(_js_helper._StringAllMatchesIterator.__proto__),
>+  moveNext: dart.fnType(core.bool, [])
>+}));
>+dart.setGetterSignature(_js_helper._StringAllMatchesIterator, () => ({
>+  __proto__: dart.getGetters(_js_helper._StringAllMatchesIterator.__proto__),
>+  current: core.Match
>+}));
>+dart.setLibraryUri(_js_helper._StringAllMatchesIterator, "dart:_js_helper");
>+dart.setFieldSignature(_js_helper._StringAllMatchesIterator, () => ({
>+  __proto__: dart.getFields(_js_helper._StringAllMatchesIterator.__proto__),
>+  [_input]: dart.finalFieldType(core.String),
>+  [_pattern]: dart.finalFieldType(core.String),
>+  [_index$0]: dart.fieldType(core.int),
>+  [_current$0]: dart.fieldType(core.Match)
>+}));
>+_js_helper.stringContainsUnchecked = function(receiver, other, startIndex) {
>+  if (typeof other == 'string') {
>+    return _js_helper.stringContainsStringUnchecked(receiver, other, startIndex);
>+  } else if (_js_helper.JSSyntaxRegExp.is(other)) {
>+    return other.hasMatch(receiver[$substring](startIndex));
>+  } else {
>+    let substr = receiver[$substring](startIndex);
>+    return core.bool._check(dart.dload(dart.dsend(other, 'allMatches', [substr]), 'isNotEmpty'));
>+  }
>+};
>+_js_helper.stringReplaceJS = function(receiver, replacer, replacement) {
>+  replacement = replacement.replace(/\$/g, "$$$$");
>+  return receiver.replace(replacer, replacement);
>+};
>+_js_helper.stringReplaceFirstRE = function(receiver, regexp, replacement, startIndex) {
>+  let match = regexp[_execGlobal](receiver, startIndex);
>+  if (match == null) return receiver;
>+  let start = match.start;
>+  let end = match.end;
>+  return _js_helper.stringReplaceRangeUnchecked(receiver, start, end, replacement);
>+};
>+_js_helper.quoteStringForRegExp = function(string) {
>+  return string.replace(/[[\]{}()*+?.\\^$|]/g, "\\$&");
>+};
>+_js_helper.stringReplaceAllUnchecked = function(receiver, pattern, replacement) {
>+  if (pattern == null) dart.argumentError(pattern);
>+  if (replacement == null) dart.argumentError(replacement);
>+  if (typeof pattern == 'string') {
>+    if (pattern === "") {
>+      if (receiver === "") {
>+        return replacement;
>+      } else {
>+        let result = new core.StringBuffer.new();
>+        let length = receiver.length;
>+        result.write(replacement);
>+        for (let i = 0; i < length; i++) {
>+          result.write(receiver[$_get](i));
>+          result.write(replacement);
>+        }
>+        return result.toString();
>+      }
>+    } else {
>+      return receiver.split(pattern).join(replacement);
>+    }
>+  } else if (_js_helper.JSSyntaxRegExp.is(pattern)) {
>+    let re = _js_helper.regExpGetGlobalNative(pattern);
>+    return _js_helper.stringReplaceJS(receiver, re, replacement);
>+  } else {
>+    dart.throw("String.replaceAll(Pattern) UNIMPLEMENTED");
>+  }
>+};
>+_js_helper._matchString = function(match) {
>+  return match._get(0);
>+};
>+_js_helper._stringIdentity = function(string) {
>+  return string;
>+};
>+_js_helper.stringReplaceAllFuncUnchecked = function(receiver, pattern, onMatch, onNonMatch) {
>+  if (pattern == null) dart.argumentError(pattern);
>+  if (onMatch == null) onMatch = dart.fn(_js_helper._matchString, MatchToString());
>+  if (onNonMatch == null) onNonMatch = dart.fn(_js_helper._stringIdentity, StringToString());
>+  if (typeof pattern == 'string') {
>+    return _js_helper.stringReplaceAllStringFuncUnchecked(receiver, pattern, onMatch, onNonMatch);
>+  }
>+  let buffer = new core.StringBuffer.new();
>+  let startIndex = 0;
>+  for (let match of pattern[$allMatches](receiver)) {
>+    buffer.write(onNonMatch(receiver[$substring](startIndex, match.start)));
>+    buffer.write(onMatch(match));
>+    startIndex = match.end;
>+  }
>+  buffer.write(onNonMatch(receiver[$substring](startIndex)));
>+  return buffer.toString();
>+};
>+_js_helper.stringReplaceAllEmptyFuncUnchecked = function(receiver, onMatch, onNonMatch) {
>+  let buffer = new core.StringBuffer.new();
>+  let length = receiver.length;
>+  let i = 0;
>+  buffer.write(onNonMatch(""));
>+  while (i < length) {
>+    buffer.write(onMatch(new _js_helper.StringMatch.new(i, receiver, "")));
>+    let code = receiver[$codeUnitAt](i);
>+    if ((code & ~1023) === 55296 && length > i + 1) {
>+      code = receiver[$codeUnitAt](i + 1);
>+      if ((code & ~1023) === 56320) {
>+        buffer.write(onNonMatch(receiver[$substring](i, i + 2)));
>+        i = i + 2;
>+        continue;
>+      }
>+    }
>+    buffer.write(onNonMatch(receiver[$_get](i)));
>+    i++;
>+  }
>+  buffer.write(onMatch(new _js_helper.StringMatch.new(i, receiver, "")));
>+  buffer.write(onNonMatch(""));
>+  return buffer.toString();
>+};
>+_js_helper.stringReplaceAllStringFuncUnchecked = function(receiver, pattern, onMatch, onNonMatch) {
>+  let patternLength = pattern.length;
>+  if (patternLength === 0) {
>+    return _js_helper.stringReplaceAllEmptyFuncUnchecked(receiver, onMatch, onNonMatch);
>+  }
>+  let length = receiver.length;
>+  let buffer = new core.StringBuffer.new();
>+  let startIndex = 0;
>+  while (startIndex < length) {
>+    let position = _js_helper.stringIndexOfStringUnchecked(receiver, pattern, startIndex);
>+    if (position === -1) {
>+      break;
>+    }
>+    buffer.write(onNonMatch(receiver[$substring](startIndex, position)));
>+    buffer.write(onMatch(new _js_helper.StringMatch.new(position, receiver, pattern)));
>+    startIndex = position + patternLength;
>+  }
>+  buffer.write(onNonMatch(receiver[$substring](startIndex)));
>+  return buffer.toString();
>+};
>+_js_helper.stringReplaceFirstUnchecked = function(receiver, pattern, replacement, startIndex) {
>+  if (pattern == null) dart.argumentError(pattern);
>+  if (typeof pattern == 'string') {
>+    let index = _js_helper.stringIndexOfStringUnchecked(receiver, pattern, startIndex);
>+    if (index < 0) return receiver;
>+    let end = index + pattern.length;
>+    return _js_helper.stringReplaceRangeUnchecked(receiver, index, end, replacement);
>+  }
>+  if (_js_helper.JSSyntaxRegExp.is(pattern)) {
>+    return startIndex === 0 ? _js_helper.stringReplaceJS(receiver, _js_helper.regExpGetNative(pattern), replacement) : _js_helper.stringReplaceFirstRE(receiver, pattern, replacement, startIndex);
>+  }
>+  let matches = pattern[$allMatches](receiver, startIndex)[$iterator];
>+  if (!dart.test(matches.moveNext())) return receiver;
>+  let match = matches.current;
>+  return receiver[$replaceRange](match.start, match.end, replacement);
>+};
>+_js_helper.stringReplaceFirstMappedUnchecked = function(receiver, pattern, replace, startIndex) {
>+  let matches = pattern[$allMatches](receiver, startIndex)[$iterator];
>+  if (!dart.test(matches.moveNext())) return receiver;
>+  let match = matches.current;
>+  let replacement = dart.str(replace(match));
>+  return receiver[$replaceRange](match.start, match.end, replacement);
>+};
>+_js_helper.stringJoinUnchecked = function(array, separator) {
>+  return array.join(separator);
>+};
>+_js_helper.stringReplaceRangeUnchecked = function(receiver, start, end, replacement) {
>+  let prefix = receiver.substring(0, start);
>+  let suffix = receiver.substring(end);
>+  return prefix + dart.str(replacement) + suffix;
>+};
>+_js_helper.getRuntimeType = function(object) {
>+  return dart.getReifiedType(object);
>+};
>+_js_helper.getIndex = function(array, index) {
>+  if (!dart.test(_js_helper.isJsArray(array))) dart.assertFailed(null, "dart:_js_helper/js_rti.dart", 14, 10, "isJsArray(array)");
>+  return array[index];
>+};
>+_js_helper.getLength = function(array) {
>+  if (!dart.test(_js_helper.isJsArray(array))) dart.assertFailed(null, "dart:_js_helper/js_rti.dart", 20, 10, "isJsArray(array)");
>+  return array.length;
>+};
>+_js_helper.isJsArray = function(value) {
>+  return _interceptors.JSArray.is(value);
>+};
>+_js_mirrors.getName = function(symbol) {
>+  if (_js_helper.PrivateSymbol.is(symbol)) {
>+    return _js_helper.PrivateSymbol.getName(symbol);
>+  } else {
>+    return _internal.Symbol.getName(_internal.Symbol.as(symbol));
>+  }
>+};
>+_js_mirrors.getSymbol = function(name, library) {
>+  return dart.throw(new core.UnimplementedError.new("MirrorSystem.getSymbol unimplemented"));
>+};
>+dart.defineLazy(_js_mirrors, {
>+  /*_js_mirrors.currentJsMirrorSystem*/get currentJsMirrorSystem() {
>+    return new _js_mirrors.JsMirrorSystem.new();
>+  },
>+  /*_js_mirrors._typeMirror*/get _typeMirror() {
>+    return Symbol("_typeMirror");
>+  }
>+});
>+_js_mirrors.reflect = function(reflectee) {
>+  if (core.Function.is(reflectee)) {
>+    return new _js_mirrors.JsClosureMirror.__(reflectee);
>+  } else {
>+    return new _js_mirrors.JsInstanceMirror.__(reflectee);
>+  }
>+};
>+_js_mirrors.reflectType = function(key) {
>+  let unwrapped = dart.unwrapType(key);
>+  let property = Object.getOwnPropertyDescriptor(unwrapped, _js_mirrors._typeMirror);
>+  if (property != null) {
>+    return property.value;
>+  }
>+  let mirror = new _js_mirrors.JsClassMirror.__(key);
>+  unwrapped[_js_mirrors._typeMirror] = mirror;
>+  return mirror;
>+};
>+_js_mirrors._getESSymbol = function(symbol) {
>+  return _js_helper.PrivateSymbol.getNativeSymbol(symbol);
>+};
>+_js_mirrors._getMember = function(symbol) {
>+  let privateSymbol = _js_mirrors._getESSymbol(symbol);
>+  if (privateSymbol != null) {
>+    return privateSymbol;
>+  }
>+  let name = _js_mirrors.getName(symbol);
>+  switch (name) {
>+    case "[]":
>+    {
>+      name = "_get";
>+      break;
>+    }
>+    case "[]=":
>+    {
>+      name = "_set";
>+      break;
>+    }
>+    case "unary-":
>+    {
>+      name = "_negate";
>+      break;
>+    }
>+    case "constructor":
>+    case "prototype":
>+    {
>+      name = "_" + dart.str(name);
>+      break;
>+    }
>+  }
>+  return name;
>+};
>+_js_mirrors._getNameForESSymbol = function(member) {
>+  if (!(typeof member == "symbol")) dart.assertFailed(null, "dart:_js_mirrors", 82, 10, "JS('bool', 'typeof # == \"symbol\"', member)");
>+  let str = dart.toString(member);
>+  if (!(str[$startsWith]("Symbol(") && str[$endsWith](")"))) dart.assertFailed(null, "dart:_js_mirrors", 84, 10, "str.startsWith('Symbol(') && str.endsWith(')')");
>+  return str[$substring](7, str.length - 1);
>+};
>+_js_mirrors._getSymbolForESSymbol = function(member) {
>+  let name = _js_mirrors._getNameForESSymbol(member);
>+  return new _js_helper.PrivateSymbol.new(name, member);
>+};
>+_js_mirrors._getSymbolForMember = function(member) {
>+  if (typeof member == 'string') {
>+    return core.Symbol.new(member);
>+  } else {
>+    let name = _js_mirrors._getNameForESSymbol(member);
>+    return new _js_helper.PrivateSymbol.new(name, member);
>+  }
>+};
>+_js_mirrors._toDartMap = function(data) {
>+  if (data == null) return new (LinkedMapOfSymbol$dynamic()).new();
>+  let map = new (LinkedMapOfSymbol$dynamic()).new();
>+  let publicMembers = Object.getOwnPropertyNames(data);
>+  for (let member of core.Iterable._check(publicMembers)) {
>+    let symbol = core.Symbol.new(core.String._check(member));
>+    map[$_set](symbol, data[member]);
>+  }
>+  let privateMembers = Object.getOwnPropertySymbols(data);
>+  for (let member of core.Iterable._check(privateMembers)) {
>+    let symbol = _js_mirrors._getSymbolForESSymbol(member);
>+    map[$_set](symbol, data[member]);
>+  }
>+  return map;
>+};
>+_js_mirrors._runtimeType = function(obj) {
>+  return dart.wrapType(dart.getReifiedType(obj));
>+};
>+_js_mirrors._unimplemented = function(t, i) {
>+  dart.throw(new core.UnimplementedError.new(dart.str(t) + "." + dart.str(_js_mirrors.getName(i.memberName)) + " unimplemented"));
>+};
>+_js_mirrors._toJsMap = function(map) {
>+  if (map == null) return null;
>+  let obj = {};
>+  map[$forEach](dart.fn((key, value) => {
>+    obj[_js_mirrors.getName(key)] = value;
>+  }, SymbolAnddynamicToNull()));
>+  return obj;
>+};
>+let const$5;
>+_js_mirrors.JsMirrorSystem = class JsMirrorSystem extends core.Object {
>+  get libraries() {
>+    return const$5 || (const$5 = dart.constMap(core.Uri, mirrors.LibraryMirror, []));
>+  }
>+  noSuchMethod(i) {
>+    _js_mirrors._unimplemented(this.runtimeType, i);
>+  }
>+  findLibrary(libraryName) {
>+    return mirrors.LibraryMirror._check(this.noSuchMethod(new dart.InvocationImpl.new('findLibrary', [libraryName], {isMethod: true})));
>+  }
>+  get isolate() {
>+    return mirrors.IsolateMirror._check(this.noSuchMethod(new dart.InvocationImpl.new('isolate', [], {isGetter: true})));
>+  }
>+  get dynamicType() {
>+    return mirrors.TypeMirror._check(this.noSuchMethod(new dart.InvocationImpl.new('dynamicType', [], {isGetter: true})));
>+  }
>+  get voidType() {
>+    return mirrors.TypeMirror._check(this.noSuchMethod(new dart.InvocationImpl.new('voidType', [], {isGetter: true})));
>+  }
>+};
>+(_js_mirrors.JsMirrorSystem.new = function() {
>+}).prototype = _js_mirrors.JsMirrorSystem.prototype;
>+dart.addTypeTests(_js_mirrors.JsMirrorSystem);
>+_js_mirrors.JsMirrorSystem[dart.implements] = () => [mirrors.MirrorSystem];
>+dart.setMethodSignature(_js_mirrors.JsMirrorSystem, () => ({
>+  __proto__: dart.getMethods(_js_mirrors.JsMirrorSystem.__proto__),
>+  findLibrary: dart.fnType(mirrors.LibraryMirror, [core.Symbol])
>+}));
>+dart.setGetterSignature(_js_mirrors.JsMirrorSystem, () => ({
>+  __proto__: dart.getGetters(_js_mirrors.JsMirrorSystem.__proto__),
>+  libraries: core.Map$(core.Uri, mirrors.LibraryMirror),
>+  isolate: mirrors.IsolateMirror,
>+  dynamicType: mirrors.TypeMirror,
>+  voidType: mirrors.TypeMirror
>+}));
>+dart.setLibraryUri(_js_mirrors.JsMirrorSystem, "dart:_js_mirrors");
>+dart.defineExtensionMethods(_js_mirrors.JsMirrorSystem, ['noSuchMethod']);
>+_js_mirrors.JsMirror = class JsMirror extends core.Object {
>+  noSuchMethod(i) {
>+    _js_mirrors._unimplemented(this.runtimeType, i);
>+  }
>+};
>+(_js_mirrors.JsMirror.new = function() {
>+}).prototype = _js_mirrors.JsMirror.prototype;
>+dart.addTypeTests(_js_mirrors.JsMirror);
>+_js_mirrors.JsMirror[dart.implements] = () => [mirrors.Mirror];
>+dart.setLibraryUri(_js_mirrors.JsMirror, "dart:_js_mirrors");
>+dart.defineExtensionMethods(_js_mirrors.JsMirror, ['noSuchMethod']);
>+_js_mirrors.JsCombinatorMirror = class JsCombinatorMirror extends _js_mirrors.JsMirror {
>+  get identifiers() {
>+    return ListOfSymbol()._check(this.noSuchMethod(new dart.InvocationImpl.new('identifiers', [], {isGetter: true})));
>+  }
>+  get isShow() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isShow', [], {isGetter: true})));
>+  }
>+  get isHide() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isHide', [], {isGetter: true})));
>+  }
>+};
>+(_js_mirrors.JsCombinatorMirror.new = function() {
>+}).prototype = _js_mirrors.JsCombinatorMirror.prototype;
>+dart.addTypeTests(_js_mirrors.JsCombinatorMirror);
>+_js_mirrors.JsCombinatorMirror[dart.implements] = () => [mirrors.CombinatorMirror];
>+dart.setGetterSignature(_js_mirrors.JsCombinatorMirror, () => ({
>+  __proto__: dart.getGetters(_js_mirrors.JsCombinatorMirror.__proto__),
>+  identifiers: core.List$(core.Symbol),
>+  isShow: core.bool,
>+  isHide: core.bool
>+}));
>+dart.setLibraryUri(_js_mirrors.JsCombinatorMirror, "dart:_js_mirrors");
>+_js_mirrors.JsDeclarationMirror = class JsDeclarationMirror extends _js_mirrors.JsMirror {
>+  get simpleName() {
>+    return core.Symbol._check(this.noSuchMethod(new dart.InvocationImpl.new('simpleName', [], {isGetter: true})));
>+  }
>+  get qualifiedName() {
>+    return core.Symbol._check(this.noSuchMethod(new dart.InvocationImpl.new('qualifiedName', [], {isGetter: true})));
>+  }
>+  get owner() {
>+    return mirrors.DeclarationMirror._check(this.noSuchMethod(new dart.InvocationImpl.new('owner', [], {isGetter: true})));
>+  }
>+  get isPrivate() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isPrivate', [], {isGetter: true})));
>+  }
>+  get isTopLevel() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isTopLevel', [], {isGetter: true})));
>+  }
>+  get location() {
>+    return mirrors.SourceLocation._check(this.noSuchMethod(new dart.InvocationImpl.new('location', [], {isGetter: true})));
>+  }
>+  get metadata() {
>+    return ListOfInstanceMirror()._check(this.noSuchMethod(new dart.InvocationImpl.new('metadata', [], {isGetter: true})));
>+  }
>+};
>+(_js_mirrors.JsDeclarationMirror.new = function() {
>+}).prototype = _js_mirrors.JsDeclarationMirror.prototype;
>+dart.addTypeTests(_js_mirrors.JsDeclarationMirror);
>+_js_mirrors.JsDeclarationMirror[dart.implements] = () => [mirrors.DeclarationMirror];
>+dart.setGetterSignature(_js_mirrors.JsDeclarationMirror, () => ({
>+  __proto__: dart.getGetters(_js_mirrors.JsDeclarationMirror.__proto__),
>+  simpleName: core.Symbol,
>+  qualifiedName: core.Symbol,
>+  owner: mirrors.DeclarationMirror,
>+  isPrivate: core.bool,
>+  isTopLevel: core.bool,
>+  location: mirrors.SourceLocation,
>+  metadata: core.List$(mirrors.InstanceMirror)
>+}));
>+dart.setLibraryUri(_js_mirrors.JsDeclarationMirror, "dart:_js_mirrors");
>+_js_mirrors.JsIsolateMirror = class JsIsolateMirror extends _js_mirrors.JsMirror {
>+  loadUri(uri) {
>+    return FutureOfLibraryMirror()._check(this.noSuchMethod(new dart.InvocationImpl.new('loadUri', [uri], {isMethod: true})));
>+  }
>+  get debugName() {
>+    return core.String._check(this.noSuchMethod(new dart.InvocationImpl.new('debugName', [], {isGetter: true})));
>+  }
>+  get isCurrent() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isCurrent', [], {isGetter: true})));
>+  }
>+  get rootLibrary() {
>+    return mirrors.LibraryMirror._check(this.noSuchMethod(new dart.InvocationImpl.new('rootLibrary', [], {isGetter: true})));
>+  }
>+};
>+(_js_mirrors.JsIsolateMirror.new = function() {
>+}).prototype = _js_mirrors.JsIsolateMirror.prototype;
>+dart.addTypeTests(_js_mirrors.JsIsolateMirror);
>+_js_mirrors.JsIsolateMirror[dart.implements] = () => [mirrors.IsolateMirror];
>+dart.setMethodSignature(_js_mirrors.JsIsolateMirror, () => ({
>+  __proto__: dart.getMethods(_js_mirrors.JsIsolateMirror.__proto__),
>+  loadUri: dart.fnType(async.Future$(mirrors.LibraryMirror), [core.Uri])
>+}));
>+dart.setGetterSignature(_js_mirrors.JsIsolateMirror, () => ({
>+  __proto__: dart.getGetters(_js_mirrors.JsIsolateMirror.__proto__),
>+  debugName: core.String,
>+  isCurrent: core.bool,
>+  rootLibrary: mirrors.LibraryMirror
>+}));
>+dart.setLibraryUri(_js_mirrors.JsIsolateMirror, "dart:_js_mirrors");
>+_js_mirrors.JsLibraryDependencyMirror = class JsLibraryDependencyMirror extends _js_mirrors.JsMirror {
>+  loadLibrary() {
>+    return FutureOfLibraryMirror()._check(this.noSuchMethod(new dart.InvocationImpl.new('loadLibrary', [], {isMethod: true})));
>+  }
>+  get isImport() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isImport', [], {isGetter: true})));
>+  }
>+  get isExport() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isExport', [], {isGetter: true})));
>+  }
>+  get isDeferred() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isDeferred', [], {isGetter: true})));
>+  }
>+  get sourceLibrary() {
>+    return mirrors.LibraryMirror._check(this.noSuchMethod(new dart.InvocationImpl.new('sourceLibrary', [], {isGetter: true})));
>+  }
>+  get targetLibrary() {
>+    return mirrors.LibraryMirror._check(this.noSuchMethod(new dart.InvocationImpl.new('targetLibrary', [], {isGetter: true})));
>+  }
>+  get prefix() {
>+    return core.Symbol._check(this.noSuchMethod(new dart.InvocationImpl.new('prefix', [], {isGetter: true})));
>+  }
>+  get combinators() {
>+    return ListOfCombinatorMirror()._check(this.noSuchMethod(new dart.InvocationImpl.new('combinators', [], {isGetter: true})));
>+  }
>+  get location() {
>+    return mirrors.SourceLocation._check(this.noSuchMethod(new dart.InvocationImpl.new('location', [], {isGetter: true})));
>+  }
>+  get metadata() {
>+    return ListOfInstanceMirror()._check(this.noSuchMethod(new dart.InvocationImpl.new('metadata', [], {isGetter: true})));
>+  }
>+};
>+(_js_mirrors.JsLibraryDependencyMirror.new = function() {
>+}).prototype = _js_mirrors.JsLibraryDependencyMirror.prototype;
>+dart.addTypeTests(_js_mirrors.JsLibraryDependencyMirror);
>+_js_mirrors.JsLibraryDependencyMirror[dart.implements] = () => [mirrors.LibraryDependencyMirror];
>+dart.setMethodSignature(_js_mirrors.JsLibraryDependencyMirror, () => ({
>+  __proto__: dart.getMethods(_js_mirrors.JsLibraryDependencyMirror.__proto__),
>+  loadLibrary: dart.fnType(async.Future$(mirrors.LibraryMirror), [])
>+}));
>+dart.setGetterSignature(_js_mirrors.JsLibraryDependencyMirror, () => ({
>+  __proto__: dart.getGetters(_js_mirrors.JsLibraryDependencyMirror.__proto__),
>+  isImport: core.bool,
>+  isExport: core.bool,
>+  isDeferred: core.bool,
>+  sourceLibrary: mirrors.LibraryMirror,
>+  targetLibrary: mirrors.LibraryMirror,
>+  prefix: core.Symbol,
>+  combinators: core.List$(mirrors.CombinatorMirror),
>+  location: mirrors.SourceLocation,
>+  metadata: core.List$(mirrors.InstanceMirror)
>+}));
>+dart.setLibraryUri(_js_mirrors.JsLibraryDependencyMirror, "dart:_js_mirrors");
>+_js_mirrors.JsObjectMirror = class JsObjectMirror extends _js_mirrors.JsMirror {
>+  invoke(memberName, positionalArguments, namedArguments) {
>+    if (namedArguments === void 0) namedArguments = null;
>+    return mirrors.InstanceMirror._check(this.noSuchMethod(new dart.InvocationImpl.new('invoke', [memberName, positionalArguments, namedArguments], {isMethod: true})));
>+  }
>+  getField(fieldName) {
>+    return mirrors.InstanceMirror._check(this.noSuchMethod(new dart.InvocationImpl.new('getField', [fieldName], {isMethod: true})));
>+  }
>+  setField(fieldName, value) {
>+    return mirrors.InstanceMirror._check(this.noSuchMethod(new dart.InvocationImpl.new('setField', [fieldName, value], {isMethod: true})));
>+  }
>+  delegate(invocation) {
>+    return this.noSuchMethod(new dart.InvocationImpl.new('delegate', [invocation], {isMethod: true}));
>+  }
>+};
>+(_js_mirrors.JsObjectMirror.new = function() {
>+}).prototype = _js_mirrors.JsObjectMirror.prototype;
>+dart.addTypeTests(_js_mirrors.JsObjectMirror);
>+_js_mirrors.JsObjectMirror[dart.implements] = () => [mirrors.ObjectMirror];
>+dart.setMethodSignature(_js_mirrors.JsObjectMirror, () => ({
>+  __proto__: dart.getMethods(_js_mirrors.JsObjectMirror.__proto__),
>+  invoke: dart.fnType(mirrors.InstanceMirror, [core.Symbol, core.List], [core.Map$(core.Symbol, dart.dynamic)]),
>+  getField: dart.fnType(mirrors.InstanceMirror, [core.Symbol]),
>+  setField: dart.fnType(mirrors.InstanceMirror, [core.Symbol, core.Object]),
>+  delegate: dart.fnType(dart.dynamic, [core.Invocation])
>+}));
>+dart.setLibraryUri(_js_mirrors.JsObjectMirror, "dart:_js_mirrors");
>+_js_mirrors.JsInstanceMirror = class JsInstanceMirror extends _js_mirrors.JsObjectMirror {
>+  get hasReflectee() {
>+    return true;
>+  }
>+  get type() {
>+    if (this.reflectee == null) return mirrors.reflectClass(dart.wrapType(core.Null));
>+    return mirrors.ClassMirror._check(_js_mirrors.reflectType(core.Type._check(_js_mirrors._runtimeType(this.reflectee))));
>+  }
>+  _equals(other) {
>+    return _js_mirrors.JsInstanceMirror.is(other) && core.identical(this.reflectee, other.reflectee);
>+  }
>+  get hashCode() {
>+    return (dart.notNull(core.identityHashCode(this.reflectee)) ^ 909522486) >>> 0;
>+  }
>+  getField(symbol) {
>+    let name = _js_mirrors._getMember(symbol);
>+    let field = dart.dloadMirror(this.reflectee, name);
>+    return _js_mirrors.reflect(field);
>+  }
>+  setField(symbol, value) {
>+    let name = _js_mirrors._getMember(symbol);
>+    dart.dputMirror(this.reflectee, name, value);
>+    return _js_mirrors.reflect(value);
>+  }
>+  invoke(symbol, args, namedArgs) {
>+    if (namedArgs === void 0) namedArgs = null;
>+    let name = _js_mirrors._getMember(symbol);
>+    let result = dart.callMethod(this.reflectee, name, null, args, _js_mirrors._toJsMap(namedArgs), name);
>+    return _js_mirrors.reflect(result);
>+  }
>+  toString() {
>+    return "InstanceMirror on '" + dart.str(this.reflectee) + "'";
>+  }
>+  delegate(invocation) {
>+    return this.noSuchMethod(new dart.InvocationImpl.new('delegate', [invocation], {isMethod: true}));
>+  }
>+};
>+(_js_mirrors.JsInstanceMirror.__ = function(reflectee) {
>+  this.reflectee = reflectee;
>+}).prototype = _js_mirrors.JsInstanceMirror.prototype;
>+dart.addTypeTests(_js_mirrors.JsInstanceMirror);
>+_js_mirrors.JsInstanceMirror[dart.implements] = () => [mirrors.InstanceMirror];
>+dart.setMethodSignature(_js_mirrors.JsInstanceMirror, () => ({
>+  __proto__: dart.getMethods(_js_mirrors.JsInstanceMirror.__proto__),
>+  _equals: dart.fnType(core.bool, [core.Object]),
>+  [$_equals]: dart.fnType(core.bool, [core.Object]),
>+  getField: dart.fnType(mirrors.InstanceMirror, [core.Symbol]),
>+  setField: dart.fnType(mirrors.InstanceMirror, [core.Symbol, core.Object]),
>+  invoke: dart.fnType(mirrors.InstanceMirror, [core.Symbol, core.List], [core.Map$(core.Symbol, dart.dynamic)]),
>+  delegate: dart.fnType(dart.dynamic, [core.Invocation])
>+}));
>+dart.setGetterSignature(_js_mirrors.JsInstanceMirror, () => ({
>+  __proto__: dart.getGetters(_js_mirrors.JsInstanceMirror.__proto__),
>+  hasReflectee: core.bool,
>+  type: mirrors.ClassMirror
>+}));
>+dart.setLibraryUri(_js_mirrors.JsInstanceMirror, "dart:_js_mirrors");
>+dart.setFieldSignature(_js_mirrors.JsInstanceMirror, () => ({
>+  __proto__: dart.getFields(_js_mirrors.JsInstanceMirror.__proto__),
>+  reflectee: dart.finalFieldType(dart.dynamic)
>+}));
>+dart.defineExtensionMethods(_js_mirrors.JsInstanceMirror, ['_equals', 'toString']);
>+dart.defineExtensionAccessors(_js_mirrors.JsInstanceMirror, ['hashCode']);
>+_js_mirrors.JsClosureMirror = class JsClosureMirror extends _js_mirrors.JsInstanceMirror {
>+  apply(args, namedArgs) {
>+    if (namedArgs === void 0) namedArgs = null;
>+    let result = dart.dcall(this.reflectee, args, _js_mirrors._toJsMap(namedArgs));
>+    return _js_mirrors.reflect(result);
>+  }
>+  delegate(invocation) {
>+    return this.noSuchMethod(new dart.InvocationImpl.new('delegate', [invocation], {isMethod: true}));
>+  }
>+  get function() {
>+    return mirrors.MethodMirror._check(this.noSuchMethod(new dart.InvocationImpl.new('function', [], {isGetter: true})));
>+  }
>+};
>+(_js_mirrors.JsClosureMirror.__ = function(reflectee) {
>+  _js_mirrors.JsClosureMirror.__proto__.__.call(this, reflectee);
>+}).prototype = _js_mirrors.JsClosureMirror.prototype;
>+dart.addTypeTests(_js_mirrors.JsClosureMirror);
>+_js_mirrors.JsClosureMirror[dart.implements] = () => [mirrors.ClosureMirror];
>+dart.setMethodSignature(_js_mirrors.JsClosureMirror, () => ({
>+  __proto__: dart.getMethods(_js_mirrors.JsClosureMirror.__proto__),
>+  apply: dart.fnType(mirrors.InstanceMirror, [core.List], [core.Map$(core.Symbol, dart.dynamic)]),
>+  delegate: dart.fnType(dart.dynamic, [core.Invocation])
>+}));
>+dart.setGetterSignature(_js_mirrors.JsClosureMirror, () => ({
>+  __proto__: dart.getGetters(_js_mirrors.JsClosureMirror.__proto__),
>+  function: mirrors.MethodMirror
>+}));
>+dart.setLibraryUri(_js_mirrors.JsClosureMirror, "dart:_js_mirrors");
>+const _cls = dart.privateName(_js_mirrors, "_cls");
>+const _raw = dart.privateName(_js_mirrors, "_raw");
>+const _originalDeclaration = dart.privateName(_js_mirrors, "_originalDeclaration");
>+const _mixin = dart.privateName(_js_mirrors, "_mixin");
>+const _typeArguments = dart.privateName(_js_mirrors, "_typeArguments");
>+const _metadata$ = dart.privateName(_js_mirrors, "_metadata");
>+const _declarations = dart.privateName(_js_mirrors, "_declarations");
>+let const$6;
>+let const$7;
>+_js_mirrors.JsClassMirror = class JsClassMirror extends _js_mirrors.JsMirror {
>+  get metadata() {
>+    if (this[_metadata$] == null) {
>+      let unwrapped = dart.unwrapType(this[_cls]);
>+      let fn = Object.hasOwnProperty.call(unwrapped, dart.metadata) ? unwrapped[dart.metadata] : null;
>+      this[_metadata$] = fn == null ? const$7 || (const$7 = dart.constList([], mirrors.InstanceMirror)) : ListOfInstanceMirror().unmodifiable(core.Iterable._check(dart.dsend(dart.dcall(fn, []), 'map', [dart.fn(i => _js_mirrors.reflect(i), dynamicToInstanceMirror())])));
>+    }
>+    return this[_metadata$];
>+  }
>+  get declarations() {
>+    if (this[_declarations] == null) {
>+      this[_declarations] = new (LinkedMapOfSymbol$DeclarationMirror()).new();
>+      let unwrapped = dart.unwrapType(this[_cls]);
>+      let constructors = _js_mirrors._toDartMap(dart.getConstructors(unwrapped));
>+      constructors[$forEach](dart.fn((symbol, ft) => {
>+        let name = _js_mirrors.getName(symbol);
>+        this[_declarations][$_set](symbol, new _js_mirrors.JsMethodMirror._constructor(this, symbol, ft));
>+      }, SymbolAnddynamicToNull()));
>+      if (dart.test(constructors[$isEmpty])) {
>+        let name = "new";
>+        let ft = dart.fnType(dart.unwrapType(this[_cls]), []);
>+        let symbol = core.Symbol.new(name);
>+        this[_declarations][$_set](symbol, new _js_mirrors.JsMethodMirror._constructor(this, symbol, ft));
>+      }
>+      let fields = _js_mirrors._toDartMap(dart.getFields(unwrapped));
>+      fields[$forEach](dart.fn((symbol, t) => {
>+        this[_declarations][$_set](symbol, new _js_mirrors.JsVariableMirror._fromField(symbol, t));
>+      }, SymbolAnddynamicToNull()));
>+      let methods = _js_mirrors._toDartMap(dart.getMethods(unwrapped));
>+      methods[$forEach](dart.fn((symbol, ft) => {
>+        let name = _js_mirrors.getName(symbol);
>+        this[_declarations][$_set](symbol, new _js_mirrors.JsMethodMirror._instanceMethod(this, symbol, ft));
>+      }, SymbolAnddynamicToNull()));
>+      function getterType(type) {
>+        if (type instanceof Array) {
>+          let array = type.slice();
>+          type = array[0];
>+          array[0] = dart.fnType(type, []);
>+          return array;
>+        } else {
>+          return dart.fnType(type, []);
>+        }
>+      }
>+      dart.fn(getterType, dynamicTodynamic());
>+      let getters = _js_mirrors._toDartMap(dart.getGetters(unwrapped));
>+      getters[$forEach](dart.fn((symbol, type) => {
>+        this[_declarations][$_set](symbol, new _js_mirrors.JsMethodMirror._instanceMethod(this, symbol, getterType(type)));
>+      }, SymbolAnddynamicToNull()));
>+      function setterType(type) {
>+        if (type instanceof Array) {
>+          let array = type.slice();
>+          type = array[0];
>+          array[0] = dart.fnType(dart.void, [type]);
>+          return array;
>+        } else {
>+          return dart.fnType(dart.void, [type]);
>+        }
>+      }
>+      dart.fn(setterType, dynamicTodynamic());
>+      let setters = _js_mirrors._toDartMap(dart.getSetters(unwrapped));
>+      setters[$forEach](dart.fn((symbol, type) => {
>+        let name = dart.notNull(_js_mirrors.getName(symbol)) + "=";
>+        symbol = new _js_helper.PrivateSymbol.new(name, _js_mirrors._getESSymbol(symbol));
>+        this[_declarations][$_set](symbol, new _js_mirrors.JsMethodMirror._instanceMethod(this, symbol, setterType(type)));
>+      }, SymbolAnddynamicToNull()));
>+      let staticFields = _js_mirrors._toDartMap(dart.getStaticFields(unwrapped));
>+      staticFields[$forEach](dart.fn((symbol, t) => {
>+        this[_declarations][$_set](symbol, new _js_mirrors.JsVariableMirror._fromField(symbol, t));
>+      }, SymbolAnddynamicToNull()));
>+      let statics = _js_mirrors._toDartMap(dart.getStaticMethods(unwrapped));
>+      statics[$forEach](dart.fn((symbol, ft) => {
>+        this[_declarations][$_set](symbol, new _js_mirrors.JsMethodMirror._staticMethod(this, symbol, ft));
>+      }, SymbolAnddynamicToNull()));
>+      let staticGetters = _js_mirrors._toDartMap(dart.getStaticGetters(unwrapped));
>+      staticGetters[$forEach](dart.fn((symbol, type) => {
>+        this[_declarations][$_set](symbol, new _js_mirrors.JsMethodMirror._staticMethod(this, symbol, getterType(type)));
>+      }, SymbolAnddynamicToNull()));
>+      let staticSetters = _js_mirrors._toDartMap(dart.getStaticSetters(unwrapped));
>+      staticSetters[$forEach](dart.fn((symbol, type) => {
>+        this[_declarations][$_set](symbol, new _js_mirrors.JsMethodMirror._staticMethod(this, symbol, setterType(type)));
>+      }, SymbolAnddynamicToNull()));
>+      this[_declarations] = MapOfSymbol$DeclarationMirror().unmodifiable(this[_declarations]);
>+    }
>+    return this[_declarations];
>+  }
>+  newInstance(constructorName, args, namedArgs) {
>+    if (namedArgs === void 0) namedArgs = null;
>+    let name = _js_mirrors.getName(constructorName);
>+    if (!(namedArgs == null || dart.test(namedArgs[$isEmpty]))) dart.assertFailed(null, "dart:_js_mirrors", 370, 12, "namedArgs == null || namedArgs.isEmpty");
>+    if (name === "") name = "new";
>+    let cls = dart.unwrapType(this[_cls]);
>+    let ctr = cls[name];
>+    let instance = cls.prototype == ctr.prototype ? new ctr(...args) : ctr(...args);
>+    return _js_mirrors.reflect(instance);
>+  }
>+  getField(symbol) {
>+    let name = _js_mirrors.getName(symbol);
>+    return _js_mirrors.reflect(dart.unwrapType(this[_cls])[name]);
>+  }
>+  setField(symbol, value) {
>+    let name = _js_mirrors.getName(symbol);
>+    dart.unwrapType(this[_cls])[name] = value;
>+    return _js_mirrors.reflect(value);
>+  }
>+  invoke(symbol, args, namedArgs) {
>+    if (namedArgs === void 0) namedArgs = null;
>+    let name = _js_mirrors.getName(symbol);
>+    if (namedArgs != null) {
>+      args = core.List.from(args);
>+      args[$add](_js_mirrors._toJsMap(namedArgs));
>+    }
>+    let result = dart.unwrapType(this[_cls])[name](...args);
>+    return _js_mirrors.reflect(result);
>+  }
>+  get superinterfaces() {
>+    let interfaceThunk = dart.unwrapType(this[_cls])[dart.implements];
>+    if (interfaceThunk == null) {
>+      return JSArrayOfClassMirror().of([]);
>+    } else {
>+      let interfaces = interfaceThunk();
>+      return ListOfClassMirror()._check(IterableOfTypeMirror()._check(interfaces[$map](mirrors.TypeMirror, dart.fn(t => _js_mirrors.reflectType(t), TypeToTypeMirror())))[$toList]());
>+    }
>+  }
>+  get hasReflectedType() {
>+    return true;
>+  }
>+  get reflectedType() {
>+    return this[_cls];
>+  }
>+  get isOriginalDeclaration() {
>+    return this[_raw] == null;
>+  }
>+  get typeArguments() {
>+    return this[_typeArguments];
>+  }
>+  get originalDeclaration() {
>+    if (this[_raw] == null) {
>+      return this;
>+    }
>+    if (this[_originalDeclaration] != null) {
>+      return this[_originalDeclaration];
>+    }
>+    this[_originalDeclaration] = new _js_mirrors.JsClassMirror.__(dart.wrapType(this[_raw]()), {instantiated: false});
>+    return this[_originalDeclaration];
>+  }
>+  get superclass() {
>+    if (dart.equals(this[_cls], dart.wrapType(core.Object))) {
>+      return null;
>+    } else {
>+      return mirrors.ClassMirror._check(_js_mirrors.reflectType(dart.wrapType(dart.unwrapType(this[_cls]).__proto__)));
>+    }
>+  }
>+  get mixin() {
>+    if (this[_mixin] != null) {
>+      return this[_mixin];
>+    }
>+    let mixin = dart.getMixin(dart.unwrapType(this[_cls]));
>+    if (mixin == null) {
>+      this[_mixin] = this;
>+      return this[_mixin];
>+    }
>+    this[_mixin] = mirrors.ClassMirror._check(_js_mirrors.reflectType(dart.wrapType(mixin)));
>+    return this[_mixin];
>+  }
>+  toString() {
>+    return "ClassMirror on '" + dart.str(this[_cls]) + "'";
>+  }
>+  get qualifiedName() {
>+    return core.Symbol._check(this.noSuchMethod(new dart.InvocationImpl.new('qualifiedName', [], {isGetter: true})));
>+  }
>+  get owner() {
>+    return mirrors.DeclarationMirror._check(this.noSuchMethod(new dart.InvocationImpl.new('owner', [], {isGetter: true})));
>+  }
>+  get isPrivate() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isPrivate', [], {isGetter: true})));
>+  }
>+  get isTopLevel() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isTopLevel', [], {isGetter: true})));
>+  }
>+  get location() {
>+    return mirrors.SourceLocation._check(this.noSuchMethod(new dart.InvocationImpl.new('location', [], {isGetter: true})));
>+  }
>+  isSubtypeOf(other) {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isSubtypeOf', [other], {isMethod: true})));
>+  }
>+  isAssignableTo(other) {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isAssignableTo', [other], {isMethod: true})));
>+  }
>+  get typeVariables() {
>+    return ListOfTypeVariableMirror()._check(this.noSuchMethod(new dart.InvocationImpl.new('typeVariables', [], {isGetter: true})));
>+  }
>+  delegate(invocation) {
>+    return this.noSuchMethod(new dart.InvocationImpl.new('delegate', [invocation], {isMethod: true}));
>+  }
>+  isSubclassOf(other) {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isSubclassOf', [other], {isMethod: true})));
>+  }
>+  get isAbstract() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isAbstract', [], {isGetter: true})));
>+  }
>+  get isEnum() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isEnum', [], {isGetter: true})));
>+  }
>+  get instanceMembers() {
>+    return MapOfSymbol$MethodMirror()._check(this.noSuchMethod(new dart.InvocationImpl.new('instanceMembers', [], {isGetter: true})));
>+  }
>+  get staticMembers() {
>+    return MapOfSymbol$MethodMirror()._check(this.noSuchMethod(new dart.InvocationImpl.new('staticMembers', [], {isGetter: true})));
>+  }
>+};
>+(_js_mirrors.JsClassMirror.__ = function(cls, opts) {
>+  let instantiated = opts && 'instantiated' in opts ? opts.instantiated : true;
>+  this[_originalDeclaration] = null;
>+  this[_mixin] = null;
>+  this[_typeArguments] = null;
>+  this[_metadata$] = null;
>+  this[_declarations] = null;
>+  this[_cls] = cls;
>+  this[_raw] = dart.test(instantiated) ? dart.getGenericClass(dart.unwrapType(cls)) : null;
>+  this.simpleName = core.Symbol.new(dart.unwrapType(cls).name);
>+  let typeArgs = dart.getGenericArgs(dart.unwrapType(this[_cls]));
>+  if (typeArgs == null) {
>+    this[_typeArguments] = const$6 || (const$6 = dart.constList([], mirrors.TypeMirror));
>+  } else {
>+    this[_typeArguments] = ListOfTypeMirror().unmodifiable(typeArgs[$map](dart.dynamic, dart.fn(t => _js_mirrors.reflectType(dart.wrapType(t)), dynamicToTypeMirror())));
>+  }
>+}).prototype = _js_mirrors.JsClassMirror.prototype;
>+dart.addTypeTests(_js_mirrors.JsClassMirror);
>+_js_mirrors.JsClassMirror[dart.implements] = () => [mirrors.ClassMirror];
>+dart.setMethodSignature(_js_mirrors.JsClassMirror, () => ({
>+  __proto__: dart.getMethods(_js_mirrors.JsClassMirror.__proto__),
>+  newInstance: dart.fnType(mirrors.InstanceMirror, [core.Symbol, core.List], [core.Map$(core.Symbol, dart.dynamic)]),
>+  getField: dart.fnType(mirrors.InstanceMirror, [core.Symbol]),
>+  setField: dart.fnType(mirrors.InstanceMirror, [core.Symbol, core.Object]),
>+  invoke: dart.fnType(mirrors.InstanceMirror, [core.Symbol, core.List], [core.Map$(core.Symbol, dart.dynamic)]),
>+  isSubtypeOf: dart.fnType(core.bool, [mirrors.TypeMirror]),
>+  isAssignableTo: dart.fnType(core.bool, [mirrors.TypeMirror]),
>+  delegate: dart.fnType(dart.dynamic, [core.Invocation]),
>+  isSubclassOf: dart.fnType(core.bool, [mirrors.ClassMirror])
>+}));
>+dart.setGetterSignature(_js_mirrors.JsClassMirror, () => ({
>+  __proto__: dart.getGetters(_js_mirrors.JsClassMirror.__proto__),
>+  metadata: core.List$(mirrors.InstanceMirror),
>+  declarations: core.Map$(core.Symbol, mirrors.DeclarationMirror),
>+  superinterfaces: core.List$(mirrors.ClassMirror),
>+  hasReflectedType: core.bool,
>+  reflectedType: core.Type,
>+  isOriginalDeclaration: core.bool,
>+  typeArguments: core.List$(mirrors.TypeMirror),
>+  originalDeclaration: mirrors.TypeMirror,
>+  superclass: mirrors.ClassMirror,
>+  mixin: mirrors.ClassMirror,
>+  qualifiedName: core.Symbol,
>+  owner: mirrors.DeclarationMirror,
>+  isPrivate: core.bool,
>+  isTopLevel: core.bool,
>+  location: mirrors.SourceLocation,
>+  typeVariables: core.List$(mirrors.TypeVariableMirror),
>+  isAbstract: core.bool,
>+  isEnum: core.bool,
>+  instanceMembers: core.Map$(core.Symbol, mirrors.MethodMirror),
>+  staticMembers: core.Map$(core.Symbol, mirrors.MethodMirror)
>+}));
>+dart.setLibraryUri(_js_mirrors.JsClassMirror, "dart:_js_mirrors");
>+dart.setFieldSignature(_js_mirrors.JsClassMirror, () => ({
>+  __proto__: dart.getFields(_js_mirrors.JsClassMirror.__proto__),
>+  [_cls]: dart.finalFieldType(core.Type),
>+  simpleName: dart.finalFieldType(core.Symbol),
>+  [_raw]: dart.finalFieldType(dart.dynamic),
>+  [_originalDeclaration]: dart.fieldType(mirrors.ClassMirror),
>+  [_mixin]: dart.fieldType(mirrors.ClassMirror),
>+  [_typeArguments]: dart.fieldType(ListOfTypeMirror()),
>+  [_metadata$]: dart.fieldType(ListOfInstanceMirror()),
>+  [_declarations]: dart.fieldType(MapOfSymbol$DeclarationMirror())
>+}));
>+dart.defineExtensionMethods(_js_mirrors.JsClassMirror, ['toString']);
>+const _symbol = dart.privateName(_js_mirrors, "_symbol");
>+const _name$0 = dart.privateName(_js_mirrors, "_name");
>+_js_mirrors.JsVariableMirror = class JsVariableMirror extends _js_mirrors.JsMirror {
>+  get simpleName() {
>+    return this[_symbol];
>+  }
>+  toString() {
>+    return "VariableMirror on '" + dart.str(this[_name$0]) + "'";
>+  }
>+  get qualifiedName() {
>+    return core.Symbol._check(this.noSuchMethod(new dart.InvocationImpl.new('qualifiedName', [], {isGetter: true})));
>+  }
>+  get owner() {
>+    return mirrors.DeclarationMirror._check(this.noSuchMethod(new dart.InvocationImpl.new('owner', [], {isGetter: true})));
>+  }
>+  get isPrivate() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isPrivate', [], {isGetter: true})));
>+  }
>+  get isTopLevel() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isTopLevel', [], {isGetter: true})));
>+  }
>+  get location() {
>+    return mirrors.SourceLocation._check(this.noSuchMethod(new dart.InvocationImpl.new('location', [], {isGetter: true})));
>+  }
>+  get isConst() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isConst', [], {isGetter: true})));
>+  }
>+};
>+(_js_mirrors.JsVariableMirror.__ = function(symbol, t, annotations, opts) {
>+  let isFinal = opts && 'isFinal' in opts ? opts.isFinal : false;
>+  this.isStatic = false;
>+  this.isFinal = isFinal;
>+  this[_symbol] = symbol;
>+  this[_name$0] = _js_mirrors.getName(symbol);
>+  this.type = _js_mirrors.reflectType(t);
>+  this.metadata = ListOfInstanceMirror().unmodifiable((() => {
>+    let t = annotations;
>+    let l = t == null ? null : t[$map](dart.dynamic, dart.fn(_js_mirrors.reflect, dynamicToInstanceMirror()));
>+    return l != null ? l : [];
>+  })());
>+}).prototype = _js_mirrors.JsVariableMirror.prototype;
>+(_js_mirrors.JsVariableMirror._fromField = function(symbol, fieldInfo) {
>+  _js_mirrors.JsVariableMirror.__.call(this, symbol, dart.wrapType(fieldInfo.type), fieldInfo.metadata, {isFinal: fieldInfo.isFinal});
>+}).prototype = _js_mirrors.JsVariableMirror.prototype;
>+dart.addTypeTests(_js_mirrors.JsVariableMirror);
>+_js_mirrors.JsVariableMirror[dart.implements] = () => [mirrors.VariableMirror];
>+dart.setGetterSignature(_js_mirrors.JsVariableMirror, () => ({
>+  __proto__: dart.getGetters(_js_mirrors.JsVariableMirror.__proto__),
>+  simpleName: core.Symbol,
>+  qualifiedName: core.Symbol,
>+  owner: mirrors.DeclarationMirror,
>+  isPrivate: core.bool,
>+  isTopLevel: core.bool,
>+  location: mirrors.SourceLocation,
>+  isConst: core.bool
>+}));
>+dart.setLibraryUri(_js_mirrors.JsVariableMirror, "dart:_js_mirrors");
>+dart.setFieldSignature(_js_mirrors.JsVariableMirror, () => ({
>+  __proto__: dart.getFields(_js_mirrors.JsVariableMirror.__proto__),
>+  [_symbol]: dart.finalFieldType(core.Symbol),
>+  [_name$0]: dart.finalFieldType(core.String),
>+  type: dart.finalFieldType(mirrors.TypeMirror),
>+  metadata: dart.finalFieldType(ListOfInstanceMirror()),
>+  isFinal: dart.finalFieldType(core.bool),
>+  isStatic: dart.finalFieldType(core.bool)
>+}));
>+dart.defineExtensionMethods(_js_mirrors.JsVariableMirror, ['toString']);
>+_js_mirrors.JsParameterMirror = class JsParameterMirror extends _js_mirrors.JsVariableMirror {
>+  toString() {
>+    return "ParameterMirror on '" + dart.str(this[_name$0]) + "'";
>+  }
>+  get qualifiedName() {
>+    return core.Symbol._check(this.noSuchMethod(new dart.InvocationImpl.new('qualifiedName', [], {isGetter: true})));
>+  }
>+  get owner() {
>+    return mirrors.DeclarationMirror._check(this.noSuchMethod(new dart.InvocationImpl.new('owner', [], {isGetter: true})));
>+  }
>+  get isPrivate() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isPrivate', [], {isGetter: true})));
>+  }
>+  get isTopLevel() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isTopLevel', [], {isGetter: true})));
>+  }
>+  get location() {
>+    return mirrors.SourceLocation._check(this.noSuchMethod(new dart.InvocationImpl.new('location', [], {isGetter: true})));
>+  }
>+  get isConst() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isConst', [], {isGetter: true})));
>+  }
>+  get isOptional() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isOptional', [], {isGetter: true})));
>+  }
>+  get isNamed() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isNamed', [], {isGetter: true})));
>+  }
>+  get hasDefaultValue() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('hasDefaultValue', [], {isGetter: true})));
>+  }
>+  get defaultValue() {
>+    return mirrors.InstanceMirror._check(this.noSuchMethod(new dart.InvocationImpl.new('defaultValue', [], {isGetter: true})));
>+  }
>+};
>+(_js_mirrors.JsParameterMirror.__ = function(member, t, annotations) {
>+  _js_mirrors.JsParameterMirror.__proto__.__.call(this, member, t, annotations);
>+}).prototype = _js_mirrors.JsParameterMirror.prototype;
>+dart.addTypeTests(_js_mirrors.JsParameterMirror);
>+_js_mirrors.JsParameterMirror[dart.implements] = () => [mirrors.ParameterMirror];
>+dart.setGetterSignature(_js_mirrors.JsParameterMirror, () => ({
>+  __proto__: dart.getGetters(_js_mirrors.JsParameterMirror.__proto__),
>+  qualifiedName: core.Symbol,
>+  owner: mirrors.DeclarationMirror,
>+  isPrivate: core.bool,
>+  isTopLevel: core.bool,
>+  location: mirrors.SourceLocation,
>+  isConst: core.bool,
>+  isOptional: core.bool,
>+  isNamed: core.bool,
>+  hasDefaultValue: core.bool,
>+  defaultValue: mirrors.InstanceMirror
>+}));
>+dart.setLibraryUri(_js_mirrors.JsParameterMirror, "dart:_js_mirrors");
>+dart.defineExtensionMethods(_js_mirrors.JsParameterMirror, ['toString']);
>+const _params = dart.privateName(_js_mirrors, "_params");
>+const _createParameterMirrorList = dart.privateName(_js_mirrors, "_createParameterMirrorList");
>+let const$8;
>+let const$9;
>+let const$10;
>+_js_mirrors.JsMethodMirror = class JsMethodMirror extends _js_mirrors.JsMirror {
>+  get isSetter() {
>+    return this[_name$0][$endsWith]("=");
>+  }
>+  get isPrivate() {
>+    return this[_name$0][$startsWith]("_");
>+  }
>+  get simpleName() {
>+    return this[_symbol];
>+  }
>+  get constructorName() {
>+    return dart.test(this.isConstructor) ? this[_symbol] : null;
>+  }
>+  get parameters() {
>+    return this[_params];
>+  }
>+  get metadata() {
>+    return this[_metadata$];
>+  }
>+  [_createParameterMirrorList](ftype) {
>+    if (ftype == null) {
>+      this[_params] = const$8 || (const$8 = dart.constList([], mirrors.ParameterMirror));
>+      this[_metadata$] = const$9 || (const$9 = dart.constList([], mirrors.InstanceMirror));
>+      return;
>+    }
>+    if (!core.Function.is(ftype) && core.List.is(ftype)) {
>+      this[_metadata$] = ListOfInstanceMirror().unmodifiable(core.Iterable._check(dart.dsend(dart.dsend(ftype, 'skip', [1]), 'map', [dart.fn(a => _js_mirrors.reflect(a), dynamicToInstanceMirror())])));
>+      ftype = dart.dindex(ftype, 0);
>+    } else {
>+      this[_metadata$] = const$10 || (const$10 = dart.constList([], mirrors.InstanceMirror));
>+    }
>+    ftype = dart.getFunctionTypeMirror(dart.AbstractFunctionType._check(ftype));
>+    let args = core.List._check(dart.dload(ftype, 'args'));
>+    let opts = core.List._check(dart.dload(ftype, 'optionals'));
>+    let params = ListOfParameterMirror().new(dart.notNull(args[$length]) + dart.notNull(opts[$length]));
>+    for (let i = 0; i < dart.notNull(args[$length]); ++i) {
>+      let type = args[$_get](i);
>+      let metadata = dart.dindex(dart.dload(ftype, 'metadata'), i);
>+      let param = new _js_mirrors.JsParameterMirror.__(core.Symbol.new(""), dart.wrapType(type), core.List._check(metadata));
>+      params[$_set](i, param);
>+    }
>+    for (let i = 0; i < dart.notNull(opts[$length]); ++i) {
>+      let type = opts[$_get](i);
>+      let metadata = dart.dindex(dart.dload(ftype, 'metadata'), dart.notNull(args[$length]) + i);
>+      let param = new _js_mirrors.JsParameterMirror.__(core.Symbol.new(""), dart.wrapType(type), core.List._check(metadata));
>+      params[$_set](i + dart.notNull(args[$length]), param);
>+    }
>+    this[_params] = ListOfParameterMirror().unmodifiable(params);
>+  }
>+  toString() {
>+    return "MethodMirror on '" + dart.str(this[_name$0]) + "'";
>+  }
>+  get qualifiedName() {
>+    return core.Symbol._check(this.noSuchMethod(new dart.InvocationImpl.new('qualifiedName', [], {isGetter: true})));
>+  }
>+  get owner() {
>+    return mirrors.DeclarationMirror._check(this.noSuchMethod(new dart.InvocationImpl.new('owner', [], {isGetter: true})));
>+  }
>+  get isTopLevel() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isTopLevel', [], {isGetter: true})));
>+  }
>+  get location() {
>+    return mirrors.SourceLocation._check(this.noSuchMethod(new dart.InvocationImpl.new('location', [], {isGetter: true})));
>+  }
>+  get returnType() {
>+    return mirrors.TypeMirror._check(this.noSuchMethod(new dart.InvocationImpl.new('returnType', [], {isGetter: true})));
>+  }
>+  get source() {
>+    return core.String._check(this.noSuchMethod(new dart.InvocationImpl.new('source', [], {isGetter: true})));
>+  }
>+  get isAbstract() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isAbstract', [], {isGetter: true})));
>+  }
>+  get isSynthetic() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isSynthetic', [], {isGetter: true})));
>+  }
>+  get isRegularMethod() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isRegularMethod', [], {isGetter: true})));
>+  }
>+  get isOperator() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isOperator', [], {isGetter: true})));
>+  }
>+  get isGetter() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isGetter', [], {isGetter: true})));
>+  }
>+  get isConstConstructor() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isConstConstructor', [], {isGetter: true})));
>+  }
>+  get isGenerativeConstructor() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isGenerativeConstructor', [], {isGetter: true})));
>+  }
>+  get isRedirectingConstructor() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isRedirectingConstructor', [], {isGetter: true})));
>+  }
>+  get isFactoryConstructor() {
>+    return core.bool._check(this.noSuchMethod(new dart.InvocationImpl.new('isFactoryConstructor', [], {isGetter: true})));
>+  }
>+};
>+(_js_mirrors.JsMethodMirror._constructor = function(cls, symbol, ftype) {
>+  this[_params] = null;
>+  this[_metadata$] = null;
>+  this.isFinal = false;
>+  this[_symbol] = symbol;
>+  this[_name$0] = _js_mirrors.getName(symbol);
>+  this.isConstructor = true;
>+  this.isStatic = false;
>+  this[_createParameterMirrorList](ftype);
>+}).prototype = _js_mirrors.JsMethodMirror.prototype;
>+(_js_mirrors.JsMethodMirror._instanceMethod = function(cls, symbol, ftype) {
>+  this[_params] = null;
>+  this[_metadata$] = null;
>+  this.isFinal = false;
>+  this[_symbol] = symbol;
>+  this[_name$0] = _js_mirrors.getName(symbol);
>+  this.isConstructor = false;
>+  this.isStatic = false;
>+  this[_createParameterMirrorList](ftype);
>+}).prototype = _js_mirrors.JsMethodMirror.prototype;
>+(_js_mirrors.JsMethodMirror._staticMethod = function(cls, symbol, ftype) {
>+  this[_params] = null;
>+  this[_metadata$] = null;
>+  this.isFinal = false;
>+  this[_symbol] = symbol;
>+  this[_name$0] = _js_mirrors.getName(symbol);
>+  this.isConstructor = false;
>+  this.isStatic = true;
>+  this[_createParameterMirrorList](ftype);
>+}).prototype = _js_mirrors.JsMethodMirror.prototype;
>+dart.addTypeTests(_js_mirrors.JsMethodMirror);
>+_js_mirrors.JsMethodMirror[dart.implements] = () => [mirrors.MethodMirror];
>+dart.setMethodSignature(_js_mirrors.JsMethodMirror, () => ({
>+  __proto__: dart.getMethods(_js_mirrors.JsMethodMirror.__proto__),
>+  [_createParameterMirrorList]: dart.fnType(dart.void, [dart.dynamic])
>+}));
>+dart.setGetterSignature(_js_mirrors.JsMethodMirror, () => ({
>+  __proto__: dart.getGetters(_js_mirrors.JsMethodMirror.__proto__),
>+  isSetter: core.bool,
>+  isPrivate: core.bool,
>+  simpleName: core.Symbol,
>+  constructorName: core.Symbol,
>+  parameters: core.List$(mirrors.ParameterMirror),
>+  metadata: core.List$(mirrors.InstanceMirror),
>+  qualifiedName: core.Symbol,
>+  owner: mirrors.DeclarationMirror,
>+  isTopLevel: core.bool,
>+  location: mirrors.SourceLocation,
>+  returnType: mirrors.TypeMirror,
>+  source: core.String,
>+  isAbstract: core.bool,
>+  isSynthetic: core.bool,
>+  isRegularMethod: core.bool,
>+  isOperator: core.bool,
>+  isGetter: core.bool,
>+  isConstConstructor: core.bool,
>+  isGenerativeConstructor: core.bool,
>+  isRedirectingConstructor: core.bool,
>+  isFactoryConstructor: core.bool
>+}));
>+dart.setLibraryUri(_js_mirrors.JsMethodMirror, "dart:_js_mirrors");
>+dart.setFieldSignature(_js_mirrors.JsMethodMirror, () => ({
>+  __proto__: dart.getFields(_js_mirrors.JsMethodMirror.__proto__),
>+  [_symbol]: dart.finalFieldType(core.Symbol),
>+  [_name$0]: dart.finalFieldType(core.String),
>+  [_params]: dart.fieldType(ListOfParameterMirror()),
>+  [_metadata$]: dart.fieldType(ListOfInstanceMirror()),
>+  isConstructor: dart.finalFieldType(core.bool),
>+  isStatic: dart.finalFieldType(core.bool),
>+  isFinal: dart.finalFieldType(core.bool)
>+}));
>+dart.defineExtensionMethods(_js_mirrors.JsMethodMirror, ['toString']);
>+_js_primitives.printString = function(string) {
>+  if (typeof dartPrint == "function") {
>+    dartPrint(string);
>+    return;
>+  }
>+  if (typeof console == "object" && typeof console.log != "undefined") {
>+    console.log(string);
>+    return;
>+  }
>+  if (typeof window == "object") {
>+    return;
>+  }
>+  if (typeof print == "function") {
>+    print(string);
>+    return;
>+  }
>+  throw "Unable to print message: " + String(string);
>+};
>+_metadata.SupportedBrowser = class SupportedBrowser extends core.Object {};
>+(_metadata.SupportedBrowser.new = function(browserName, minimumVersion) {
>+  if (minimumVersion === void 0) minimumVersion = null;
>+  this.browserName = browserName;
>+  this.minimumVersion = minimumVersion;
>+}).prototype = _metadata.SupportedBrowser.prototype;
>+dart.addTypeTests(_metadata.SupportedBrowser);
>+dart.setLibraryUri(_metadata.SupportedBrowser, "dart:_metadata");
>+dart.setFieldSignature(_metadata.SupportedBrowser, () => ({
>+  __proto__: dart.getFields(_metadata.SupportedBrowser.__proto__),
>+  browserName: dart.finalFieldType(core.String),
>+  minimumVersion: dart.finalFieldType(core.String)
>+}));
>+dart.defineLazy(_metadata.SupportedBrowser, {
>+  /*_metadata.SupportedBrowser.CHROME*/get CHROME() {
>+    return "Chrome";
>+  },
>+  /*_metadata.SupportedBrowser.FIREFOX*/get FIREFOX() {
>+    return "Firefox";
>+  },
>+  /*_metadata.SupportedBrowser.IE*/get IE() {
>+    return "Internet Explorer";
>+  },
>+  /*_metadata.SupportedBrowser.OPERA*/get OPERA() {
>+    return "Opera";
>+  },
>+  /*_metadata.SupportedBrowser.SAFARI*/get SAFARI() {
>+    return "Safari";
>+  }
>+});
>+_metadata.Experimental = class Experimental extends core.Object {};
>+(_metadata.Experimental.new = function() {
>+}).prototype = _metadata.Experimental.prototype;
>+dart.addTypeTests(_metadata.Experimental);
>+dart.setLibraryUri(_metadata.Experimental, "dart:_metadata");
>+_metadata.DomName = class DomName extends core.Object {};
>+(_metadata.DomName.new = function(name) {
>+  this.name = name;
>+}).prototype = _metadata.DomName.prototype;
>+dart.addTypeTests(_metadata.DomName);
>+dart.setLibraryUri(_metadata.DomName, "dart:_metadata");
>+dart.setFieldSignature(_metadata.DomName, () => ({
>+  __proto__: dart.getFields(_metadata.DomName.__proto__),
>+  name: dart.finalFieldType(core.String)
>+}));
>+_metadata.DocsEditable = class DocsEditable extends core.Object {};
>+(_metadata.DocsEditable.new = function() {
>+}).prototype = _metadata.DocsEditable.prototype;
>+dart.addTypeTests(_metadata.DocsEditable);
>+dart.setLibraryUri(_metadata.DocsEditable, "dart:_metadata");
>+_metadata.Unstable = class Unstable extends core.Object {};
>+(_metadata.Unstable.new = function() {
>+}).prototype = _metadata.Unstable.prototype;
>+dart.addTypeTests(_metadata.Unstable);
>+dart.setLibraryUri(_metadata.Unstable, "dart:_metadata");
>+_native_typed_data.NativeByteBuffer = class NativeByteBuffer extends core.Object {
>+  get [$lengthInBytes]() {
>+    return this.byteLength;
>+  }
>+  get [$runtimeType]() {
>+    return dart.wrapType(typed_data.ByteBuffer);
>+  }
>+  [$asUint8List](offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return _native_typed_data.NativeUint8List.view(this, offsetInBytes, length);
>+  }
>+  [$asInt8List](offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return _native_typed_data.NativeInt8List.view(this, offsetInBytes, length);
>+  }
>+  [$asUint8ClampedList](offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return _native_typed_data.NativeUint8ClampedList.view(this, offsetInBytes, length);
>+  }
>+  [$asUint16List](offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return _native_typed_data.NativeUint16List.view(this, offsetInBytes, length);
>+  }
>+  [$asInt16List](offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return _native_typed_data.NativeInt16List.view(this, offsetInBytes, length);
>+  }
>+  [$asUint32List](offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return _native_typed_data.NativeUint32List.view(this, offsetInBytes, length);
>+  }
>+  [$asInt32List](offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return _native_typed_data.NativeInt32List.view(this, offsetInBytes, length);
>+  }
>+  [$asUint64List](offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    dart.throw(new core.UnsupportedError.new("Uint64List not supported by dart2js."));
>+  }
>+  [$asInt64List](offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    dart.throw(new core.UnsupportedError.new("Int64List not supported by dart2js."));
>+  }
>+  [$asInt32x4List](offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    let storage = _native_typed_data.NativeInt32List._check(this[$asInt32List](offsetInBytes, length != null ? dart.notNull(length) * 4 : null));
>+    return new _native_typed_data.NativeInt32x4List._externalStorage(storage);
>+  }
>+  [$asFloat32List](offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return _native_typed_data.NativeFloat32List.view(this, offsetInBytes, length);
>+  }
>+  [$asFloat64List](offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return _native_typed_data.NativeFloat64List.view(this, offsetInBytes, length);
>+  }
>+  [$asFloat32x4List](offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    let storage = _native_typed_data.NativeFloat32List._check(this[$asFloat32List](offsetInBytes, length != null ? dart.notNull(length) * 4 : null));
>+    return new _native_typed_data.NativeFloat32x4List._externalStorage(storage);
>+  }
>+  [$asFloat64x2List](offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    let storage = _native_typed_data.NativeFloat64List._check(this[$asFloat64List](offsetInBytes, length != null ? dart.notNull(length) * 2 : null));
>+    return new _native_typed_data.NativeFloat64x2List._externalStorage(storage);
>+  }
>+  [$asByteData](offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return _native_typed_data.NativeByteData.view(this, offsetInBytes, length);
>+  }
>+};
>+(_native_typed_data.NativeByteBuffer.new = function() {
>+}).prototype = _native_typed_data.NativeByteBuffer.prototype;
>+dart.addTypeTests(_native_typed_data.NativeByteBuffer);
>+_native_typed_data.NativeByteBuffer[dart.implements] = () => [typed_data.ByteBuffer];
>+dart.setMethodSignature(_native_typed_data.NativeByteBuffer, () => ({
>+  __proto__: dart.getMethods(_native_typed_data.NativeByteBuffer.__proto__),
>+  [$asUint8List]: dart.fnType(typed_data.Uint8List, [], [core.int, core.int]),
>+  [$asInt8List]: dart.fnType(typed_data.Int8List, [], [core.int, core.int]),
>+  [$asUint8ClampedList]: dart.fnType(typed_data.Uint8ClampedList, [], [core.int, core.int]),
>+  [$asUint16List]: dart.fnType(typed_data.Uint16List, [], [core.int, core.int]),
>+  [$asInt16List]: dart.fnType(typed_data.Int16List, [], [core.int, core.int]),
>+  [$asUint32List]: dart.fnType(typed_data.Uint32List, [], [core.int, core.int]),
>+  [$asInt32List]: dart.fnType(typed_data.Int32List, [], [core.int, core.int]),
>+  [$asUint64List]: dart.fnType(typed_data.Uint64List, [], [core.int, core.int]),
>+  [$asInt64List]: dart.fnType(typed_data.Int64List, [], [core.int, core.int]),
>+  [$asInt32x4List]: dart.fnType(typed_data.Int32x4List, [], [core.int, core.int]),
>+  [$asFloat32List]: dart.fnType(typed_data.Float32List, [], [core.int, core.int]),
>+  [$asFloat64List]: dart.fnType(typed_data.Float64List, [], [core.int, core.int]),
>+  [$asFloat32x4List]: dart.fnType(typed_data.Float32x4List, [], [core.int, core.int]),
>+  [$asFloat64x2List]: dart.fnType(typed_data.Float64x2List, [], [core.int, core.int]),
>+  [$asByteData]: dart.fnType(typed_data.ByteData, [], [core.int, core.int])
>+}));
>+dart.setGetterSignature(_native_typed_data.NativeByteBuffer, () => ({
>+  __proto__: dart.getGetters(_native_typed_data.NativeByteBuffer.__proto__),
>+  [$lengthInBytes]: core.int
>+}));
>+dart.setLibraryUri(_native_typed_data.NativeByteBuffer, "dart:_native_typed_data");
>+dart.registerExtension("ArrayBuffer", _native_typed_data.NativeByteBuffer);
>+const _storage = dart.privateName(_native_typed_data, "_storage");
>+typed_data.Float32x4 = class Float32x4 extends core.Object {
>+  static new(x, y, z, w) {
>+    return new _native_typed_data.NativeFloat32x4.new(x, y, z, w);
>+  }
>+  static splat(v) {
>+    return new _native_typed_data.NativeFloat32x4.splat(v);
>+  }
>+  static zero() {
>+    return new _native_typed_data.NativeFloat32x4.zero();
>+  }
>+  static fromInt32x4Bits(x) {
>+    return _native_typed_data.NativeFloat32x4.fromInt32x4Bits(x);
>+  }
>+  static fromFloat64x2(v) {
>+    return new _native_typed_data.NativeFloat32x4.fromFloat64x2(v);
>+  }
>+};
>+(typed_data.Float32x4[dart.mixinNew] = function() {
>+}).prototype = typed_data.Float32x4.prototype;
>+dart.addTypeTests(typed_data.Float32x4);
>+dart.setLibraryUri(typed_data.Float32x4, "dart:typed_data");
>+dart.defineLazy(typed_data.Float32x4, {
>+  /*typed_data.Float32x4.xxxx*/get xxxx() {
>+    return 0;
>+  },
>+  /*typed_data.Float32x4.xxxy*/get xxxy() {
>+    return 64;
>+  },
>+  /*typed_data.Float32x4.xxxz*/get xxxz() {
>+    return 128;
>+  },
>+  /*typed_data.Float32x4.xxxw*/get xxxw() {
>+    return 192;
>+  },
>+  /*typed_data.Float32x4.xxyx*/get xxyx() {
>+    return 16;
>+  },
>+  /*typed_data.Float32x4.xxyy*/get xxyy() {
>+    return 80;
>+  },
>+  /*typed_data.Float32x4.xxyz*/get xxyz() {
>+    return 144;
>+  },
>+  /*typed_data.Float32x4.xxyw*/get xxyw() {
>+    return 208;
>+  },
>+  /*typed_data.Float32x4.xxzx*/get xxzx() {
>+    return 32;
>+  },
>+  /*typed_data.Float32x4.xxzy*/get xxzy() {
>+    return 96;
>+  },
>+  /*typed_data.Float32x4.xxzz*/get xxzz() {
>+    return 160;
>+  },
>+  /*typed_data.Float32x4.xxzw*/get xxzw() {
>+    return 224;
>+  },
>+  /*typed_data.Float32x4.xxwx*/get xxwx() {
>+    return 48;
>+  },
>+  /*typed_data.Float32x4.xxwy*/get xxwy() {
>+    return 112;
>+  },
>+  /*typed_data.Float32x4.xxwz*/get xxwz() {
>+    return 176;
>+  },
>+  /*typed_data.Float32x4.xxww*/get xxww() {
>+    return 240;
>+  },
>+  /*typed_data.Float32x4.xyxx*/get xyxx() {
>+    return 4;
>+  },
>+  /*typed_data.Float32x4.xyxy*/get xyxy() {
>+    return 68;
>+  },
>+  /*typed_data.Float32x4.xyxz*/get xyxz() {
>+    return 132;
>+  },
>+  /*typed_data.Float32x4.xyxw*/get xyxw() {
>+    return 196;
>+  },
>+  /*typed_data.Float32x4.xyyx*/get xyyx() {
>+    return 20;
>+  },
>+  /*typed_data.Float32x4.xyyy*/get xyyy() {
>+    return 84;
>+  },
>+  /*typed_data.Float32x4.xyyz*/get xyyz() {
>+    return 148;
>+  },
>+  /*typed_data.Float32x4.xyyw*/get xyyw() {
>+    return 212;
>+  },
>+  /*typed_data.Float32x4.xyzx*/get xyzx() {
>+    return 36;
>+  },
>+  /*typed_data.Float32x4.xyzy*/get xyzy() {
>+    return 100;
>+  },
>+  /*typed_data.Float32x4.xyzz*/get xyzz() {
>+    return 164;
>+  },
>+  /*typed_data.Float32x4.xyzw*/get xyzw() {
>+    return 228;
>+  },
>+  /*typed_data.Float32x4.xywx*/get xywx() {
>+    return 52;
>+  },
>+  /*typed_data.Float32x4.xywy*/get xywy() {
>+    return 116;
>+  },
>+  /*typed_data.Float32x4.xywz*/get xywz() {
>+    return 180;
>+  },
>+  /*typed_data.Float32x4.xyww*/get xyww() {
>+    return 244;
>+  },
>+  /*typed_data.Float32x4.xzxx*/get xzxx() {
>+    return 8;
>+  },
>+  /*typed_data.Float32x4.xzxy*/get xzxy() {
>+    return 72;
>+  },
>+  /*typed_data.Float32x4.xzxz*/get xzxz() {
>+    return 136;
>+  },
>+  /*typed_data.Float32x4.xzxw*/get xzxw() {
>+    return 200;
>+  },
>+  /*typed_data.Float32x4.xzyx*/get xzyx() {
>+    return 24;
>+  },
>+  /*typed_data.Float32x4.xzyy*/get xzyy() {
>+    return 88;
>+  },
>+  /*typed_data.Float32x4.xzyz*/get xzyz() {
>+    return 152;
>+  },
>+  /*typed_data.Float32x4.xzyw*/get xzyw() {
>+    return 216;
>+  },
>+  /*typed_data.Float32x4.xzzx*/get xzzx() {
>+    return 40;
>+  },
>+  /*typed_data.Float32x4.xzzy*/get xzzy() {
>+    return 104;
>+  },
>+  /*typed_data.Float32x4.xzzz*/get xzzz() {
>+    return 168;
>+  },
>+  /*typed_data.Float32x4.xzzw*/get xzzw() {
>+    return 232;
>+  },
>+  /*typed_data.Float32x4.xzwx*/get xzwx() {
>+    return 56;
>+  },
>+  /*typed_data.Float32x4.xzwy*/get xzwy() {
>+    return 120;
>+  },
>+  /*typed_data.Float32x4.xzwz*/get xzwz() {
>+    return 184;
>+  },
>+  /*typed_data.Float32x4.xzww*/get xzww() {
>+    return 248;
>+  },
>+  /*typed_data.Float32x4.xwxx*/get xwxx() {
>+    return 12;
>+  },
>+  /*typed_data.Float32x4.xwxy*/get xwxy() {
>+    return 76;
>+  },
>+  /*typed_data.Float32x4.xwxz*/get xwxz() {
>+    return 140;
>+  },
>+  /*typed_data.Float32x4.xwxw*/get xwxw() {
>+    return 204;
>+  },
>+  /*typed_data.Float32x4.xwyx*/get xwyx() {
>+    return 28;
>+  },
>+  /*typed_data.Float32x4.xwyy*/get xwyy() {
>+    return 92;
>+  },
>+  /*typed_data.Float32x4.xwyz*/get xwyz() {
>+    return 156;
>+  },
>+  /*typed_data.Float32x4.xwyw*/get xwyw() {
>+    return 220;
>+  },
>+  /*typed_data.Float32x4.xwzx*/get xwzx() {
>+    return 44;
>+  },
>+  /*typed_data.Float32x4.xwzy*/get xwzy() {
>+    return 108;
>+  },
>+  /*typed_data.Float32x4.xwzz*/get xwzz() {
>+    return 172;
>+  },
>+  /*typed_data.Float32x4.xwzw*/get xwzw() {
>+    return 236;
>+  },
>+  /*typed_data.Float32x4.xwwx*/get xwwx() {
>+    return 60;
>+  },
>+  /*typed_data.Float32x4.xwwy*/get xwwy() {
>+    return 124;
>+  },
>+  /*typed_data.Float32x4.xwwz*/get xwwz() {
>+    return 188;
>+  },
>+  /*typed_data.Float32x4.xwww*/get xwww() {
>+    return 252;
>+  },
>+  /*typed_data.Float32x4.yxxx*/get yxxx() {
>+    return 1;
>+  },
>+  /*typed_data.Float32x4.yxxy*/get yxxy() {
>+    return 65;
>+  },
>+  /*typed_data.Float32x4.yxxz*/get yxxz() {
>+    return 129;
>+  },
>+  /*typed_data.Float32x4.yxxw*/get yxxw() {
>+    return 193;
>+  },
>+  /*typed_data.Float32x4.yxyx*/get yxyx() {
>+    return 17;
>+  },
>+  /*typed_data.Float32x4.yxyy*/get yxyy() {
>+    return 81;
>+  },
>+  /*typed_data.Float32x4.yxyz*/get yxyz() {
>+    return 145;
>+  },
>+  /*typed_data.Float32x4.yxyw*/get yxyw() {
>+    return 209;
>+  },
>+  /*typed_data.Float32x4.yxzx*/get yxzx() {
>+    return 33;
>+  },
>+  /*typed_data.Float32x4.yxzy*/get yxzy() {
>+    return 97;
>+  },
>+  /*typed_data.Float32x4.yxzz*/get yxzz() {
>+    return 161;
>+  },
>+  /*typed_data.Float32x4.yxzw*/get yxzw() {
>+    return 225;
>+  },
>+  /*typed_data.Float32x4.yxwx*/get yxwx() {
>+    return 49;
>+  },
>+  /*typed_data.Float32x4.yxwy*/get yxwy() {
>+    return 113;
>+  },
>+  /*typed_data.Float32x4.yxwz*/get yxwz() {
>+    return 177;
>+  },
>+  /*typed_data.Float32x4.yxww*/get yxww() {
>+    return 241;
>+  },
>+  /*typed_data.Float32x4.yyxx*/get yyxx() {
>+    return 5;
>+  },
>+  /*typed_data.Float32x4.yyxy*/get yyxy() {
>+    return 69;
>+  },
>+  /*typed_data.Float32x4.yyxz*/get yyxz() {
>+    return 133;
>+  },
>+  /*typed_data.Float32x4.yyxw*/get yyxw() {
>+    return 197;
>+  },
>+  /*typed_data.Float32x4.yyyx*/get yyyx() {
>+    return 21;
>+  },
>+  /*typed_data.Float32x4.yyyy*/get yyyy() {
>+    return 85;
>+  },
>+  /*typed_data.Float32x4.yyyz*/get yyyz() {
>+    return 149;
>+  },
>+  /*typed_data.Float32x4.yyyw*/get yyyw() {
>+    return 213;
>+  },
>+  /*typed_data.Float32x4.yyzx*/get yyzx() {
>+    return 37;
>+  },
>+  /*typed_data.Float32x4.yyzy*/get yyzy() {
>+    return 101;
>+  },
>+  /*typed_data.Float32x4.yyzz*/get yyzz() {
>+    return 165;
>+  },
>+  /*typed_data.Float32x4.yyzw*/get yyzw() {
>+    return 229;
>+  },
>+  /*typed_data.Float32x4.yywx*/get yywx() {
>+    return 53;
>+  },
>+  /*typed_data.Float32x4.yywy*/get yywy() {
>+    return 117;
>+  },
>+  /*typed_data.Float32x4.yywz*/get yywz() {
>+    return 181;
>+  },
>+  /*typed_data.Float32x4.yyww*/get yyww() {
>+    return 245;
>+  },
>+  /*typed_data.Float32x4.yzxx*/get yzxx() {
>+    return 9;
>+  },
>+  /*typed_data.Float32x4.yzxy*/get yzxy() {
>+    return 73;
>+  },
>+  /*typed_data.Float32x4.yzxz*/get yzxz() {
>+    return 137;
>+  },
>+  /*typed_data.Float32x4.yzxw*/get yzxw() {
>+    return 201;
>+  },
>+  /*typed_data.Float32x4.yzyx*/get yzyx() {
>+    return 25;
>+  },
>+  /*typed_data.Float32x4.yzyy*/get yzyy() {
>+    return 89;
>+  },
>+  /*typed_data.Float32x4.yzyz*/get yzyz() {
>+    return 153;
>+  },
>+  /*typed_data.Float32x4.yzyw*/get yzyw() {
>+    return 217;
>+  },
>+  /*typed_data.Float32x4.yzzx*/get yzzx() {
>+    return 41;
>+  },
>+  /*typed_data.Float32x4.yzzy*/get yzzy() {
>+    return 105;
>+  },
>+  /*typed_data.Float32x4.yzzz*/get yzzz() {
>+    return 169;
>+  },
>+  /*typed_data.Float32x4.yzzw*/get yzzw() {
>+    return 233;
>+  },
>+  /*typed_data.Float32x4.yzwx*/get yzwx() {
>+    return 57;
>+  },
>+  /*typed_data.Float32x4.yzwy*/get yzwy() {
>+    return 121;
>+  },
>+  /*typed_data.Float32x4.yzwz*/get yzwz() {
>+    return 185;
>+  },
>+  /*typed_data.Float32x4.yzww*/get yzww() {
>+    return 249;
>+  },
>+  /*typed_data.Float32x4.ywxx*/get ywxx() {
>+    return 13;
>+  },
>+  /*typed_data.Float32x4.ywxy*/get ywxy() {
>+    return 77;
>+  },
>+  /*typed_data.Float32x4.ywxz*/get ywxz() {
>+    return 141;
>+  },
>+  /*typed_data.Float32x4.ywxw*/get ywxw() {
>+    return 205;
>+  },
>+  /*typed_data.Float32x4.ywyx*/get ywyx() {
>+    return 29;
>+  },
>+  /*typed_data.Float32x4.ywyy*/get ywyy() {
>+    return 93;
>+  },
>+  /*typed_data.Float32x4.ywyz*/get ywyz() {
>+    return 157;
>+  },
>+  /*typed_data.Float32x4.ywyw*/get ywyw() {
>+    return 221;
>+  },
>+  /*typed_data.Float32x4.ywzx*/get ywzx() {
>+    return 45;
>+  },
>+  /*typed_data.Float32x4.ywzy*/get ywzy() {
>+    return 109;
>+  },
>+  /*typed_data.Float32x4.ywzz*/get ywzz() {
>+    return 173;
>+  },
>+  /*typed_data.Float32x4.ywzw*/get ywzw() {
>+    return 237;
>+  },
>+  /*typed_data.Float32x4.ywwx*/get ywwx() {
>+    return 61;
>+  },
>+  /*typed_data.Float32x4.ywwy*/get ywwy() {
>+    return 125;
>+  },
>+  /*typed_data.Float32x4.ywwz*/get ywwz() {
>+    return 189;
>+  },
>+  /*typed_data.Float32x4.ywww*/get ywww() {
>+    return 253;
>+  },
>+  /*typed_data.Float32x4.zxxx*/get zxxx() {
>+    return 2;
>+  },
>+  /*typed_data.Float32x4.zxxy*/get zxxy() {
>+    return 66;
>+  },
>+  /*typed_data.Float32x4.zxxz*/get zxxz() {
>+    return 130;
>+  },
>+  /*typed_data.Float32x4.zxxw*/get zxxw() {
>+    return 194;
>+  },
>+  /*typed_data.Float32x4.zxyx*/get zxyx() {
>+    return 18;
>+  },
>+  /*typed_data.Float32x4.zxyy*/get zxyy() {
>+    return 82;
>+  },
>+  /*typed_data.Float32x4.zxyz*/get zxyz() {
>+    return 146;
>+  },
>+  /*typed_data.Float32x4.zxyw*/get zxyw() {
>+    return 210;
>+  },
>+  /*typed_data.Float32x4.zxzx*/get zxzx() {
>+    return 34;
>+  },
>+  /*typed_data.Float32x4.zxzy*/get zxzy() {
>+    return 98;
>+  },
>+  /*typed_data.Float32x4.zxzz*/get zxzz() {
>+    return 162;
>+  },
>+  /*typed_data.Float32x4.zxzw*/get zxzw() {
>+    return 226;
>+  },
>+  /*typed_data.Float32x4.zxwx*/get zxwx() {
>+    return 50;
>+  },
>+  /*typed_data.Float32x4.zxwy*/get zxwy() {
>+    return 114;
>+  },
>+  /*typed_data.Float32x4.zxwz*/get zxwz() {
>+    return 178;
>+  },
>+  /*typed_data.Float32x4.zxww*/get zxww() {
>+    return 242;
>+  },
>+  /*typed_data.Float32x4.zyxx*/get zyxx() {
>+    return 6;
>+  },
>+  /*typed_data.Float32x4.zyxy*/get zyxy() {
>+    return 70;
>+  },
>+  /*typed_data.Float32x4.zyxz*/get zyxz() {
>+    return 134;
>+  },
>+  /*typed_data.Float32x4.zyxw*/get zyxw() {
>+    return 198;
>+  },
>+  /*typed_data.Float32x4.zyyx*/get zyyx() {
>+    return 22;
>+  },
>+  /*typed_data.Float32x4.zyyy*/get zyyy() {
>+    return 86;
>+  },
>+  /*typed_data.Float32x4.zyyz*/get zyyz() {
>+    return 150;
>+  },
>+  /*typed_data.Float32x4.zyyw*/get zyyw() {
>+    return 214;
>+  },
>+  /*typed_data.Float32x4.zyzx*/get zyzx() {
>+    return 38;
>+  },
>+  /*typed_data.Float32x4.zyzy*/get zyzy() {
>+    return 102;
>+  },
>+  /*typed_data.Float32x4.zyzz*/get zyzz() {
>+    return 166;
>+  },
>+  /*typed_data.Float32x4.zyzw*/get zyzw() {
>+    return 230;
>+  },
>+  /*typed_data.Float32x4.zywx*/get zywx() {
>+    return 54;
>+  },
>+  /*typed_data.Float32x4.zywy*/get zywy() {
>+    return 118;
>+  },
>+  /*typed_data.Float32x4.zywz*/get zywz() {
>+    return 182;
>+  },
>+  /*typed_data.Float32x4.zyww*/get zyww() {
>+    return 246;
>+  },
>+  /*typed_data.Float32x4.zzxx*/get zzxx() {
>+    return 10;
>+  },
>+  /*typed_data.Float32x4.zzxy*/get zzxy() {
>+    return 74;
>+  },
>+  /*typed_data.Float32x4.zzxz*/get zzxz() {
>+    return 138;
>+  },
>+  /*typed_data.Float32x4.zzxw*/get zzxw() {
>+    return 202;
>+  },
>+  /*typed_data.Float32x4.zzyx*/get zzyx() {
>+    return 26;
>+  },
>+  /*typed_data.Float32x4.zzyy*/get zzyy() {
>+    return 90;
>+  },
>+  /*typed_data.Float32x4.zzyz*/get zzyz() {
>+    return 154;
>+  },
>+  /*typed_data.Float32x4.zzyw*/get zzyw() {
>+    return 218;
>+  },
>+  /*typed_data.Float32x4.zzzx*/get zzzx() {
>+    return 42;
>+  },
>+  /*typed_data.Float32x4.zzzy*/get zzzy() {
>+    return 106;
>+  },
>+  /*typed_data.Float32x4.zzzz*/get zzzz() {
>+    return 170;
>+  },
>+  /*typed_data.Float32x4.zzzw*/get zzzw() {
>+    return 234;
>+  },
>+  /*typed_data.Float32x4.zzwx*/get zzwx() {
>+    return 58;
>+  },
>+  /*typed_data.Float32x4.zzwy*/get zzwy() {
>+    return 122;
>+  },
>+  /*typed_data.Float32x4.zzwz*/get zzwz() {
>+    return 186;
>+  },
>+  /*typed_data.Float32x4.zzww*/get zzww() {
>+    return 250;
>+  },
>+  /*typed_data.Float32x4.zwxx*/get zwxx() {
>+    return 14;
>+  },
>+  /*typed_data.Float32x4.zwxy*/get zwxy() {
>+    return 78;
>+  },
>+  /*typed_data.Float32x4.zwxz*/get zwxz() {
>+    return 142;
>+  },
>+  /*typed_data.Float32x4.zwxw*/get zwxw() {
>+    return 206;
>+  },
>+  /*typed_data.Float32x4.zwyx*/get zwyx() {
>+    return 30;
>+  },
>+  /*typed_data.Float32x4.zwyy*/get zwyy() {
>+    return 94;
>+  },
>+  /*typed_data.Float32x4.zwyz*/get zwyz() {
>+    return 158;
>+  },
>+  /*typed_data.Float32x4.zwyw*/get zwyw() {
>+    return 222;
>+  },
>+  /*typed_data.Float32x4.zwzx*/get zwzx() {
>+    return 46;
>+  },
>+  /*typed_data.Float32x4.zwzy*/get zwzy() {
>+    return 110;
>+  },
>+  /*typed_data.Float32x4.zwzz*/get zwzz() {
>+    return 174;
>+  },
>+  /*typed_data.Float32x4.zwzw*/get zwzw() {
>+    return 238;
>+  },
>+  /*typed_data.Float32x4.zwwx*/get zwwx() {
>+    return 62;
>+  },
>+  /*typed_data.Float32x4.zwwy*/get zwwy() {
>+    return 126;
>+  },
>+  /*typed_data.Float32x4.zwwz*/get zwwz() {
>+    return 190;
>+  },
>+  /*typed_data.Float32x4.zwww*/get zwww() {
>+    return 254;
>+  },
>+  /*typed_data.Float32x4.wxxx*/get wxxx() {
>+    return 3;
>+  },
>+  /*typed_data.Float32x4.wxxy*/get wxxy() {
>+    return 67;
>+  },
>+  /*typed_data.Float32x4.wxxz*/get wxxz() {
>+    return 131;
>+  },
>+  /*typed_data.Float32x4.wxxw*/get wxxw() {
>+    return 195;
>+  },
>+  /*typed_data.Float32x4.wxyx*/get wxyx() {
>+    return 19;
>+  },
>+  /*typed_data.Float32x4.wxyy*/get wxyy() {
>+    return 83;
>+  },
>+  /*typed_data.Float32x4.wxyz*/get wxyz() {
>+    return 147;
>+  },
>+  /*typed_data.Float32x4.wxyw*/get wxyw() {
>+    return 211;
>+  },
>+  /*typed_data.Float32x4.wxzx*/get wxzx() {
>+    return 35;
>+  },
>+  /*typed_data.Float32x4.wxzy*/get wxzy() {
>+    return 99;
>+  },
>+  /*typed_data.Float32x4.wxzz*/get wxzz() {
>+    return 163;
>+  },
>+  /*typed_data.Float32x4.wxzw*/get wxzw() {
>+    return 227;
>+  },
>+  /*typed_data.Float32x4.wxwx*/get wxwx() {
>+    return 51;
>+  },
>+  /*typed_data.Float32x4.wxwy*/get wxwy() {
>+    return 115;
>+  },
>+  /*typed_data.Float32x4.wxwz*/get wxwz() {
>+    return 179;
>+  },
>+  /*typed_data.Float32x4.wxww*/get wxww() {
>+    return 243;
>+  },
>+  /*typed_data.Float32x4.wyxx*/get wyxx() {
>+    return 7;
>+  },
>+  /*typed_data.Float32x4.wyxy*/get wyxy() {
>+    return 71;
>+  },
>+  /*typed_data.Float32x4.wyxz*/get wyxz() {
>+    return 135;
>+  },
>+  /*typed_data.Float32x4.wyxw*/get wyxw() {
>+    return 199;
>+  },
>+  /*typed_data.Float32x4.wyyx*/get wyyx() {
>+    return 23;
>+  },
>+  /*typed_data.Float32x4.wyyy*/get wyyy() {
>+    return 87;
>+  },
>+  /*typed_data.Float32x4.wyyz*/get wyyz() {
>+    return 151;
>+  },
>+  /*typed_data.Float32x4.wyyw*/get wyyw() {
>+    return 215;
>+  },
>+  /*typed_data.Float32x4.wyzx*/get wyzx() {
>+    return 39;
>+  },
>+  /*typed_data.Float32x4.wyzy*/get wyzy() {
>+    return 103;
>+  },
>+  /*typed_data.Float32x4.wyzz*/get wyzz() {
>+    return 167;
>+  },
>+  /*typed_data.Float32x4.wyzw*/get wyzw() {
>+    return 231;
>+  },
>+  /*typed_data.Float32x4.wywx*/get wywx() {
>+    return 55;
>+  },
>+  /*typed_data.Float32x4.wywy*/get wywy() {
>+    return 119;
>+  },
>+  /*typed_data.Float32x4.wywz*/get wywz() {
>+    return 183;
>+  },
>+  /*typed_data.Float32x4.wyww*/get wyww() {
>+    return 247;
>+  },
>+  /*typed_data.Float32x4.wzxx*/get wzxx() {
>+    return 11;
>+  },
>+  /*typed_data.Float32x4.wzxy*/get wzxy() {
>+    return 75;
>+  },
>+  /*typed_data.Float32x4.wzxz*/get wzxz() {
>+    return 139;
>+  },
>+  /*typed_data.Float32x4.wzxw*/get wzxw() {
>+    return 203;
>+  },
>+  /*typed_data.Float32x4.wzyx*/get wzyx() {
>+    return 27;
>+  },
>+  /*typed_data.Float32x4.wzyy*/get wzyy() {
>+    return 91;
>+  },
>+  /*typed_data.Float32x4.wzyz*/get wzyz() {
>+    return 155;
>+  },
>+  /*typed_data.Float32x4.wzyw*/get wzyw() {
>+    return 219;
>+  },
>+  /*typed_data.Float32x4.wzzx*/get wzzx() {
>+    return 43;
>+  },
>+  /*typed_data.Float32x4.wzzy*/get wzzy() {
>+    return 107;
>+  },
>+  /*typed_data.Float32x4.wzzz*/get wzzz() {
>+    return 171;
>+  },
>+  /*typed_data.Float32x4.wzzw*/get wzzw() {
>+    return 235;
>+  },
>+  /*typed_data.Float32x4.wzwx*/get wzwx() {
>+    return 59;
>+  },
>+  /*typed_data.Float32x4.wzwy*/get wzwy() {
>+    return 123;
>+  },
>+  /*typed_data.Float32x4.wzwz*/get wzwz() {
>+    return 187;
>+  },
>+  /*typed_data.Float32x4.wzww*/get wzww() {
>+    return 251;
>+  },
>+  /*typed_data.Float32x4.wwxx*/get wwxx() {
>+    return 15;
>+  },
>+  /*typed_data.Float32x4.wwxy*/get wwxy() {
>+    return 79;
>+  },
>+  /*typed_data.Float32x4.wwxz*/get wwxz() {
>+    return 143;
>+  },
>+  /*typed_data.Float32x4.wwxw*/get wwxw() {
>+    return 207;
>+  },
>+  /*typed_data.Float32x4.wwyx*/get wwyx() {
>+    return 31;
>+  },
>+  /*typed_data.Float32x4.wwyy*/get wwyy() {
>+    return 95;
>+  },
>+  /*typed_data.Float32x4.wwyz*/get wwyz() {
>+    return 159;
>+  },
>+  /*typed_data.Float32x4.wwyw*/get wwyw() {
>+    return 223;
>+  },
>+  /*typed_data.Float32x4.wwzx*/get wwzx() {
>+    return 47;
>+  },
>+  /*typed_data.Float32x4.wwzy*/get wwzy() {
>+    return 111;
>+  },
>+  /*typed_data.Float32x4.wwzz*/get wwzz() {
>+    return 175;
>+  },
>+  /*typed_data.Float32x4.wwzw*/get wwzw() {
>+    return 239;
>+  },
>+  /*typed_data.Float32x4.wwwx*/get wwwx() {
>+    return 63;
>+  },
>+  /*typed_data.Float32x4.wwwy*/get wwwy() {
>+    return 127;
>+  },
>+  /*typed_data.Float32x4.wwwz*/get wwwz() {
>+    return 191;
>+  },
>+  /*typed_data.Float32x4.wwww*/get wwww() {
>+    return 255;
>+  }
>+});
>+const Object_ListMixin$ = class Object_ListMixin extends core.Object {};
>+(Object_ListMixin$.new = function() {
>+}).prototype = Object_ListMixin$.prototype;
>+dart.applyMixin(Object_ListMixin$, collection.ListMixin$(typed_data.Float32x4));
>+const Object_FixedLengthListMixin$ = class Object_FixedLengthListMixin extends Object_ListMixin$ {};
>+(Object_FixedLengthListMixin$.new = function() {
>+}).prototype = Object_FixedLengthListMixin$.prototype;
>+dart.applyMixin(Object_FixedLengthListMixin$, _internal.FixedLengthListMixin$(typed_data.Float32x4));
>+_native_typed_data.NativeFloat32x4List = class NativeFloat32x4List extends Object_FixedLengthListMixin$ {
>+  get runtimeType() {
>+    return dart.wrapType(typed_data.Float32x4List);
>+  }
>+  static fromList(list) {
>+    if (_native_typed_data.NativeFloat32x4List.is(list)) {
>+      return new _native_typed_data.NativeFloat32x4List._externalStorage(_native_typed_data.NativeFloat32List.fromList(list[_storage]));
>+    } else {
>+      return new _native_typed_data.NativeFloat32x4List._slowFromList(list);
>+    }
>+  }
>+  get buffer() {
>+    return this[_storage].buffer;
>+  }
>+  get lengthInBytes() {
>+    return this[_storage][$lengthInBytes];
>+  }
>+  get offsetInBytes() {
>+    return this[_storage][$offsetInBytes];
>+  }
>+  get elementSizeInBytes() {
>+    return typed_data.Float32x4List.bytesPerElement;
>+  }
>+  get length() {
>+    return (dart.notNull(this[_storage][$length]) / 4)[$truncate]();
>+  }
>+  set length(value) {
>+    super.length = value;
>+  }
>+  _get(index) {
>+    _native_typed_data._checkValidIndex(index, this, this.length);
>+    let _x = this[_storage][$_get](dart.notNull(index) * 4 + 0);
>+    let _y = this[_storage][$_get](dart.notNull(index) * 4 + 1);
>+    let _z = this[_storage][$_get](dart.notNull(index) * 4 + 2);
>+    let _w = this[_storage][$_get](dart.notNull(index) * 4 + 3);
>+    return new _native_typed_data.NativeFloat32x4._truncated(_x, _y, _z, _w);
>+  }
>+  _set(index, value) {
>+    typed_data.Float32x4._check(value);
>+    _native_typed_data._checkValidIndex(index, this, this.length);
>+    this[_storage][$_set](dart.notNull(index) * 4 + 0, value.x);
>+    this[_storage][$_set](dart.notNull(index) * 4 + 1, value.y);
>+    this[_storage][$_set](dart.notNull(index) * 4 + 2, value.z);
>+    this[_storage][$_set](dart.notNull(index) * 4 + 3, value.w);
>+    return value;
>+  }
>+  sublist(start, end) {
>+    if (end === void 0) end = null;
>+    end = _native_typed_data._checkValidRange(start, end, this.length);
>+    return new _native_typed_data.NativeFloat32x4List._externalStorage(_native_typed_data.NativeFloat32List._check(this[_storage][$sublist](dart.notNull(start) * 4, dart.notNull(end) * 4)));
>+  }
>+};
>+(_native_typed_data.NativeFloat32x4List.new = function(length) {
>+  this[_storage] = _native_typed_data.NativeFloat32List.new(dart.notNull(length) * 4);
>+}).prototype = _native_typed_data.NativeFloat32x4List.prototype;
>+(_native_typed_data.NativeFloat32x4List._externalStorage = function(storage) {
>+  this[_storage] = storage;
>+}).prototype = _native_typed_data.NativeFloat32x4List.prototype;
>+(_native_typed_data.NativeFloat32x4List._slowFromList = function(list) {
>+  this[_storage] = _native_typed_data.NativeFloat32List.new(dart.notNull(list[$length]) * 4);
>+  for (let i = 0; i < dart.notNull(list[$length]); i++) {
>+    let e = list[$_get](i);
>+    this[_storage][$_set](i * 4 + 0, e.x);
>+    this[_storage][$_set](i * 4 + 1, e.y);
>+    this[_storage][$_set](i * 4 + 2, e.z);
>+    this[_storage][$_set](i * 4 + 3, e.w);
>+  }
>+}).prototype = _native_typed_data.NativeFloat32x4List.prototype;
>+dart.addTypeTests(_native_typed_data.NativeFloat32x4List);
>+_native_typed_data.NativeFloat32x4List[dart.implements] = () => [typed_data.Float32x4List];
>+dart.setMethodSignature(_native_typed_data.NativeFloat32x4List, () => ({
>+  __proto__: dart.getMethods(_native_typed_data.NativeFloat32x4List.__proto__),
>+  _get: dart.fnType(typed_data.Float32x4, [core.int]),
>+  [$_get]: dart.fnType(typed_data.Float32x4, [core.int]),
>+  _set: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  sublist: dart.fnType(core.List$(typed_data.Float32x4), [core.int], [core.int]),
>+  [$sublist]: dart.fnType(core.List$(typed_data.Float32x4), [core.int], [core.int])
>+}));
>+dart.setGetterSignature(_native_typed_data.NativeFloat32x4List, () => ({
>+  __proto__: dart.getGetters(_native_typed_data.NativeFloat32x4List.__proto__),
>+  buffer: typed_data.ByteBuffer,
>+  [$buffer]: typed_data.ByteBuffer,
>+  lengthInBytes: core.int,
>+  [$lengthInBytes]: core.int,
>+  offsetInBytes: core.int,
>+  [$offsetInBytes]: core.int,
>+  elementSizeInBytes: core.int,
>+  [$elementSizeInBytes]: core.int,
>+  length: core.int,
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(_native_typed_data.NativeFloat32x4List, "dart:_native_typed_data");
>+dart.setFieldSignature(_native_typed_data.NativeFloat32x4List, () => ({
>+  __proto__: dart.getFields(_native_typed_data.NativeFloat32x4List.__proto__),
>+  [_storage]: dart.finalFieldType(_native_typed_data.NativeFloat32List)
>+}));
>+dart.defineExtensionMethods(_native_typed_data.NativeFloat32x4List, ['_get', '_set', 'sublist']);
>+dart.defineExtensionAccessors(_native_typed_data.NativeFloat32x4List, [
>+  'runtimeType',
>+  'buffer',
>+  'lengthInBytes',
>+  'offsetInBytes',
>+  'elementSizeInBytes',
>+  'length'
>+]);
>+typed_data.Int32x4 = class Int32x4 extends core.Object {
>+  static new(x, y, z, w) {
>+    return new _native_typed_data.NativeInt32x4.new(x, y, z, w);
>+  }
>+  static bool(x, y, z, w) {
>+    return new _native_typed_data.NativeInt32x4.bool(x, y, z, w);
>+  }
>+  static fromFloat32x4Bits(x) {
>+    return _native_typed_data.NativeInt32x4.fromFloat32x4Bits(x);
>+  }
>+};
>+(typed_data.Int32x4[dart.mixinNew] = function() {
>+}).prototype = typed_data.Int32x4.prototype;
>+dart.addTypeTests(typed_data.Int32x4);
>+dart.setLibraryUri(typed_data.Int32x4, "dart:typed_data");
>+dart.defineLazy(typed_data.Int32x4, {
>+  /*typed_data.Int32x4.xxxx*/get xxxx() {
>+    return 0;
>+  },
>+  /*typed_data.Int32x4.xxxy*/get xxxy() {
>+    return 64;
>+  },
>+  /*typed_data.Int32x4.xxxz*/get xxxz() {
>+    return 128;
>+  },
>+  /*typed_data.Int32x4.xxxw*/get xxxw() {
>+    return 192;
>+  },
>+  /*typed_data.Int32x4.xxyx*/get xxyx() {
>+    return 16;
>+  },
>+  /*typed_data.Int32x4.xxyy*/get xxyy() {
>+    return 80;
>+  },
>+  /*typed_data.Int32x4.xxyz*/get xxyz() {
>+    return 144;
>+  },
>+  /*typed_data.Int32x4.xxyw*/get xxyw() {
>+    return 208;
>+  },
>+  /*typed_data.Int32x4.xxzx*/get xxzx() {
>+    return 32;
>+  },
>+  /*typed_data.Int32x4.xxzy*/get xxzy() {
>+    return 96;
>+  },
>+  /*typed_data.Int32x4.xxzz*/get xxzz() {
>+    return 160;
>+  },
>+  /*typed_data.Int32x4.xxzw*/get xxzw() {
>+    return 224;
>+  },
>+  /*typed_data.Int32x4.xxwx*/get xxwx() {
>+    return 48;
>+  },
>+  /*typed_data.Int32x4.xxwy*/get xxwy() {
>+    return 112;
>+  },
>+  /*typed_data.Int32x4.xxwz*/get xxwz() {
>+    return 176;
>+  },
>+  /*typed_data.Int32x4.xxww*/get xxww() {
>+    return 240;
>+  },
>+  /*typed_data.Int32x4.xyxx*/get xyxx() {
>+    return 4;
>+  },
>+  /*typed_data.Int32x4.xyxy*/get xyxy() {
>+    return 68;
>+  },
>+  /*typed_data.Int32x4.xyxz*/get xyxz() {
>+    return 132;
>+  },
>+  /*typed_data.Int32x4.xyxw*/get xyxw() {
>+    return 196;
>+  },
>+  /*typed_data.Int32x4.xyyx*/get xyyx() {
>+    return 20;
>+  },
>+  /*typed_data.Int32x4.xyyy*/get xyyy() {
>+    return 84;
>+  },
>+  /*typed_data.Int32x4.xyyz*/get xyyz() {
>+    return 148;
>+  },
>+  /*typed_data.Int32x4.xyyw*/get xyyw() {
>+    return 212;
>+  },
>+  /*typed_data.Int32x4.xyzx*/get xyzx() {
>+    return 36;
>+  },
>+  /*typed_data.Int32x4.xyzy*/get xyzy() {
>+    return 100;
>+  },
>+  /*typed_data.Int32x4.xyzz*/get xyzz() {
>+    return 164;
>+  },
>+  /*typed_data.Int32x4.xyzw*/get xyzw() {
>+    return 228;
>+  },
>+  /*typed_data.Int32x4.xywx*/get xywx() {
>+    return 52;
>+  },
>+  /*typed_data.Int32x4.xywy*/get xywy() {
>+    return 116;
>+  },
>+  /*typed_data.Int32x4.xywz*/get xywz() {
>+    return 180;
>+  },
>+  /*typed_data.Int32x4.xyww*/get xyww() {
>+    return 244;
>+  },
>+  /*typed_data.Int32x4.xzxx*/get xzxx() {
>+    return 8;
>+  },
>+  /*typed_data.Int32x4.xzxy*/get xzxy() {
>+    return 72;
>+  },
>+  /*typed_data.Int32x4.xzxz*/get xzxz() {
>+    return 136;
>+  },
>+  /*typed_data.Int32x4.xzxw*/get xzxw() {
>+    return 200;
>+  },
>+  /*typed_data.Int32x4.xzyx*/get xzyx() {
>+    return 24;
>+  },
>+  /*typed_data.Int32x4.xzyy*/get xzyy() {
>+    return 88;
>+  },
>+  /*typed_data.Int32x4.xzyz*/get xzyz() {
>+    return 152;
>+  },
>+  /*typed_data.Int32x4.xzyw*/get xzyw() {
>+    return 216;
>+  },
>+  /*typed_data.Int32x4.xzzx*/get xzzx() {
>+    return 40;
>+  },
>+  /*typed_data.Int32x4.xzzy*/get xzzy() {
>+    return 104;
>+  },
>+  /*typed_data.Int32x4.xzzz*/get xzzz() {
>+    return 168;
>+  },
>+  /*typed_data.Int32x4.xzzw*/get xzzw() {
>+    return 232;
>+  },
>+  /*typed_data.Int32x4.xzwx*/get xzwx() {
>+    return 56;
>+  },
>+  /*typed_data.Int32x4.xzwy*/get xzwy() {
>+    return 120;
>+  },
>+  /*typed_data.Int32x4.xzwz*/get xzwz() {
>+    return 184;
>+  },
>+  /*typed_data.Int32x4.xzww*/get xzww() {
>+    return 248;
>+  },
>+  /*typed_data.Int32x4.xwxx*/get xwxx() {
>+    return 12;
>+  },
>+  /*typed_data.Int32x4.xwxy*/get xwxy() {
>+    return 76;
>+  },
>+  /*typed_data.Int32x4.xwxz*/get xwxz() {
>+    return 140;
>+  },
>+  /*typed_data.Int32x4.xwxw*/get xwxw() {
>+    return 204;
>+  },
>+  /*typed_data.Int32x4.xwyx*/get xwyx() {
>+    return 28;
>+  },
>+  /*typed_data.Int32x4.xwyy*/get xwyy() {
>+    return 92;
>+  },
>+  /*typed_data.Int32x4.xwyz*/get xwyz() {
>+    return 156;
>+  },
>+  /*typed_data.Int32x4.xwyw*/get xwyw() {
>+    return 220;
>+  },
>+  /*typed_data.Int32x4.xwzx*/get xwzx() {
>+    return 44;
>+  },
>+  /*typed_data.Int32x4.xwzy*/get xwzy() {
>+    return 108;
>+  },
>+  /*typed_data.Int32x4.xwzz*/get xwzz() {
>+    return 172;
>+  },
>+  /*typed_data.Int32x4.xwzw*/get xwzw() {
>+    return 236;
>+  },
>+  /*typed_data.Int32x4.xwwx*/get xwwx() {
>+    return 60;
>+  },
>+  /*typed_data.Int32x4.xwwy*/get xwwy() {
>+    return 124;
>+  },
>+  /*typed_data.Int32x4.xwwz*/get xwwz() {
>+    return 188;
>+  },
>+  /*typed_data.Int32x4.xwww*/get xwww() {
>+    return 252;
>+  },
>+  /*typed_data.Int32x4.yxxx*/get yxxx() {
>+    return 1;
>+  },
>+  /*typed_data.Int32x4.yxxy*/get yxxy() {
>+    return 65;
>+  },
>+  /*typed_data.Int32x4.yxxz*/get yxxz() {
>+    return 129;
>+  },
>+  /*typed_data.Int32x4.yxxw*/get yxxw() {
>+    return 193;
>+  },
>+  /*typed_data.Int32x4.yxyx*/get yxyx() {
>+    return 17;
>+  },
>+  /*typed_data.Int32x4.yxyy*/get yxyy() {
>+    return 81;
>+  },
>+  /*typed_data.Int32x4.yxyz*/get yxyz() {
>+    return 145;
>+  },
>+  /*typed_data.Int32x4.yxyw*/get yxyw() {
>+    return 209;
>+  },
>+  /*typed_data.Int32x4.yxzx*/get yxzx() {
>+    return 33;
>+  },
>+  /*typed_data.Int32x4.yxzy*/get yxzy() {
>+    return 97;
>+  },
>+  /*typed_data.Int32x4.yxzz*/get yxzz() {
>+    return 161;
>+  },
>+  /*typed_data.Int32x4.yxzw*/get yxzw() {
>+    return 225;
>+  },
>+  /*typed_data.Int32x4.yxwx*/get yxwx() {
>+    return 49;
>+  },
>+  /*typed_data.Int32x4.yxwy*/get yxwy() {
>+    return 113;
>+  },
>+  /*typed_data.Int32x4.yxwz*/get yxwz() {
>+    return 177;
>+  },
>+  /*typed_data.Int32x4.yxww*/get yxww() {
>+    return 241;
>+  },
>+  /*typed_data.Int32x4.yyxx*/get yyxx() {
>+    return 5;
>+  },
>+  /*typed_data.Int32x4.yyxy*/get yyxy() {
>+    return 69;
>+  },
>+  /*typed_data.Int32x4.yyxz*/get yyxz() {
>+    return 133;
>+  },
>+  /*typed_data.Int32x4.yyxw*/get yyxw() {
>+    return 197;
>+  },
>+  /*typed_data.Int32x4.yyyx*/get yyyx() {
>+    return 21;
>+  },
>+  /*typed_data.Int32x4.yyyy*/get yyyy() {
>+    return 85;
>+  },
>+  /*typed_data.Int32x4.yyyz*/get yyyz() {
>+    return 149;
>+  },
>+  /*typed_data.Int32x4.yyyw*/get yyyw() {
>+    return 213;
>+  },
>+  /*typed_data.Int32x4.yyzx*/get yyzx() {
>+    return 37;
>+  },
>+  /*typed_data.Int32x4.yyzy*/get yyzy() {
>+    return 101;
>+  },
>+  /*typed_data.Int32x4.yyzz*/get yyzz() {
>+    return 165;
>+  },
>+  /*typed_data.Int32x4.yyzw*/get yyzw() {
>+    return 229;
>+  },
>+  /*typed_data.Int32x4.yywx*/get yywx() {
>+    return 53;
>+  },
>+  /*typed_data.Int32x4.yywy*/get yywy() {
>+    return 117;
>+  },
>+  /*typed_data.Int32x4.yywz*/get yywz() {
>+    return 181;
>+  },
>+  /*typed_data.Int32x4.yyww*/get yyww() {
>+    return 245;
>+  },
>+  /*typed_data.Int32x4.yzxx*/get yzxx() {
>+    return 9;
>+  },
>+  /*typed_data.Int32x4.yzxy*/get yzxy() {
>+    return 73;
>+  },
>+  /*typed_data.Int32x4.yzxz*/get yzxz() {
>+    return 137;
>+  },
>+  /*typed_data.Int32x4.yzxw*/get yzxw() {
>+    return 201;
>+  },
>+  /*typed_data.Int32x4.yzyx*/get yzyx() {
>+    return 25;
>+  },
>+  /*typed_data.Int32x4.yzyy*/get yzyy() {
>+    return 89;
>+  },
>+  /*typed_data.Int32x4.yzyz*/get yzyz() {
>+    return 153;
>+  },
>+  /*typed_data.Int32x4.yzyw*/get yzyw() {
>+    return 217;
>+  },
>+  /*typed_data.Int32x4.yzzx*/get yzzx() {
>+    return 41;
>+  },
>+  /*typed_data.Int32x4.yzzy*/get yzzy() {
>+    return 105;
>+  },
>+  /*typed_data.Int32x4.yzzz*/get yzzz() {
>+    return 169;
>+  },
>+  /*typed_data.Int32x4.yzzw*/get yzzw() {
>+    return 233;
>+  },
>+  /*typed_data.Int32x4.yzwx*/get yzwx() {
>+    return 57;
>+  },
>+  /*typed_data.Int32x4.yzwy*/get yzwy() {
>+    return 121;
>+  },
>+  /*typed_data.Int32x4.yzwz*/get yzwz() {
>+    return 185;
>+  },
>+  /*typed_data.Int32x4.yzww*/get yzww() {
>+    return 249;
>+  },
>+  /*typed_data.Int32x4.ywxx*/get ywxx() {
>+    return 13;
>+  },
>+  /*typed_data.Int32x4.ywxy*/get ywxy() {
>+    return 77;
>+  },
>+  /*typed_data.Int32x4.ywxz*/get ywxz() {
>+    return 141;
>+  },
>+  /*typed_data.Int32x4.ywxw*/get ywxw() {
>+    return 205;
>+  },
>+  /*typed_data.Int32x4.ywyx*/get ywyx() {
>+    return 29;
>+  },
>+  /*typed_data.Int32x4.ywyy*/get ywyy() {
>+    return 93;
>+  },
>+  /*typed_data.Int32x4.ywyz*/get ywyz() {
>+    return 157;
>+  },
>+  /*typed_data.Int32x4.ywyw*/get ywyw() {
>+    return 221;
>+  },
>+  /*typed_data.Int32x4.ywzx*/get ywzx() {
>+    return 45;
>+  },
>+  /*typed_data.Int32x4.ywzy*/get ywzy() {
>+    return 109;
>+  },
>+  /*typed_data.Int32x4.ywzz*/get ywzz() {
>+    return 173;
>+  },
>+  /*typed_data.Int32x4.ywzw*/get ywzw() {
>+    return 237;
>+  },
>+  /*typed_data.Int32x4.ywwx*/get ywwx() {
>+    return 61;
>+  },
>+  /*typed_data.Int32x4.ywwy*/get ywwy() {
>+    return 125;
>+  },
>+  /*typed_data.Int32x4.ywwz*/get ywwz() {
>+    return 189;
>+  },
>+  /*typed_data.Int32x4.ywww*/get ywww() {
>+    return 253;
>+  },
>+  /*typed_data.Int32x4.zxxx*/get zxxx() {
>+    return 2;
>+  },
>+  /*typed_data.Int32x4.zxxy*/get zxxy() {
>+    return 66;
>+  },
>+  /*typed_data.Int32x4.zxxz*/get zxxz() {
>+    return 130;
>+  },
>+  /*typed_data.Int32x4.zxxw*/get zxxw() {
>+    return 194;
>+  },
>+  /*typed_data.Int32x4.zxyx*/get zxyx() {
>+    return 18;
>+  },
>+  /*typed_data.Int32x4.zxyy*/get zxyy() {
>+    return 82;
>+  },
>+  /*typed_data.Int32x4.zxyz*/get zxyz() {
>+    return 146;
>+  },
>+  /*typed_data.Int32x4.zxyw*/get zxyw() {
>+    return 210;
>+  },
>+  /*typed_data.Int32x4.zxzx*/get zxzx() {
>+    return 34;
>+  },
>+  /*typed_data.Int32x4.zxzy*/get zxzy() {
>+    return 98;
>+  },
>+  /*typed_data.Int32x4.zxzz*/get zxzz() {
>+    return 162;
>+  },
>+  /*typed_data.Int32x4.zxzw*/get zxzw() {
>+    return 226;
>+  },
>+  /*typed_data.Int32x4.zxwx*/get zxwx() {
>+    return 50;
>+  },
>+  /*typed_data.Int32x4.zxwy*/get zxwy() {
>+    return 114;
>+  },
>+  /*typed_data.Int32x4.zxwz*/get zxwz() {
>+    return 178;
>+  },
>+  /*typed_data.Int32x4.zxww*/get zxww() {
>+    return 242;
>+  },
>+  /*typed_data.Int32x4.zyxx*/get zyxx() {
>+    return 6;
>+  },
>+  /*typed_data.Int32x4.zyxy*/get zyxy() {
>+    return 70;
>+  },
>+  /*typed_data.Int32x4.zyxz*/get zyxz() {
>+    return 134;
>+  },
>+  /*typed_data.Int32x4.zyxw*/get zyxw() {
>+    return 198;
>+  },
>+  /*typed_data.Int32x4.zyyx*/get zyyx() {
>+    return 22;
>+  },
>+  /*typed_data.Int32x4.zyyy*/get zyyy() {
>+    return 86;
>+  },
>+  /*typed_data.Int32x4.zyyz*/get zyyz() {
>+    return 150;
>+  },
>+  /*typed_data.Int32x4.zyyw*/get zyyw() {
>+    return 214;
>+  },
>+  /*typed_data.Int32x4.zyzx*/get zyzx() {
>+    return 38;
>+  },
>+  /*typed_data.Int32x4.zyzy*/get zyzy() {
>+    return 102;
>+  },
>+  /*typed_data.Int32x4.zyzz*/get zyzz() {
>+    return 166;
>+  },
>+  /*typed_data.Int32x4.zyzw*/get zyzw() {
>+    return 230;
>+  },
>+  /*typed_data.Int32x4.zywx*/get zywx() {
>+    return 54;
>+  },
>+  /*typed_data.Int32x4.zywy*/get zywy() {
>+    return 118;
>+  },
>+  /*typed_data.Int32x4.zywz*/get zywz() {
>+    return 182;
>+  },
>+  /*typed_data.Int32x4.zyww*/get zyww() {
>+    return 246;
>+  },
>+  /*typed_data.Int32x4.zzxx*/get zzxx() {
>+    return 10;
>+  },
>+  /*typed_data.Int32x4.zzxy*/get zzxy() {
>+    return 74;
>+  },
>+  /*typed_data.Int32x4.zzxz*/get zzxz() {
>+    return 138;
>+  },
>+  /*typed_data.Int32x4.zzxw*/get zzxw() {
>+    return 202;
>+  },
>+  /*typed_data.Int32x4.zzyx*/get zzyx() {
>+    return 26;
>+  },
>+  /*typed_data.Int32x4.zzyy*/get zzyy() {
>+    return 90;
>+  },
>+  /*typed_data.Int32x4.zzyz*/get zzyz() {
>+    return 154;
>+  },
>+  /*typed_data.Int32x4.zzyw*/get zzyw() {
>+    return 218;
>+  },
>+  /*typed_data.Int32x4.zzzx*/get zzzx() {
>+    return 42;
>+  },
>+  /*typed_data.Int32x4.zzzy*/get zzzy() {
>+    return 106;
>+  },
>+  /*typed_data.Int32x4.zzzz*/get zzzz() {
>+    return 170;
>+  },
>+  /*typed_data.Int32x4.zzzw*/get zzzw() {
>+    return 234;
>+  },
>+  /*typed_data.Int32x4.zzwx*/get zzwx() {
>+    return 58;
>+  },
>+  /*typed_data.Int32x4.zzwy*/get zzwy() {
>+    return 122;
>+  },
>+  /*typed_data.Int32x4.zzwz*/get zzwz() {
>+    return 186;
>+  },
>+  /*typed_data.Int32x4.zzww*/get zzww() {
>+    return 250;
>+  },
>+  /*typed_data.Int32x4.zwxx*/get zwxx() {
>+    return 14;
>+  },
>+  /*typed_data.Int32x4.zwxy*/get zwxy() {
>+    return 78;
>+  },
>+  /*typed_data.Int32x4.zwxz*/get zwxz() {
>+    return 142;
>+  },
>+  /*typed_data.Int32x4.zwxw*/get zwxw() {
>+    return 206;
>+  },
>+  /*typed_data.Int32x4.zwyx*/get zwyx() {
>+    return 30;
>+  },
>+  /*typed_data.Int32x4.zwyy*/get zwyy() {
>+    return 94;
>+  },
>+  /*typed_data.Int32x4.zwyz*/get zwyz() {
>+    return 158;
>+  },
>+  /*typed_data.Int32x4.zwyw*/get zwyw() {
>+    return 222;
>+  },
>+  /*typed_data.Int32x4.zwzx*/get zwzx() {
>+    return 46;
>+  },
>+  /*typed_data.Int32x4.zwzy*/get zwzy() {
>+    return 110;
>+  },
>+  /*typed_data.Int32x4.zwzz*/get zwzz() {
>+    return 174;
>+  },
>+  /*typed_data.Int32x4.zwzw*/get zwzw() {
>+    return 238;
>+  },
>+  /*typed_data.Int32x4.zwwx*/get zwwx() {
>+    return 62;
>+  },
>+  /*typed_data.Int32x4.zwwy*/get zwwy() {
>+    return 126;
>+  },
>+  /*typed_data.Int32x4.zwwz*/get zwwz() {
>+    return 190;
>+  },
>+  /*typed_data.Int32x4.zwww*/get zwww() {
>+    return 254;
>+  },
>+  /*typed_data.Int32x4.wxxx*/get wxxx() {
>+    return 3;
>+  },
>+  /*typed_data.Int32x4.wxxy*/get wxxy() {
>+    return 67;
>+  },
>+  /*typed_data.Int32x4.wxxz*/get wxxz() {
>+    return 131;
>+  },
>+  /*typed_data.Int32x4.wxxw*/get wxxw() {
>+    return 195;
>+  },
>+  /*typed_data.Int32x4.wxyx*/get wxyx() {
>+    return 19;
>+  },
>+  /*typed_data.Int32x4.wxyy*/get wxyy() {
>+    return 83;
>+  },
>+  /*typed_data.Int32x4.wxyz*/get wxyz() {
>+    return 147;
>+  },
>+  /*typed_data.Int32x4.wxyw*/get wxyw() {
>+    return 211;
>+  },
>+  /*typed_data.Int32x4.wxzx*/get wxzx() {
>+    return 35;
>+  },
>+  /*typed_data.Int32x4.wxzy*/get wxzy() {
>+    return 99;
>+  },
>+  /*typed_data.Int32x4.wxzz*/get wxzz() {
>+    return 163;
>+  },
>+  /*typed_data.Int32x4.wxzw*/get wxzw() {
>+    return 227;
>+  },
>+  /*typed_data.Int32x4.wxwx*/get wxwx() {
>+    return 51;
>+  },
>+  /*typed_data.Int32x4.wxwy*/get wxwy() {
>+    return 115;
>+  },
>+  /*typed_data.Int32x4.wxwz*/get wxwz() {
>+    return 179;
>+  },
>+  /*typed_data.Int32x4.wxww*/get wxww() {
>+    return 243;
>+  },
>+  /*typed_data.Int32x4.wyxx*/get wyxx() {
>+    return 7;
>+  },
>+  /*typed_data.Int32x4.wyxy*/get wyxy() {
>+    return 71;
>+  },
>+  /*typed_data.Int32x4.wyxz*/get wyxz() {
>+    return 135;
>+  },
>+  /*typed_data.Int32x4.wyxw*/get wyxw() {
>+    return 199;
>+  },
>+  /*typed_data.Int32x4.wyyx*/get wyyx() {
>+    return 23;
>+  },
>+  /*typed_data.Int32x4.wyyy*/get wyyy() {
>+    return 87;
>+  },
>+  /*typed_data.Int32x4.wyyz*/get wyyz() {
>+    return 151;
>+  },
>+  /*typed_data.Int32x4.wyyw*/get wyyw() {
>+    return 215;
>+  },
>+  /*typed_data.Int32x4.wyzx*/get wyzx() {
>+    return 39;
>+  },
>+  /*typed_data.Int32x4.wyzy*/get wyzy() {
>+    return 103;
>+  },
>+  /*typed_data.Int32x4.wyzz*/get wyzz() {
>+    return 167;
>+  },
>+  /*typed_data.Int32x4.wyzw*/get wyzw() {
>+    return 231;
>+  },
>+  /*typed_data.Int32x4.wywx*/get wywx() {
>+    return 55;
>+  },
>+  /*typed_data.Int32x4.wywy*/get wywy() {
>+    return 119;
>+  },
>+  /*typed_data.Int32x4.wywz*/get wywz() {
>+    return 183;
>+  },
>+  /*typed_data.Int32x4.wyww*/get wyww() {
>+    return 247;
>+  },
>+  /*typed_data.Int32x4.wzxx*/get wzxx() {
>+    return 11;
>+  },
>+  /*typed_data.Int32x4.wzxy*/get wzxy() {
>+    return 75;
>+  },
>+  /*typed_data.Int32x4.wzxz*/get wzxz() {
>+    return 139;
>+  },
>+  /*typed_data.Int32x4.wzxw*/get wzxw() {
>+    return 203;
>+  },
>+  /*typed_data.Int32x4.wzyx*/get wzyx() {
>+    return 27;
>+  },
>+  /*typed_data.Int32x4.wzyy*/get wzyy() {
>+    return 91;
>+  },
>+  /*typed_data.Int32x4.wzyz*/get wzyz() {
>+    return 155;
>+  },
>+  /*typed_data.Int32x4.wzyw*/get wzyw() {
>+    return 219;
>+  },
>+  /*typed_data.Int32x4.wzzx*/get wzzx() {
>+    return 43;
>+  },
>+  /*typed_data.Int32x4.wzzy*/get wzzy() {
>+    return 107;
>+  },
>+  /*typed_data.Int32x4.wzzz*/get wzzz() {
>+    return 171;
>+  },
>+  /*typed_data.Int32x4.wzzw*/get wzzw() {
>+    return 235;
>+  },
>+  /*typed_data.Int32x4.wzwx*/get wzwx() {
>+    return 59;
>+  },
>+  /*typed_data.Int32x4.wzwy*/get wzwy() {
>+    return 123;
>+  },
>+  /*typed_data.Int32x4.wzwz*/get wzwz() {
>+    return 187;
>+  },
>+  /*typed_data.Int32x4.wzww*/get wzww() {
>+    return 251;
>+  },
>+  /*typed_data.Int32x4.wwxx*/get wwxx() {
>+    return 15;
>+  },
>+  /*typed_data.Int32x4.wwxy*/get wwxy() {
>+    return 79;
>+  },
>+  /*typed_data.Int32x4.wwxz*/get wwxz() {
>+    return 143;
>+  },
>+  /*typed_data.Int32x4.wwxw*/get wwxw() {
>+    return 207;
>+  },
>+  /*typed_data.Int32x4.wwyx*/get wwyx() {
>+    return 31;
>+  },
>+  /*typed_data.Int32x4.wwyy*/get wwyy() {
>+    return 95;
>+  },
>+  /*typed_data.Int32x4.wwyz*/get wwyz() {
>+    return 159;
>+  },
>+  /*typed_data.Int32x4.wwyw*/get wwyw() {
>+    return 223;
>+  },
>+  /*typed_data.Int32x4.wwzx*/get wwzx() {
>+    return 47;
>+  },
>+  /*typed_data.Int32x4.wwzy*/get wwzy() {
>+    return 111;
>+  },
>+  /*typed_data.Int32x4.wwzz*/get wwzz() {
>+    return 175;
>+  },
>+  /*typed_data.Int32x4.wwzw*/get wwzw() {
>+    return 239;
>+  },
>+  /*typed_data.Int32x4.wwwx*/get wwwx() {
>+    return 63;
>+  },
>+  /*typed_data.Int32x4.wwwy*/get wwwy() {
>+    return 127;
>+  },
>+  /*typed_data.Int32x4.wwwz*/get wwwz() {
>+    return 191;
>+  },
>+  /*typed_data.Int32x4.wwww*/get wwww() {
>+    return 255;
>+  }
>+});
>+const Object_ListMixin$$ = class Object_ListMixin extends core.Object {};
>+(Object_ListMixin$$.new = function() {
>+}).prototype = Object_ListMixin$$.prototype;
>+dart.applyMixin(Object_ListMixin$$, collection.ListMixin$(typed_data.Int32x4));
>+const Object_FixedLengthListMixin$$ = class Object_FixedLengthListMixin extends Object_ListMixin$$ {};
>+(Object_FixedLengthListMixin$$.new = function() {
>+}).prototype = Object_FixedLengthListMixin$$.prototype;
>+dart.applyMixin(Object_FixedLengthListMixin$$, _internal.FixedLengthListMixin$(typed_data.Int32x4));
>+_native_typed_data.NativeInt32x4List = class NativeInt32x4List extends Object_FixedLengthListMixin$$ {
>+  get runtimeType() {
>+    return dart.wrapType(typed_data.Int32x4List);
>+  }
>+  static fromList(list) {
>+    if (_native_typed_data.NativeInt32x4List.is(list)) {
>+      return new _native_typed_data.NativeInt32x4List._externalStorage(_native_typed_data.NativeInt32List.fromList(list[_storage]));
>+    } else {
>+      return new _native_typed_data.NativeInt32x4List._slowFromList(list);
>+    }
>+  }
>+  get buffer() {
>+    return this[_storage][$buffer];
>+  }
>+  get lengthInBytes() {
>+    return this[_storage][$lengthInBytes];
>+  }
>+  get offsetInBytes() {
>+    return this[_storage][$offsetInBytes];
>+  }
>+  get elementSizeInBytes() {
>+    return typed_data.Int32x4List.bytesPerElement;
>+  }
>+  get length() {
>+    return (dart.notNull(this[_storage][$length]) / 4)[$truncate]();
>+  }
>+  set length(value) {
>+    super.length = value;
>+  }
>+  _get(index) {
>+    _native_typed_data._checkValidIndex(index, this, this.length);
>+    let _x = this[_storage][$_get](dart.notNull(index) * 4 + 0);
>+    let _y = this[_storage][$_get](dart.notNull(index) * 4 + 1);
>+    let _z = this[_storage][$_get](dart.notNull(index) * 4 + 2);
>+    let _w = this[_storage][$_get](dart.notNull(index) * 4 + 3);
>+    return new _native_typed_data.NativeInt32x4._truncated(_x, _y, _z, _w);
>+  }
>+  _set(index, value) {
>+    typed_data.Int32x4._check(value);
>+    _native_typed_data._checkValidIndex(index, this, this.length);
>+    this[_storage][$_set](dart.notNull(index) * 4 + 0, value.x);
>+    this[_storage][$_set](dart.notNull(index) * 4 + 1, value.y);
>+    this[_storage][$_set](dart.notNull(index) * 4 + 2, value.z);
>+    this[_storage][$_set](dart.notNull(index) * 4 + 3, value.w);
>+    return value;
>+  }
>+  sublist(start, end) {
>+    if (end === void 0) end = null;
>+    end = _native_typed_data._checkValidRange(start, end, this.length);
>+    return new _native_typed_data.NativeInt32x4List._externalStorage(typed_data.Int32List._check(this[_storage][$sublist](dart.notNull(start) * 4, dart.notNull(end) * 4)));
>+  }
>+};
>+(_native_typed_data.NativeInt32x4List.new = function(length) {
>+  this[_storage] = _native_typed_data.NativeInt32List.new(dart.notNull(length) * 4);
>+}).prototype = _native_typed_data.NativeInt32x4List.prototype;
>+(_native_typed_data.NativeInt32x4List._externalStorage = function(storage) {
>+  this[_storage] = storage;
>+}).prototype = _native_typed_data.NativeInt32x4List.prototype;
>+(_native_typed_data.NativeInt32x4List._slowFromList = function(list) {
>+  this[_storage] = _native_typed_data.NativeInt32List.new(dart.notNull(list[$length]) * 4);
>+  for (let i = 0; i < dart.notNull(list[$length]); i++) {
>+    let e = list[$_get](i);
>+    this[_storage][$_set](i * 4 + 0, e.x);
>+    this[_storage][$_set](i * 4 + 1, e.y);
>+    this[_storage][$_set](i * 4 + 2, e.z);
>+    this[_storage][$_set](i * 4 + 3, e.w);
>+  }
>+}).prototype = _native_typed_data.NativeInt32x4List.prototype;
>+dart.addTypeTests(_native_typed_data.NativeInt32x4List);
>+_native_typed_data.NativeInt32x4List[dart.implements] = () => [typed_data.Int32x4List];
>+dart.setMethodSignature(_native_typed_data.NativeInt32x4List, () => ({
>+  __proto__: dart.getMethods(_native_typed_data.NativeInt32x4List.__proto__),
>+  _get: dart.fnType(typed_data.Int32x4, [core.int]),
>+  [$_get]: dart.fnType(typed_data.Int32x4, [core.int]),
>+  _set: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  sublist: dart.fnType(core.List$(typed_data.Int32x4), [core.int], [core.int]),
>+  [$sublist]: dart.fnType(core.List$(typed_data.Int32x4), [core.int], [core.int])
>+}));
>+dart.setGetterSignature(_native_typed_data.NativeInt32x4List, () => ({
>+  __proto__: dart.getGetters(_native_typed_data.NativeInt32x4List.__proto__),
>+  buffer: typed_data.ByteBuffer,
>+  [$buffer]: typed_data.ByteBuffer,
>+  lengthInBytes: core.int,
>+  [$lengthInBytes]: core.int,
>+  offsetInBytes: core.int,
>+  [$offsetInBytes]: core.int,
>+  elementSizeInBytes: core.int,
>+  [$elementSizeInBytes]: core.int,
>+  length: core.int,
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(_native_typed_data.NativeInt32x4List, "dart:_native_typed_data");
>+dart.setFieldSignature(_native_typed_data.NativeInt32x4List, () => ({
>+  __proto__: dart.getFields(_native_typed_data.NativeInt32x4List.__proto__),
>+  [_storage]: dart.finalFieldType(typed_data.Int32List)
>+}));
>+dart.defineExtensionMethods(_native_typed_data.NativeInt32x4List, ['_get', '_set', 'sublist']);
>+dart.defineExtensionAccessors(_native_typed_data.NativeInt32x4List, [
>+  'runtimeType',
>+  'buffer',
>+  'lengthInBytes',
>+  'offsetInBytes',
>+  'elementSizeInBytes',
>+  'length'
>+]);
>+typed_data.Float64x2 = class Float64x2 extends core.Object {
>+  static new(x, y) {
>+    return new _native_typed_data.NativeFloat64x2.new(x, y);
>+  }
>+  static splat(v) {
>+    return new _native_typed_data.NativeFloat64x2.splat(v);
>+  }
>+  static zero() {
>+    return new _native_typed_data.NativeFloat64x2.zero();
>+  }
>+  static fromFloat32x4(v) {
>+    return new _native_typed_data.NativeFloat64x2.fromFloat32x4(v);
>+  }
>+};
>+(typed_data.Float64x2[dart.mixinNew] = function() {
>+}).prototype = typed_data.Float64x2.prototype;
>+dart.addTypeTests(typed_data.Float64x2);
>+dart.setLibraryUri(typed_data.Float64x2, "dart:typed_data");
>+const Object_ListMixin$$0 = class Object_ListMixin extends core.Object {};
>+(Object_ListMixin$$0.new = function() {
>+}).prototype = Object_ListMixin$$0.prototype;
>+dart.applyMixin(Object_ListMixin$$0, collection.ListMixin$(typed_data.Float64x2));
>+const Object_FixedLengthListMixin$$0 = class Object_FixedLengthListMixin extends Object_ListMixin$$0 {};
>+(Object_FixedLengthListMixin$$0.new = function() {
>+}).prototype = Object_FixedLengthListMixin$$0.prototype;
>+dart.applyMixin(Object_FixedLengthListMixin$$0, _internal.FixedLengthListMixin$(typed_data.Float64x2));
>+_native_typed_data.NativeFloat64x2List = class NativeFloat64x2List extends Object_FixedLengthListMixin$$0 {
>+  static fromList(list) {
>+    if (_native_typed_data.NativeFloat64x2List.is(list)) {
>+      return new _native_typed_data.NativeFloat64x2List._externalStorage(_native_typed_data.NativeFloat64List.fromList(list[_storage]));
>+    } else {
>+      return new _native_typed_data.NativeFloat64x2List._slowFromList(list);
>+    }
>+  }
>+  get runtimeType() {
>+    return dart.wrapType(typed_data.Float64x2List);
>+  }
>+  get buffer() {
>+    return this[_storage].buffer;
>+  }
>+  get lengthInBytes() {
>+    return this[_storage][$lengthInBytes];
>+  }
>+  get offsetInBytes() {
>+    return this[_storage][$offsetInBytes];
>+  }
>+  get elementSizeInBytes() {
>+    return typed_data.Float64x2List.bytesPerElement;
>+  }
>+  get length() {
>+    return (dart.notNull(this[_storage][$length]) / 2)[$truncate]();
>+  }
>+  set length(value) {
>+    super.length = value;
>+  }
>+  _get(index) {
>+    _native_typed_data._checkValidIndex(index, this, this.length);
>+    let _x = this[_storage][$_get](dart.notNull(index) * 2 + 0);
>+    let _y = this[_storage][$_get](dart.notNull(index) * 2 + 1);
>+    return typed_data.Float64x2.new(_x, _y);
>+  }
>+  _set(index, value) {
>+    typed_data.Float64x2._check(value);
>+    _native_typed_data._checkValidIndex(index, this, this.length);
>+    this[_storage][$_set](dart.notNull(index) * 2 + 0, value.x);
>+    this[_storage][$_set](dart.notNull(index) * 2 + 1, value.y);
>+    return value;
>+  }
>+  sublist(start, end) {
>+    if (end === void 0) end = null;
>+    end = _native_typed_data._checkValidRange(start, end, this.length);
>+    return new _native_typed_data.NativeFloat64x2List._externalStorage(_native_typed_data.NativeFloat64List._check(this[_storage][$sublist](dart.notNull(start) * 2, dart.notNull(end) * 2)));
>+  }
>+};
>+(_native_typed_data.NativeFloat64x2List.new = function(length) {
>+  this[_storage] = _native_typed_data.NativeFloat64List.new(dart.notNull(length) * 2);
>+}).prototype = _native_typed_data.NativeFloat64x2List.prototype;
>+(_native_typed_data.NativeFloat64x2List._externalStorage = function(storage) {
>+  this[_storage] = storage;
>+}).prototype = _native_typed_data.NativeFloat64x2List.prototype;
>+(_native_typed_data.NativeFloat64x2List._slowFromList = function(list) {
>+  this[_storage] = _native_typed_data.NativeFloat64List.new(dart.notNull(list[$length]) * 2);
>+  for (let i = 0; i < dart.notNull(list[$length]); i++) {
>+    let e = list[$_get](i);
>+    this[_storage][$_set](i * 2 + 0, e.x);
>+    this[_storage][$_set](i * 2 + 1, e.y);
>+  }
>+}).prototype = _native_typed_data.NativeFloat64x2List.prototype;
>+dart.addTypeTests(_native_typed_data.NativeFloat64x2List);
>+_native_typed_data.NativeFloat64x2List[dart.implements] = () => [typed_data.Float64x2List];
>+dart.setMethodSignature(_native_typed_data.NativeFloat64x2List, () => ({
>+  __proto__: dart.getMethods(_native_typed_data.NativeFloat64x2List.__proto__),
>+  _get: dart.fnType(typed_data.Float64x2, [core.int]),
>+  [$_get]: dart.fnType(typed_data.Float64x2, [core.int]),
>+  _set: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  sublist: dart.fnType(core.List$(typed_data.Float64x2), [core.int], [core.int]),
>+  [$sublist]: dart.fnType(core.List$(typed_data.Float64x2), [core.int], [core.int])
>+}));
>+dart.setGetterSignature(_native_typed_data.NativeFloat64x2List, () => ({
>+  __proto__: dart.getGetters(_native_typed_data.NativeFloat64x2List.__proto__),
>+  buffer: typed_data.ByteBuffer,
>+  [$buffer]: typed_data.ByteBuffer,
>+  lengthInBytes: core.int,
>+  [$lengthInBytes]: core.int,
>+  offsetInBytes: core.int,
>+  [$offsetInBytes]: core.int,
>+  elementSizeInBytes: core.int,
>+  [$elementSizeInBytes]: core.int,
>+  length: core.int,
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(_native_typed_data.NativeFloat64x2List, "dart:_native_typed_data");
>+dart.setFieldSignature(_native_typed_data.NativeFloat64x2List, () => ({
>+  __proto__: dart.getFields(_native_typed_data.NativeFloat64x2List.__proto__),
>+  [_storage]: dart.finalFieldType(_native_typed_data.NativeFloat64List)
>+}));
>+dart.defineExtensionMethods(_native_typed_data.NativeFloat64x2List, ['_get', '_set', 'sublist']);
>+dart.defineExtensionAccessors(_native_typed_data.NativeFloat64x2List, [
>+  'runtimeType',
>+  'buffer',
>+  'lengthInBytes',
>+  'offsetInBytes',
>+  'elementSizeInBytes',
>+  'length'
>+]);
>+const _invalidPosition = dart.privateName(_native_typed_data, "_invalidPosition");
>+const _checkPosition = dart.privateName(_native_typed_data, "_checkPosition");
>+_native_typed_data.NativeTypedData = class NativeTypedData extends core.Object {
>+  get [$buffer]() {
>+    return this.buffer;
>+  }
>+  get [$lengthInBytes]() {
>+    return this.byteLength;
>+  }
>+  get [$offsetInBytes]() {
>+    return this.byteOffset;
>+  }
>+  get [$elementSizeInBytes]() {
>+    return this.BYTES_PER_ELEMENT;
>+  }
>+  [_invalidPosition](position, length, name) {
>+    if (!core.int.is(position)) {
>+      dart.throw(new core.ArgumentError.value(position, name, "Invalid list position"));
>+    } else {
>+      dart.throw(new core.RangeError.range(position, 0, length, name));
>+    }
>+  }
>+  [_checkPosition](position, length, name) {
>+    if (position >>> 0 !== position || position > dart.notNull(length)) {
>+      this[_invalidPosition](position, length, name);
>+    }
>+  }
>+};
>+(_native_typed_data.NativeTypedData.new = function() {
>+}).prototype = _native_typed_data.NativeTypedData.prototype;
>+dart.addTypeTests(_native_typed_data.NativeTypedData);
>+_native_typed_data.NativeTypedData[dart.implements] = () => [typed_data.TypedData];
>+dart.setMethodSignature(_native_typed_data.NativeTypedData, () => ({
>+  __proto__: dart.getMethods(_native_typed_data.NativeTypedData.__proto__),
>+  [_invalidPosition]: dart.fnType(dart.void, [core.int, core.int, core.String]),
>+  [_checkPosition]: dart.fnType(dart.void, [core.int, core.int, core.String])
>+}));
>+dart.setGetterSignature(_native_typed_data.NativeTypedData, () => ({
>+  __proto__: dart.getGetters(_native_typed_data.NativeTypedData.__proto__),
>+  [$buffer]: typed_data.ByteBuffer,
>+  [$lengthInBytes]: core.int,
>+  [$offsetInBytes]: core.int,
>+  [$elementSizeInBytes]: core.int
>+}));
>+dart.setLibraryUri(_native_typed_data.NativeTypedData, "dart:_native_typed_data");
>+dart.registerExtension("ArrayBufferView", _native_typed_data.NativeTypedData);
>+_native_typed_data._checkLength = function(length) {
>+  if (!core.int.is(length)) dart.throw(new core.ArgumentError.new("Invalid length " + dart.str(length)));
>+  return core.int._check(length);
>+};
>+_native_typed_data._checkViewArguments = function(buffer, offsetInBytes, length) {
>+  if (!_native_typed_data.NativeByteBuffer.is(buffer)) {
>+    dart.throw(new core.ArgumentError.new("Invalid view buffer"));
>+  }
>+  if (!core.int.is(offsetInBytes)) {
>+    dart.throw(new core.ArgumentError.new("Invalid view offsetInBytes " + dart.str(offsetInBytes)));
>+  }
>+  if (length != null && !core.int.is(length)) {
>+    dart.throw(new core.ArgumentError.new("Invalid view length " + dart.str(length)));
>+  }
>+};
>+_native_typed_data._ensureNativeList = function(list) {
>+  if (_interceptors.JSIndexable.is(list)) return list;
>+  let result = core.List.new(list[$length]);
>+  for (let i = 0; i < dart.notNull(list[$length]); i++) {
>+    result[$_set](i, list[$_get](i));
>+  }
>+  return result;
>+};
>+const _getFloat32 = dart.privateName(_native_typed_data, "_getFloat32");
>+const _getFloat64 = dart.privateName(_native_typed_data, "_getFloat64");
>+const _getInt16 = dart.privateName(_native_typed_data, "_getInt16");
>+const _getInt32 = dart.privateName(_native_typed_data, "_getInt32");
>+const _getUint16 = dart.privateName(_native_typed_data, "_getUint16");
>+const _getUint32 = dart.privateName(_native_typed_data, "_getUint32");
>+const _setFloat32 = dart.privateName(_native_typed_data, "_setFloat32");
>+const _setFloat64 = dart.privateName(_native_typed_data, "_setFloat64");
>+const _setInt16 = dart.privateName(_native_typed_data, "_setInt16");
>+const _setInt32 = dart.privateName(_native_typed_data, "_setInt32");
>+const _setUint16 = dart.privateName(_native_typed_data, "_setUint16");
>+const _setUint32 = dart.privateName(_native_typed_data, "_setUint32");
>+_native_typed_data.NativeByteData = class NativeByteData extends _native_typed_data.NativeTypedData {
>+  static new(length) {
>+    return _native_typed_data.NativeByteData._create1(_native_typed_data._checkLength(length));
>+  }
>+  static view(buffer, offsetInBytes, length) {
>+    _native_typed_data._checkViewArguments(buffer, offsetInBytes, length);
>+    return length == null ? _native_typed_data.NativeByteData._create2(buffer, offsetInBytes) : _native_typed_data.NativeByteData._create3(buffer, offsetInBytes, length);
>+  }
>+  get [$runtimeType]() {
>+    return dart.wrapType(typed_data.ByteData);
>+  }
>+  get [$elementSizeInBytes]() {
>+    return 1;
>+  }
>+  [$getFloat32](byteOffset, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    return this[_getFloat32](byteOffset, typed_data.Endian.little._equals(endian));
>+  }
>+  [_getFloat32](...args) {
>+    return this.getFloat32.apply(this, args);
>+  }
>+  [$getFloat64](byteOffset, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    return this[_getFloat64](byteOffset, typed_data.Endian.little._equals(endian));
>+  }
>+  [_getFloat64](...args) {
>+    return this.getFloat64.apply(this, args);
>+  }
>+  [$getInt16](byteOffset, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    return this[_getInt16](byteOffset, typed_data.Endian.little._equals(endian));
>+  }
>+  [_getInt16](...args) {
>+    return this.getInt16.apply(this, args);
>+  }
>+  [$getInt32](byteOffset, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    return this[_getInt32](byteOffset, typed_data.Endian.little._equals(endian));
>+  }
>+  [_getInt32](...args) {
>+    return this.getInt32.apply(this, args);
>+  }
>+  [$getInt64](byteOffset, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    dart.throw(new core.UnsupportedError.new("Int64 accessor not supported by dart2js."));
>+  }
>+  [$getInt8](...args) {
>+    return this.getInt8.apply(this, args);
>+  }
>+  [$getUint16](byteOffset, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    return this[_getUint16](byteOffset, typed_data.Endian.little._equals(endian));
>+  }
>+  [_getUint16](...args) {
>+    return this.getUint16.apply(this, args);
>+  }
>+  [$getUint32](byteOffset, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    return this[_getUint32](byteOffset, typed_data.Endian.little._equals(endian));
>+  }
>+  [_getUint32](...args) {
>+    return this.getUint32.apply(this, args);
>+  }
>+  [$getUint64](byteOffset, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    dart.throw(new core.UnsupportedError.new("Uint64 accessor not supported by dart2js."));
>+  }
>+  [$getUint8](...args) {
>+    return this.getUint8.apply(this, args);
>+  }
>+  [$setFloat32](byteOffset, value, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    return this[_setFloat32](byteOffset, value, typed_data.Endian.little._equals(endian));
>+  }
>+  [_setFloat32](...args) {
>+    return this.setFloat32.apply(this, args);
>+  }
>+  [$setFloat64](byteOffset, value, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    return this[_setFloat64](byteOffset, value, typed_data.Endian.little._equals(endian));
>+  }
>+  [_setFloat64](...args) {
>+    return this.setFloat64.apply(this, args);
>+  }
>+  [$setInt16](byteOffset, value, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    return this[_setInt16](byteOffset, value, typed_data.Endian.little._equals(endian));
>+  }
>+  [_setInt16](...args) {
>+    return this.setInt16.apply(this, args);
>+  }
>+  [$setInt32](byteOffset, value, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    return this[_setInt32](byteOffset, value, typed_data.Endian.little._equals(endian));
>+  }
>+  [_setInt32](...args) {
>+    return this.setInt32.apply(this, args);
>+  }
>+  [$setInt64](byteOffset, value, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    dart.throw(new core.UnsupportedError.new("Int64 accessor not supported by dart2js."));
>+  }
>+  [$setInt8](...args) {
>+    return this.setInt8.apply(this, args);
>+  }
>+  [$setUint16](byteOffset, value, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    return this[_setUint16](byteOffset, value, typed_data.Endian.little._equals(endian));
>+  }
>+  [_setUint16](...args) {
>+    return this.setUint16.apply(this, args);
>+  }
>+  [$setUint32](byteOffset, value, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    return this[_setUint32](byteOffset, value, typed_data.Endian.little._equals(endian));
>+  }
>+  [_setUint32](...args) {
>+    return this.setUint32.apply(this, args);
>+  }
>+  [$setUint64](byteOffset, value, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    dart.throw(new core.UnsupportedError.new("Uint64 accessor not supported by dart2js."));
>+  }
>+  [$setUint8](...args) {
>+    return this.setUint8.apply(this, args);
>+  }
>+  static _create1(arg) {
>+    return new DataView(new ArrayBuffer(arg));
>+  }
>+  static _create2(arg1, arg2) {
>+    return new DataView(arg1, arg2);
>+  }
>+  static _create3(arg1, arg2, arg3) {
>+    return new DataView(arg1, arg2, arg3);
>+  }
>+};
>+dart.addTypeTests(_native_typed_data.NativeByteData);
>+_native_typed_data.NativeByteData[dart.implements] = () => [typed_data.ByteData];
>+dart.setMethodSignature(_native_typed_data.NativeByteData, () => ({
>+  __proto__: dart.getMethods(_native_typed_data.NativeByteData.__proto__),
>+  [$getFloat32]: dart.fnType(core.double, [core.int], [typed_data.Endian]),
>+  [_getFloat32]: dart.fnType(core.double, [core.int], [core.bool]),
>+  [$getFloat64]: dart.fnType(core.double, [core.int], [typed_data.Endian]),
>+  [_getFloat64]: dart.fnType(core.double, [core.int], [core.bool]),
>+  [$getInt16]: dart.fnType(core.int, [core.int], [typed_data.Endian]),
>+  [_getInt16]: dart.fnType(core.int, [core.int], [core.bool]),
>+  [$getInt32]: dart.fnType(core.int, [core.int], [typed_data.Endian]),
>+  [_getInt32]: dart.fnType(core.int, [core.int], [core.bool]),
>+  [$getInt64]: dart.fnType(core.int, [core.int], [typed_data.Endian]),
>+  [$getInt8]: dart.fnType(core.int, [core.int]),
>+  [$getUint16]: dart.fnType(core.int, [core.int], [typed_data.Endian]),
>+  [_getUint16]: dart.fnType(core.int, [core.int], [core.bool]),
>+  [$getUint32]: dart.fnType(core.int, [core.int], [typed_data.Endian]),
>+  [_getUint32]: dart.fnType(core.int, [core.int], [core.bool]),
>+  [$getUint64]: dart.fnType(core.int, [core.int], [typed_data.Endian]),
>+  [$getUint8]: dart.fnType(core.int, [core.int]),
>+  [$setFloat32]: dart.fnType(dart.void, [core.int, core.num], [typed_data.Endian]),
>+  [_setFloat32]: dart.fnType(dart.void, [core.int, core.num], [core.bool]),
>+  [$setFloat64]: dart.fnType(dart.void, [core.int, core.num], [typed_data.Endian]),
>+  [_setFloat64]: dart.fnType(dart.void, [core.int, core.num], [core.bool]),
>+  [$setInt16]: dart.fnType(dart.void, [core.int, core.int], [typed_data.Endian]),
>+  [_setInt16]: dart.fnType(dart.void, [core.int, core.int], [core.bool]),
>+  [$setInt32]: dart.fnType(dart.void, [core.int, core.int], [typed_data.Endian]),
>+  [_setInt32]: dart.fnType(dart.void, [core.int, core.int], [core.bool]),
>+  [$setInt64]: dart.fnType(dart.void, [core.int, core.int], [typed_data.Endian]),
>+  [$setInt8]: dart.fnType(dart.void, [core.int, core.int]),
>+  [$setUint16]: dart.fnType(dart.void, [core.int, core.int], [typed_data.Endian]),
>+  [_setUint16]: dart.fnType(dart.void, [core.int, core.int], [core.bool]),
>+  [$setUint32]: dart.fnType(dart.void, [core.int, core.int], [typed_data.Endian]),
>+  [_setUint32]: dart.fnType(dart.void, [core.int, core.int], [core.bool]),
>+  [$setUint64]: dart.fnType(dart.void, [core.int, core.int], [typed_data.Endian]),
>+  [$setUint8]: dart.fnType(dart.void, [core.int, core.int])
>+}));
>+dart.setLibraryUri(_native_typed_data.NativeByteData, "dart:_native_typed_data");
>+dart.registerExtension("DataView", _native_typed_data.NativeByteData);
>+const _setRangeFast = dart.privateName(_native_typed_data, "_setRangeFast");
>+_native_typed_data.NativeTypedArray = class NativeTypedArray extends _native_typed_data.NativeTypedData {
>+  [_setRangeFast](start, end, source, skipCount) {
>+    let targetLength = this[$length];
>+    this[_checkPosition](start, targetLength, "start");
>+    this[_checkPosition](end, targetLength, "end");
>+    if (dart.notNull(start) > dart.notNull(end)) dart.throw(new core.RangeError.range(start, 0, end));
>+    let count = dart.notNull(end) - dart.notNull(start);
>+    if (dart.notNull(skipCount) < 0) dart.throw(new core.ArgumentError.new(skipCount));
>+    let sourceLength = source[$length];
>+    if (dart.notNull(sourceLength) - dart.notNull(skipCount) < count) {
>+      dart.throw(new core.StateError.new("Not enough elements"));
>+    }
>+    if (skipCount !== 0 || sourceLength !== count) {
>+      source = source.subarray(skipCount, dart.notNull(skipCount) + count);
>+    }
>+    this.set(source, start);
>+  }
>+};
>+(_native_typed_data.NativeTypedArray.new = function() {
>+}).prototype = _native_typed_data.NativeTypedArray.prototype;
>+dart.addTypeTests(_native_typed_data.NativeTypedArray);
>+_native_typed_data.NativeTypedArray[dart.implements] = () => [_js_helper.JavaScriptIndexingBehavior];
>+dart.setMethodSignature(_native_typed_data.NativeTypedArray, () => ({
>+  __proto__: dart.getMethods(_native_typed_data.NativeTypedArray.__proto__),
>+  [_setRangeFast]: dart.fnType(dart.void, [core.int, core.int, _native_typed_data.NativeTypedArray, core.int])
>+}));
>+dart.setLibraryUri(_native_typed_data.NativeTypedArray, "dart:_native_typed_data");
>+core.double = class double extends core.num {
>+  static parse(source, onError) {
>+    if (onError === void 0) onError = null;
>+    return _js_helper.Primitives.parseDouble(source, onError);
>+  }
>+  static tryParse(source) {
>+    return _js_helper.Primitives.parseDouble(source, dart.fn(core._kNull, dynamicToNull()));
>+  }
>+};
>+(core.double.new = function() {
>+}).prototype = core.double.prototype;
>+core.double.is = function is_num(o) {
>+  return typeof o == "number";
>+};
>+core.double.as = function as_num(o) {
>+  if (typeof o == "number" || o == null) return o;
>+  return dart.as(o, core.double, false);
>+};
>+core.double._check = function check_num(o) {
>+  if (typeof o == "number" || o == null) return o;
>+  return dart.as(o, core.double, true);
>+};
>+dart.setLibraryUri(core.double, "dart:core");
>+dart.defineLazy(core.double, {
>+  /*core.double.nan*/get nan() {
>+    return 0.0 / 0.0;
>+  },
>+  /*core.double.infinity*/get infinity() {
>+    return 1.0 / 0.0;
>+  },
>+  /*core.double.negativeInfinity*/get negativeInfinity() {
>+    return -Infinity;
>+  },
>+  /*core.double.minPositive*/get minPositive() {
>+    return 5e-324;
>+  },
>+  /*core.double.maxFinite*/get maxFinite() {
>+    return 1.7976931348623157e+308;
>+  }
>+});
>+const NativeTypedArray_ListMixin$ = class NativeTypedArray_ListMixin extends _native_typed_data.NativeTypedArray {};
>+(NativeTypedArray_ListMixin$.new = function() {
>+}).prototype = NativeTypedArray_ListMixin$.prototype;
>+dart.applyMixin(NativeTypedArray_ListMixin$, collection.ListMixin$(core.double));
>+const NativeTypedArray_FixedLengthListMixin$ = class NativeTypedArray_FixedLengthListMixin extends NativeTypedArray_ListMixin$ {};
>+(NativeTypedArray_FixedLengthListMixin$.new = function() {
>+}).prototype = NativeTypedArray_FixedLengthListMixin$.prototype;
>+dart.applyMixin(NativeTypedArray_FixedLengthListMixin$, _internal.FixedLengthListMixin$(core.double));
>+_native_typed_data.NativeTypedArrayOfDouble = class NativeTypedArrayOfDouble extends NativeTypedArray_FixedLengthListMixin$ {
>+  get length() {
>+    return this.length;
>+  }
>+  set length(value) {
>+    super.length = value;
>+  }
>+  _get(index) {
>+    _native_typed_data._checkValidIndex(index, this, this[$length]);
>+    return this[index];
>+  }
>+  _set(index, value) {
>+    core.num._check(value);
>+    _native_typed_data._checkValidIndex(index, this, this[$length]);
>+    this[index] = value;
>+    return value;
>+  }
>+  setRange(start, end, iterable, skipCount) {
>+    IterableOfdouble()._check(iterable);
>+    if (skipCount === void 0) skipCount = 0;
>+    if (_native_typed_data.NativeTypedArrayOfDouble.is(iterable)) {
>+      this[_setRangeFast](start, end, iterable, skipCount);
>+      return;
>+    }
>+    super[$setRange](start, end, iterable, skipCount);
>+  }
>+};
>+(_native_typed_data.NativeTypedArrayOfDouble.new = function() {
>+}).prototype = _native_typed_data.NativeTypedArrayOfDouble.prototype;
>+dart.addTypeTests(_native_typed_data.NativeTypedArrayOfDouble);
>+dart.setMethodSignature(_native_typed_data.NativeTypedArrayOfDouble, () => ({
>+  __proto__: dart.getMethods(_native_typed_data.NativeTypedArrayOfDouble.__proto__),
>+  _get: dart.fnType(core.double, [core.int]),
>+  [$_get]: dart.fnType(core.double, [core.int]),
>+  _set: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  setRange: dart.fnType(dart.void, [core.int, core.int, core.Object], [core.int]),
>+  [$setRange]: dart.fnType(dart.void, [core.int, core.int, core.Object], [core.int])
>+}));
>+dart.setGetterSignature(_native_typed_data.NativeTypedArrayOfDouble, () => ({
>+  __proto__: dart.getGetters(_native_typed_data.NativeTypedArrayOfDouble.__proto__),
>+  length: core.int,
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(_native_typed_data.NativeTypedArrayOfDouble, "dart:_native_typed_data");
>+dart.defineExtensionMethods(_native_typed_data.NativeTypedArrayOfDouble, ['_get', '_set', 'setRange']);
>+dart.defineExtensionAccessors(_native_typed_data.NativeTypedArrayOfDouble, ['length']);
>+const NativeTypedArray_ListMixin$$ = class NativeTypedArray_ListMixin extends _native_typed_data.NativeTypedArray {};
>+(NativeTypedArray_ListMixin$$.new = function() {
>+}).prototype = NativeTypedArray_ListMixin$$.prototype;
>+dart.applyMixin(NativeTypedArray_ListMixin$$, collection.ListMixin$(core.int));
>+const NativeTypedArray_FixedLengthListMixin$$ = class NativeTypedArray_FixedLengthListMixin extends NativeTypedArray_ListMixin$$ {};
>+(NativeTypedArray_FixedLengthListMixin$$.new = function() {
>+}).prototype = NativeTypedArray_FixedLengthListMixin$$.prototype;
>+dart.applyMixin(NativeTypedArray_FixedLengthListMixin$$, _internal.FixedLengthListMixin$(core.int));
>+_native_typed_data.NativeTypedArrayOfInt = class NativeTypedArrayOfInt extends NativeTypedArray_FixedLengthListMixin$$ {
>+  get length() {
>+    return this.length;
>+  }
>+  set length(value) {
>+    super.length = value;
>+  }
>+  _set(index, value) {
>+    core.int._check(value);
>+    _native_typed_data._checkValidIndex(index, this, this[$length]);
>+    this[index] = value;
>+    return value;
>+  }
>+  setRange(start, end, iterable, skipCount) {
>+    IterableOfint()._check(iterable);
>+    if (skipCount === void 0) skipCount = 0;
>+    if (_native_typed_data.NativeTypedArrayOfInt.is(iterable)) {
>+      this[_setRangeFast](start, end, iterable, skipCount);
>+      return;
>+    }
>+    super[$setRange](start, end, iterable, skipCount);
>+  }
>+};
>+(_native_typed_data.NativeTypedArrayOfInt.new = function() {
>+}).prototype = _native_typed_data.NativeTypedArrayOfInt.prototype;
>+_native_typed_data.NativeTypedArrayOfInt.prototype[dart.isList] = true;
>+dart.addTypeTests(_native_typed_data.NativeTypedArrayOfInt);
>+_native_typed_data.NativeTypedArrayOfInt[dart.implements] = () => [ListOfint()];
>+dart.setMethodSignature(_native_typed_data.NativeTypedArrayOfInt, () => ({
>+  __proto__: dart.getMethods(_native_typed_data.NativeTypedArrayOfInt.__proto__),
>+  _set: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  setRange: dart.fnType(dart.void, [core.int, core.int, core.Object], [core.int]),
>+  [$setRange]: dart.fnType(dart.void, [core.int, core.int, core.Object], [core.int])
>+}));
>+dart.setGetterSignature(_native_typed_data.NativeTypedArrayOfInt, () => ({
>+  __proto__: dart.getGetters(_native_typed_data.NativeTypedArrayOfInt.__proto__),
>+  length: core.int,
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(_native_typed_data.NativeTypedArrayOfInt, "dart:_native_typed_data");
>+dart.defineExtensionMethods(_native_typed_data.NativeTypedArrayOfInt, ['_set', 'setRange']);
>+dart.defineExtensionAccessors(_native_typed_data.NativeTypedArrayOfInt, ['length']);
>+_native_typed_data.NativeFloat32List = class NativeFloat32List extends _native_typed_data.NativeTypedArrayOfDouble {
>+  static new(length) {
>+    return _native_typed_data.NativeFloat32List._create1(_native_typed_data._checkLength(length));
>+  }
>+  static fromList(elements) {
>+    return _native_typed_data.NativeFloat32List._create1(_native_typed_data._ensureNativeList(elements));
>+  }
>+  static view(buffer, offsetInBytes, length) {
>+    _native_typed_data._checkViewArguments(buffer, offsetInBytes, length);
>+    return length == null ? _native_typed_data.NativeFloat32List._create2(buffer, offsetInBytes) : _native_typed_data.NativeFloat32List._create3(buffer, offsetInBytes, length);
>+  }
>+  get [$runtimeType]() {
>+    return dart.wrapType(typed_data.Float32List);
>+  }
>+  [$sublist](start, end) {
>+    if (end === void 0) end = null;
>+    end = _native_typed_data._checkValidRange(start, end, this[$length]);
>+    let source = this.subarray(start, end);
>+    return _native_typed_data.NativeFloat32List._create1(source);
>+  }
>+  static _create1(arg) {
>+    return new Float32Array(arg);
>+  }
>+  static _create2(arg1, arg2) {
>+    return new Float32Array(arg1, arg2);
>+  }
>+  static _create3(arg1, arg2, arg3) {
>+    return new Float32Array(arg1, arg2, arg3);
>+  }
>+};
>+dart.addTypeTests(_native_typed_data.NativeFloat32List);
>+_native_typed_data.NativeFloat32List[dart.implements] = () => [typed_data.Float32List];
>+dart.setMethodSignature(_native_typed_data.NativeFloat32List, () => ({
>+  __proto__: dart.getMethods(_native_typed_data.NativeFloat32List.__proto__),
>+  [$sublist]: dart.fnType(core.List$(core.double), [core.int], [core.int])
>+}));
>+dart.setLibraryUri(_native_typed_data.NativeFloat32List, "dart:_native_typed_data");
>+dart.registerExtension("Float32Array", _native_typed_data.NativeFloat32List);
>+_native_typed_data.NativeFloat64List = class NativeFloat64List extends _native_typed_data.NativeTypedArrayOfDouble {
>+  static new(length) {
>+    return _native_typed_data.NativeFloat64List._create1(_native_typed_data._checkLength(length));
>+  }
>+  static fromList(elements) {
>+    return _native_typed_data.NativeFloat64List._create1(_native_typed_data._ensureNativeList(elements));
>+  }
>+  static view(buffer, offsetInBytes, length) {
>+    _native_typed_data._checkViewArguments(buffer, offsetInBytes, length);
>+    return length == null ? _native_typed_data.NativeFloat64List._create2(buffer, offsetInBytes) : _native_typed_data.NativeFloat64List._create3(buffer, offsetInBytes, length);
>+  }
>+  get [$runtimeType]() {
>+    return dart.wrapType(typed_data.Float64List);
>+  }
>+  [$sublist](start, end) {
>+    if (end === void 0) end = null;
>+    end = _native_typed_data._checkValidRange(start, end, this[$length]);
>+    let source = this.subarray(start, end);
>+    return _native_typed_data.NativeFloat64List._create1(source);
>+  }
>+  static _create1(arg) {
>+    return new Float64Array(arg);
>+  }
>+  static _create2(arg1, arg2) {
>+    return new Float64Array(arg1, arg2);
>+  }
>+  static _create3(arg1, arg2, arg3) {
>+    return new Float64Array(arg1, arg2, arg3);
>+  }
>+};
>+dart.addTypeTests(_native_typed_data.NativeFloat64List);
>+_native_typed_data.NativeFloat64List[dart.implements] = () => [typed_data.Float64List];
>+dart.setMethodSignature(_native_typed_data.NativeFloat64List, () => ({
>+  __proto__: dart.getMethods(_native_typed_data.NativeFloat64List.__proto__),
>+  [$sublist]: dart.fnType(core.List$(core.double), [core.int], [core.int])
>+}));
>+dart.setLibraryUri(_native_typed_data.NativeFloat64List, "dart:_native_typed_data");
>+dart.registerExtension("Float64Array", _native_typed_data.NativeFloat64List);
>+_native_typed_data.NativeInt16List = class NativeInt16List extends _native_typed_data.NativeTypedArrayOfInt {
>+  static new(length) {
>+    return _native_typed_data.NativeInt16List._create1(_native_typed_data._checkLength(length));
>+  }
>+  static fromList(elements) {
>+    return _native_typed_data.NativeInt16List._create1(_native_typed_data._ensureNativeList(elements));
>+  }
>+  static view(buffer, offsetInBytes, length) {
>+    _native_typed_data._checkViewArguments(buffer, offsetInBytes, length);
>+    return length == null ? _native_typed_data.NativeInt16List._create2(buffer, offsetInBytes) : _native_typed_data.NativeInt16List._create3(buffer, offsetInBytes, length);
>+  }
>+  get [$runtimeType]() {
>+    return dart.wrapType(typed_data.Int16List);
>+  }
>+  [$_get](index) {
>+    _native_typed_data._checkValidIndex(index, this, this[$length]);
>+    return this[index];
>+  }
>+  [$sublist](start, end) {
>+    if (end === void 0) end = null;
>+    end = _native_typed_data._checkValidRange(start, end, this[$length]);
>+    let source = this.subarray(start, end);
>+    return _native_typed_data.NativeInt16List._create1(source);
>+  }
>+  static _create1(arg) {
>+    return new Int16Array(arg);
>+  }
>+  static _create2(arg1, arg2) {
>+    return new Int16Array(arg1, arg2);
>+  }
>+  static _create3(arg1, arg2, arg3) {
>+    return new Int16Array(arg1, arg2, arg3);
>+  }
>+};
>+dart.addTypeTests(_native_typed_data.NativeInt16List);
>+_native_typed_data.NativeInt16List[dart.implements] = () => [typed_data.Int16List];
>+dart.setMethodSignature(_native_typed_data.NativeInt16List, () => ({
>+  __proto__: dart.getMethods(_native_typed_data.NativeInt16List.__proto__),
>+  [$_get]: dart.fnType(core.int, [core.int]),
>+  [$sublist]: dart.fnType(core.List$(core.int), [core.int], [core.int])
>+}));
>+dart.setLibraryUri(_native_typed_data.NativeInt16List, "dart:_native_typed_data");
>+dart.registerExtension("Int16Array", _native_typed_data.NativeInt16List);
>+_native_typed_data.NativeInt32List = class NativeInt32List extends _native_typed_data.NativeTypedArrayOfInt {
>+  static new(length) {
>+    return _native_typed_data.NativeInt32List._create1(_native_typed_data._checkLength(length));
>+  }
>+  static fromList(elements) {
>+    return _native_typed_data.NativeInt32List._create1(_native_typed_data._ensureNativeList(elements));
>+  }
>+  static view(buffer, offsetInBytes, length) {
>+    _native_typed_data._checkViewArguments(buffer, offsetInBytes, length);
>+    return length == null ? _native_typed_data.NativeInt32List._create2(buffer, offsetInBytes) : _native_typed_data.NativeInt32List._create3(buffer, offsetInBytes, length);
>+  }
>+  get [$runtimeType]() {
>+    return dart.wrapType(typed_data.Int32List);
>+  }
>+  [$_get](index) {
>+    _native_typed_data._checkValidIndex(index, this, this[$length]);
>+    return this[index];
>+  }
>+  [$sublist](start, end) {
>+    if (end === void 0) end = null;
>+    end = _native_typed_data._checkValidRange(start, end, this[$length]);
>+    let source = this.subarray(start, end);
>+    return _native_typed_data.NativeInt32List._create1(source);
>+  }
>+  static _create1(arg) {
>+    return new Int32Array(arg);
>+  }
>+  static _create2(arg1, arg2) {
>+    return new Int32Array(arg1, arg2);
>+  }
>+  static _create3(arg1, arg2, arg3) {
>+    return new Int32Array(arg1, arg2, arg3);
>+  }
>+};
>+dart.addTypeTests(_native_typed_data.NativeInt32List);
>+_native_typed_data.NativeInt32List[dart.implements] = () => [typed_data.Int32List];
>+dart.setMethodSignature(_native_typed_data.NativeInt32List, () => ({
>+  __proto__: dart.getMethods(_native_typed_data.NativeInt32List.__proto__),
>+  [$_get]: dart.fnType(core.int, [core.int]),
>+  [$sublist]: dart.fnType(core.List$(core.int), [core.int], [core.int])
>+}));
>+dart.setLibraryUri(_native_typed_data.NativeInt32List, "dart:_native_typed_data");
>+dart.registerExtension("Int32Array", _native_typed_data.NativeInt32List);
>+_native_typed_data.NativeInt8List = class NativeInt8List extends _native_typed_data.NativeTypedArrayOfInt {
>+  static new(length) {
>+    return _native_typed_data.NativeInt8List._create1(_native_typed_data._checkLength(length));
>+  }
>+  static fromList(elements) {
>+    return _native_typed_data.NativeInt8List._create1(_native_typed_data._ensureNativeList(elements));
>+  }
>+  static view(buffer, offsetInBytes, length) {
>+    _native_typed_data._checkViewArguments(buffer, offsetInBytes, length);
>+    return _native_typed_data.NativeInt8List._check(length == null ? _native_typed_data.NativeInt8List._create2(buffer, offsetInBytes) : _native_typed_data.NativeInt8List._create3(buffer, offsetInBytes, length));
>+  }
>+  get [$runtimeType]() {
>+    return dart.wrapType(typed_data.Int8List);
>+  }
>+  [$_get](index) {
>+    _native_typed_data._checkValidIndex(index, this, this[$length]);
>+    return this[index];
>+  }
>+  [$sublist](start, end) {
>+    if (end === void 0) end = null;
>+    end = _native_typed_data._checkValidRange(start, end, this[$length]);
>+    let source = this.subarray(start, end);
>+    return _native_typed_data.NativeInt8List._create1(source);
>+  }
>+  static _create1(arg) {
>+    return new Int8Array(arg);
>+  }
>+  static _create2(arg1, arg2) {
>+    return new Int8Array(arg1, arg2);
>+  }
>+  static _create3(arg1, arg2, arg3) {
>+    return new Int8Array(arg1, arg2, arg3);
>+  }
>+};
>+dart.addTypeTests(_native_typed_data.NativeInt8List);
>+_native_typed_data.NativeInt8List[dart.implements] = () => [typed_data.Int8List];
>+dart.setMethodSignature(_native_typed_data.NativeInt8List, () => ({
>+  __proto__: dart.getMethods(_native_typed_data.NativeInt8List.__proto__),
>+  [$_get]: dart.fnType(core.int, [core.int]),
>+  [$sublist]: dart.fnType(core.List$(core.int), [core.int], [core.int])
>+}));
>+dart.setLibraryUri(_native_typed_data.NativeInt8List, "dart:_native_typed_data");
>+dart.registerExtension("Int8Array", _native_typed_data.NativeInt8List);
>+_native_typed_data.NativeUint16List = class NativeUint16List extends _native_typed_data.NativeTypedArrayOfInt {
>+  static new(length) {
>+    return _native_typed_data.NativeUint16List._create1(_native_typed_data._checkLength(length));
>+  }
>+  static fromList(list) {
>+    return _native_typed_data.NativeUint16List._create1(_native_typed_data._ensureNativeList(list));
>+  }
>+  static view(buffer, offsetInBytes, length) {
>+    _native_typed_data._checkViewArguments(buffer, offsetInBytes, length);
>+    return length == null ? _native_typed_data.NativeUint16List._create2(buffer, offsetInBytes) : _native_typed_data.NativeUint16List._create3(buffer, offsetInBytes, length);
>+  }
>+  get [$runtimeType]() {
>+    return dart.wrapType(typed_data.Uint16List);
>+  }
>+  [$_get](index) {
>+    _native_typed_data._checkValidIndex(index, this, this[$length]);
>+    return this[index];
>+  }
>+  [$sublist](start, end) {
>+    if (end === void 0) end = null;
>+    end = _native_typed_data._checkValidRange(start, end, this[$length]);
>+    let source = this.subarray(start, end);
>+    return _native_typed_data.NativeUint16List._create1(source);
>+  }
>+  static _create1(arg) {
>+    return new Uint16Array(arg);
>+  }
>+  static _create2(arg1, arg2) {
>+    return new Uint16Array(arg1, arg2);
>+  }
>+  static _create3(arg1, arg2, arg3) {
>+    return new Uint16Array(arg1, arg2, arg3);
>+  }
>+};
>+dart.addTypeTests(_native_typed_data.NativeUint16List);
>+_native_typed_data.NativeUint16List[dart.implements] = () => [typed_data.Uint16List];
>+dart.setMethodSignature(_native_typed_data.NativeUint16List, () => ({
>+  __proto__: dart.getMethods(_native_typed_data.NativeUint16List.__proto__),
>+  [$_get]: dart.fnType(core.int, [core.int]),
>+  [$sublist]: dart.fnType(core.List$(core.int), [core.int], [core.int])
>+}));
>+dart.setLibraryUri(_native_typed_data.NativeUint16List, "dart:_native_typed_data");
>+dart.registerExtension("Uint16Array", _native_typed_data.NativeUint16List);
>+_native_typed_data.NativeUint32List = class NativeUint32List extends _native_typed_data.NativeTypedArrayOfInt {
>+  static new(length) {
>+    return _native_typed_data.NativeUint32List._create1(_native_typed_data._checkLength(length));
>+  }
>+  static fromList(elements) {
>+    return _native_typed_data.NativeUint32List._create1(_native_typed_data._ensureNativeList(elements));
>+  }
>+  static view(buffer, offsetInBytes, length) {
>+    _native_typed_data._checkViewArguments(buffer, offsetInBytes, length);
>+    return length == null ? _native_typed_data.NativeUint32List._create2(buffer, offsetInBytes) : _native_typed_data.NativeUint32List._create3(buffer, offsetInBytes, length);
>+  }
>+  get [$runtimeType]() {
>+    return dart.wrapType(typed_data.Uint32List);
>+  }
>+  [$_get](index) {
>+    _native_typed_data._checkValidIndex(index, this, this[$length]);
>+    return this[index];
>+  }
>+  [$sublist](start, end) {
>+    if (end === void 0) end = null;
>+    end = _native_typed_data._checkValidRange(start, end, this[$length]);
>+    let source = this.subarray(start, end);
>+    return _native_typed_data.NativeUint32List._create1(source);
>+  }
>+  static _create1(arg) {
>+    return new Uint32Array(arg);
>+  }
>+  static _create2(arg1, arg2) {
>+    return new Uint32Array(arg1, arg2);
>+  }
>+  static _create3(arg1, arg2, arg3) {
>+    return new Uint32Array(arg1, arg2, arg3);
>+  }
>+};
>+dart.addTypeTests(_native_typed_data.NativeUint32List);
>+_native_typed_data.NativeUint32List[dart.implements] = () => [typed_data.Uint32List];
>+dart.setMethodSignature(_native_typed_data.NativeUint32List, () => ({
>+  __proto__: dart.getMethods(_native_typed_data.NativeUint32List.__proto__),
>+  [$_get]: dart.fnType(core.int, [core.int]),
>+  [$sublist]: dart.fnType(core.List$(core.int), [core.int], [core.int])
>+}));
>+dart.setLibraryUri(_native_typed_data.NativeUint32List, "dart:_native_typed_data");
>+dart.registerExtension("Uint32Array", _native_typed_data.NativeUint32List);
>+_native_typed_data.NativeUint8ClampedList = class NativeUint8ClampedList extends _native_typed_data.NativeTypedArrayOfInt {
>+  static new(length) {
>+    return _native_typed_data.NativeUint8ClampedList._create1(_native_typed_data._checkLength(length));
>+  }
>+  static fromList(elements) {
>+    return _native_typed_data.NativeUint8ClampedList._create1(_native_typed_data._ensureNativeList(elements));
>+  }
>+  static view(buffer, offsetInBytes, length) {
>+    _native_typed_data._checkViewArguments(buffer, offsetInBytes, length);
>+    return length == null ? _native_typed_data.NativeUint8ClampedList._create2(buffer, offsetInBytes) : _native_typed_data.NativeUint8ClampedList._create3(buffer, offsetInBytes, length);
>+  }
>+  get [$runtimeType]() {
>+    return dart.wrapType(typed_data.Uint8ClampedList);
>+  }
>+  get [$length]() {
>+    return this.length;
>+  }
>+  set [$length](value) {
>+    super[$length] = value;
>+  }
>+  [$_get](index) {
>+    _native_typed_data._checkValidIndex(index, this, this[$length]);
>+    return this[index];
>+  }
>+  [$sublist](start, end) {
>+    if (end === void 0) end = null;
>+    end = _native_typed_data._checkValidRange(start, end, this[$length]);
>+    let source = this.subarray(start, end);
>+    return _native_typed_data.NativeUint8ClampedList._create1(source);
>+  }
>+  static _create1(arg) {
>+    return new Uint8ClampedArray(arg);
>+  }
>+  static _create2(arg1, arg2) {
>+    return new Uint8ClampedArray(arg1, arg2);
>+  }
>+  static _create3(arg1, arg2, arg3) {
>+    return new Uint8ClampedArray(arg1, arg2, arg3);
>+  }
>+};
>+dart.addTypeTests(_native_typed_data.NativeUint8ClampedList);
>+_native_typed_data.NativeUint8ClampedList[dart.implements] = () => [typed_data.Uint8ClampedList];
>+dart.setMethodSignature(_native_typed_data.NativeUint8ClampedList, () => ({
>+  __proto__: dart.getMethods(_native_typed_data.NativeUint8ClampedList.__proto__),
>+  [$_get]: dart.fnType(core.int, [core.int]),
>+  [$sublist]: dart.fnType(core.List$(core.int), [core.int], [core.int])
>+}));
>+dart.setLibraryUri(_native_typed_data.NativeUint8ClampedList, "dart:_native_typed_data");
>+dart.registerExtension("Uint8ClampedArray", _native_typed_data.NativeUint8ClampedList);
>+dart.registerExtension("CanvasPixelArray", _native_typed_data.NativeUint8ClampedList);
>+_native_typed_data.NativeUint8List = class NativeUint8List extends _native_typed_data.NativeTypedArrayOfInt {
>+  static new(length) {
>+    return _native_typed_data.NativeUint8List._create1(_native_typed_data._checkLength(length));
>+  }
>+  static fromList(elements) {
>+    return _native_typed_data.NativeUint8List._create1(_native_typed_data._ensureNativeList(elements));
>+  }
>+  static view(buffer, offsetInBytes, length) {
>+    _native_typed_data._checkViewArguments(buffer, offsetInBytes, length);
>+    return length == null ? _native_typed_data.NativeUint8List._create2(buffer, offsetInBytes) : _native_typed_data.NativeUint8List._create3(buffer, offsetInBytes, length);
>+  }
>+  get [$runtimeType]() {
>+    return dart.wrapType(typed_data.Uint8List);
>+  }
>+  get [$length]() {
>+    return this.length;
>+  }
>+  set [$length](value) {
>+    super[$length] = value;
>+  }
>+  [$_get](index) {
>+    _native_typed_data._checkValidIndex(index, this, this[$length]);
>+    return this[index];
>+  }
>+  [$sublist](start, end) {
>+    if (end === void 0) end = null;
>+    end = _native_typed_data._checkValidRange(start, end, this[$length]);
>+    let source = this.subarray(start, end);
>+    return _native_typed_data.NativeUint8List._create1(source);
>+  }
>+  static _create1(arg) {
>+    return new Uint8Array(arg);
>+  }
>+  static _create2(arg1, arg2) {
>+    return new Uint8Array(arg1, arg2);
>+  }
>+  static _create3(arg1, arg2, arg3) {
>+    return new Uint8Array(arg1, arg2, arg3);
>+  }
>+};
>+dart.addTypeTests(_native_typed_data.NativeUint8List);
>+_native_typed_data.NativeUint8List[dart.implements] = () => [typed_data.Uint8List];
>+dart.setMethodSignature(_native_typed_data.NativeUint8List, () => ({
>+  __proto__: dart.getMethods(_native_typed_data.NativeUint8List.__proto__),
>+  [$_get]: dart.fnType(core.int, [core.int]),
>+  [$sublist]: dart.fnType(core.List$(core.int), [core.int], [core.int])
>+}));
>+dart.setLibraryUri(_native_typed_data.NativeUint8List, "dart:_native_typed_data");
>+dart.registerExtension("Uint8Array", _native_typed_data.NativeUint8List);
>+_native_typed_data.NativeFloat32x4 = class NativeFloat32x4 extends core.Object {
>+  static _truncate(x) {
>+    _native_typed_data.NativeFloat32x4._list[$_set](0, core.num._check(x));
>+    return _native_typed_data.NativeFloat32x4._list[$_get](0);
>+  }
>+  static fromInt32x4Bits(i) {
>+    _native_typed_data.NativeFloat32x4._uint32view[$_set](0, i.x);
>+    _native_typed_data.NativeFloat32x4._uint32view[$_set](1, i.y);
>+    _native_typed_data.NativeFloat32x4._uint32view[$_set](2, i.z);
>+    _native_typed_data.NativeFloat32x4._uint32view[$_set](3, i.w);
>+    return new _native_typed_data.NativeFloat32x4._truncated(_native_typed_data.NativeFloat32x4._list[$_get](0), _native_typed_data.NativeFloat32x4._list[$_get](1), _native_typed_data.NativeFloat32x4._list[$_get](2), _native_typed_data.NativeFloat32x4._list[$_get](3));
>+  }
>+  toString() {
>+    return "[" + dart.str(this.x) + ", " + dart.str(this.y) + ", " + dart.str(this.z) + ", " + dart.str(this.w) + "]";
>+  }
>+  ['+'](other) {
>+    let _x = dart.notNull(this.x) + dart.notNull(other.x);
>+    let _y = dart.notNull(this.y) + dart.notNull(other.y);
>+    let _z = dart.notNull(this.z) + dart.notNull(other.z);
>+    let _w = dart.notNull(this.w) + dart.notNull(other.w);
>+    return new _native_typed_data.NativeFloat32x4._doubles(_x, _y, _z, _w);
>+  }
>+  _negate() {
>+    return new _native_typed_data.NativeFloat32x4._truncated(-dart.notNull(this.x), -dart.notNull(this.y), -dart.notNull(this.z), -dart.notNull(this.w));
>+  }
>+  ['-'](other) {
>+    let _x = dart.notNull(this.x) - dart.notNull(other.x);
>+    let _y = dart.notNull(this.y) - dart.notNull(other.y);
>+    let _z = dart.notNull(this.z) - dart.notNull(other.z);
>+    let _w = dart.notNull(this.w) - dart.notNull(other.w);
>+    return new _native_typed_data.NativeFloat32x4._doubles(_x, _y, _z, _w);
>+  }
>+  ['*'](other) {
>+    let _x = dart.notNull(this.x) * dart.notNull(other.x);
>+    let _y = dart.notNull(this.y) * dart.notNull(other.y);
>+    let _z = dart.notNull(this.z) * dart.notNull(other.z);
>+    let _w = dart.notNull(this.w) * dart.notNull(other.w);
>+    return new _native_typed_data.NativeFloat32x4._doubles(_x, _y, _z, _w);
>+  }
>+  ['/'](other) {
>+    let _x = dart.notNull(this.x) / dart.notNull(other.x);
>+    let _y = dart.notNull(this.y) / dart.notNull(other.y);
>+    let _z = dart.notNull(this.z) / dart.notNull(other.z);
>+    let _w = dart.notNull(this.w) / dart.notNull(other.w);
>+    return new _native_typed_data.NativeFloat32x4._doubles(_x, _y, _z, _w);
>+  }
>+  lessThan(other) {
>+    let _cx = dart.notNull(this.x) < dart.notNull(other.x);
>+    let _cy = dart.notNull(this.y) < dart.notNull(other.y);
>+    let _cz = dart.notNull(this.z) < dart.notNull(other.z);
>+    let _cw = dart.notNull(this.w) < dart.notNull(other.w);
>+    return new _native_typed_data.NativeInt32x4._truncated(_cx ? -1 : 0, _cy ? -1 : 0, _cz ? -1 : 0, _cw ? -1 : 0);
>+  }
>+  lessThanOrEqual(other) {
>+    let _cx = dart.notNull(this.x) <= dart.notNull(other.x);
>+    let _cy = dart.notNull(this.y) <= dart.notNull(other.y);
>+    let _cz = dart.notNull(this.z) <= dart.notNull(other.z);
>+    let _cw = dart.notNull(this.w) <= dart.notNull(other.w);
>+    return new _native_typed_data.NativeInt32x4._truncated(_cx ? -1 : 0, _cy ? -1 : 0, _cz ? -1 : 0, _cw ? -1 : 0);
>+  }
>+  greaterThan(other) {
>+    let _cx = dart.notNull(this.x) > dart.notNull(other.x);
>+    let _cy = dart.notNull(this.y) > dart.notNull(other.y);
>+    let _cz = dart.notNull(this.z) > dart.notNull(other.z);
>+    let _cw = dart.notNull(this.w) > dart.notNull(other.w);
>+    return new _native_typed_data.NativeInt32x4._truncated(_cx ? -1 : 0, _cy ? -1 : 0, _cz ? -1 : 0, _cw ? -1 : 0);
>+  }
>+  greaterThanOrEqual(other) {
>+    let _cx = dart.notNull(this.x) >= dart.notNull(other.x);
>+    let _cy = dart.notNull(this.y) >= dart.notNull(other.y);
>+    let _cz = dart.notNull(this.z) >= dart.notNull(other.z);
>+    let _cw = dart.notNull(this.w) >= dart.notNull(other.w);
>+    return new _native_typed_data.NativeInt32x4._truncated(_cx ? -1 : 0, _cy ? -1 : 0, _cz ? -1 : 0, _cw ? -1 : 0);
>+  }
>+  equal(other) {
>+    let _cx = this.x == other.x;
>+    let _cy = this.y == other.y;
>+    let _cz = this.z == other.z;
>+    let _cw = this.w == other.w;
>+    return new _native_typed_data.NativeInt32x4._truncated(_cx ? -1 : 0, _cy ? -1 : 0, _cz ? -1 : 0, _cw ? -1 : 0);
>+  }
>+  notEqual(other) {
>+    let _cx = this.x != other.x;
>+    let _cy = this.y != other.y;
>+    let _cz = this.z != other.z;
>+    let _cw = this.w != other.w;
>+    return new _native_typed_data.NativeInt32x4._truncated(_cx ? -1 : 0, _cy ? -1 : 0, _cz ? -1 : 0, _cw ? -1 : 0);
>+  }
>+  scale(s) {
>+    let _x = dart.notNull(s) * dart.notNull(this.x);
>+    let _y = dart.notNull(s) * dart.notNull(this.y);
>+    let _z = dart.notNull(s) * dart.notNull(this.z);
>+    let _w = dart.notNull(s) * dart.notNull(this.w);
>+    return new _native_typed_data.NativeFloat32x4._doubles(_x, _y, _z, _w);
>+  }
>+  abs() {
>+    let _x = this.x[$abs]();
>+    let _y = this.y[$abs]();
>+    let _z = this.z[$abs]();
>+    let _w = this.w[$abs]();
>+    return new _native_typed_data.NativeFloat32x4._truncated(_x, _y, _z, _w);
>+  }
>+  clamp(lowerLimit, upperLimit) {
>+    let _lx = lowerLimit.x;
>+    let _ly = lowerLimit.y;
>+    let _lz = lowerLimit.z;
>+    let _lw = lowerLimit.w;
>+    let _ux = upperLimit.x;
>+    let _uy = upperLimit.y;
>+    let _uz = upperLimit.z;
>+    let _uw = upperLimit.w;
>+    let _x = this.x;
>+    let _y = this.y;
>+    let _z = this.z;
>+    let _w = this.w;
>+    _x = dart.notNull(_x) > dart.notNull(_ux) ? _ux : _x;
>+    _y = dart.notNull(_y) > dart.notNull(_uy) ? _uy : _y;
>+    _z = dart.notNull(_z) > dart.notNull(_uz) ? _uz : _z;
>+    _w = dart.notNull(_w) > dart.notNull(_uw) ? _uw : _w;
>+    _x = dart.notNull(_x) < dart.notNull(_lx) ? _lx : _x;
>+    _y = dart.notNull(_y) < dart.notNull(_ly) ? _ly : _y;
>+    _z = dart.notNull(_z) < dart.notNull(_lz) ? _lz : _z;
>+    _w = dart.notNull(_w) < dart.notNull(_lw) ? _lw : _w;
>+    return new _native_typed_data.NativeFloat32x4._truncated(_x, _y, _z, _w);
>+  }
>+  get signMask() {
>+    let view = _native_typed_data.NativeFloat32x4._uint32view;
>+    let mx = null, my = null, mz = null, mw = null;
>+    _native_typed_data.NativeFloat32x4._list[$_set](0, this.x);
>+    _native_typed_data.NativeFloat32x4._list[$_set](1, this.y);
>+    _native_typed_data.NativeFloat32x4._list[$_set](2, this.z);
>+    _native_typed_data.NativeFloat32x4._list[$_set](3, this.w);
>+    mx = (dart.notNull(view[$_get](0)) & 2147483648) >>> 31;
>+    my = (dart.notNull(view[$_get](1)) & 2147483648) >>> 30;
>+    mz = (dart.notNull(view[$_get](2)) & 2147483648) >>> 29;
>+    mw = (dart.notNull(view[$_get](3)) & 2147483648) >>> 28;
>+    return core.int._check(dart.dsend(dart.dsend(dart.dsend(mx, '|', [my]), '|', [mz]), '|', [mw]));
>+  }
>+  shuffle(mask) {
>+    if (dart.notNull(mask) < 0 || dart.notNull(mask) > 255) {
>+      dart.throw(new core.RangeError.range(mask, 0, 255, "mask"));
>+    }
>+    _native_typed_data.NativeFloat32x4._list[$_set](0, this.x);
>+    _native_typed_data.NativeFloat32x4._list[$_set](1, this.y);
>+    _native_typed_data.NativeFloat32x4._list[$_set](2, this.z);
>+    _native_typed_data.NativeFloat32x4._list[$_set](3, this.w);
>+    let _x = _native_typed_data.NativeFloat32x4._list[$_get](dart.notNull(mask) & 3);
>+    let _y = _native_typed_data.NativeFloat32x4._list[$_get](dart.notNull(mask) >> 2 & 3);
>+    let _z = _native_typed_data.NativeFloat32x4._list[$_get](dart.notNull(mask) >> 4 & 3);
>+    let _w = _native_typed_data.NativeFloat32x4._list[$_get](dart.notNull(mask) >> 6 & 3);
>+    return new _native_typed_data.NativeFloat32x4._truncated(_x, _y, _z, _w);
>+  }
>+  shuffleMix(other, mask) {
>+    if (dart.notNull(mask) < 0 || dart.notNull(mask) > 255) {
>+      dart.throw(new core.RangeError.range(mask, 0, 255, "mask"));
>+    }
>+    _native_typed_data.NativeFloat32x4._list[$_set](0, this.x);
>+    _native_typed_data.NativeFloat32x4._list[$_set](1, this.y);
>+    _native_typed_data.NativeFloat32x4._list[$_set](2, this.z);
>+    _native_typed_data.NativeFloat32x4._list[$_set](3, this.w);
>+    let _x = _native_typed_data.NativeFloat32x4._list[$_get](dart.notNull(mask) & 3);
>+    let _y = _native_typed_data.NativeFloat32x4._list[$_get](dart.notNull(mask) >> 2 & 3);
>+    _native_typed_data.NativeFloat32x4._list[$_set](0, other.x);
>+    _native_typed_data.NativeFloat32x4._list[$_set](1, other.y);
>+    _native_typed_data.NativeFloat32x4._list[$_set](2, other.z);
>+    _native_typed_data.NativeFloat32x4._list[$_set](3, other.w);
>+    let _z = _native_typed_data.NativeFloat32x4._list[$_get](dart.notNull(mask) >> 4 & 3);
>+    let _w = _native_typed_data.NativeFloat32x4._list[$_get](dart.notNull(mask) >> 6 & 3);
>+    return new _native_typed_data.NativeFloat32x4._truncated(_x, _y, _z, _w);
>+  }
>+  withX(newX) {
>+    return new _native_typed_data.NativeFloat32x4._truncated(core.double._check(_native_typed_data.NativeFloat32x4._truncate(newX)), this.y, this.z, this.w);
>+  }
>+  withY(newY) {
>+    return new _native_typed_data.NativeFloat32x4._truncated(this.x, core.double._check(_native_typed_data.NativeFloat32x4._truncate(newY)), this.z, this.w);
>+  }
>+  withZ(newZ) {
>+    return new _native_typed_data.NativeFloat32x4._truncated(this.x, this.y, core.double._check(_native_typed_data.NativeFloat32x4._truncate(newZ)), this.w);
>+  }
>+  withW(newW) {
>+    return new _native_typed_data.NativeFloat32x4._truncated(this.x, this.y, this.z, core.double._check(_native_typed_data.NativeFloat32x4._truncate(newW)));
>+  }
>+  min(other) {
>+    let _x = dart.notNull(this.x) < dart.notNull(other.x) ? this.x : other.x;
>+    let _y = dart.notNull(this.y) < dart.notNull(other.y) ? this.y : other.y;
>+    let _z = dart.notNull(this.z) < dart.notNull(other.z) ? this.z : other.z;
>+    let _w = dart.notNull(this.w) < dart.notNull(other.w) ? this.w : other.w;
>+    return new _native_typed_data.NativeFloat32x4._truncated(_x, _y, _z, _w);
>+  }
>+  max(other) {
>+    let _x = dart.notNull(this.x) > dart.notNull(other.x) ? this.x : other.x;
>+    let _y = dart.notNull(this.y) > dart.notNull(other.y) ? this.y : other.y;
>+    let _z = dart.notNull(this.z) > dart.notNull(other.z) ? this.z : other.z;
>+    let _w = dart.notNull(this.w) > dart.notNull(other.w) ? this.w : other.w;
>+    return new _native_typed_data.NativeFloat32x4._truncated(_x, _y, _z, _w);
>+  }
>+  sqrt() {
>+    let _x = math.sqrt(this.x);
>+    let _y = math.sqrt(this.y);
>+    let _z = math.sqrt(this.z);
>+    let _w = math.sqrt(this.w);
>+    return new _native_typed_data.NativeFloat32x4._doubles(_x, _y, _z, _w);
>+  }
>+  reciprocal() {
>+    let _x = 1.0 / dart.notNull(this.x);
>+    let _y = 1.0 / dart.notNull(this.y);
>+    let _z = 1.0 / dart.notNull(this.z);
>+    let _w = 1.0 / dart.notNull(this.w);
>+    return new _native_typed_data.NativeFloat32x4._doubles(_x, _y, _z, _w);
>+  }
>+  reciprocalSqrt() {
>+    let _x = math.sqrt(1.0 / dart.notNull(this.x));
>+    let _y = math.sqrt(1.0 / dart.notNull(this.y));
>+    let _z = math.sqrt(1.0 / dart.notNull(this.z));
>+    let _w = math.sqrt(1.0 / dart.notNull(this.w));
>+    return new _native_typed_data.NativeFloat32x4._doubles(_x, _y, _z, _w);
>+  }
>+};
>+(_native_typed_data.NativeFloat32x4.new = function(x, y, z, w) {
>+  this.x = core.double._check(_native_typed_data.NativeFloat32x4._truncate(x));
>+  this.y = core.double._check(_native_typed_data.NativeFloat32x4._truncate(y));
>+  this.z = core.double._check(_native_typed_data.NativeFloat32x4._truncate(z));
>+  this.w = core.double._check(_native_typed_data.NativeFloat32x4._truncate(w));
>+  if (!(typeof x == 'number')) dart.throw(new core.ArgumentError.new(x));
>+  if (!(typeof y == 'number')) dart.throw(new core.ArgumentError.new(y));
>+  if (!(typeof z == 'number')) dart.throw(new core.ArgumentError.new(z));
>+  if (!(typeof w == 'number')) dart.throw(new core.ArgumentError.new(w));
>+}).prototype = _native_typed_data.NativeFloat32x4.prototype;
>+(_native_typed_data.NativeFloat32x4.splat = function(v) {
>+  _native_typed_data.NativeFloat32x4.new.call(this, v, v, v, v);
>+}).prototype = _native_typed_data.NativeFloat32x4.prototype;
>+(_native_typed_data.NativeFloat32x4.zero = function() {
>+  _native_typed_data.NativeFloat32x4._truncated.call(this, 0.0, 0.0, 0.0, 0.0);
>+}).prototype = _native_typed_data.NativeFloat32x4.prototype;
>+(_native_typed_data.NativeFloat32x4.fromFloat64x2 = function(v) {
>+  _native_typed_data.NativeFloat32x4._truncated.call(this, core.double._check(_native_typed_data.NativeFloat32x4._truncate(v.x)), core.double._check(_native_typed_data.NativeFloat32x4._truncate(v.y)), 0.0, 0.0);
>+}).prototype = _native_typed_data.NativeFloat32x4.prototype;
>+(_native_typed_data.NativeFloat32x4._doubles = function(x, y, z, w) {
>+  this.x = core.double._check(_native_typed_data.NativeFloat32x4._truncate(x));
>+  this.y = core.double._check(_native_typed_data.NativeFloat32x4._truncate(y));
>+  this.z = core.double._check(_native_typed_data.NativeFloat32x4._truncate(z));
>+  this.w = core.double._check(_native_typed_data.NativeFloat32x4._truncate(w));
>+}).prototype = _native_typed_data.NativeFloat32x4.prototype;
>+(_native_typed_data.NativeFloat32x4._truncated = function(x, y, z, w) {
>+  this.x = x;
>+  this.y = y;
>+  this.z = z;
>+  this.w = w;
>+}).prototype = _native_typed_data.NativeFloat32x4.prototype;
>+dart.addTypeTests(_native_typed_data.NativeFloat32x4);
>+_native_typed_data.NativeFloat32x4[dart.implements] = () => [typed_data.Float32x4];
>+dart.setMethodSignature(_native_typed_data.NativeFloat32x4, () => ({
>+  __proto__: dart.getMethods(_native_typed_data.NativeFloat32x4.__proto__),
>+  '+': dart.fnType(typed_data.Float32x4, [typed_data.Float32x4]),
>+  _negate: dart.fnType(typed_data.Float32x4, []),
>+  '-': dart.fnType(typed_data.Float32x4, [typed_data.Float32x4]),
>+  '*': dart.fnType(typed_data.Float32x4, [typed_data.Float32x4]),
>+  '/': dart.fnType(typed_data.Float32x4, [typed_data.Float32x4]),
>+  lessThan: dart.fnType(typed_data.Int32x4, [typed_data.Float32x4]),
>+  lessThanOrEqual: dart.fnType(typed_data.Int32x4, [typed_data.Float32x4]),
>+  greaterThan: dart.fnType(typed_data.Int32x4, [typed_data.Float32x4]),
>+  greaterThanOrEqual: dart.fnType(typed_data.Int32x4, [typed_data.Float32x4]),
>+  equal: dart.fnType(typed_data.Int32x4, [typed_data.Float32x4]),
>+  notEqual: dart.fnType(typed_data.Int32x4, [typed_data.Float32x4]),
>+  scale: dart.fnType(typed_data.Float32x4, [core.double]),
>+  abs: dart.fnType(typed_data.Float32x4, []),
>+  clamp: dart.fnType(typed_data.Float32x4, [typed_data.Float32x4, typed_data.Float32x4]),
>+  shuffle: dart.fnType(typed_data.Float32x4, [core.int]),
>+  shuffleMix: dart.fnType(typed_data.Float32x4, [typed_data.Float32x4, core.int]),
>+  withX: dart.fnType(typed_data.Float32x4, [core.double]),
>+  withY: dart.fnType(typed_data.Float32x4, [core.double]),
>+  withZ: dart.fnType(typed_data.Float32x4, [core.double]),
>+  withW: dart.fnType(typed_data.Float32x4, [core.double]),
>+  min: dart.fnType(typed_data.Float32x4, [typed_data.Float32x4]),
>+  max: dart.fnType(typed_data.Float32x4, [typed_data.Float32x4]),
>+  sqrt: dart.fnType(typed_data.Float32x4, []),
>+  reciprocal: dart.fnType(typed_data.Float32x4, []),
>+  reciprocalSqrt: dart.fnType(typed_data.Float32x4, [])
>+}));
>+dart.setGetterSignature(_native_typed_data.NativeFloat32x4, () => ({
>+  __proto__: dart.getGetters(_native_typed_data.NativeFloat32x4.__proto__),
>+  signMask: core.int
>+}));
>+dart.setLibraryUri(_native_typed_data.NativeFloat32x4, "dart:_native_typed_data");
>+dart.setFieldSignature(_native_typed_data.NativeFloat32x4, () => ({
>+  __proto__: dart.getFields(_native_typed_data.NativeFloat32x4.__proto__),
>+  x: dart.finalFieldType(core.double),
>+  y: dart.finalFieldType(core.double),
>+  z: dart.finalFieldType(core.double),
>+  w: dart.finalFieldType(core.double)
>+}));
>+dart.defineExtensionMethods(_native_typed_data.NativeFloat32x4, ['toString']);
>+dart.defineLazy(_native_typed_data.NativeFloat32x4, {
>+  /*_native_typed_data.NativeFloat32x4._list*/get _list() {
>+    return _native_typed_data.NativeFloat32List.new(4);
>+  },
>+  /*_native_typed_data.NativeFloat32x4._uint32view*/get _uint32view() {
>+    return _native_typed_data.NativeFloat32x4._list.buffer[$asUint32List]();
>+  }
>+});
>+_native_typed_data.NativeInt32x4 = class NativeInt32x4 extends core.Object {
>+  static _truncate(x) {
>+    _native_typed_data.NativeInt32x4._list[$_set](0, core.int._check(x));
>+    return _native_typed_data.NativeInt32x4._list[$_get](0);
>+  }
>+  static fromFloat32x4Bits(f) {
>+    let floatList = _native_typed_data.NativeFloat32x4._list;
>+    floatList[$_set](0, f.x);
>+    floatList[$_set](1, f.y);
>+    floatList[$_set](2, f.z);
>+    floatList[$_set](3, f.w);
>+    let view = _native_typed_data.NativeInt32List._check(floatList.buffer[$asInt32List]());
>+    return new _native_typed_data.NativeInt32x4._truncated(view[$_get](0), view[$_get](1), view[$_get](2), view[$_get](3));
>+  }
>+  toString() {
>+    return "[" + dart.str(this.x) + ", " + dart.str(this.y) + ", " + dart.str(this.z) + ", " + dart.str(this.w) + "]";
>+  }
>+  ['|'](other) {
>+    return new _native_typed_data.NativeInt32x4._truncated(this.x | other.x, this.y | other.y, this.z | other.z, this.w | other.w);
>+  }
>+  ['&'](other) {
>+    return new _native_typed_data.NativeInt32x4._truncated(this.x & other.x, this.y & other.y, this.z & other.z, this.w & other.w);
>+  }
>+  ['^'](other) {
>+    return new _native_typed_data.NativeInt32x4._truncated(this.x ^ other.x, this.y ^ other.y, this.z ^ other.z, this.w ^ other.w);
>+  }
>+  ['+'](other) {
>+    return new _native_typed_data.NativeInt32x4._truncated(this.x + other.x | 0, this.y + other.y | 0, this.z + other.z | 0, this.w + other.w | 0);
>+  }
>+  ['-'](other) {
>+    return new _native_typed_data.NativeInt32x4._truncated(this.x - other.x | 0, this.y - other.y | 0, this.z - other.z | 0, this.w - other.w | 0);
>+  }
>+  _negate() {
>+    return new _native_typed_data.NativeInt32x4._truncated(-this.x | 0, -this.y | 0, -this.z | 0, -this.w | 0);
>+  }
>+  get signMask() {
>+    let mx = (dart.notNull(this.x) & 2147483648) >>> 31;
>+    let my = (dart.notNull(this.y) & 2147483648) >>> 31;
>+    let mz = (dart.notNull(this.z) & 2147483648) >>> 31;
>+    let mw = (dart.notNull(this.w) & 2147483648) >>> 31;
>+    return (mx | my << 1 | mz << 2 | mw << 3) >>> 0;
>+  }
>+  shuffle(mask) {
>+    if (dart.notNull(mask) < 0 || dart.notNull(mask) > 255) {
>+      dart.throw(new core.RangeError.range(mask, 0, 255, "mask"));
>+    }
>+    _native_typed_data.NativeInt32x4._list[$_set](0, this.x);
>+    _native_typed_data.NativeInt32x4._list[$_set](1, this.y);
>+    _native_typed_data.NativeInt32x4._list[$_set](2, this.z);
>+    _native_typed_data.NativeInt32x4._list[$_set](3, this.w);
>+    let _x = _native_typed_data.NativeInt32x4._list[$_get](dart.notNull(mask) & 3);
>+    let _y = _native_typed_data.NativeInt32x4._list[$_get](dart.notNull(mask) >> 2 & 3);
>+    let _z = _native_typed_data.NativeInt32x4._list[$_get](dart.notNull(mask) >> 4 & 3);
>+    let _w = _native_typed_data.NativeInt32x4._list[$_get](dart.notNull(mask) >> 6 & 3);
>+    return new _native_typed_data.NativeInt32x4._truncated(_x, _y, _z, _w);
>+  }
>+  shuffleMix(other, mask) {
>+    if (dart.notNull(mask) < 0 || dart.notNull(mask) > 255) {
>+      dart.throw(new core.RangeError.range(mask, 0, 255, "mask"));
>+    }
>+    _native_typed_data.NativeInt32x4._list[$_set](0, this.x);
>+    _native_typed_data.NativeInt32x4._list[$_set](1, this.y);
>+    _native_typed_data.NativeInt32x4._list[$_set](2, this.z);
>+    _native_typed_data.NativeInt32x4._list[$_set](3, this.w);
>+    let _x = _native_typed_data.NativeInt32x4._list[$_get](dart.notNull(mask) & 3);
>+    let _y = _native_typed_data.NativeInt32x4._list[$_get](dart.notNull(mask) >> 2 & 3);
>+    _native_typed_data.NativeInt32x4._list[$_set](0, other.x);
>+    _native_typed_data.NativeInt32x4._list[$_set](1, other.y);
>+    _native_typed_data.NativeInt32x4._list[$_set](2, other.z);
>+    _native_typed_data.NativeInt32x4._list[$_set](3, other.w);
>+    let _z = _native_typed_data.NativeInt32x4._list[$_get](dart.notNull(mask) >> 4 & 3);
>+    let _w = _native_typed_data.NativeInt32x4._list[$_get](dart.notNull(mask) >> 6 & 3);
>+    return new _native_typed_data.NativeInt32x4._truncated(_x, _y, _z, _w);
>+  }
>+  withX(x) {
>+    let _x = core.int._check(_native_typed_data.NativeInt32x4._truncate(x));
>+    return new _native_typed_data.NativeInt32x4._truncated(_x, this.y, this.z, this.w);
>+  }
>+  withY(y) {
>+    let _y = core.int._check(_native_typed_data.NativeInt32x4._truncate(y));
>+    return new _native_typed_data.NativeInt32x4._truncated(this.x, _y, this.z, this.w);
>+  }
>+  withZ(z) {
>+    let _z = core.int._check(_native_typed_data.NativeInt32x4._truncate(z));
>+    return new _native_typed_data.NativeInt32x4._truncated(this.x, this.y, _z, this.w);
>+  }
>+  withW(w) {
>+    let _w = core.int._check(_native_typed_data.NativeInt32x4._truncate(w));
>+    return new _native_typed_data.NativeInt32x4._truncated(this.x, this.y, this.z, _w);
>+  }
>+  get flagX() {
>+    return this.x !== 0;
>+  }
>+  get flagY() {
>+    return this.y !== 0;
>+  }
>+  get flagZ() {
>+    return this.z !== 0;
>+  }
>+  get flagW() {
>+    return this.w !== 0;
>+  }
>+  withFlagX(flagX) {
>+    let _x = dart.test(flagX) ? -1 : 0;
>+    return new _native_typed_data.NativeInt32x4._truncated(_x, this.y, this.z, this.w);
>+  }
>+  withFlagY(flagY) {
>+    let _y = dart.test(flagY) ? -1 : 0;
>+    return new _native_typed_data.NativeInt32x4._truncated(this.x, _y, this.z, this.w);
>+  }
>+  withFlagZ(flagZ) {
>+    let _z = dart.test(flagZ) ? -1 : 0;
>+    return new _native_typed_data.NativeInt32x4._truncated(this.x, this.y, _z, this.w);
>+  }
>+  withFlagW(flagW) {
>+    let _w = dart.test(flagW) ? -1 : 0;
>+    return new _native_typed_data.NativeInt32x4._truncated(this.x, this.y, this.z, _w);
>+  }
>+  select(trueValue, falseValue) {
>+    let floatList = _native_typed_data.NativeFloat32x4._list;
>+    let intView = _native_typed_data.NativeFloat32x4._uint32view;
>+    floatList[$_set](0, trueValue.x);
>+    floatList[$_set](1, trueValue.y);
>+    floatList[$_set](2, trueValue.z);
>+    floatList[$_set](3, trueValue.w);
>+    let stx = intView[$_get](0);
>+    let sty = intView[$_get](1);
>+    let stz = intView[$_get](2);
>+    let stw = intView[$_get](3);
>+    floatList[$_set](0, falseValue.x);
>+    floatList[$_set](1, falseValue.y);
>+    floatList[$_set](2, falseValue.z);
>+    floatList[$_set](3, falseValue.w);
>+    let sfx = intView[$_get](0);
>+    let sfy = intView[$_get](1);
>+    let sfz = intView[$_get](2);
>+    let sfw = intView[$_get](3);
>+    let _x = (dart.notNull(this.x) & dart.notNull(stx) | ~dart.notNull(this.x) & dart.notNull(sfx)) >>> 0;
>+    let _y = (dart.notNull(this.y) & dart.notNull(sty) | ~dart.notNull(this.y) & dart.notNull(sfy)) >>> 0;
>+    let _z = (dart.notNull(this.z) & dart.notNull(stz) | ~dart.notNull(this.z) & dart.notNull(sfz)) >>> 0;
>+    let _w = (dart.notNull(this.w) & dart.notNull(stw) | ~dart.notNull(this.w) & dart.notNull(sfw)) >>> 0;
>+    intView[$_set](0, _x);
>+    intView[$_set](1, _y);
>+    intView[$_set](2, _z);
>+    intView[$_set](3, _w);
>+    return new _native_typed_data.NativeFloat32x4._truncated(floatList[$_get](0), floatList[$_get](1), floatList[$_get](2), floatList[$_get](3));
>+  }
>+};
>+(_native_typed_data.NativeInt32x4.new = function(x, y, z, w) {
>+  this.x = core.int._check(_native_typed_data.NativeInt32x4._truncate(x));
>+  this.y = core.int._check(_native_typed_data.NativeInt32x4._truncate(y));
>+  this.z = core.int._check(_native_typed_data.NativeInt32x4._truncate(z));
>+  this.w = core.int._check(_native_typed_data.NativeInt32x4._truncate(w));
>+  if (x != this.x && !core.int.is(x)) dart.throw(new core.ArgumentError.new(x));
>+  if (y != this.y && !core.int.is(y)) dart.throw(new core.ArgumentError.new(y));
>+  if (z != this.z && !core.int.is(z)) dart.throw(new core.ArgumentError.new(z));
>+  if (w != this.w && !core.int.is(w)) dart.throw(new core.ArgumentError.new(w));
>+}).prototype = _native_typed_data.NativeInt32x4.prototype;
>+(_native_typed_data.NativeInt32x4.bool = function(x, y, z, w) {
>+  this.x = dart.test(x) ? -1 : 0;
>+  this.y = dart.test(y) ? -1 : 0;
>+  this.z = dart.test(z) ? -1 : 0;
>+  this.w = dart.test(w) ? -1 : 0;
>+}).prototype = _native_typed_data.NativeInt32x4.prototype;
>+(_native_typed_data.NativeInt32x4._truncated = function(x, y, z, w) {
>+  this.x = x;
>+  this.y = y;
>+  this.z = z;
>+  this.w = w;
>+}).prototype = _native_typed_data.NativeInt32x4.prototype;
>+dart.addTypeTests(_native_typed_data.NativeInt32x4);
>+_native_typed_data.NativeInt32x4[dart.implements] = () => [typed_data.Int32x4];
>+dart.setMethodSignature(_native_typed_data.NativeInt32x4, () => ({
>+  __proto__: dart.getMethods(_native_typed_data.NativeInt32x4.__proto__),
>+  '|': dart.fnType(typed_data.Int32x4, [typed_data.Int32x4]),
>+  '&': dart.fnType(typed_data.Int32x4, [typed_data.Int32x4]),
>+  '^': dart.fnType(typed_data.Int32x4, [typed_data.Int32x4]),
>+  '+': dart.fnType(typed_data.Int32x4, [typed_data.Int32x4]),
>+  '-': dart.fnType(typed_data.Int32x4, [typed_data.Int32x4]),
>+  _negate: dart.fnType(typed_data.Int32x4, []),
>+  shuffle: dart.fnType(typed_data.Int32x4, [core.int]),
>+  shuffleMix: dart.fnType(typed_data.Int32x4, [typed_data.Int32x4, core.int]),
>+  withX: dart.fnType(typed_data.Int32x4, [core.int]),
>+  withY: dart.fnType(typed_data.Int32x4, [core.int]),
>+  withZ: dart.fnType(typed_data.Int32x4, [core.int]),
>+  withW: dart.fnType(typed_data.Int32x4, [core.int]),
>+  withFlagX: dart.fnType(typed_data.Int32x4, [core.bool]),
>+  withFlagY: dart.fnType(typed_data.Int32x4, [core.bool]),
>+  withFlagZ: dart.fnType(typed_data.Int32x4, [core.bool]),
>+  withFlagW: dart.fnType(typed_data.Int32x4, [core.bool]),
>+  select: dart.fnType(typed_data.Float32x4, [typed_data.Float32x4, typed_data.Float32x4])
>+}));
>+dart.setGetterSignature(_native_typed_data.NativeInt32x4, () => ({
>+  __proto__: dart.getGetters(_native_typed_data.NativeInt32x4.__proto__),
>+  signMask: core.int,
>+  flagX: core.bool,
>+  flagY: core.bool,
>+  flagZ: core.bool,
>+  flagW: core.bool
>+}));
>+dart.setLibraryUri(_native_typed_data.NativeInt32x4, "dart:_native_typed_data");
>+dart.setFieldSignature(_native_typed_data.NativeInt32x4, () => ({
>+  __proto__: dart.getFields(_native_typed_data.NativeInt32x4.__proto__),
>+  x: dart.finalFieldType(core.int),
>+  y: dart.finalFieldType(core.int),
>+  z: dart.finalFieldType(core.int),
>+  w: dart.finalFieldType(core.int)
>+}));
>+dart.defineExtensionMethods(_native_typed_data.NativeInt32x4, ['toString']);
>+dart.defineLazy(_native_typed_data.NativeInt32x4, {
>+  /*_native_typed_data.NativeInt32x4._list*/get _list() {
>+    return _native_typed_data.NativeInt32List.new(4);
>+  }
>+});
>+_native_typed_data.NativeFloat64x2 = class NativeFloat64x2 extends core.Object {
>+  toString() {
>+    return "[" + dart.str(this.x) + ", " + dart.str(this.y) + "]";
>+  }
>+  ['+'](other) {
>+    return new _native_typed_data.NativeFloat64x2._doubles(dart.notNull(this.x) + dart.notNull(other.x), dart.notNull(this.y) + dart.notNull(other.y));
>+  }
>+  _negate() {
>+    return new _native_typed_data.NativeFloat64x2._doubles(-dart.notNull(this.x), -dart.notNull(this.y));
>+  }
>+  ['-'](other) {
>+    return new _native_typed_data.NativeFloat64x2._doubles(dart.notNull(this.x) - dart.notNull(other.x), dart.notNull(this.y) - dart.notNull(other.y));
>+  }
>+  ['*'](other) {
>+    return new _native_typed_data.NativeFloat64x2._doubles(dart.notNull(this.x) * dart.notNull(other.x), dart.notNull(this.y) * dart.notNull(other.y));
>+  }
>+  ['/'](other) {
>+    return new _native_typed_data.NativeFloat64x2._doubles(dart.notNull(this.x) / dart.notNull(other.x), dart.notNull(this.y) / dart.notNull(other.y));
>+  }
>+  scale(s) {
>+    return new _native_typed_data.NativeFloat64x2._doubles(dart.notNull(this.x) * dart.notNull(s), dart.notNull(this.y) * dart.notNull(s));
>+  }
>+  abs() {
>+    return new _native_typed_data.NativeFloat64x2._doubles(this.x[$abs](), this.y[$abs]());
>+  }
>+  clamp(lowerLimit, upperLimit) {
>+    let _lx = lowerLimit.x;
>+    let _ly = lowerLimit.y;
>+    let _ux = upperLimit.x;
>+    let _uy = upperLimit.y;
>+    let _x = this.x;
>+    let _y = this.y;
>+    _x = dart.notNull(_x) > dart.notNull(_ux) ? _ux : _x;
>+    _y = dart.notNull(_y) > dart.notNull(_uy) ? _uy : _y;
>+    _x = dart.notNull(_x) < dart.notNull(_lx) ? _lx : _x;
>+    _y = dart.notNull(_y) < dart.notNull(_ly) ? _ly : _y;
>+    return new _native_typed_data.NativeFloat64x2._doubles(_x, _y);
>+  }
>+  get signMask() {
>+    let view = _native_typed_data.NativeFloat64x2._uint32View;
>+    _native_typed_data.NativeFloat64x2._list[$_set](0, this.x);
>+    _native_typed_data.NativeFloat64x2._list[$_set](1, this.y);
>+    let mx = (dart.notNull(view[$_get](1)) & 2147483648) >>> 31;
>+    let my = (dart.notNull(view[$_get](3)) & 2147483648) >>> 31;
>+    return (mx | my << 1) >>> 0;
>+  }
>+  withX(x) {
>+    if (!(typeof x == 'number')) dart.throw(new core.ArgumentError.new(x));
>+    return new _native_typed_data.NativeFloat64x2._doubles(x, this.y);
>+  }
>+  withY(y) {
>+    if (!(typeof y == 'number')) dart.throw(new core.ArgumentError.new(y));
>+    return new _native_typed_data.NativeFloat64x2._doubles(this.x, y);
>+  }
>+  min(other) {
>+    return new _native_typed_data.NativeFloat64x2._doubles(dart.notNull(this.x) < dart.notNull(other.x) ? this.x : other.x, dart.notNull(this.y) < dart.notNull(other.y) ? this.y : other.y);
>+  }
>+  max(other) {
>+    return new _native_typed_data.NativeFloat64x2._doubles(dart.notNull(this.x) > dart.notNull(other.x) ? this.x : other.x, dart.notNull(this.y) > dart.notNull(other.y) ? this.y : other.y);
>+  }
>+  sqrt() {
>+    return new _native_typed_data.NativeFloat64x2._doubles(math.sqrt(this.x), math.sqrt(this.y));
>+  }
>+};
>+(_native_typed_data.NativeFloat64x2.new = function(x, y) {
>+  this.x = x;
>+  this.y = y;
>+  if (!(typeof this.x == 'number')) dart.throw(new core.ArgumentError.new(this.x));
>+  if (!(typeof this.y == 'number')) dart.throw(new core.ArgumentError.new(this.y));
>+}).prototype = _native_typed_data.NativeFloat64x2.prototype;
>+(_native_typed_data.NativeFloat64x2.splat = function(v) {
>+  _native_typed_data.NativeFloat64x2.new.call(this, v, v);
>+}).prototype = _native_typed_data.NativeFloat64x2.prototype;
>+(_native_typed_data.NativeFloat64x2.zero = function() {
>+  _native_typed_data.NativeFloat64x2.splat.call(this, 0.0);
>+}).prototype = _native_typed_data.NativeFloat64x2.prototype;
>+(_native_typed_data.NativeFloat64x2.fromFloat32x4 = function(v) {
>+  _native_typed_data.NativeFloat64x2.new.call(this, v.x, v.y);
>+}).prototype = _native_typed_data.NativeFloat64x2.prototype;
>+(_native_typed_data.NativeFloat64x2._doubles = function(x, y) {
>+  this.x = x;
>+  this.y = y;
>+}).prototype = _native_typed_data.NativeFloat64x2.prototype;
>+dart.addTypeTests(_native_typed_data.NativeFloat64x2);
>+_native_typed_data.NativeFloat64x2[dart.implements] = () => [typed_data.Float64x2];
>+dart.setMethodSignature(_native_typed_data.NativeFloat64x2, () => ({
>+  __proto__: dart.getMethods(_native_typed_data.NativeFloat64x2.__proto__),
>+  '+': dart.fnType(typed_data.Float64x2, [typed_data.Float64x2]),
>+  _negate: dart.fnType(typed_data.Float64x2, []),
>+  '-': dart.fnType(typed_data.Float64x2, [typed_data.Float64x2]),
>+  '*': dart.fnType(typed_data.Float64x2, [typed_data.Float64x2]),
>+  '/': dart.fnType(typed_data.Float64x2, [typed_data.Float64x2]),
>+  scale: dart.fnType(typed_data.Float64x2, [core.double]),
>+  abs: dart.fnType(typed_data.Float64x2, []),
>+  clamp: dart.fnType(typed_data.Float64x2, [typed_data.Float64x2, typed_data.Float64x2]),
>+  withX: dart.fnType(typed_data.Float64x2, [core.double]),
>+  withY: dart.fnType(typed_data.Float64x2, [core.double]),
>+  min: dart.fnType(typed_data.Float64x2, [typed_data.Float64x2]),
>+  max: dart.fnType(typed_data.Float64x2, [typed_data.Float64x2]),
>+  sqrt: dart.fnType(typed_data.Float64x2, [])
>+}));
>+dart.setGetterSignature(_native_typed_data.NativeFloat64x2, () => ({
>+  __proto__: dart.getGetters(_native_typed_data.NativeFloat64x2.__proto__),
>+  signMask: core.int
>+}));
>+dart.setLibraryUri(_native_typed_data.NativeFloat64x2, "dart:_native_typed_data");
>+dart.setFieldSignature(_native_typed_data.NativeFloat64x2, () => ({
>+  __proto__: dart.getFields(_native_typed_data.NativeFloat64x2.__proto__),
>+  x: dart.finalFieldType(core.double),
>+  y: dart.finalFieldType(core.double)
>+}));
>+dart.defineExtensionMethods(_native_typed_data.NativeFloat64x2, ['toString']);
>+dart.defineLazy(_native_typed_data.NativeFloat64x2, {
>+  /*_native_typed_data.NativeFloat64x2._list*/get _list() {
>+    return _native_typed_data.NativeFloat64List.new(2);
>+  },
>+  set _list(_) {},
>+  /*_native_typed_data.NativeFloat64x2._uint32View*/get _uint32View() {
>+    return _native_typed_data.NativeUint32List._check(_native_typed_data.NativeFloat64x2._list.buffer[$asUint32List]());
>+  },
>+  set _uint32View(_) {}
>+});
>+_native_typed_data._isInvalidArrayIndex = function(index) {
>+  return index >>> 0 !== index;
>+};
>+_native_typed_data._checkValidIndex = function(index, list, length) {
>+  if (dart.test(_native_typed_data._isInvalidArrayIndex(index)) || index >= dart.notNull(length)) {
>+    dart.throw(_js_helper.diagnoseIndexError(list, index));
>+  }
>+};
>+_native_typed_data._checkValidRange = function(start, end, length) {
>+  if (dart.test(_native_typed_data._isInvalidArrayIndex(start)) || (end == null ? dart.notNull(start) > dart.notNull(length) : dart.test(_native_typed_data._isInvalidArrayIndex(end)) || dart.notNull(start) > dart.notNull(end) || dart.notNull(end) > dart.notNull(length))) {
>+    dart.throw(_js_helper.diagnoseRangeError(start, end, length));
>+  }
>+  if (end == null) return length;
>+  return end;
>+};
>+const _thenNoZoneRegistration = dart.privateName(async, "_thenNoZoneRegistration");
>+const _completeWithValue = dart.privateName(async, "_completeWithValue");
>+const _asyncComplete = dart.privateName(async, "_asyncComplete");
>+async.async = function(T, initGenerator) {
>+  let iter = null;
>+  let onValue = null;
>+  let onError = null;
>+  function onAwait(value) {
>+    let f = null;
>+    if (async._Future.is(value)) {
>+      f = value;
>+    } else if (async.Future.is(value)) {
>+      f = new async._Future.new();
>+      async._Future._chainForeignFuture(value, f);
>+    } else {
>+      f = new async._Future.value(value);
>+    }
>+    f = f[_thenNoZoneRegistration](core.Object, onValue, onError);
>+    return f;
>+  }
>+  onValue = value => {
>+    let iteratorResult = iter.next(value);
>+    value = iteratorResult.value;
>+    return iteratorResult.done ? value : onAwait(value);
>+  };
>+  onError = (value, stackTrace) => {
>+    let iteratorResult = iter.throw(dart.createErrorWithStack(value, stackTrace));
>+    value = iteratorResult.value;
>+    return iteratorResult.done ? value : onAwait(value);
>+  };
>+  let zone = async.Zone.current;
>+  if (!(zone === async._rootZone)) {
>+    onValue = zone.registerUnaryCallback(core.Object, core.Object, onValue);
>+    onError = zone.registerBinaryCallback(core.Object, core.Object, core.StackTrace, onError);
>+  }
>+  let asyncFuture = new (async._Future$(T)).new();
>+  let isRunningAsEvent = false;
>+  function runBody() {
>+    try {
>+      iter = initGenerator()[Symbol.iterator]();
>+      let iteratorValue = iter.next(null);
>+      let value = iteratorValue.value;
>+      if (iteratorValue.done) {
>+        if (async.Future.is(value)) {
>+          if (async._Future.is(value)) {
>+            async._Future._chainCoreFuture(value, asyncFuture);
>+          } else {
>+            async._Future._chainForeignFuture(value, asyncFuture);
>+          }
>+        } else if (isRunningAsEvent) {
>+          asyncFuture[_completeWithValue](value);
>+        } else {
>+          asyncFuture[_asyncComplete](value);
>+        }
>+      } else {
>+        async._Future._chainCoreFuture(onAwait(value), asyncFuture);
>+      }
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      let s = dart.stackTrace(e$);
>+      if (isRunningAsEvent) {
>+        async._completeWithErrorCallback(asyncFuture, e, s);
>+      } else {
>+        async._asyncCompleteWithErrorCallback(asyncFuture, e, s);
>+      }
>+    }
>+  }
>+  if (dart.test(dart.startAsyncSynchronously)) {
>+    runBody();
>+    isRunningAsEvent = true;
>+  } else {
>+    isRunningAsEvent = true;
>+    async.scheduleMicrotask(runBody);
>+  }
>+  return asyncFuture;
>+};
>+const _handleErrorCallback = dart.privateName(async, "_handleErrorCallback");
>+const _runBodyCallback = dart.privateName(async, "_runBodyCallback");
>+const _fatal = dart.privateName(async, "_fatal");
>+const _is__AsyncStarImpl_default = Symbol('_is__AsyncStarImpl_default');
>+async._AsyncStarImpl$ = dart.generic(T => {
>+  let StreamControllerOfT = () => (StreamControllerOfT = dart.constFn(async.StreamController$(T)))();
>+  let StreamOfT = () => (StreamOfT = dart.constFn(async.Stream$(T)))();
>+  let _AsyncStarImplOfT = () => (_AsyncStarImplOfT = dart.constFn(async._AsyncStarImpl$(T)))();
>+  let _AsyncStarImplOfTToObject = () => (_AsyncStarImplOfTToObject = dart.constFn(dart.fnType(core.Object, [_AsyncStarImplOfT()])))();
>+  class _AsyncStarImpl extends core.Object {
>+    get stream() {
>+      return this.controller.stream;
>+    }
>+    get handleError() {
>+      if (this[_handleErrorCallback] == null) {
>+        this[_handleErrorCallback] = dart.fn((error, stackTrace) => {
>+          try {
>+            this.jsIterator.throw(dart.createErrorWithStack(error, stackTrace));
>+          } catch (e$) {
>+            let e = dart.getThrown(e$);
>+            let newStack = dart.stackTrace(e$);
>+            this.addError(e, newStack);
>+          }
>+        }, ObjectAndStackTraceToNull());
>+        let zone = async.Zone.current;
>+        if (!(zone === async.Zone.root)) {
>+          this[_handleErrorCallback] = zone.bindBinaryCallback(core.Null, core.Object, core.StackTrace, this[_handleErrorCallback]);
>+        }
>+      }
>+      return this[_handleErrorCallback];
>+    }
>+    scheduleGenerator() {
>+      if (this.isScheduled || dart.test(this.controller.isPaused) || this.isSuspendedAtYieldStar || this.isSuspendedAtAwait) {
>+        return;
>+      }
>+      this.isScheduled = true;
>+      let zone = async.Zone.current;
>+      if (this[_runBodyCallback] == null) {
>+        this[_runBodyCallback] = this.runBody.bind(this);
>+        if (!(zone === async.Zone.root)) {
>+          let registered = zone.registerUnaryCallback(dart.void, core.Object, this[_runBodyCallback]);
>+          this[_runBodyCallback] = dart.fn(arg => {
>+            if (arg === void 0) arg = null;
>+            return zone.runUnaryGuarded(core.Object, registered, arg);
>+          }, __Tovoid());
>+        }
>+      }
>+      zone.scheduleMicrotask(this[_runBodyCallback]);
>+    }
>+    runBody(awaitValue) {
>+      this.isScheduled = false;
>+      this.isSuspendedAtYield = false;
>+      this.isSuspendedAtAwait = false;
>+      let iterResult = null;
>+      try {
>+        iterResult = this.jsIterator.next(awaitValue);
>+      } catch (e$) {
>+        let e = dart.getThrown(e$);
>+        let s = dart.stackTrace(e$);
>+        this.addError(e, s);
>+        return null;
>+      }
>+      if (iterResult.done) {
>+        this.close();
>+        return null;
>+      }
>+      if (this.isSuspendedAtYield || this.isSuspendedAtYieldStar) return null;
>+      this.isSuspendedAtAwait = true;
>+      let value = iterResult.value;
>+      let f = null;
>+      if (async._Future.is(value)) {
>+        f = value;
>+      } else if (async.Future.is(value)) {
>+        f = new async._Future.new();
>+        async._Future._chainForeignFuture(value, f);
>+      } else {
>+        f = new async._Future.value(value);
>+      }
>+      f[_thenNoZoneRegistration](dart.void, this[_runBodyCallback], this.handleError);
>+    }
>+    add(event) {
>+      T._check(event);
>+      if (!this.onListenReceived) this[_fatal]("yield before stream is listened to");
>+      if (this.isSuspendedAtYield) this[_fatal]("unexpected yield");
>+      if (!dart.test(this.controller.hasListener)) {
>+        return true;
>+      }
>+      this.controller.add(event);
>+      this.scheduleGenerator();
>+      this.isSuspendedAtYield = true;
>+      return false;
>+    }
>+    addStream(stream) {
>+      StreamOfT()._check(stream);
>+      if (!this.onListenReceived) this[_fatal]("yield* before stream is listened to");
>+      if (!dart.test(this.controller.hasListener)) return true;
>+      this.isSuspendedAtYieldStar = true;
>+      let whenDoneAdding = this.controller.addStream(stream, {cancelOnError: false});
>+      FutureOfNull()._check(whenDoneAdding.then(core.Null, dart.fn(_ => {
>+        this.isSuspendedAtYieldStar = false;
>+        this.scheduleGenerator();
>+        if (!this.isScheduled) this.isSuspendedAtYield = true;
>+      }, dynamicToNull()), {onError: this.handleError}));
>+      return false;
>+    }
>+    addError(error, stackTrace) {
>+      if (this.cancellationCompleter != null && !dart.test(this.cancellationCompleter.isCompleted)) {
>+        this.cancellationCompleter.completeError(error, stackTrace);
>+      } else if (dart.test(this.controller.hasListener)) {
>+        this.controller.addError(error, stackTrace);
>+      }
>+      this.close();
>+    }
>+    close() {
>+      if (this.cancellationCompleter != null && !dart.test(this.cancellationCompleter.isCompleted)) {
>+        this.cancellationCompleter.complete();
>+      }
>+      this.controller.close();
>+    }
>+    onListen() {
>+      if (!!this.onListenReceived) dart.assertFailed(null, "dart:async", 485, 12, "!onListenReceived");
>+      this.onListenReceived = true;
>+      this.scheduleGenerator();
>+    }
>+    onResume() {
>+      if (this.isSuspendedAtYield) {
>+        this.scheduleGenerator();
>+      }
>+    }
>+    onCancel() {
>+      if (dart.test(this.controller.isClosed)) {
>+        return null;
>+      }
>+      if (this.cancellationCompleter == null) {
>+        this.cancellationCompleter = async.Completer.new();
>+        if (this.isSuspendedAtYield) {
>+          this.scheduleGenerator();
>+        }
>+      }
>+      return this.cancellationCompleter.future;
>+    }
>+    [_fatal](message) {
>+      return dart.throw(new core.StateError.new(message));
>+    }
>+  }
>+  (_AsyncStarImpl.new = function(initGenerator) {
>+    this.controller = null;
>+    this.isSuspendedAtYieldStar = false;
>+    this.onListenReceived = false;
>+    this.isScheduled = false;
>+    this.isSuspendedAtYield = false;
>+    this.isSuspendedAtAwait = false;
>+    this.cancellationCompleter = null;
>+    this.jsIterator = null;
>+    this[_handleErrorCallback] = null;
>+    this[_runBodyCallback] = null;
>+    this.initGenerator = initGenerator;
>+    this.controller = StreamControllerOfT().new({onListen: this.onListen.bind(this), onResume: this.onResume.bind(this), onCancel: this.onCancel.bind(this)});
>+    this.jsIterator = this.initGenerator(this)[Symbol.iterator]();
>+  }).prototype = _AsyncStarImpl.prototype;
>+  dart.addTypeTests(_AsyncStarImpl);
>+  _AsyncStarImpl.prototype[_is__AsyncStarImpl_default] = true;
>+  dart.setMethodSignature(_AsyncStarImpl, () => ({
>+    __proto__: dart.getMethods(_AsyncStarImpl.__proto__),
>+    scheduleGenerator: dart.fnType(dart.void, []),
>+    runBody: dart.fnType(dart.void, [dart.dynamic]),
>+    add: dart.fnType(core.bool, [core.Object]),
>+    addStream: dart.fnType(core.bool, [core.Object]),
>+    addError: dart.fnType(dart.void, [core.Object, core.StackTrace]),
>+    close: dart.fnType(dart.void, []),
>+    onListen: dart.fnType(dart.dynamic, []),
>+    onResume: dart.fnType(dart.dynamic, []),
>+    onCancel: dart.fnType(dart.dynamic, []),
>+    [_fatal]: dart.fnType(dart.dynamic, [core.String])
>+  }));
>+  dart.setGetterSignature(_AsyncStarImpl, () => ({
>+    __proto__: dart.getGetters(_AsyncStarImpl.__proto__),
>+    stream: async.Stream$(T),
>+    handleError: dart.fnType(core.Null, [core.Object, core.StackTrace])
>+  }));
>+  dart.setLibraryUri(_AsyncStarImpl, "dart:async");
>+  dart.setFieldSignature(_AsyncStarImpl, () => ({
>+    __proto__: dart.getFields(_AsyncStarImpl.__proto__),
>+    controller: dart.fieldType(StreamControllerOfT()),
>+    initGenerator: dart.fieldType(_AsyncStarImplOfTToObject()),
>+    isSuspendedAtYieldStar: dart.fieldType(core.bool),
>+    onListenReceived: dart.fieldType(core.bool),
>+    isScheduled: dart.fieldType(core.bool),
>+    isSuspendedAtYield: dart.fieldType(core.bool),
>+    isSuspendedAtAwait: dart.fieldType(core.bool),
>+    cancellationCompleter: dart.fieldType(async.Completer),
>+    jsIterator: dart.fieldType(core.Object),
>+    [_handleErrorCallback]: dart.fieldType(ObjectAndStackTraceToNull()),
>+    [_runBodyCallback]: dart.fieldType(__Tovoid())
>+  }));
>+  return _AsyncStarImpl;
>+});
>+async._AsyncStarImpl = async._AsyncStarImpl$();
>+dart.addTypeTests(async._AsyncStarImpl, _is__AsyncStarImpl_default);
>+async._invokeErrorHandler = function(errorHandler, error, stackTrace) {
>+  if (NullAndNullTodynamic().is(errorHandler)) {
>+    return dart.dcall(errorHandler, [error, stackTrace]);
>+  } else {
>+    let unaryErrorHandler = dynamicTodynamic()._check(errorHandler);
>+    return unaryErrorHandler(error);
>+  }
>+};
>+const _controller = dart.privateName(async, "_controller");
>+const _subscribe = dart.privateName(async, "_subscribe");
>+const _createSubscription = dart.privateName(async, "_createSubscription");
>+const _onListen = dart.privateName(async, "_onListen");
>+const _is__StreamImpl_default = Symbol('_is__StreamImpl_default');
>+async._StreamImpl$ = dart.generic(T => {
>+  let _BufferingStreamSubscriptionOfT = () => (_BufferingStreamSubscriptionOfT = dart.constFn(async._BufferingStreamSubscription$(T)))();
>+  class _StreamImpl extends async.Stream$(T) {
>+    listen(onData, opts) {
>+      let onError = opts && 'onError' in opts ? opts.onError : null;
>+      let onDone = opts && 'onDone' in opts ? opts.onDone : null;
>+      let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
>+      cancelOnError = true === cancelOnError;
>+      let subscription = this[_createSubscription](onData, onError, onDone, cancelOnError);
>+      this[_onListen](subscription);
>+      return subscription;
>+    }
>+    [_createSubscription](onData, onError, onDone, cancelOnError) {
>+      return new (_BufferingStreamSubscriptionOfT()).new(onData, onError, onDone, cancelOnError);
>+    }
>+    [_onListen](subscription) {}
>+  }
>+  (_StreamImpl.new = function() {
>+    _StreamImpl.__proto__.new.call(this);
>+  }).prototype = _StreamImpl.prototype;
>+  dart.addTypeTests(_StreamImpl);
>+  _StreamImpl.prototype[_is__StreamImpl_default] = true;
>+  dart.setMethodSignature(_StreamImpl, () => ({
>+    __proto__: dart.getMethods(_StreamImpl.__proto__),
>+    listen: dart.fnType(async.StreamSubscription$(T), [dart.fnType(dart.void, [T])], {onError: core.Function, onDone: dart.fnType(dart.void, []), cancelOnError: core.bool}),
>+    [_createSubscription]: dart.fnType(async.StreamSubscription$(T), [dart.fnType(dart.void, [T]), core.Function, dart.fnType(dart.void, []), core.bool]),
>+    [_onListen]: dart.fnType(dart.void, [async.StreamSubscription])
>+  }));
>+  dart.setLibraryUri(_StreamImpl, "dart:async");
>+  return _StreamImpl;
>+});
>+async._StreamImpl = async._StreamImpl$();
>+dart.addTypeTests(async._StreamImpl, _is__StreamImpl_default);
>+const _is__ControllerStream_default = Symbol('_is__ControllerStream_default');
>+async._ControllerStream$ = dart.generic(T => {
>+  let _StreamControllerLifecycleOfT = () => (_StreamControllerLifecycleOfT = dart.constFn(async._StreamControllerLifecycle$(T)))();
>+  class _ControllerStream extends async._StreamImpl$(T) {
>+    [_createSubscription](onData, onError, onDone, cancelOnError) {
>+      return this[_controller][_subscribe](onData, onError, onDone, cancelOnError);
>+    }
>+    get hashCode() {
>+      return (dart.notNull(dart.hashCode(this[_controller])) ^ 892482866) >>> 0;
>+    }
>+    _equals(other) {
>+      if (this === other) return true;
>+      return async._ControllerStream.is(other) && other[_controller] == this[_controller];
>+    }
>+  }
>+  (_ControllerStream.new = function(controller) {
>+    this[_controller] = controller;
>+    _ControllerStream.__proto__.new.call(this);
>+  }).prototype = _ControllerStream.prototype;
>+  dart.addTypeTests(_ControllerStream);
>+  _ControllerStream.prototype[_is__ControllerStream_default] = true;
>+  dart.setMethodSignature(_ControllerStream, () => ({
>+    __proto__: dart.getMethods(_ControllerStream.__proto__),
>+    _equals: dart.fnType(core.bool, [core.Object]),
>+    [$_equals]: dart.fnType(core.bool, [core.Object])
>+  }));
>+  dart.setGetterSignature(_ControllerStream, () => ({
>+    __proto__: dart.getGetters(_ControllerStream.__proto__),
>+    hashCode: core.int,
>+    [$hashCode]: core.int
>+  }));
>+  dart.setLibraryUri(_ControllerStream, "dart:async");
>+  dart.setFieldSignature(_ControllerStream, () => ({
>+    __proto__: dart.getFields(_ControllerStream.__proto__),
>+    [_controller]: dart.fieldType(_StreamControllerLifecycleOfT())
>+  }));
>+  dart.defineExtensionMethods(_ControllerStream, ['_equals']);
>+  dart.defineExtensionAccessors(_ControllerStream, ['hashCode']);
>+  return _ControllerStream;
>+});
>+async._ControllerStream = async._ControllerStream$();
>+dart.addTypeTests(async._ControllerStream, _is__ControllerStream_default);
>+const _is__BroadcastStream_default = Symbol('_is__BroadcastStream_default');
>+async._BroadcastStream$ = dart.generic(T => {
>+  class _BroadcastStream extends async._ControllerStream$(T) {
>+    get isBroadcast() {
>+      return true;
>+    }
>+  }
>+  (_BroadcastStream.new = function(controller) {
>+    _BroadcastStream.__proto__.new.call(this, controller);
>+  }).prototype = _BroadcastStream.prototype;
>+  dart.addTypeTests(_BroadcastStream);
>+  _BroadcastStream.prototype[_is__BroadcastStream_default] = true;
>+  dart.setLibraryUri(_BroadcastStream, "dart:async");
>+  return _BroadcastStream;
>+});
>+async._BroadcastStream = async._BroadcastStream$();
>+dart.addTypeTests(async._BroadcastStream, _is__BroadcastStream_default);
>+const _eventState = dart.privateName(async, "_eventState");
>+const _next$ = dart.privateName(async, "_next");
>+const _previous$ = dart.privateName(async, "_previous");
>+const _expectsEvent = dart.privateName(async, "_expectsEvent");
>+const _toggleEventId = dart.privateName(async, "_toggleEventId");
>+const _isFiring = dart.privateName(async, "_isFiring");
>+const _setRemoveAfterFiring = dart.privateName(async, "_setRemoveAfterFiring");
>+const _removeAfterFiring = dart.privateName(async, "_removeAfterFiring");
>+const _onPause = dart.privateName(async, "_onPause");
>+const _onResume = dart.privateName(async, "_onResume");
>+const _recordCancel = dart.privateName(async, "_recordCancel");
>+const _onCancel = dart.privateName(async, "_onCancel");
>+const _recordPause = dart.privateName(async, "_recordPause");
>+const _recordResume = dart.privateName(async, "_recordResume");
>+const _state = dart.privateName(async, "_state");
>+const _onData$ = dart.privateName(async, "_onData");
>+const _onError = dart.privateName(async, "_onError");
>+const _onDone = dart.privateName(async, "_onDone");
>+const _zone$ = dart.privateName(async, "_zone");
>+const _cancelFuture = dart.privateName(async, "_cancelFuture");
>+const _pending = dart.privateName(async, "_pending");
>+const _setPendingEvents = dart.privateName(async, "_setPendingEvents");
>+const _isCanceled = dart.privateName(async, "_isCanceled");
>+const _isPaused = dart.privateName(async, "_isPaused");
>+const _isInputPaused = dart.privateName(async, "_isInputPaused");
>+const _inCallback = dart.privateName(async, "_inCallback");
>+const _guardCallback = dart.privateName(async, "_guardCallback");
>+const _decrementPauseCount = dart.privateName(async, "_decrementPauseCount");
>+const _hasPending = dart.privateName(async, "_hasPending");
>+const _mayResumeInput = dart.privateName(async, "_mayResumeInput");
>+const _cancel = dart.privateName(async, "_cancel");
>+const _isClosed = dart.privateName(async, "_isClosed");
>+const _waitsForCancel = dart.privateName(async, "_waitsForCancel");
>+const _canFire = dart.privateName(async, "_canFire");
>+const _cancelOnError = dart.privateName(async, "_cancelOnError");
>+const _sendData = dart.privateName(async, "_sendData");
>+const _addPending = dart.privateName(async, "_addPending");
>+const _sendError = dart.privateName(async, "_sendError");
>+const _sendDone = dart.privateName(async, "_sendDone");
>+let const$11;
>+const _close = dart.privateName(async, "_close");
>+const _checkState = dart.privateName(async, "_checkState");
>+const _is__BufferingStreamSubscription_default = Symbol('_is__BufferingStreamSubscription_default');
>+async._BufferingStreamSubscription$ = dart.generic(T => {
>+  let _PendingEventsOfT = () => (_PendingEventsOfT = dart.constFn(async._PendingEvents$(T)))();
>+  let _DelayedDataOfT = () => (_DelayedDataOfT = dart.constFn(async._DelayedData$(T)))();
>+  let _StreamImplEventsOfT = () => (_StreamImplEventsOfT = dart.constFn(async._StreamImplEvents$(T)))();
>+  let StreamSubscriptionOfT = () => (StreamSubscriptionOfT = dart.constFn(async.StreamSubscription$(T)))();
>+  let _EventSinkOfT = () => (_EventSinkOfT = dart.constFn(async._EventSink$(T)))();
>+  let _EventDispatchOfT = () => (_EventDispatchOfT = dart.constFn(async._EventDispatch$(T)))();
>+  let TTovoid = () => (TTovoid = dart.constFn(dart.fnType(dart.void, [T])))();
>+  class _BufferingStreamSubscription extends core.Object {
>+    [_setPendingEvents](pendingEvents) {
>+      _PendingEventsOfT()._check(pendingEvents);
>+      if (!(this[_pending] == null)) dart.assertFailed(null, "dart:async/stream_impl.dart", 124, 12, "_pending == null");
>+      if (pendingEvents == null) return;
>+      this[_pending] = pendingEvents;
>+      if (!dart.test(pendingEvents.isEmpty)) {
>+        this[_state] = (dart.notNull(this[_state]) | 64) >>> 0;
>+        this[_pending].schedule(this);
>+      }
>+    }
>+    onData(handleData) {
>+      let t = handleData;
>+      t == null ? handleData = dart.fn(async._nullDataHandler, ObjectTovoid()) : t;
>+      this[_onData$] = this[_zone$].registerUnaryCallback(dart.dynamic, T, handleData);
>+    }
>+    onError(handleError) {
>+      let t = handleError;
>+      t == null ? handleError = dart.fn(async._nullErrorHandler, Object__Tovoid()) : t;
>+      if (ObjectAndStackTraceTovoid().is(handleError)) {
>+        this[_onError] = this[_zone$].registerBinaryCallback(dart.dynamic, core.Object, core.StackTrace, handleError);
>+      } else if (ObjectTovoid().is(handleError)) {
>+        this[_onError] = this[_zone$].registerUnaryCallback(dart.dynamic, core.Object, handleError);
>+      } else {
>+        dart.throw(new core.ArgumentError.new("handleError callback must take either an Object " + "(the error), or both an Object (the error) and a StackTrace."));
>+      }
>+    }
>+    onDone(handleDone) {
>+      let t = handleDone;
>+      t == null ? handleDone = dart.fn(async._nullDoneHandler, VoidTovoid()) : t;
>+      this[_onDone] = this[_zone$].registerCallback(dart.void, handleDone);
>+    }
>+    pause(resumeSignal) {
>+      if (resumeSignal === void 0) resumeSignal = null;
>+      if (dart.test(this[_isCanceled])) return;
>+      let wasPaused = this[_isPaused];
>+      let wasInputPaused = this[_isInputPaused];
>+      this[_state] = (dart.notNull(this[_state]) + 128 | 4) >>> 0;
>+      if (resumeSignal != null) resumeSignal.whenComplete(dart.bind(this, 'resume'));
>+      if (!dart.test(wasPaused) && this[_pending] != null) this[_pending].cancelSchedule();
>+      if (!dart.test(wasInputPaused) && !dart.test(this[_inCallback])) this[_guardCallback](dart.bind(this, _onPause));
>+    }
>+    resume() {
>+      if (dart.test(this[_isCanceled])) return;
>+      if (dart.test(this[_isPaused])) {
>+        this[_decrementPauseCount]();
>+        if (!dart.test(this[_isPaused])) {
>+          if (dart.test(this[_hasPending]) && !dart.test(this[_pending].isEmpty)) {
>+            this[_pending].schedule(this);
>+          } else {
>+            if (!dart.test(this[_mayResumeInput])) dart.assertFailed(null, "dart:async/stream_impl.dart", 180, 18, "_mayResumeInput");
>+            this[_state] = (dart.notNull(this[_state]) & ~4) >>> 0;
>+            if (!dart.test(this[_inCallback])) this[_guardCallback](dart.bind(this, _onResume));
>+          }
>+        }
>+      }
>+    }
>+    cancel() {
>+      this[_state] = (dart.notNull(this[_state]) & ~16) >>> 0;
>+      if (!dart.test(this[_isCanceled])) {
>+        this[_cancel]();
>+      }
>+      let l = this[_cancelFuture];
>+      return l != null ? l : async.Future._nullFuture;
>+    }
>+    asFuture(E, futureValue) {
>+      if (futureValue === void 0) futureValue = null;
>+      let result = new (async._Future$(E)).new();
>+      this[_onDone] = dart.fn(() => {
>+        result[_complete](futureValue);
>+      }, VoidToNull());
>+      this[_onError] = dart.fn((error, stackTrace) => {
>+        let cancelFuture = this.cancel();
>+        if (!(cancelFuture == async.Future._nullFuture)) {
>+          cancelFuture.whenComplete(dart.fn(() => {
>+            result[_completeError](error, stackTrace);
>+          }, VoidToNull()));
>+        } else {
>+          result[_completeError](error, stackTrace);
>+        }
>+      }, dynamicAndStackTraceToNull());
>+      return result;
>+    }
>+    get [_isInputPaused]() {
>+      return (dart.notNull(this[_state]) & 4) !== 0;
>+    }
>+    get [_isClosed]() {
>+      return (dart.notNull(this[_state]) & 2) !== 0;
>+    }
>+    get [_isCanceled]() {
>+      return (dart.notNull(this[_state]) & 8) !== 0;
>+    }
>+    get [_waitsForCancel]() {
>+      return (dart.notNull(this[_state]) & 16) !== 0;
>+    }
>+    get [_inCallback]() {
>+      return (dart.notNull(this[_state]) & 32) !== 0;
>+    }
>+    get [_hasPending]() {
>+      return (dart.notNull(this[_state]) & 64) !== 0;
>+    }
>+    get [_isPaused]() {
>+      return dart.notNull(this[_state]) >= 128;
>+    }
>+    get [_canFire]() {
>+      return dart.notNull(this[_state]) < 32;
>+    }
>+    get [_mayResumeInput]() {
>+      return !dart.test(this[_isPaused]) && (this[_pending] == null || dart.test(this[_pending].isEmpty));
>+    }
>+    get [_cancelOnError]() {
>+      return (dart.notNull(this[_state]) & 1) !== 0;
>+    }
>+    get isPaused() {
>+      return this[_isPaused];
>+    }
>+    [_cancel]() {
>+      this[_state] = (dart.notNull(this[_state]) | 8) >>> 0;
>+      if (dart.test(this[_hasPending])) {
>+        this[_pending].cancelSchedule();
>+      }
>+      if (!dart.test(this[_inCallback])) this[_pending] = null;
>+      this[_cancelFuture] = this[_onCancel]();
>+    }
>+    [_decrementPauseCount]() {
>+      if (!dart.test(this[_isPaused])) dart.assertFailed(null, "dart:async/stream_impl.dart", 253, 12, "_isPaused");
>+      this[_state] = dart.notNull(this[_state]) - 128;
>+    }
>+    [_add](data) {
>+      T._check(data);
>+      if (!!dart.test(this[_isClosed])) dart.assertFailed(null, "dart:async/stream_impl.dart", 260, 12, "!_isClosed");
>+      if (dart.test(this[_isCanceled])) return;
>+      if (dart.test(this[_canFire])) {
>+        this[_sendData](data);
>+      } else {
>+        this[_addPending](new (_DelayedDataOfT()).new(data));
>+      }
>+    }
>+    [_addError](error, stackTrace) {
>+      if (dart.test(this[_isCanceled])) return;
>+      if (dart.test(this[_canFire])) {
>+        this[_sendError](error, stackTrace);
>+      } else {
>+        this[_addPending](new async._DelayedError.new(error, stackTrace));
>+      }
>+    }
>+    [_close]() {
>+      if (!!dart.test(this[_isClosed])) dart.assertFailed(null, "dart:async/stream_impl.dart", 279, 12, "!_isClosed");
>+      if (dart.test(this[_isCanceled])) return;
>+      this[_state] = (dart.notNull(this[_state]) | 2) >>> 0;
>+      if (dart.test(this[_canFire])) {
>+        this[_sendDone]();
>+      } else {
>+        this[_addPending](const$11 || (const$11 = dart.const(new async._DelayedDone.new())));
>+      }
>+    }
>+    [_onPause]() {
>+      if (!dart.test(this[_isInputPaused])) dart.assertFailed(null, "dart:async/stream_impl.dart", 294, 12, "_isInputPaused");
>+    }
>+    [_onResume]() {
>+      if (!!dart.test(this[_isInputPaused])) dart.assertFailed(null, "dart:async/stream_impl.dart", 298, 12, "!_isInputPaused");
>+    }
>+    [_onCancel]() {
>+      if (!dart.test(this[_isCanceled])) dart.assertFailed(null, "dart:async/stream_impl.dart", 302, 12, "_isCanceled");
>+      return null;
>+    }
>+    [_addPending](event) {
>+      let pending = _StreamImplEventsOfT()._check(this[_pending]);
>+      if (this[_pending] == null) {
>+        pending = this[_pending] = new (_StreamImplEventsOfT()).new();
>+      }
>+      pending.add(event);
>+      if (!dart.test(this[_hasPending])) {
>+        this[_state] = (dart.notNull(this[_state]) | 64) >>> 0;
>+        if (!dart.test(this[_isPaused])) {
>+          this[_pending].schedule(this);
>+        }
>+      }
>+    }
>+    [_sendData](data) {
>+      T._check(data);
>+      if (!!dart.test(this[_isCanceled])) dart.assertFailed(null, "dart:async/stream_impl.dart", 331, 12, "!_isCanceled");
>+      if (!!dart.test(this[_isPaused])) dart.assertFailed(null, "dart:async/stream_impl.dart", 332, 12, "!_isPaused");
>+      if (!!dart.test(this[_inCallback])) dart.assertFailed(null, "dart:async/stream_impl.dart", 333, 12, "!_inCallback");
>+      let wasInputPaused = this[_isInputPaused];
>+      this[_state] = (dart.notNull(this[_state]) | 32) >>> 0;
>+      this[_zone$].runUnaryGuarded(T, this[_onData$], data);
>+      this[_state] = (dart.notNull(this[_state]) & ~32) >>> 0;
>+      this[_checkState](wasInputPaused);
>+    }
>+    [_sendError](error, stackTrace) {
>+      if (!!dart.test(this[_isCanceled])) dart.assertFailed(null, "dart:async/stream_impl.dart", 342, 12, "!_isCanceled");
>+      if (!!dart.test(this[_isPaused])) dart.assertFailed(null, "dart:async/stream_impl.dart", 343, 12, "!_isPaused");
>+      if (!!dart.test(this[_inCallback])) dart.assertFailed(null, "dart:async/stream_impl.dart", 344, 12, "!_inCallback");
>+      let wasInputPaused = this[_isInputPaused];
>+      const sendError = () => {
>+        if (dart.test(this[_isCanceled]) && !dart.test(this[_waitsForCancel])) return;
>+        this[_state] = (dart.notNull(this[_state]) | 32) >>> 0;
>+        let onError = this[_onError];
>+        if (ObjectAndStackTraceTovoid().is(onError)) {
>+          this[_zone$].runBinaryGuarded(core.Object, core.StackTrace, onError, error, stackTrace);
>+        } else {
>+          if (!ObjectTovoid().is(this[_onError])) dart.assertFailed(null, "dart:async/stream_impl.dart", 357, 16, "_onError is void Function(Object)");
>+          this[_zone$].runUnaryGuarded(core.Object, ObjectTovoid()._check(this[_onError]), error);
>+        }
>+        this[_state] = (dart.notNull(this[_state]) & ~32) >>> 0;
>+      };
>+      dart.fn(sendError, VoidTovoid());
>+      if (dart.test(this[_cancelOnError])) {
>+        this[_state] = (dart.notNull(this[_state]) | 16) >>> 0;
>+        this[_cancel]();
>+        if (this[_cancelFuture] != null && !(this[_cancelFuture] == async.Future._nullFuture)) {
>+          this[_cancelFuture].whenComplete(sendError);
>+        } else {
>+          sendError();
>+        }
>+      } else {
>+        sendError();
>+        this[_checkState](wasInputPaused);
>+      }
>+    }
>+    [_sendDone]() {
>+      if (!!dart.test(this[_isCanceled])) dart.assertFailed(null, "dart:async/stream_impl.dart", 380, 12, "!_isCanceled");
>+      if (!!dart.test(this[_isPaused])) dart.assertFailed(null, "dart:async/stream_impl.dart", 381, 12, "!_isPaused");
>+      if (!!dart.test(this[_inCallback])) dart.assertFailed(null, "dart:async/stream_impl.dart", 382, 12, "!_inCallback");
>+      const sendDone = () => {
>+        if (!dart.test(this[_waitsForCancel])) return;
>+        this[_state] = (dart.notNull(this[_state]) | 8 | 2 | 32) >>> 0;
>+        this[_zone$].runGuarded(this[_onDone]);
>+        this[_state] = (dart.notNull(this[_state]) & ~32) >>> 0;
>+      };
>+      dart.fn(sendDone, VoidTovoid());
>+      this[_cancel]();
>+      this[_state] = (dart.notNull(this[_state]) | 16) >>> 0;
>+      if (this[_cancelFuture] != null && !(this[_cancelFuture] == async.Future._nullFuture)) {
>+        this[_cancelFuture].whenComplete(sendDone);
>+      } else {
>+        sendDone();
>+      }
>+    }
>+    [_guardCallback](callback) {
>+      if (!!dart.test(this[_inCallback])) dart.assertFailed(null, "dart:async/stream_impl.dart", 411, 12, "!_inCallback");
>+      let wasInputPaused = this[_isInputPaused];
>+      this[_state] = (dart.notNull(this[_state]) | 32) >>> 0;
>+      callback();
>+      this[_state] = (dart.notNull(this[_state]) & ~32) >>> 0;
>+      this[_checkState](wasInputPaused);
>+    }
>+    [_checkState](wasInputPaused) {
>+      if (!!dart.test(this[_inCallback])) dart.assertFailed(null, "dart:async/stream_impl.dart", 430, 12, "!_inCallback");
>+      if (dart.test(this[_hasPending]) && dart.test(this[_pending].isEmpty)) {
>+        this[_state] = (dart.notNull(this[_state]) & ~64) >>> 0;
>+        if (dart.test(this[_isInputPaused]) && dart.test(this[_mayResumeInput])) {
>+          this[_state] = (dart.notNull(this[_state]) & ~4) >>> 0;
>+        }
>+      }
>+      while (true) {
>+        if (dart.test(this[_isCanceled])) {
>+          this[_pending] = null;
>+          return;
>+        }
>+        let isInputPaused = this[_isInputPaused];
>+        if (wasInputPaused == isInputPaused) break;
>+        this[_state] = (dart.notNull(this[_state]) ^ 32) >>> 0;
>+        if (dart.test(isInputPaused)) {
>+          this[_onPause]();
>+        } else {
>+          this[_onResume]();
>+        }
>+        this[_state] = (dart.notNull(this[_state]) & ~32) >>> 0;
>+        wasInputPaused = isInputPaused;
>+      }
>+      if (dart.test(this[_hasPending]) && !dart.test(this[_isPaused])) {
>+        this[_pending].schedule(this);
>+      }
>+    }
>+  }
>+  (_BufferingStreamSubscription.new = function(onData, onError, onDone, cancelOnError) {
>+    this[_onData$] = null;
>+    this[_onError] = null;
>+    this[_onDone] = null;
>+    this[_zone$] = async.Zone.current;
>+    this[_cancelFuture] = null;
>+    this[_pending] = null;
>+    this[_state] = dart.test(cancelOnError) ? 1 : 0;
>+    this.onData(onData);
>+    this.onError(onError);
>+    this.onDone(onDone);
>+  }).prototype = _BufferingStreamSubscription.prototype;
>+  _BufferingStreamSubscription.prototype[dart.isStreamSubscription] = true;
>+  dart.addTypeTests(_BufferingStreamSubscription);
>+  _BufferingStreamSubscription.prototype[_is__BufferingStreamSubscription_default] = true;
>+  _BufferingStreamSubscription[dart.implements] = () => [StreamSubscriptionOfT(), _EventSinkOfT(), _EventDispatchOfT()];
>+  dart.setMethodSignature(_BufferingStreamSubscription, () => ({
>+    __proto__: dart.getMethods(_BufferingStreamSubscription.__proto__),
>+    [_setPendingEvents]: dart.fnType(dart.void, [core.Object]),
>+    onData: dart.fnType(dart.void, [dart.fnType(dart.void, [T])]),
>+    onError: dart.fnType(dart.void, [core.Function]),
>+    onDone: dart.fnType(dart.void, [dart.fnType(dart.void, [])]),
>+    pause: dart.fnType(dart.void, [], [async.Future]),
>+    resume: dart.fnType(dart.void, []),
>+    cancel: dart.fnType(async.Future, []),
>+    asFuture: dart.gFnType(E => [async.Future$(E), [], [E]]),
>+    [_cancel]: dart.fnType(dart.void, []),
>+    [_decrementPauseCount]: dart.fnType(dart.void, []),
>+    [_add]: dart.fnType(dart.void, [core.Object]),
>+    [_addError]: dart.fnType(dart.void, [core.Object, core.StackTrace]),
>+    [_close]: dart.fnType(dart.void, []),
>+    [_onPause]: dart.fnType(dart.void, []),
>+    [_onResume]: dart.fnType(dart.void, []),
>+    [_onCancel]: dart.fnType(async.Future, []),
>+    [_addPending]: dart.fnType(dart.void, [async._DelayedEvent]),
>+    [_sendData]: dart.fnType(dart.void, [core.Object]),
>+    [_sendError]: dart.fnType(dart.void, [core.Object, core.StackTrace]),
>+    [_sendDone]: dart.fnType(dart.void, []),
>+    [_guardCallback]: dart.fnType(dart.void, [dart.fnType(dart.void, [])]),
>+    [_checkState]: dart.fnType(dart.void, [core.bool])
>+  }));
>+  dart.setGetterSignature(_BufferingStreamSubscription, () => ({
>+    __proto__: dart.getGetters(_BufferingStreamSubscription.__proto__),
>+    [_isInputPaused]: core.bool,
>+    [_isClosed]: core.bool,
>+    [_isCanceled]: core.bool,
>+    [_waitsForCancel]: core.bool,
>+    [_inCallback]: core.bool,
>+    [_hasPending]: core.bool,
>+    [_isPaused]: core.bool,
>+    [_canFire]: core.bool,
>+    [_mayResumeInput]: core.bool,
>+    [_cancelOnError]: core.bool,
>+    isPaused: core.bool
>+  }));
>+  dart.setLibraryUri(_BufferingStreamSubscription, "dart:async");
>+  dart.setFieldSignature(_BufferingStreamSubscription, () => ({
>+    __proto__: dart.getFields(_BufferingStreamSubscription.__proto__),
>+    [_onData$]: dart.fieldType(TTovoid()),
>+    [_onError]: dart.fieldType(core.Function),
>+    [_onDone]: dart.fieldType(VoidTovoid()),
>+    [_zone$]: dart.finalFieldType(async.Zone),
>+    [_state]: dart.fieldType(core.int),
>+    [_cancelFuture]: dart.fieldType(async.Future),
>+    [_pending]: dart.fieldType(_PendingEventsOfT())
>+  }));
>+  return _BufferingStreamSubscription;
>+});
>+async._BufferingStreamSubscription = async._BufferingStreamSubscription$();
>+dart.defineLazy(async._BufferingStreamSubscription, {
>+  /*async._BufferingStreamSubscription._STATE_CANCEL_ON_ERROR*/get _STATE_CANCEL_ON_ERROR() {
>+    return 1;
>+  },
>+  /*async._BufferingStreamSubscription._STATE_CLOSED*/get _STATE_CLOSED() {
>+    return 2;
>+  },
>+  /*async._BufferingStreamSubscription._STATE_INPUT_PAUSED*/get _STATE_INPUT_PAUSED() {
>+    return 4;
>+  },
>+  /*async._BufferingStreamSubscription._STATE_CANCELED*/get _STATE_CANCELED() {
>+    return 8;
>+  },
>+  /*async._BufferingStreamSubscription._STATE_WAIT_FOR_CANCEL*/get _STATE_WAIT_FOR_CANCEL() {
>+    return 16;
>+  },
>+  /*async._BufferingStreamSubscription._STATE_IN_CALLBACK*/get _STATE_IN_CALLBACK() {
>+    return 32;
>+  },
>+  /*async._BufferingStreamSubscription._STATE_HAS_PENDING*/get _STATE_HAS_PENDING() {
>+    return 64;
>+  },
>+  /*async._BufferingStreamSubscription._STATE_PAUSE_COUNT*/get _STATE_PAUSE_COUNT() {
>+    return 128;
>+  }
>+});
>+dart.addTypeTests(async._BufferingStreamSubscription, _is__BufferingStreamSubscription_default);
>+const _is__ControllerSubscription_default = Symbol('_is__ControllerSubscription_default');
>+async._ControllerSubscription$ = dart.generic(T => {
>+  let _StreamControllerLifecycleOfT = () => (_StreamControllerLifecycleOfT = dart.constFn(async._StreamControllerLifecycle$(T)))();
>+  class _ControllerSubscription extends async._BufferingStreamSubscription$(T) {
>+    [_onCancel]() {
>+      return this[_controller][_recordCancel](this);
>+    }
>+    [_onPause]() {
>+      this[_controller][_recordPause](this);
>+    }
>+    [_onResume]() {
>+      this[_controller][_recordResume](this);
>+    }
>+  }
>+  (_ControllerSubscription.new = function(controller, onData, onError, onDone, cancelOnError) {
>+    this[_controller] = controller;
>+    _ControllerSubscription.__proto__.new.call(this, onData, onError, onDone, cancelOnError);
>+  }).prototype = _ControllerSubscription.prototype;
>+  dart.addTypeTests(_ControllerSubscription);
>+  _ControllerSubscription.prototype[_is__ControllerSubscription_default] = true;
>+  dart.setLibraryUri(_ControllerSubscription, "dart:async");
>+  dart.setFieldSignature(_ControllerSubscription, () => ({
>+    __proto__: dart.getFields(_ControllerSubscription.__proto__),
>+    [_controller]: dart.finalFieldType(_StreamControllerLifecycleOfT())
>+  }));
>+  return _ControllerSubscription;
>+});
>+async._ControllerSubscription = async._ControllerSubscription$();
>+dart.addTypeTests(async._ControllerSubscription, _is__ControllerSubscription_default);
>+const _is__BroadcastSubscription_default = Symbol('_is__BroadcastSubscription_default');
>+async._BroadcastSubscription$ = dart.generic(T => {
>+  let _BroadcastSubscriptionOfT = () => (_BroadcastSubscriptionOfT = dart.constFn(async._BroadcastSubscription$(T)))();
>+  class _BroadcastSubscription extends async._ControllerSubscription$(T) {
>+    get [_next$]() {
>+      return this[_next];
>+    }
>+    set [_next$](value) {
>+      this[_next] = _BroadcastSubscriptionOfT()._check(value);
>+    }
>+    get [_previous$]() {
>+      return this[_previous];
>+    }
>+    set [_previous$](value) {
>+      this[_previous] = _BroadcastSubscriptionOfT()._check(value);
>+    }
>+    [_expectsEvent](eventId) {
>+      return (dart.notNull(this[_eventState]) & 1) === eventId;
>+    }
>+    [_toggleEventId]() {
>+      this[_eventState] = (dart.notNull(this[_eventState]) ^ 1) >>> 0;
>+    }
>+    get [_isFiring]() {
>+      return (dart.notNull(this[_eventState]) & 2) !== 0;
>+    }
>+    [_setRemoveAfterFiring]() {
>+      if (!dart.test(this[_isFiring])) dart.assertFailed(null, "dart:async/broadcast_stream_controller.dart", 41, 12, "_isFiring");
>+      this[_eventState] = (dart.notNull(this[_eventState]) | 4) >>> 0;
>+    }
>+    get [_removeAfterFiring]() {
>+      return (dart.notNull(this[_eventState]) & 4) !== 0;
>+    }
>+    [_onPause]() {}
>+    [_onResume]() {}
>+  }
>+  (_BroadcastSubscription.new = function(controller, onData, onError, onDone, cancelOnError) {
>+    this[_eventState] = 0;
>+    this[_next] = null;
>+    this[_previous] = null;
>+    _BroadcastSubscription.__proto__.new.call(this, controller, onData, onError, onDone, cancelOnError);
>+    this[_next$] = this[_previous$] = this;
>+  }).prototype = _BroadcastSubscription.prototype;
>+  dart.addTypeTests(_BroadcastSubscription);
>+  _BroadcastSubscription.prototype[_is__BroadcastSubscription_default] = true;
>+  const _next = Symbol("_BroadcastSubscription._next");
>+  const _previous = Symbol("_BroadcastSubscription._previous");
>+  dart.setMethodSignature(_BroadcastSubscription, () => ({
>+    __proto__: dart.getMethods(_BroadcastSubscription.__proto__),
>+    [_expectsEvent]: dart.fnType(core.bool, [core.int]),
>+    [_toggleEventId]: dart.fnType(dart.void, []),
>+    [_setRemoveAfterFiring]: dart.fnType(dart.void, [])
>+  }));
>+  dart.setGetterSignature(_BroadcastSubscription, () => ({
>+    __proto__: dart.getGetters(_BroadcastSubscription.__proto__),
>+    [_isFiring]: core.bool,
>+    [_removeAfterFiring]: core.bool
>+  }));
>+  dart.setLibraryUri(_BroadcastSubscription, "dart:async");
>+  dart.setFieldSignature(_BroadcastSubscription, () => ({
>+    __proto__: dart.getFields(_BroadcastSubscription.__proto__),
>+    [_eventState]: dart.fieldType(core.int),
>+    [_next$]: dart.fieldType(_BroadcastSubscriptionOfT()),
>+    [_previous$]: dart.fieldType(_BroadcastSubscriptionOfT())
>+  }));
>+  return _BroadcastSubscription;
>+});
>+async._BroadcastSubscription = async._BroadcastSubscription$();
>+dart.defineLazy(async._BroadcastSubscription, {
>+  /*async._BroadcastSubscription._STATE_EVENT_ID*/get _STATE_EVENT_ID() {
>+    return 1;
>+  },
>+  /*async._BroadcastSubscription._STATE_FIRING*/get _STATE_FIRING() {
>+    return 2;
>+  },
>+  /*async._BroadcastSubscription._STATE_REMOVE_AFTER_FIRING*/get _STATE_REMOVE_AFTER_FIRING() {
>+    return 4;
>+  }
>+});
>+dart.addTypeTests(async._BroadcastSubscription, _is__BroadcastSubscription_default);
>+const _firstSubscription = dart.privateName(async, "_firstSubscription");
>+const _lastSubscription = dart.privateName(async, "_lastSubscription");
>+const _addStreamState = dart.privateName(async, "_addStreamState");
>+const _doneFuture = dart.privateName(async, "_doneFuture");
>+const _isEmpty = dart.privateName(async, "_isEmpty");
>+const _hasOneListener = dart.privateName(async, "_hasOneListener");
>+const _isAddingStream = dart.privateName(async, "_isAddingStream");
>+const _mayAddEvent = dart.privateName(async, "_mayAddEvent");
>+const _ensureDoneFuture = dart.privateName(async, "_ensureDoneFuture");
>+const _addListener = dart.privateName(async, "_addListener");
>+const _removeListener = dart.privateName(async, "_removeListener");
>+const _callOnCancel = dart.privateName(async, "_callOnCancel");
>+const _addEventError = dart.privateName(async, "_addEventError");
>+const _forEachListener = dart.privateName(async, "_forEachListener");
>+const _mayComplete = dart.privateName(async, "_mayComplete");
>+const _is__BroadcastStreamController_default = Symbol('_is__BroadcastStreamController_default');
>+async._BroadcastStreamController$ = dart.generic(T => {
>+  let _BroadcastStreamOfT = () => (_BroadcastStreamOfT = dart.constFn(async._BroadcastStream$(T)))();
>+  let _StreamSinkWrapperOfT = () => (_StreamSinkWrapperOfT = dart.constFn(async._StreamSinkWrapper$(T)))();
>+  let _BroadcastSubscriptionOfT = () => (_BroadcastSubscriptionOfT = dart.constFn(async._BroadcastSubscription$(T)))();
>+  let _DoneStreamSubscriptionOfT = () => (_DoneStreamSubscriptionOfT = dart.constFn(async._DoneStreamSubscription$(T)))();
>+  let StreamSubscriptionOfT = () => (StreamSubscriptionOfT = dart.constFn(async.StreamSubscription$(T)))();
>+  let StreamOfT = () => (StreamOfT = dart.constFn(async.Stream$(T)))();
>+  let _AddStreamStateOfT = () => (_AddStreamStateOfT = dart.constFn(async._AddStreamState$(T)))();
>+  let _StreamControllerBaseOfT = () => (_StreamControllerBaseOfT = dart.constFn(async._StreamControllerBase$(T)))();
>+  class _BroadcastStreamController extends core.Object {
>+    get onPause() {
>+      dart.throw(new core.UnsupportedError.new("Broadcast stream controllers do not support pause callbacks"));
>+    }
>+    set onPause(onPauseHandler) {
>+      dart.throw(new core.UnsupportedError.new("Broadcast stream controllers do not support pause callbacks"));
>+    }
>+    get onResume() {
>+      dart.throw(new core.UnsupportedError.new("Broadcast stream controllers do not support pause callbacks"));
>+    }
>+    set onResume(onResumeHandler) {
>+      dart.throw(new core.UnsupportedError.new("Broadcast stream controllers do not support pause callbacks"));
>+    }
>+    get stream() {
>+      return new (_BroadcastStreamOfT()).new(this);
>+    }
>+    get sink() {
>+      return new (_StreamSinkWrapperOfT()).new(this);
>+    }
>+    get isClosed() {
>+      return (dart.notNull(this[_state]) & 4) !== 0;
>+    }
>+    get isPaused() {
>+      return false;
>+    }
>+    get hasListener() {
>+      return !dart.test(this[_isEmpty]);
>+    }
>+    get [_hasOneListener]() {
>+      if (!!dart.test(this[_isEmpty])) dart.assertFailed(null, "dart:async/broadcast_stream_controller.dart", 143, 12, "!_isEmpty");
>+      return this[_firstSubscription] == this[_lastSubscription];
>+    }
>+    get [_isFiring]() {
>+      return (dart.notNull(this[_state]) & 2) !== 0;
>+    }
>+    get [_isAddingStream]() {
>+      return (dart.notNull(this[_state]) & 8) !== 0;
>+    }
>+    get [_mayAddEvent]() {
>+      return dart.notNull(this[_state]) < 4;
>+    }
>+    [_ensureDoneFuture]() {
>+      if (this[_doneFuture] != null) return this[_doneFuture];
>+      return this[_doneFuture] = new async._Future.new();
>+    }
>+    get [_isEmpty]() {
>+      return this[_firstSubscription] == null;
>+    }
>+    [_addListener](subscription) {
>+      _BroadcastSubscriptionOfT()._check(subscription);
>+      if (!(subscription[_next$] == subscription)) dart.assertFailed(null, "dart:async/broadcast_stream_controller.dart", 165, 12, "identical(subscription._next, subscription)");
>+      subscription[_eventState] = dart.notNull(this[_state]) & 1;
>+      let oldLast = this[_lastSubscription];
>+      this[_lastSubscription] = subscription;
>+      subscription[_next$] = null;
>+      subscription[_previous$] = oldLast;
>+      if (oldLast == null) {
>+        this[_firstSubscription] = subscription;
>+      } else {
>+        oldLast[_next$] = subscription;
>+      }
>+    }
>+    [_removeListener](subscription) {
>+      _BroadcastSubscriptionOfT()._check(subscription);
>+      if (!(subscription[_controller] === this)) dart.assertFailed(null, "dart:async/broadcast_stream_controller.dart", 180, 12, "identical(subscription._controller, this)");
>+      if (!!(subscription[_next$] == subscription)) dart.assertFailed(null, "dart:async/broadcast_stream_controller.dart", 181, 12, "!identical(subscription._next, subscription)");
>+      let previous = subscription[_previous$];
>+      let next = subscription[_next$];
>+      if (previous == null) {
>+        this[_firstSubscription] = next;
>+      } else {
>+        previous[_next$] = next;
>+      }
>+      if (next == null) {
>+        this[_lastSubscription] = previous;
>+      } else {
>+        next[_previous$] = previous;
>+      }
>+      subscription[_next$] = subscription[_previous$] = subscription;
>+    }
>+    [_subscribe](onData, onError, onDone, cancelOnError) {
>+      if (dart.test(this.isClosed)) {
>+        let t = onDone;
>+        t == null ? onDone = dart.fn(async._nullDoneHandler, VoidTovoid()) : t;
>+        return new (_DoneStreamSubscriptionOfT()).new(onDone);
>+      }
>+      let subscription = new (_BroadcastSubscriptionOfT()).new(this, onData, onError, onDone, cancelOnError);
>+      this[_addListener](_BroadcastSubscriptionOfT()._check(subscription));
>+      if (this[_firstSubscription] == this[_lastSubscription]) {
>+        async._runGuarded(this.onListen);
>+      }
>+      return subscription;
>+    }
>+    [_recordCancel](sub) {
>+      StreamSubscriptionOfT()._check(sub);
>+      let subscription = _BroadcastSubscriptionOfT()._check(sub);
>+      if (subscription[_next$] == subscription) return null;
>+      if (dart.test(subscription[_isFiring])) {
>+        subscription[_setRemoveAfterFiring]();
>+      } else {
>+        this[_removeListener](subscription);
>+        if (!dart.test(this[_isFiring]) && dart.test(this[_isEmpty])) {
>+          this[_callOnCancel]();
>+        }
>+      }
>+      return null;
>+    }
>+    [_recordPause](subscription) {
>+      StreamSubscriptionOfT()._check(subscription);
>+    }
>+    [_recordResume](subscription) {
>+      StreamSubscriptionOfT()._check(subscription);
>+    }
>+    [_addEventError]() {
>+      if (dart.test(this.isClosed)) {
>+        return new core.StateError.new("Cannot add new events after calling close");
>+      }
>+      if (!dart.test(this[_isAddingStream])) dart.assertFailed(null, "dart:async/broadcast_stream_controller.dart", 244, 12, "_isAddingStream");
>+      return new core.StateError.new("Cannot add new events while doing an addStream");
>+    }
>+    add(data) {
>+      T._check(data);
>+      if (!dart.test(this[_mayAddEvent])) dart.throw(this[_addEventError]());
>+      this[_sendData](data);
>+    }
>+    addError(error, stackTrace) {
>+      if (stackTrace === void 0) stackTrace = null;
>+      error = async._nonNullError(error);
>+      if (!dart.test(this[_mayAddEvent])) dart.throw(this[_addEventError]());
>+      let replacement = async.Zone.current.errorCallback(error, stackTrace);
>+      if (replacement != null) {
>+        error = async._nonNullError(replacement.error);
>+        stackTrace = replacement.stackTrace;
>+      }
>+      this[_sendError](error, stackTrace);
>+    }
>+    close() {
>+      if (dart.test(this.isClosed)) {
>+        if (!(this[_doneFuture] != null)) dart.assertFailed(null, "dart:async/broadcast_stream_controller.dart", 266, 14, "_doneFuture != null");
>+        return this[_doneFuture];
>+      }
>+      if (!dart.test(this[_mayAddEvent])) dart.throw(this[_addEventError]());
>+      this[_state] = (dart.notNull(this[_state]) | 4) >>> 0;
>+      let doneFuture = this[_ensureDoneFuture]();
>+      this[_sendDone]();
>+      return doneFuture;
>+    }
>+    get done() {
>+      return this[_ensureDoneFuture]();
>+    }
>+    addStream(stream, opts) {
>+      StreamOfT()._check(stream);
>+      let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
>+      if (!dart.test(this[_mayAddEvent])) dart.throw(this[_addEventError]());
>+      this[_state] = (dart.notNull(this[_state]) | 8) >>> 0;
>+      this[_addStreamState] = new (_AddStreamStateOfT()).new(this, stream, cancelOnError != null ? cancelOnError : false);
>+      return this[_addStreamState].addStreamFuture;
>+    }
>+    [_add](data) {
>+      T._check(data);
>+      this[_sendData](data);
>+    }
>+    [_addError](error, stackTrace) {
>+      this[_sendError](error, stackTrace);
>+    }
>+    [_close]() {
>+      if (!dart.test(this[_isAddingStream])) dart.assertFailed(null, "dart:async/broadcast_stream_controller.dart", 295, 12, "_isAddingStream");
>+      let addState = this[_addStreamState];
>+      this[_addStreamState] = null;
>+      this[_state] = (dart.notNull(this[_state]) & ~8) >>> 0;
>+      addState.complete();
>+    }
>+    [_forEachListener](action) {
>+      if (dart.test(this[_isFiring])) {
>+        dart.throw(new core.StateError.new("Cannot fire new event. Controller is already firing an event"));
>+      }
>+      if (dart.test(this[_isEmpty])) return;
>+      let id = dart.notNull(this[_state]) & 1;
>+      this[_state] = (dart.notNull(this[_state]) ^ (1 | 2)) >>> 0;
>+      let subscription = this[_firstSubscription];
>+      while (subscription != null) {
>+        if (dart.test(subscription[_expectsEvent](id))) {
>+          subscription[_eventState] = (dart.notNull(subscription[_eventState]) | async._BroadcastSubscription._STATE_FIRING) >>> 0;
>+          action(subscription);
>+          subscription[_toggleEventId]();
>+          let next = subscription[_next$];
>+          if (dart.test(subscription[_removeAfterFiring])) {
>+            this[_removeListener](subscription);
>+          }
>+          subscription[_eventState] = (dart.notNull(subscription[_eventState]) & ~async._BroadcastSubscription._STATE_FIRING) >>> 0;
>+          subscription = next;
>+        } else {
>+          subscription = subscription[_next$];
>+        }
>+      }
>+      this[_state] = (dart.notNull(this[_state]) & ~2) >>> 0;
>+      if (dart.test(this[_isEmpty])) {
>+        this[_callOnCancel]();
>+      }
>+    }
>+    [_callOnCancel]() {
>+      if (!dart.test(this[_isEmpty])) dart.assertFailed(null, "dart:async/broadcast_stream_controller.dart", 344, 12, "_isEmpty");
>+      if (dart.test(this.isClosed) && dart.test(this[_doneFuture][_mayComplete])) {
>+        this[_doneFuture][_asyncComplete](null);
>+      }
>+      async._runGuarded(this.onCancel);
>+    }
>+  }
>+  (_BroadcastStreamController.new = function(onListen, onCancel) {
>+    this[_firstSubscription] = null;
>+    this[_lastSubscription] = null;
>+    this[_addStreamState] = null;
>+    this[_doneFuture] = null;
>+    this.onListen = onListen;
>+    this.onCancel = onCancel;
>+    this[_state] = 0;
>+  }).prototype = _BroadcastStreamController.prototype;
>+  dart.addTypeTests(_BroadcastStreamController);
>+  _BroadcastStreamController.prototype[_is__BroadcastStreamController_default] = true;
>+  _BroadcastStreamController[dart.implements] = () => [_StreamControllerBaseOfT()];
>+  dart.setMethodSignature(_BroadcastStreamController, () => ({
>+    __proto__: dart.getMethods(_BroadcastStreamController.__proto__),
>+    [_ensureDoneFuture]: dart.fnType(async._Future, []),
>+    [_addListener]: dart.fnType(dart.void, [core.Object]),
>+    [_removeListener]: dart.fnType(dart.void, [core.Object]),
>+    [_subscribe]: dart.fnType(async.StreamSubscription$(T), [dart.fnType(dart.void, [T]), core.Function, dart.fnType(dart.void, []), core.bool]),
>+    [_recordCancel]: dart.fnType(async.Future, [core.Object]),
>+    [_recordPause]: dart.fnType(dart.void, [core.Object]),
>+    [_recordResume]: dart.fnType(dart.void, [core.Object]),
>+    [_addEventError]: dart.fnType(core.Error, []),
>+    add: dart.fnType(dart.void, [core.Object]),
>+    addError: dart.fnType(dart.void, [core.Object], [core.StackTrace]),
>+    close: dart.fnType(async.Future, []),
>+    addStream: dart.fnType(async.Future, [core.Object], {cancelOnError: core.bool}),
>+    [_add]: dart.fnType(dart.void, [core.Object]),
>+    [_addError]: dart.fnType(dart.void, [core.Object, core.StackTrace]),
>+    [_close]: dart.fnType(dart.void, []),
>+    [_forEachListener]: dart.fnType(dart.void, [dart.fnType(dart.void, [async._BufferingStreamSubscription$(T)])]),
>+    [_callOnCancel]: dart.fnType(dart.void, [])
>+  }));
>+  dart.setGetterSignature(_BroadcastStreamController, () => ({
>+    __proto__: dart.getGetters(_BroadcastStreamController.__proto__),
>+    onPause: dart.fnType(dart.void, []),
>+    onResume: dart.fnType(dart.void, []),
>+    stream: async.Stream$(T),
>+    sink: async.StreamSink$(T),
>+    isClosed: core.bool,
>+    isPaused: core.bool,
>+    hasListener: core.bool,
>+    [_hasOneListener]: core.bool,
>+    [_isFiring]: core.bool,
>+    [_isAddingStream]: core.bool,
>+    [_mayAddEvent]: core.bool,
>+    [_isEmpty]: core.bool,
>+    done: async.Future
>+  }));
>+  dart.setSetterSignature(_BroadcastStreamController, () => ({
>+    __proto__: dart.getSetters(_BroadcastStreamController.__proto__),
>+    onPause: dart.fnType(dart.void, []),
>+    onResume: dart.fnType(dart.void, [])
>+  }));
>+  dart.setLibraryUri(_BroadcastStreamController, "dart:async");
>+  dart.setFieldSignature(_BroadcastStreamController, () => ({
>+    __proto__: dart.getFields(_BroadcastStreamController.__proto__),
>+    onListen: dart.fieldType(VoidTovoid()),
>+    onCancel: dart.fieldType(VoidTodynamic()),
>+    [_state]: dart.fieldType(core.int),
>+    [_firstSubscription]: dart.fieldType(_BroadcastSubscriptionOfT()),
>+    [_lastSubscription]: dart.fieldType(_BroadcastSubscriptionOfT()),
>+    [_addStreamState]: dart.fieldType(_AddStreamStateOfT()),
>+    [_doneFuture]: dart.fieldType(async._Future)
>+  }));
>+  return _BroadcastStreamController;
>+});
>+async._BroadcastStreamController = async._BroadcastStreamController$();
>+dart.defineLazy(async._BroadcastStreamController, {
>+  /*async._BroadcastStreamController._STATE_INITIAL*/get _STATE_INITIAL() {
>+    return 0;
>+  },
>+  /*async._BroadcastStreamController._STATE_EVENT_ID*/get _STATE_EVENT_ID() {
>+    return 1;
>+  },
>+  /*async._BroadcastStreamController._STATE_FIRING*/get _STATE_FIRING() {
>+    return 2;
>+  },
>+  /*async._BroadcastStreamController._STATE_CLOSED*/get _STATE_CLOSED() {
>+    return 4;
>+  },
>+  /*async._BroadcastStreamController._STATE_ADDSTREAM*/get _STATE_ADDSTREAM() {
>+    return 8;
>+  }
>+});
>+dart.addTypeTests(async._BroadcastStreamController, _is__BroadcastStreamController_default);
>+const _is__SyncBroadcastStreamController_default = Symbol('_is__SyncBroadcastStreamController_default');
>+async._SyncBroadcastStreamController$ = dart.generic(T => {
>+  let _BufferingStreamSubscriptionOfT = () => (_BufferingStreamSubscriptionOfT = dart.constFn(async._BufferingStreamSubscription$(T)))();
>+  let _BufferingStreamSubscriptionOfTToNull = () => (_BufferingStreamSubscriptionOfTToNull = dart.constFn(dart.fnType(core.Null, [_BufferingStreamSubscriptionOfT()])))();
>+  let SynchronousStreamControllerOfT = () => (SynchronousStreamControllerOfT = dart.constFn(async.SynchronousStreamController$(T)))();
>+  class _SyncBroadcastStreamController extends async._BroadcastStreamController$(T) {
>+    get [_mayAddEvent]() {
>+      return dart.test(super[_mayAddEvent]) && !dart.test(this[_isFiring]);
>+    }
>+    [_addEventError]() {
>+      if (dart.test(this[_isFiring])) {
>+        return new core.StateError.new("Cannot fire new event. Controller is already firing an event");
>+      }
>+      return super[_addEventError]();
>+    }
>+    [_sendData](data) {
>+      T._check(data);
>+      if (dart.test(this[_isEmpty])) return;
>+      if (dart.test(this[_hasOneListener])) {
>+        this[_state] = (dart.notNull(this[_state]) | async._BroadcastStreamController._STATE_FIRING) >>> 0;
>+        let subscription = this[_firstSubscription];
>+        subscription[_add](data);
>+        this[_state] = (dart.notNull(this[_state]) & ~async._BroadcastStreamController._STATE_FIRING) >>> 0;
>+        if (dart.test(this[_isEmpty])) {
>+          this[_callOnCancel]();
>+        }
>+        return;
>+      }
>+      this[_forEachListener](dart.fn(subscription => {
>+        subscription[_add](data);
>+      }, _BufferingStreamSubscriptionOfTToNull()));
>+    }
>+    [_sendError](error, stackTrace) {
>+      if (dart.test(this[_isEmpty])) return;
>+      this[_forEachListener](dart.fn(subscription => {
>+        subscription[_addError](error, stackTrace);
>+      }, _BufferingStreamSubscriptionOfTToNull()));
>+    }
>+    [_sendDone]() {
>+      if (!dart.test(this[_isEmpty])) {
>+        this[_forEachListener](dart.fn(subscription => {
>+          subscription[_close]();
>+        }, _BufferingStreamSubscriptionOfTToNull()));
>+      } else {
>+        if (!(this[_doneFuture] != null)) dart.assertFailed(null, "dart:async/broadcast_stream_controller.dart", 400, 14, "_doneFuture != null");
>+        if (!dart.test(this[_doneFuture][_mayComplete])) dart.assertFailed(null, "dart:async/broadcast_stream_controller.dart", 401, 14, "_doneFuture._mayComplete");
>+        this[_doneFuture][_asyncComplete](null);
>+      }
>+    }
>+  }
>+  (_SyncBroadcastStreamController.new = function(onListen, onCancel) {
>+    _SyncBroadcastStreamController.__proto__.new.call(this, onListen, onCancel);
>+  }).prototype = _SyncBroadcastStreamController.prototype;
>+  dart.addTypeTests(_SyncBroadcastStreamController);
>+  _SyncBroadcastStreamController.prototype[_is__SyncBroadcastStreamController_default] = true;
>+  _SyncBroadcastStreamController[dart.implements] = () => [SynchronousStreamControllerOfT()];
>+  dart.setMethodSignature(_SyncBroadcastStreamController, () => ({
>+    __proto__: dart.getMethods(_SyncBroadcastStreamController.__proto__),
>+    [_sendData]: dart.fnType(dart.void, [core.Object]),
>+    [_sendError]: dart.fnType(dart.void, [core.Object, core.StackTrace]),
>+    [_sendDone]: dart.fnType(dart.void, [])
>+  }));
>+  dart.setLibraryUri(_SyncBroadcastStreamController, "dart:async");
>+  return _SyncBroadcastStreamController;
>+});
>+async._SyncBroadcastStreamController = async._SyncBroadcastStreamController$();
>+dart.addTypeTests(async._SyncBroadcastStreamController, _is__SyncBroadcastStreamController_default);
>+let const$12;
>+const _is__AsyncBroadcastStreamController_default = Symbol('_is__AsyncBroadcastStreamController_default');
>+async._AsyncBroadcastStreamController$ = dart.generic(T => {
>+  let _DelayedDataOfT = () => (_DelayedDataOfT = dart.constFn(async._DelayedData$(T)))();
>+  class _AsyncBroadcastStreamController extends async._BroadcastStreamController$(T) {
>+    [_sendData](data) {
>+      T._check(data);
>+      for (let subscription = this[_firstSubscription]; subscription != null; subscription = subscription[_next$]) {
>+        subscription[_addPending](new (_DelayedDataOfT()).new(data));
>+      }
>+    }
>+    [_sendError](error, stackTrace) {
>+      for (let subscription = this[_firstSubscription]; subscription != null; subscription = subscription[_next$]) {
>+        subscription[_addPending](new async._DelayedError.new(error, stackTrace));
>+      }
>+    }
>+    [_sendDone]() {
>+      if (!dart.test(this[_isEmpty])) {
>+        for (let subscription = this[_firstSubscription]; subscription != null; subscription = subscription[_next$]) {
>+          subscription[_addPending](const$12 || (const$12 = dart.const(new async._DelayedDone.new())));
>+        }
>+      } else {
>+        if (!(this[_doneFuture] != null)) dart.assertFailed(null, "dart:async/broadcast_stream_controller.dart", 437, 14, "_doneFuture != null");
>+        if (!dart.test(this[_doneFuture][_mayComplete])) dart.assertFailed(null, "dart:async/broadcast_stream_controller.dart", 438, 14, "_doneFuture._mayComplete");
>+        this[_doneFuture][_asyncComplete](null);
>+      }
>+    }
>+  }
>+  (_AsyncBroadcastStreamController.new = function(onListen, onCancel) {
>+    _AsyncBroadcastStreamController.__proto__.new.call(this, onListen, onCancel);
>+  }).prototype = _AsyncBroadcastStreamController.prototype;
>+  dart.addTypeTests(_AsyncBroadcastStreamController);
>+  _AsyncBroadcastStreamController.prototype[_is__AsyncBroadcastStreamController_default] = true;
>+  dart.setMethodSignature(_AsyncBroadcastStreamController, () => ({
>+    __proto__: dart.getMethods(_AsyncBroadcastStreamController.__proto__),
>+    [_sendData]: dart.fnType(dart.void, [core.Object]),
>+    [_sendError]: dart.fnType(dart.void, [core.Object, core.StackTrace]),
>+    [_sendDone]: dart.fnType(dart.void, [])
>+  }));
>+  dart.setLibraryUri(_AsyncBroadcastStreamController, "dart:async");
>+  return _AsyncBroadcastStreamController;
>+});
>+async._AsyncBroadcastStreamController = async._AsyncBroadcastStreamController$();
>+dart.addTypeTests(async._AsyncBroadcastStreamController, _is__AsyncBroadcastStreamController_default);
>+const _addPendingEvent = dart.privateName(async, "_addPendingEvent");
>+let const$13;
>+const _is__AsBroadcastStreamController_default = Symbol('_is__AsBroadcastStreamController_default');
>+async._AsBroadcastStreamController$ = dart.generic(T => {
>+  let _StreamImplEventsOfT = () => (_StreamImplEventsOfT = dart.constFn(async._StreamImplEvents$(T)))();
>+  let _DelayedDataOfT = () => (_DelayedDataOfT = dart.constFn(async._DelayedData$(T)))();
>+  let _EventDispatchOfT = () => (_EventDispatchOfT = dart.constFn(async._EventDispatch$(T)))();
>+  class _AsBroadcastStreamController extends async._SyncBroadcastStreamController$(T) {
>+    get [_hasPending]() {
>+      return this[_pending] != null && !dart.test(this[_pending].isEmpty);
>+    }
>+    [_addPendingEvent](event) {
>+      let t = this[_pending];
>+      t == null ? this[_pending] = new (_StreamImplEventsOfT()).new() : t;
>+      this[_pending].add(event);
>+    }
>+    add(data) {
>+      T._check(data);
>+      if (!dart.test(this.isClosed) && dart.test(this[_isFiring])) {
>+        this[_addPendingEvent](new (_DelayedDataOfT()).new(data));
>+        return;
>+      }
>+      super.add(data);
>+      while (dart.test(this[_hasPending])) {
>+        this[_pending].handleNext(this);
>+      }
>+    }
>+    addError(error, stackTrace) {
>+      if (stackTrace === void 0) stackTrace = null;
>+      if (!dart.test(this.isClosed) && dart.test(this[_isFiring])) {
>+        this[_addPendingEvent](new async._DelayedError.new(error, stackTrace));
>+        return;
>+      }
>+      if (!dart.test(this[_mayAddEvent])) dart.throw(this[_addEventError]());
>+      this[_sendError](error, stackTrace);
>+      while (dart.test(this[_hasPending])) {
>+        this[_pending].handleNext(this);
>+      }
>+    }
>+    close() {
>+      if (!dart.test(this.isClosed) && dart.test(this[_isFiring])) {
>+        this[_addPendingEvent](const$13 || (const$13 = dart.const(new async._DelayedDone.new())));
>+        this[_state] = (dart.notNull(this[_state]) | async._BroadcastStreamController._STATE_CLOSED) >>> 0;
>+        return super.done;
>+      }
>+      let result = super.close();
>+      if (!!dart.test(this[_hasPending])) dart.assertFailed(null, "dart:async/broadcast_stream_controller.dart", 499, 12, "!_hasPending");
>+      return result;
>+    }
>+    [_callOnCancel]() {
>+      if (dart.test(this[_hasPending])) {
>+        this[_pending].clear();
>+        this[_pending] = null;
>+      }
>+      super[_callOnCancel]();
>+    }
>+  }
>+  (_AsBroadcastStreamController.new = function(onListen, onCancel) {
>+    this[_pending] = null;
>+    _AsBroadcastStreamController.__proto__.new.call(this, onListen, onCancel);
>+  }).prototype = _AsBroadcastStreamController.prototype;
>+  dart.addTypeTests(_AsBroadcastStreamController);
>+  _AsBroadcastStreamController.prototype[_is__AsBroadcastStreamController_default] = true;
>+  _AsBroadcastStreamController[dart.implements] = () => [_EventDispatchOfT()];
>+  dart.setMethodSignature(_AsBroadcastStreamController, () => ({
>+    __proto__: dart.getMethods(_AsBroadcastStreamController.__proto__),
>+    [_addPendingEvent]: dart.fnType(dart.void, [async._DelayedEvent]),
>+    add: dart.fnType(dart.void, [core.Object])
>+  }));
>+  dart.setGetterSignature(_AsBroadcastStreamController, () => ({
>+    __proto__: dart.getGetters(_AsBroadcastStreamController.__proto__),
>+    [_hasPending]: core.bool
>+  }));
>+  dart.setLibraryUri(_AsBroadcastStreamController, "dart:async");
>+  dart.setFieldSignature(_AsBroadcastStreamController, () => ({
>+    __proto__: dart.getFields(_AsBroadcastStreamController.__proto__),
>+    [_pending]: dart.fieldType(_StreamImplEventsOfT())
>+  }));
>+  return _AsBroadcastStreamController;
>+});
>+async._AsBroadcastStreamController = async._AsBroadcastStreamController$();
>+dart.addTypeTests(async._AsBroadcastStreamController, _is__AsBroadcastStreamController_default);
>+async.DeferredLibrary = class DeferredLibrary extends core.Object {
>+  get libraryName() {
>+    return this[libraryName$];
>+  }
>+  set libraryName(value) {
>+    super.libraryName = value;
>+  }
>+  get uri() {
>+    return this[uri$];
>+  }
>+  set uri(value) {
>+    super.uri = value;
>+  }
>+  load() {
>+    dart.throw("DeferredLibrary not supported. " + "please use the `import \"lib.dart\" deferred as lib` syntax.");
>+  }
>+};
>+(async.DeferredLibrary.new = function(libraryName, opts) {
>+  let uri = opts && 'uri' in opts ? opts.uri : null;
>+  this[libraryName$] = libraryName;
>+  this[uri$] = uri;
>+}).prototype = async.DeferredLibrary.prototype;
>+dart.addTypeTests(async.DeferredLibrary);
>+const libraryName$ = Symbol("DeferredLibrary.libraryName");
>+const uri$ = Symbol("DeferredLibrary.uri");
>+dart.setMethodSignature(async.DeferredLibrary, () => ({
>+  __proto__: dart.getMethods(async.DeferredLibrary.__proto__),
>+  load: dart.fnType(async.Future$(core.Null), [])
>+}));
>+dart.setLibraryUri(async.DeferredLibrary, "dart:async");
>+dart.setFieldSignature(async.DeferredLibrary, () => ({
>+  __proto__: dart.getFields(async.DeferredLibrary.__proto__),
>+  libraryName: dart.finalFieldType(core.String),
>+  uri: dart.finalFieldType(core.String)
>+}));
>+const _s = dart.privateName(async, "_s");
>+async.DeferredLoadException = class DeferredLoadException extends core.Object {
>+  toString() {
>+    return "DeferredLoadException: '" + dart.str(this[_s]) + "'";
>+  }
>+};
>+(async.DeferredLoadException.new = function(s) {
>+  this[_s] = s;
>+}).prototype = async.DeferredLoadException.prototype;
>+dart.addTypeTests(async.DeferredLoadException);
>+async.DeferredLoadException[dart.implements] = () => [core.Exception];
>+dart.setLibraryUri(async.DeferredLoadException, "dart:async");
>+dart.setFieldSignature(async.DeferredLoadException, () => ({
>+  __proto__: dart.getFields(async.DeferredLoadException.__proto__),
>+  [_s]: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionMethods(async.DeferredLoadException, ['toString']);
>+async.FutureOr$ = dart.generic(T => {
>+  let FutureOfT = () => (FutureOfT = dart.constFn(async.Future$(T)))();
>+  class FutureOr extends core.Object {}
>+  (FutureOr.__ = function() {
>+    dart.throw(new core.UnsupportedError.new("FutureOr can't be instantiated"));
>+  }).prototype = FutureOr.prototype;
>+  FutureOr.is = function is_FutureOr(o) {
>+    return T.is(o) || FutureOfT().is(o);
>+  };
>+  FutureOr.as = function as_FutureOr(o) {
>+    if (o == null || T.is(o) || FutureOfT().is(o)) return o;
>+    return dart.as(o, this, false);
>+  };
>+  FutureOr._check = function check_FutureOr(o) {
>+    if (o == null || T.is(o) || FutureOfT().is(o)) return o;
>+    return dart.as(o, this, true);
>+  };
>+  dart.setLibraryUri(FutureOr, "dart:async");
>+  return FutureOr;
>+});
>+async.FutureOr = async.FutureOr$();
>+const _asyncCompleteError = dart.privateName(async, "_asyncCompleteError");
>+let const$14;
>+async.Future$ = dart.generic(T => {
>+  let _FutureOfT = () => (_FutureOfT = dart.constFn(async._Future$(T)))();
>+  let FutureOfT = () => (FutureOfT = dart.constFn(async.Future$(T)))();
>+  class Future extends core.Object {
>+    static new(computation) {
>+      let result = new (_FutureOfT()).new();
>+      async.Timer.run(dart.fn(() => {
>+        try {
>+          result[_complete](computation());
>+        } catch (e$) {
>+          let e = dart.getThrown(e$);
>+          let s = dart.stackTrace(e$);
>+          async._completeWithErrorCallback(result, e, s);
>+        }
>+      }, VoidToNull()));
>+      return result;
>+    }
>+    static microtask(computation) {
>+      let result = new (_FutureOfT()).new();
>+      async.scheduleMicrotask(dart.fn(() => {
>+        try {
>+          result[_complete](computation());
>+        } catch (e$) {
>+          let e = dart.getThrown(e$);
>+          let s = dart.stackTrace(e$);
>+          async._completeWithErrorCallback(result, e, s);
>+        }
>+      }, VoidToNull()));
>+      return result;
>+    }
>+    static sync(computation) {
>+      try {
>+        let result = computation();
>+        if (FutureOfT().is(result)) {
>+          return result;
>+        } else {
>+          return new (_FutureOfT()).value(T._check(result));
>+        }
>+      } catch (e) {
>+        let error = dart.getThrown(e);
>+        let stackTrace = dart.stackTrace(e);
>+        let future = new (_FutureOfT()).new();
>+        let replacement = async.Zone.current.errorCallback(error, stackTrace);
>+        if (replacement != null) {
>+          future[_asyncCompleteError](async._nonNullError(replacement.error), replacement.stackTrace);
>+        } else {
>+          future[_asyncCompleteError](error, stackTrace);
>+        }
>+        return future;
>+      }
>+    }
>+    static value(value) {
>+      if (value === void 0) value = null;
>+      return new (_FutureOfT()).immediate(value);
>+    }
>+    static error(error, stackTrace) {
>+      if (stackTrace === void 0) stackTrace = null;
>+      error = async._nonNullError(error);
>+      if (!(async.Zone.current === async._rootZone)) {
>+        let replacement = async.Zone.current.errorCallback(error, stackTrace);
>+        if (replacement != null) {
>+          error = async._nonNullError(replacement.error);
>+          stackTrace = replacement.stackTrace;
>+        }
>+      }
>+      return new (_FutureOfT()).immediateError(error, stackTrace);
>+    }
>+    static delayed(duration, computation) {
>+      if (computation === void 0) computation = null;
>+      let result = new (_FutureOfT()).new();
>+      async.Timer.new(duration, dart.fn(() => {
>+        if (computation == null) {
>+          result[_complete](null);
>+        } else {
>+          try {
>+            result[_complete](computation());
>+          } catch (e$) {
>+            let e = dart.getThrown(e$);
>+            let s = dart.stackTrace(e$);
>+            async._completeWithErrorCallback(result, e, s);
>+          }
>+        }
>+      }, VoidToNull()));
>+      return result;
>+    }
>+    static wait(T, futures, opts) {
>+      let eagerError = opts && 'eagerError' in opts ? opts.eagerError : false;
>+      let cleanUp = opts && 'cleanUp' in opts ? opts.cleanUp : null;
>+      let result = new (async._Future$(core.List$(T))).new();
>+      let values = null;
>+      let remaining = 0;
>+      let error = null;
>+      let stackTrace = null;
>+      function handleError(theError, theStackTrace) {
>+        remaining--;
>+        if (values != null) {
>+          if (cleanUp != null) {
>+            for (let value of values) {
>+              if (value != null) {
>+                FutureOfNull().sync(dart.fn(() => {
>+                  cleanUp(value);
>+                }, VoidToNull()));
>+              }
>+            }
>+          }
>+          values = null;
>+          if (remaining === 0 || dart.test(eagerError)) {
>+            result[_completeError](theError, theStackTrace);
>+          } else {
>+            error = theError;
>+            stackTrace = theStackTrace;
>+          }
>+        } else if (remaining === 0 && !dart.test(eagerError)) {
>+          result[_completeError](error, stackTrace);
>+        }
>+      }
>+      dart.fn(handleError, dynamicAndStackTraceToNull());
>+      try {
>+        for (let future of futures) {
>+          let pos = remaining;
>+          FutureOfNull()._check(future.then(core.Null, dart.fn(value => {
>+            remaining--;
>+            if (values != null) {
>+              values[$_set](pos, value);
>+              if (remaining === 0) {
>+                result[_completeWithValue](values);
>+              }
>+            } else {
>+              if (cleanUp != null && value != null) {
>+                FutureOfNull().sync(dart.fn(() => {
>+                  cleanUp(value);
>+                }, VoidToNull()));
>+              }
>+              if (remaining === 0 && !dart.test(eagerError)) {
>+                result[_completeError](error, stackTrace);
>+              }
>+            }
>+          }, dart.fnType(core.Null, [T])), {onError: handleError}));
>+          remaining++;
>+        }
>+        if (remaining === 0) {
>+          return async.Future$(core.List$(T)).value(const$14 || (const$14 = dart.constList([], core.Null)));
>+        }
>+        values = core.List$(T).new(remaining);
>+      } catch (e$) {
>+        let e = dart.getThrown(e$);
>+        let st = dart.stackTrace(e$);
>+        if (remaining === 0 || dart.test(eagerError)) {
>+          return async.Future$(core.List$(T)).error(e, st);
>+        } else {
>+          error = e;
>+          stackTrace = st;
>+        }
>+      }
>+      return result;
>+    }
>+    static any(T, futures) {
>+      let completer = async.Completer$(T).sync();
>+      let onValue = value => {
>+        if (!dart.test(completer.isCompleted)) completer.complete(value);
>+      };
>+      dart.fn(onValue, dart.fnType(core.Null, [T]));
>+      let onError = (error, stack) => {
>+        if (!dart.test(completer.isCompleted)) completer.completeError(error, stack);
>+      };
>+      dart.fn(onError, dynamicAndStackTraceToNull());
>+      for (let future of futures) {
>+        FutureOfNull()._check(future.then(core.Null, onValue, {onError: onError}));
>+      }
>+      return completer.future;
>+    }
>+    static forEach(T, elements, action) {
>+      let iterator = elements[$iterator];
>+      return async.Future.doWhile(dart.fn(() => {
>+        if (!dart.test(iterator.moveNext())) return false;
>+        let result = action(iterator.current);
>+        if (async.Future.is(result)) return FutureOfbool()._check(result.then(core.bool, dart.fn(async.Future._kTrue, dynamicTobool())));
>+        return true;
>+      }, VoidToFutureOrOfbool()));
>+    }
>+    static _kTrue(_) {
>+      return true;
>+    }
>+    static doWhile(action) {
>+      let doneSignal = new async._Future.new();
>+      let nextIteration = null;
>+      nextIteration = async.Zone.current.bindUnaryCallbackGuarded(core.bool, dart.fn(keepGoing => {
>+        while (dart.test(keepGoing)) {
>+          let result = null;
>+          try {
>+            result = action();
>+          } catch (e) {
>+            let error = dart.getThrown(e);
>+            let stackTrace = dart.stackTrace(e);
>+            async._asyncCompleteWithErrorCallback(doneSignal, error, stackTrace);
>+            return;
>+          }
>+          if (FutureOfbool().is(result)) {
>+            result.then(dart.void, nextIteration, {onError: dart.bind(doneSignal, _completeError)});
>+            return;
>+          }
>+          keepGoing = core.bool._check(result);
>+        }
>+        doneSignal[_complete](null);
>+      }, boolToNull()));
>+      nextIteration(true);
>+      return doneSignal;
>+    }
>+  }
>+  (Future[dart.mixinNew] = function() {
>+  }).prototype = Future.prototype;
>+  dart.addTypeTests(Future);
>+  Future.prototype[dart.isFuture] = true;
>+  dart.setLibraryUri(Future, "dart:async");
>+  return Future;
>+});
>+async.Future = async.Future$();
>+dart.defineLazy(async.Future, {
>+  /*async.Future._nullFuture*/get _nullFuture() {
>+    return new (_FutureOfNull()).zoneValue(null, async.Zone.root);
>+  },
>+  /*async.Future._falseFuture*/get _falseFuture() {
>+    return new (_FutureOfbool()).zoneValue(false, async.Zone.root);
>+  }
>+});
>+dart.addTypeTests(async.Future, dart.isFuture);
>+async.TimeoutException = class TimeoutException extends core.Object {
>+  get message() {
>+    return this[message$0];
>+  }
>+  set message(value) {
>+    super.message = value;
>+  }
>+  get duration() {
>+    return this[duration$];
>+  }
>+  set duration(value) {
>+    super.duration = value;
>+  }
>+  toString() {
>+    let result = "TimeoutException";
>+    if (this.duration != null) result = "TimeoutException after " + dart.str(this.duration);
>+    if (this.message != null) result = result + ": " + dart.str(this.message);
>+    return result;
>+  }
>+};
>+(async.TimeoutException.new = function(message, duration) {
>+  if (duration === void 0) duration = null;
>+  this[message$0] = message;
>+  this[duration$] = duration;
>+}).prototype = async.TimeoutException.prototype;
>+dart.addTypeTests(async.TimeoutException);
>+const message$0 = Symbol("TimeoutException.message");
>+const duration$ = Symbol("TimeoutException.duration");
>+async.TimeoutException[dart.implements] = () => [core.Exception];
>+dart.setLibraryUri(async.TimeoutException, "dart:async");
>+dart.setFieldSignature(async.TimeoutException, () => ({
>+  __proto__: dart.getFields(async.TimeoutException.__proto__),
>+  message: dart.finalFieldType(core.String),
>+  duration: dart.finalFieldType(core.Duration)
>+}));
>+dart.defineExtensionMethods(async.TimeoutException, ['toString']);
>+const _is_Completer_default = Symbol('_is_Completer_default');
>+async.Completer$ = dart.generic(T => {
>+  let _AsyncCompleterOfT = () => (_AsyncCompleterOfT = dart.constFn(async._AsyncCompleter$(T)))();
>+  let _SyncCompleterOfT = () => (_SyncCompleterOfT = dart.constFn(async._SyncCompleter$(T)))();
>+  class Completer extends core.Object {
>+    static new() {
>+      return new (_AsyncCompleterOfT()).new();
>+    }
>+    static sync() {
>+      return new (_SyncCompleterOfT()).new();
>+    }
>+  }
>+  (Completer[dart.mixinNew] = function() {
>+  }).prototype = Completer.prototype;
>+  dart.addTypeTests(Completer);
>+  Completer.prototype[_is_Completer_default] = true;
>+  dart.setLibraryUri(Completer, "dart:async");
>+  return Completer;
>+});
>+async.Completer = async.Completer$();
>+dart.addTypeTests(async.Completer, _is_Completer_default);
>+async._completeWithErrorCallback = function(result, error, stackTrace) {
>+  let replacement = async.Zone.current.errorCallback(error, stackTrace);
>+  if (replacement != null) {
>+    error = async._nonNullError(replacement.error);
>+    stackTrace = replacement.stackTrace;
>+  }
>+  result[_completeError](error, stackTrace);
>+};
>+async._asyncCompleteWithErrorCallback = function(result, error, stackTrace) {
>+  let replacement = async.Zone.current.errorCallback(error, stackTrace);
>+  if (replacement != null) {
>+    error = async._nonNullError(replacement.error);
>+    stackTrace = replacement.stackTrace;
>+  }
>+  result[_asyncCompleteError](error, stackTrace);
>+};
>+async._nonNullError = function(error) {
>+  return error != null ? error : new core.NullThrownError.new();
>+};
>+const _is__Completer_default = Symbol('_is__Completer_default');
>+async._Completer$ = dart.generic(T => {
>+  let _FutureOfT = () => (_FutureOfT = dart.constFn(async._Future$(T)))();
>+  let CompleterOfT = () => (CompleterOfT = dart.constFn(async.Completer$(T)))();
>+  class _Completer extends core.Object {
>+    completeError(error, stackTrace) {
>+      if (stackTrace === void 0) stackTrace = null;
>+      error = async._nonNullError(error);
>+      if (!dart.test(this.future[_mayComplete])) dart.throw(new core.StateError.new("Future already completed"));
>+      let replacement = async.Zone.current.errorCallback(error, stackTrace);
>+      if (replacement != null) {
>+        error = async._nonNullError(replacement.error);
>+        stackTrace = replacement.stackTrace;
>+      }
>+      this[_completeError](error, stackTrace);
>+    }
>+    get isCompleted() {
>+      return !dart.test(this.future[_mayComplete]);
>+    }
>+  }
>+  (_Completer.new = function() {
>+    this.future = new (_FutureOfT()).new();
>+  }).prototype = _Completer.prototype;
>+  dart.addTypeTests(_Completer);
>+  _Completer.prototype[_is__Completer_default] = true;
>+  _Completer[dart.implements] = () => [CompleterOfT()];
>+  dart.setMethodSignature(_Completer, () => ({
>+    __proto__: dart.getMethods(_Completer.__proto__),
>+    completeError: dart.fnType(dart.void, [core.Object], [core.StackTrace])
>+  }));
>+  dart.setGetterSignature(_Completer, () => ({
>+    __proto__: dart.getGetters(_Completer.__proto__),
>+    isCompleted: core.bool
>+  }));
>+  dart.setLibraryUri(_Completer, "dart:async");
>+  dart.setFieldSignature(_Completer, () => ({
>+    __proto__: dart.getFields(_Completer.__proto__),
>+    future: dart.finalFieldType(_FutureOfT())
>+  }));
>+  return _Completer;
>+});
>+async._Completer = async._Completer$();
>+dart.addTypeTests(async._Completer, _is__Completer_default);
>+const _is__AsyncCompleter_default = Symbol('_is__AsyncCompleter_default');
>+async._AsyncCompleter$ = dart.generic(T => {
>+  let FutureOrOfT = () => (FutureOrOfT = dart.constFn(async.FutureOr$(T)))();
>+  class _AsyncCompleter extends async._Completer$(T) {
>+    complete(value) {
>+      if (value === void 0) value = null;
>+      FutureOrOfT()._check(value);
>+      if (!dart.test(this.future[_mayComplete])) dart.throw(new core.StateError.new("Future already completed"));
>+      this.future[_asyncComplete](value);
>+    }
>+    [_completeError](error, stackTrace) {
>+      this.future[_asyncCompleteError](error, stackTrace);
>+    }
>+  }
>+  (_AsyncCompleter.new = function() {
>+    _AsyncCompleter.__proto__.new.call(this);
>+  }).prototype = _AsyncCompleter.prototype;
>+  dart.addTypeTests(_AsyncCompleter);
>+  _AsyncCompleter.prototype[_is__AsyncCompleter_default] = true;
>+  dart.setMethodSignature(_AsyncCompleter, () => ({
>+    __proto__: dart.getMethods(_AsyncCompleter.__proto__),
>+    complete: dart.fnType(dart.void, [], [core.Object]),
>+    [_completeError]: dart.fnType(dart.void, [core.Object, core.StackTrace])
>+  }));
>+  dart.setLibraryUri(_AsyncCompleter, "dart:async");
>+  return _AsyncCompleter;
>+});
>+async._AsyncCompleter = async._AsyncCompleter$();
>+dart.addTypeTests(async._AsyncCompleter, _is__AsyncCompleter_default);
>+const _is__SyncCompleter_default = Symbol('_is__SyncCompleter_default');
>+async._SyncCompleter$ = dart.generic(T => {
>+  let FutureOrOfT = () => (FutureOrOfT = dart.constFn(async.FutureOr$(T)))();
>+  class _SyncCompleter extends async._Completer$(T) {
>+    complete(value) {
>+      if (value === void 0) value = null;
>+      FutureOrOfT()._check(value);
>+      if (!dart.test(this.future[_mayComplete])) dart.throw(new core.StateError.new("Future already completed"));
>+      this.future[_complete](value);
>+    }
>+    [_completeError](error, stackTrace) {
>+      this.future[_completeError](error, stackTrace);
>+    }
>+  }
>+  (_SyncCompleter.new = function() {
>+    _SyncCompleter.__proto__.new.call(this);
>+  }).prototype = _SyncCompleter.prototype;
>+  dart.addTypeTests(_SyncCompleter);
>+  _SyncCompleter.prototype[_is__SyncCompleter_default] = true;
>+  dart.setMethodSignature(_SyncCompleter, () => ({
>+    __proto__: dart.getMethods(_SyncCompleter.__proto__),
>+    complete: dart.fnType(dart.void, [], [core.Object]),
>+    [_completeError]: dart.fnType(dart.void, [core.Object, core.StackTrace])
>+  }));
>+  dart.setLibraryUri(_SyncCompleter, "dart:async");
>+  return _SyncCompleter;
>+});
>+async._SyncCompleter = async._SyncCompleter$();
>+dart.addTypeTests(async._SyncCompleter, _is__SyncCompleter_default);
>+const _nextListener = dart.privateName(async, "_nextListener");
>+const _onValue = dart.privateName(async, "_onValue");
>+const _errorTest = dart.privateName(async, "_errorTest");
>+const _whenCompleteAction = dart.privateName(async, "_whenCompleteAction");
>+const _is__FutureListener_default = Symbol('_is__FutureListener_default');
>+async._FutureListener$ = dart.generic((S, T) => {
>+  let SToFutureOrOfT = () => (SToFutureOrOfT = dart.constFn(dart.fnType(FutureOrOfT(), [S])))();
>+  let FutureOrOfT = () => (FutureOrOfT = dart.constFn(async.FutureOr$(T)))();
>+  let _FutureOfT = () => (_FutureOfT = dart.constFn(async._Future$(T)))();
>+  class _FutureListener extends core.Object {
>+    get [_zone$]() {
>+      return this.result[_zone$];
>+    }
>+    get handlesValue() {
>+      return (dart.notNull(this.state) & 1) !== 0;
>+    }
>+    get handlesError() {
>+      return (dart.notNull(this.state) & 2) !== 0;
>+    }
>+    get hasErrorTest() {
>+      return this.state === 6;
>+    }
>+    get handlesComplete() {
>+      return this.state === 8;
>+    }
>+    get [_onValue]() {
>+      if (!dart.test(this.handlesValue)) dart.assertFailed(null, "dart:async/future_impl.dart", 102, 12, "handlesValue");
>+      return SToFutureOrOfT()._check(this.callback);
>+    }
>+    get [_onError]() {
>+      return this.errorCallback;
>+    }
>+    get [_errorTest]() {
>+      if (!dart.test(this.hasErrorTest)) dart.assertFailed(null, "dart:async/future_impl.dart", 108, 12, "hasErrorTest");
>+      return ObjectTobool()._check(this.callback);
>+    }
>+    get [_whenCompleteAction]() {
>+      if (!dart.test(this.handlesComplete)) dart.assertFailed(null, "dart:async/future_impl.dart", 113, 12, "handlesComplete");
>+      return VoidTodynamic()._check(this.callback);
>+    }
>+    get hasErrorCallback() {
>+      if (!dart.test(this.handlesError)) dart.assertFailed(null, "dart:async/future_impl.dart", 121, 12, "handlesError");
>+      return this[_onError] != null;
>+    }
>+    handleValue(sourceResult) {
>+      S._check(sourceResult);
>+      return this[_zone$].runUnary(FutureOrOfT(), S, this[_onValue], sourceResult);
>+    }
>+    matchesErrorTest(asyncError) {
>+      if (!dart.test(this.hasErrorTest)) return true;
>+      return this[_zone$].runUnary(core.bool, core.Object, this[_errorTest], asyncError.error);
>+    }
>+    handleError(asyncError) {
>+      if (!(dart.test(this.handlesError) && dart.test(this.hasErrorCallback))) dart.assertFailed(null, "dart:async/future_impl.dart", 135, 12, "handlesError && hasErrorCallback");
>+      let errorCallback = this.errorCallback;
>+      if (ObjectAndStackTraceTodynamic().is(errorCallback)) {
>+        return FutureOrOfT()._check(this[_zone$].runBinary(dart.dynamic, core.Object, core.StackTrace, errorCallback, asyncError.error, asyncError.stackTrace));
>+      } else {
>+        if (!ObjectTodynamic().is(errorCallback)) dart.assertFailed(null, "dart:async/future_impl.dart", 143, 14, "errorCallback is dynamic Function(Object)");
>+        return FutureOrOfT()._check(this[_zone$].runUnary(dart.dynamic, core.Object, ObjectTodynamic()._check(errorCallback), asyncError.error));
>+      }
>+    }
>+    handleWhenComplete() {
>+      if (!!dart.test(this.handlesError)) dart.assertFailed(null, "dart:async/future_impl.dart", 149, 12, "!handlesError");
>+      return this[_zone$].run(dart.dynamic, this[_whenCompleteAction]);
>+    }
>+  }
>+  (_FutureListener.then = function(result, onValue, errorCallback) {
>+    this[_nextListener] = null;
>+    this.result = result;
>+    this.callback = onValue;
>+    this.errorCallback = errorCallback;
>+    this.state = errorCallback == null ? 1 : 3;
>+  }).prototype = _FutureListener.prototype;
>+  (_FutureListener.catchError = function(result, errorCallback, callback) {
>+    this[_nextListener] = null;
>+    this.result = result;
>+    this.errorCallback = errorCallback;
>+    this.callback = callback;
>+    this.state = callback == null ? 2 : 6;
>+  }).prototype = _FutureListener.prototype;
>+  (_FutureListener.whenComplete = function(result, callback) {
>+    this[_nextListener] = null;
>+    this.result = result;
>+    this.callback = callback;
>+    this.errorCallback = null;
>+    this.state = 8;
>+  }).prototype = _FutureListener.prototype;
>+  dart.addTypeTests(_FutureListener);
>+  _FutureListener.prototype[_is__FutureListener_default] = true;
>+  dart.setMethodSignature(_FutureListener, () => ({
>+    __proto__: dart.getMethods(_FutureListener.__proto__),
>+    handleValue: dart.fnType(async.FutureOr$(T), [core.Object]),
>+    matchesErrorTest: dart.fnType(core.bool, [async.AsyncError]),
>+    handleError: dart.fnType(async.FutureOr$(T), [async.AsyncError]),
>+    handleWhenComplete: dart.fnType(dart.dynamic, [])
>+  }));
>+  dart.setGetterSignature(_FutureListener, () => ({
>+    __proto__: dart.getGetters(_FutureListener.__proto__),
>+    [_zone$]: async.Zone,
>+    handlesValue: core.bool,
>+    handlesError: core.bool,
>+    hasErrorTest: core.bool,
>+    handlesComplete: core.bool,
>+    [_onValue]: dart.fnType(async.FutureOr$(T), [S]),
>+    [_onError]: core.Function,
>+    [_errorTest]: dart.fnType(core.bool, [core.Object]),
>+    [_whenCompleteAction]: dart.fnType(dart.dynamic, []),
>+    hasErrorCallback: core.bool
>+  }));
>+  dart.setLibraryUri(_FutureListener, "dart:async");
>+  dart.setFieldSignature(_FutureListener, () => ({
>+    __proto__: dart.getFields(_FutureListener.__proto__),
>+    [_nextListener]: dart.fieldType(async._FutureListener),
>+    result: dart.finalFieldType(_FutureOfT()),
>+    state: dart.finalFieldType(core.int),
>+    callback: dart.finalFieldType(core.Function),
>+    errorCallback: dart.finalFieldType(core.Function)
>+  }));
>+  return _FutureListener;
>+});
>+async._FutureListener = async._FutureListener$();
>+dart.defineLazy(async._FutureListener, {
>+  /*async._FutureListener.maskValue*/get maskValue() {
>+    return 1;
>+  },
>+  /*async._FutureListener.maskError*/get maskError() {
>+    return 2;
>+  },
>+  /*async._FutureListener.maskTestError*/get maskTestError() {
>+    return 4;
>+  },
>+  /*async._FutureListener.maskWhencomplete*/get maskWhencomplete() {
>+    return 8;
>+  },
>+  /*async._FutureListener.stateChain*/get stateChain() {
>+    return 0;
>+  },
>+  /*async._FutureListener.stateThen*/get stateThen() {
>+    return 1;
>+  },
>+  /*async._FutureListener.stateThenOnerror*/get stateThenOnerror() {
>+    return 1 | 2;
>+  },
>+  /*async._FutureListener.stateCatcherror*/get stateCatcherror() {
>+    return 2;
>+  },
>+  /*async._FutureListener.stateCatcherrorTest*/get stateCatcherrorTest() {
>+    return 2 | 4;
>+  },
>+  /*async._FutureListener.stateWhencomplete*/get stateWhencomplete() {
>+    return 8;
>+  }
>+});
>+dart.addTypeTests(async._FutureListener, _is__FutureListener_default);
>+const _resultOrListeners = dart.privateName(async, "_resultOrListeners");
>+const _setValue = dart.privateName(async, "_setValue");
>+const _isPendingComplete = dart.privateName(async, "_isPendingComplete");
>+const _mayAddListener = dart.privateName(async, "_mayAddListener");
>+const _isChained = dart.privateName(async, "_isChained");
>+const _isComplete = dart.privateName(async, "_isComplete");
>+const _hasError = dart.privateName(async, "_hasError");
>+const _setChained = dart.privateName(async, "_setChained");
>+const _setPendingComplete = dart.privateName(async, "_setPendingComplete");
>+const _clearPendingComplete = dart.privateName(async, "_clearPendingComplete");
>+const _error = dart.privateName(async, "_error");
>+const _chainSource = dart.privateName(async, "_chainSource");
>+const _setErrorObject = dart.privateName(async, "_setErrorObject");
>+const _setError = dart.privateName(async, "_setError");
>+const _cloneResult = dart.privateName(async, "_cloneResult");
>+const _prependListeners = dart.privateName(async, "_prependListeners");
>+const _reverseListeners = dart.privateName(async, "_reverseListeners");
>+const _removeListeners = dart.privateName(async, "_removeListeners");
>+const _chainFuture = dart.privateName(async, "_chainFuture");
>+const _is__Future_default = Symbol('_is__Future_default');
>+async._Future$ = dart.generic(T => {
>+  let _FutureOfT = () => (_FutureOfT = dart.constFn(async._Future$(T)))();
>+  let _FutureListenerOfT$T = () => (_FutureListenerOfT$T = dart.constFn(async._FutureListener$(T, T)))();
>+  let StreamOfT = () => (StreamOfT = dart.constFn(async.Stream$(T)))();
>+  let FutureOrOfT = () => (FutureOrOfT = dart.constFn(async.FutureOr$(T)))();
>+  let FutureOfT = () => (FutureOfT = dart.constFn(async.Future$(T)))();
>+  let VoidToFutureOrOfT = () => (VoidToFutureOrOfT = dart.constFn(dart.fnType(FutureOrOfT(), [])))();
>+  let TToNull = () => (TToNull = dart.constFn(dart.fnType(core.Null, [T])))();
>+  class _Future extends core.Object {
>+    get [_mayComplete]() {
>+      return this[_state] === 0;
>+    }
>+    get [_isPendingComplete]() {
>+      return this[_state] === 1;
>+    }
>+    get [_mayAddListener]() {
>+      return dart.notNull(this[_state]) <= 1;
>+    }
>+    get [_isChained]() {
>+      return this[_state] === 2;
>+    }
>+    get [_isComplete]() {
>+      return dart.notNull(this[_state]) >= 4;
>+    }
>+    get [_hasError]() {
>+      return this[_state] === 8;
>+    }
>+    [_setChained](source) {
>+      if (!dart.test(this[_mayAddListener])) dart.assertFailed(null, "dart:async/future_impl.dart", 233, 12, "_mayAddListener");
>+      this[_state] = 2;
>+      this[_resultOrListeners] = source;
>+    }
>+    then(R, f, opts) {
>+      let onError = opts && 'onError' in opts ? opts.onError : null;
>+      let currentZone = async.Zone.current;
>+      if (!(currentZone === async._rootZone)) {
>+        f = currentZone.registerUnaryCallback(async.FutureOr$(R), T, f);
>+        if (onError != null) {
>+          onError = async._registerErrorHandler(onError, currentZone);
>+        }
>+      }
>+      return this[_thenNoZoneRegistration](R, f, onError);
>+    }
>+    [_thenNoZoneRegistration](E, f, onError) {
>+      let result = new (async._Future$(E)).new();
>+      this[_addListener](new (async._FutureListener$(T, E)).then(result, f, onError));
>+      return result;
>+    }
>+    catchError(onError, opts) {
>+      let test = opts && 'test' in opts ? opts.test : null;
>+      let result = new (_FutureOfT()).new();
>+      if (!(result[_zone$] === async._rootZone)) {
>+        onError = async._registerErrorHandler(onError, result[_zone$]);
>+        if (test != null) test = result[_zone$].registerUnaryCallback(core.bool, dart.dynamic, test);
>+      }
>+      this[_addListener](new (_FutureListenerOfT$T()).catchError(result, onError, test));
>+      return result;
>+    }
>+    whenComplete(action) {
>+      let result = new (_FutureOfT()).new();
>+      if (!(result[_zone$] === async._rootZone)) {
>+        action = result[_zone$].registerCallback(dart.dynamic, action);
>+      }
>+      this[_addListener](new (_FutureListenerOfT$T()).whenComplete(result, action));
>+      return result;
>+    }
>+    asStream() {
>+      return StreamOfT().fromFuture(this);
>+    }
>+    [_setPendingComplete]() {
>+      if (!dart.test(this[_mayComplete])) dart.assertFailed(null, "dart:async/future_impl.dart", 282, 12, "_mayComplete");
>+      this[_state] = 1;
>+    }
>+    [_clearPendingComplete]() {
>+      if (!dart.test(this[_isPendingComplete])) dart.assertFailed(null, "dart:async/future_impl.dart", 287, 12, "_isPendingComplete");
>+      this[_state] = 0;
>+    }
>+    get [_error]() {
>+      if (!dart.test(this[_hasError])) dart.assertFailed(null, "dart:async/future_impl.dart", 292, 12, "_hasError");
>+      return async.AsyncError._check(this[_resultOrListeners]);
>+    }
>+    get [_chainSource]() {
>+      if (!dart.test(this[_isChained])) dart.assertFailed(null, "dart:async/future_impl.dart", 297, 12, "_isChained");
>+      return async._Future._check(this[_resultOrListeners]);
>+    }
>+    [_setValue](value) {
>+      T._check(value);
>+      if (!!dart.test(this[_isComplete])) dart.assertFailed(null, "dart:async/future_impl.dart", 303, 12, "!_isComplete");
>+      this[_state] = 4;
>+      this[_resultOrListeners] = value;
>+    }
>+    [_setErrorObject](error) {
>+      if (!!dart.test(this[_isComplete])) dart.assertFailed(null, "dart:async/future_impl.dart", 309, 12, "!_isComplete");
>+      this[_state] = 8;
>+      this[_resultOrListeners] = error;
>+    }
>+    [_setError](error, stackTrace) {
>+      this[_setErrorObject](new async.AsyncError.new(error, stackTrace));
>+    }
>+    [_cloneResult](source) {
>+      if (!!dart.test(this[_isComplete])) dart.assertFailed(null, "dart:async/future_impl.dart", 322, 12, "!_isComplete");
>+      if (!dart.test(source[_isComplete])) dart.assertFailed(null, "dart:async/future_impl.dart", 323, 12, "source._isComplete");
>+      this[_state] = source[_state];
>+      this[_resultOrListeners] = source[_resultOrListeners];
>+    }
>+    [_addListener](listener) {
>+      if (!(listener[_nextListener] == null)) dart.assertFailed(null, "dart:async/future_impl.dart", 329, 12, "listener._nextListener == null");
>+      if (dart.test(this[_mayAddListener])) {
>+        listener[_nextListener] = async._FutureListener._check(this[_resultOrListeners]);
>+        this[_resultOrListeners] = listener;
>+      } else {
>+        if (dart.test(this[_isChained])) {
>+          let source = this[_chainSource];
>+          if (!dart.test(source[_isComplete])) {
>+            source[_addListener](listener);
>+            return;
>+          }
>+          this[_cloneResult](source);
>+        }
>+        if (!dart.test(this[_isComplete])) dart.assertFailed(null, "dart:async/future_impl.dart", 345, 14, "_isComplete");
>+        this[_zone$].scheduleMicrotask(dart.fn(() => {
>+          async._Future._propagateToListeners(this, listener);
>+        }, VoidToNull()));
>+      }
>+    }
>+    [_prependListeners](listeners) {
>+      if (listeners == null) return;
>+      if (dart.test(this[_mayAddListener])) {
>+        let existingListeners = async._FutureListener._check(this[_resultOrListeners]);
>+        this[_resultOrListeners] = listeners;
>+        if (existingListeners != null) {
>+          let cursor = listeners;
>+          while (cursor[_nextListener] != null) {
>+            cursor = cursor[_nextListener];
>+          }
>+          cursor[_nextListener] = existingListeners;
>+        }
>+      } else {
>+        if (dart.test(this[_isChained])) {
>+          let source = this[_chainSource];
>+          if (!dart.test(source[_isComplete])) {
>+            source[_prependListeners](listeners);
>+            return;
>+          }
>+          this[_cloneResult](source);
>+        }
>+        if (!dart.test(this[_isComplete])) dart.assertFailed(null, "dart:async/future_impl.dart", 377, 14, "_isComplete");
>+        listeners = this[_reverseListeners](listeners);
>+        this[_zone$].scheduleMicrotask(dart.fn(() => {
>+          async._Future._propagateToListeners(this, listeners);
>+        }, VoidToNull()));
>+      }
>+    }
>+    [_removeListeners]() {
>+      if (!!dart.test(this[_isComplete])) dart.assertFailed(null, "dart:async/future_impl.dart", 388, 12, "!_isComplete");
>+      let current = async._FutureListener._check(this[_resultOrListeners]);
>+      this[_resultOrListeners] = null;
>+      return this[_reverseListeners](current);
>+    }
>+    [_reverseListeners](listeners) {
>+      let prev = null;
>+      let current = listeners;
>+      while (current != null) {
>+        let next = current[_nextListener];
>+        current[_nextListener] = prev;
>+        prev = current;
>+        current = next;
>+      }
>+      return prev;
>+    }
>+    static _chainForeignFuture(source, target) {
>+      if (!!dart.test(target[_isComplete])) dart.assertFailed(null, "dart:async/future_impl.dart", 411, 12, "!target._isComplete");
>+      if (!!async._Future.is(source)) dart.assertFailed(null, "dart:async/future_impl.dart", 412, 12, "source is! _Future");
>+      target[_setPendingComplete]();
>+      try {
>+        FutureOfNull()._check(source.then(core.Null, dart.fn(value => {
>+          if (!dart.test(target[_isPendingComplete])) dart.assertFailed(null, "dart:async/future_impl.dart", 418, 16, "target._isPendingComplete");
>+          target[_clearPendingComplete]();
>+          target[_complete](value);
>+        }, dynamicToNull()), {onError: dart.fn((error, stackTrace) => {
>+            if (stackTrace === void 0) stackTrace = null;
>+            if (!dart.test(target[_isPendingComplete])) dart.assertFailed(null, "dart:async/future_impl.dart", 430, 16, "target._isPendingComplete");
>+            target[_completeError](error, stackTrace);
>+          }, dynamic__ToNull())}));
>+      } catch (e$) {
>+        let e = dart.getThrown(e$);
>+        let s = dart.stackTrace(e$);
>+        async.scheduleMicrotask(dart.fn(() => {
>+          target[_completeError](e, s);
>+        }, VoidToNull()));
>+      }
>+    }
>+    static _chainCoreFuture(source, target) {
>+      if (!dart.test(target[_mayAddListener])) dart.assertFailed(null, "dart:async/future_impl.dart", 447, 12, "target._mayAddListener");
>+      while (dart.test(source[_isChained])) {
>+        source = source[_chainSource];
>+      }
>+      if (dart.test(source[_isComplete])) {
>+        let listeners = target[_removeListeners]();
>+        target[_cloneResult](source);
>+        async._Future._propagateToListeners(target, listeners);
>+      } else {
>+        let listeners = async._FutureListener._check(target[_resultOrListeners]);
>+        target[_setChained](source);
>+        source[_prependListeners](listeners);
>+      }
>+    }
>+    [_complete](value) {
>+      FutureOrOfT()._check(value);
>+      if (!!dart.test(this[_isComplete])) dart.assertFailed(null, "dart:async/future_impl.dart", 463, 12, "!_isComplete");
>+      if (FutureOfT().is(value)) {
>+        if (_FutureOfT().is(value)) {
>+          async._Future._chainCoreFuture(value, this);
>+        } else {
>+          async._Future._chainForeignFuture(value, this);
>+        }
>+      } else {
>+        let listeners = this[_removeListeners]();
>+        this[_setValue](T._check(value));
>+        async._Future._propagateToListeners(this, listeners);
>+      }
>+    }
>+    [_completeWithValue](value) {
>+      T._check(value);
>+      if (!!dart.test(this[_isComplete])) dart.assertFailed(null, "dart:async/future_impl.dart", 478, 12, "!_isComplete");
>+      if (!!FutureOfT().is(value)) dart.assertFailed(null, "dart:async/future_impl.dart", 479, 12, "value is! Future<T>");
>+      let listeners = this[_removeListeners]();
>+      this[_setValue](value);
>+      async._Future._propagateToListeners(this, listeners);
>+    }
>+    [_completeError](error, stackTrace) {
>+      if (stackTrace === void 0) stackTrace = null;
>+      if (!!dart.test(this[_isComplete])) dart.assertFailed(null, "dart:async/future_impl.dart", 487, 12, "!_isComplete");
>+      let listeners = this[_removeListeners]();
>+      this[_setError](error, stackTrace);
>+      async._Future._propagateToListeners(this, listeners);
>+    }
>+    [_asyncComplete](value) {
>+      FutureOrOfT()._check(value);
>+      if (!!dart.test(this[_isComplete])) dart.assertFailed(null, "dart:async/future_impl.dart", 495, 12, "!_isComplete");
>+      if (FutureOfT().is(value)) {
>+        this[_chainFuture](value);
>+        return;
>+      }
>+      this[_setPendingComplete]();
>+      this[_zone$].scheduleMicrotask(dart.fn(() => {
>+        this[_completeWithValue](T._check(value));
>+      }, VoidToNull()));
>+    }
>+    [_chainFuture](value) {
>+      FutureOfT()._check(value);
>+      if (_FutureOfT().is(value)) {
>+        if (dart.test(value[_hasError])) {
>+          this[_setPendingComplete]();
>+          this[_zone$].scheduleMicrotask(dart.fn(() => {
>+            async._Future._chainCoreFuture(value, this);
>+          }, VoidToNull()));
>+        } else {
>+          async._Future._chainCoreFuture(value, this);
>+        }
>+        return;
>+      }
>+      async._Future._chainForeignFuture(value, this);
>+    }
>+    [_asyncCompleteError](error, stackTrace) {
>+      if (!!dart.test(this[_isComplete])) dart.assertFailed(null, "dart:async/future_impl.dart", 535, 12, "!_isComplete");
>+      this[_setPendingComplete]();
>+      this[_zone$].scheduleMicrotask(dart.fn(() => {
>+        this[_completeError](error, stackTrace);
>+      }, VoidToNull()));
>+    }
>+    static _propagateToListeners(source, listeners) {
>+      while (true) {
>+        if (!dart.test(source[_isComplete])) dart.assertFailed(null, "dart:async/future_impl.dart", 549, 14, "source._isComplete");
>+        let hasError = source[_hasError];
>+        if (listeners == null) {
>+          if (dart.test(hasError)) {
>+            let asyncError = source[_error];
>+            source[_zone$].handleUncaughtError(asyncError.error, asyncError.stackTrace);
>+          }
>+          return;
>+        }
>+        while (listeners[_nextListener] != null) {
>+          let listener = listeners;
>+          listeners = listener[_nextListener];
>+          listener[_nextListener] = null;
>+          async._Future._propagateToListeners(source, listener);
>+        }
>+        let listener = listeners;
>+        let sourceResult = source[_resultOrListeners];
>+        let listenerHasError = hasError;
>+        let listenerValueOrError = sourceResult;
>+        if (dart.test(hasError) || dart.test(listener.handlesValue) || dart.test(listener.handlesComplete)) {
>+          let zone = listener[_zone$];
>+          if (dart.test(hasError) && !dart.test(source[_zone$].inSameErrorZone(zone))) {
>+            let asyncError = source[_error];
>+            source[_zone$].handleUncaughtError(asyncError.error, asyncError.stackTrace);
>+            return;
>+          }
>+          let oldZone = null;
>+          if (!(async.Zone.current == zone)) {
>+            oldZone = async.Zone._enter(zone);
>+          }
>+          function handleWhenCompleteCallback() {
>+            if (!!dart.test(listener.handlesValue)) dart.assertFailed(null, "dart:async/future_impl.dart", 605, 18, "!listener.handlesValue");
>+            if (!!dart.test(listener.handlesError)) dart.assertFailed(null, "dart:async/future_impl.dart", 606, 18, "!listener.handlesError");
>+            let completeResult = null;
>+            try {
>+              completeResult = listener.handleWhenComplete();
>+            } catch (e$) {
>+              let e = dart.getThrown(e$);
>+              let s = dart.stackTrace(e$);
>+              if (dart.test(hasError) && core.identical(source[_error].error, e)) {
>+                listenerValueOrError = source[_error];
>+              } else {
>+                listenerValueOrError = new async.AsyncError.new(e, s);
>+              }
>+              listenerHasError = true;
>+              return;
>+            }
>+            if (async.Future.is(completeResult)) {
>+              if (async._Future.is(completeResult) && dart.test(completeResult[_isComplete])) {
>+                if (dart.test(completeResult[_hasError])) {
>+                  listenerValueOrError = completeResult[_error];
>+                  listenerHasError = true;
>+                }
>+                return;
>+              }
>+              let originalSource = source;
>+              listenerValueOrError = completeResult.then(dart.dynamic, dart.fn(_ => originalSource, dynamicTo_Future()));
>+              listenerHasError = false;
>+            }
>+          }
>+          dart.fn(handleWhenCompleteCallback, VoidTovoid());
>+          function handleValueCallback() {
>+            try {
>+              listenerValueOrError = listener.handleValue(sourceResult);
>+            } catch (e$) {
>+              let e = dart.getThrown(e$);
>+              let s = dart.stackTrace(e$);
>+              listenerValueOrError = new async.AsyncError.new(e, s);
>+              listenerHasError = true;
>+            }
>+          }
>+          dart.fn(handleValueCallback, VoidTovoid());
>+          function handleError() {
>+            try {
>+              let asyncError = source[_error];
>+              if (dart.test(listener.matchesErrorTest(asyncError)) && dart.test(listener.hasErrorCallback)) {
>+                listenerValueOrError = listener.handleError(asyncError);
>+                listenerHasError = false;
>+              }
>+            } catch (e$) {
>+              let e = dart.getThrown(e$);
>+              let s = dart.stackTrace(e$);
>+              if (core.identical(source[_error].error, e)) {
>+                listenerValueOrError = source[_error];
>+              } else {
>+                listenerValueOrError = new async.AsyncError.new(e, s);
>+              }
>+              listenerHasError = true;
>+            }
>+          }
>+          dart.fn(handleError, VoidTovoid());
>+          if (dart.test(listener.handlesComplete)) {
>+            handleWhenCompleteCallback();
>+          } else if (!dart.test(hasError)) {
>+            if (dart.test(listener.handlesValue)) {
>+              handleValueCallback();
>+            }
>+          } else {
>+            if (dart.test(listener.handlesError)) {
>+              handleError();
>+            }
>+          }
>+          if (oldZone != null) async.Zone._leave(oldZone);
>+          if (async.Future.is(listenerValueOrError)) {
>+            let chainSource = async.Future._check(listenerValueOrError);
>+            let result = listener.result;
>+            if (async._Future.is(chainSource)) {
>+              if (dart.test(chainSource[_isComplete])) {
>+                listeners = result[_removeListeners]();
>+                result[_cloneResult](chainSource);
>+                source = chainSource;
>+                continue;
>+              } else {
>+                async._Future._chainCoreFuture(chainSource, result);
>+              }
>+            } else {
>+              async._Future._chainForeignFuture(chainSource, result);
>+            }
>+            return;
>+          }
>+        }
>+        let result = listener.result;
>+        listeners = result[_removeListeners]();
>+        if (!dart.test(listenerHasError)) {
>+          result[_setValue](listenerValueOrError);
>+        } else {
>+          let asyncError = async.AsyncError._check(listenerValueOrError);
>+          result[_setErrorObject](asyncError);
>+        }
>+        source = result;
>+      }
>+    }
>+    timeout(timeLimit, opts) {
>+      let onTimeout = opts && 'onTimeout' in opts ? opts.onTimeout : null;
>+      VoidToFutureOrOfT()._check(onTimeout);
>+      if (dart.test(this[_isComplete])) return new (_FutureOfT()).immediate(this);
>+      let result = new (_FutureOfT()).new();
>+      let timer = null;
>+      if (onTimeout == null) {
>+        timer = async.Timer.new(timeLimit, dart.fn(() => {
>+          result[_completeError](new async.TimeoutException.new("Future not completed", timeLimit));
>+        }, VoidToNull()));
>+      } else {
>+        let zone = async.Zone.current;
>+        onTimeout = zone.registerCallback(FutureOrOfT(), onTimeout);
>+        timer = async.Timer.new(timeLimit, dart.fn(() => {
>+          try {
>+            result[_complete](zone.run(FutureOrOfT(), onTimeout));
>+          } catch (e$) {
>+            let e = dart.getThrown(e$);
>+            let s = dart.stackTrace(e$);
>+            result[_completeError](e, s);
>+          }
>+        }, VoidToNull()));
>+      }
>+      this.then(core.Null, dart.fn(v => {
>+        if (dart.test(timer.isActive)) {
>+          timer.cancel();
>+          result[_completeWithValue](v);
>+        }
>+      }, TToNull()), {onError: dart.fn((e, s) => {
>+          if (dart.test(timer.isActive)) {
>+            timer.cancel();
>+            result[_completeError](e, s);
>+          }
>+        }, dynamicAndStackTraceToNull())});
>+      return result;
>+    }
>+  }
>+  (_Future.new = function() {
>+    this[_state] = 0;
>+    this[_resultOrListeners] = null;
>+    this[_zone$] = async.Zone.current;
>+  }).prototype = _Future.prototype;
>+  (_Future.immediate = function(result) {
>+    this[_state] = 0;
>+    this[_resultOrListeners] = null;
>+    this[_zone$] = async.Zone.current;
>+    this[_asyncComplete](result);
>+  }).prototype = _Future.prototype;
>+  (_Future.zoneValue = function(value, zone) {
>+    this[_state] = 0;
>+    this[_resultOrListeners] = null;
>+    this[_zone$] = zone;
>+    this[_setValue](value);
>+  }).prototype = _Future.prototype;
>+  (_Future.immediateError = function(error, stackTrace) {
>+    if (stackTrace === void 0) stackTrace = null;
>+    this[_state] = 0;
>+    this[_resultOrListeners] = null;
>+    this[_zone$] = async.Zone.current;
>+    this[_asyncCompleteError](error, stackTrace);
>+  }).prototype = _Future.prototype;
>+  (_Future.value = function(value) {
>+    _Future.zoneValue.call(this, value, async.Zone.current);
>+  }).prototype = _Future.prototype;
>+  _Future.prototype[dart.isFuture] = true;
>+  dart.addTypeTests(_Future);
>+  _Future.prototype[_is__Future_default] = true;
>+  _Future[dart.implements] = () => [FutureOfT()];
>+  dart.setMethodSignature(_Future, () => ({
>+    __proto__: dart.getMethods(_Future.__proto__),
>+    [_setChained]: dart.fnType(dart.void, [async._Future]),
>+    then: dart.gFnType(R => [async.Future$(R), [dart.fnType(async.FutureOr$(R), [T])], {onError: core.Function}]),
>+    [_thenNoZoneRegistration]: dart.gFnType(E => [async.Future$(E), [dart.fnType(async.FutureOr$(E), [T]), core.Function]]),
>+    catchError: dart.fnType(async.Future$(T), [core.Function], {test: dart.fnType(core.bool, [dart.dynamic])}),
>+    whenComplete: dart.fnType(async.Future$(T), [dart.fnType(dart.dynamic, [])]),
>+    asStream: dart.fnType(async.Stream$(T), []),
>+    [_setPendingComplete]: dart.fnType(dart.void, []),
>+    [_clearPendingComplete]: dart.fnType(dart.void, []),
>+    [_setValue]: dart.fnType(dart.void, [core.Object]),
>+    [_setErrorObject]: dart.fnType(dart.void, [async.AsyncError]),
>+    [_setError]: dart.fnType(dart.void, [core.Object, core.StackTrace]),
>+    [_cloneResult]: dart.fnType(dart.void, [async._Future]),
>+    [_addListener]: dart.fnType(dart.void, [async._FutureListener]),
>+    [_prependListeners]: dart.fnType(dart.void, [async._FutureListener]),
>+    [_removeListeners]: dart.fnType(async._FutureListener, []),
>+    [_reverseListeners]: dart.fnType(async._FutureListener, [async._FutureListener]),
>+    [_complete]: dart.fnType(dart.void, [core.Object]),
>+    [_completeWithValue]: dart.fnType(dart.void, [core.Object]),
>+    [_completeError]: dart.fnType(dart.void, [core.Object], [core.StackTrace]),
>+    [_asyncComplete]: dart.fnType(dart.void, [core.Object]),
>+    [_chainFuture]: dart.fnType(dart.void, [core.Object]),
>+    [_asyncCompleteError]: dart.fnType(dart.void, [dart.dynamic, core.StackTrace]),
>+    timeout: dart.fnType(async.Future$(T), [core.Duration], {onTimeout: core.Object})
>+  }));
>+  dart.setGetterSignature(_Future, () => ({
>+    __proto__: dart.getGetters(_Future.__proto__),
>+    [_mayComplete]: core.bool,
>+    [_isPendingComplete]: core.bool,
>+    [_mayAddListener]: core.bool,
>+    [_isChained]: core.bool,
>+    [_isComplete]: core.bool,
>+    [_hasError]: core.bool,
>+    [_error]: async.AsyncError,
>+    [_chainSource]: async._Future
>+  }));
>+  dart.setLibraryUri(_Future, "dart:async");
>+  dart.setFieldSignature(_Future, () => ({
>+    __proto__: dart.getFields(_Future.__proto__),
>+    [_state]: dart.fieldType(core.int),
>+    [_zone$]: dart.finalFieldType(async.Zone),
>+    [_resultOrListeners]: dart.fieldType(dart.dynamic)
>+  }));
>+  return _Future;
>+});
>+async._Future = async._Future$();
>+dart.defineLazy(async._Future, {
>+  /*async._Future._stateIncomplete*/get _stateIncomplete() {
>+    return 0;
>+  },
>+  /*async._Future._statePendingComplete*/get _statePendingComplete() {
>+    return 1;
>+  },
>+  /*async._Future._stateChained*/get _stateChained() {
>+    return 2;
>+  },
>+  /*async._Future._stateValue*/get _stateValue() {
>+    return 4;
>+  },
>+  /*async._Future._stateError*/get _stateError() {
>+    return 8;
>+  }
>+});
>+dart.addTypeTests(async._Future, _is__Future_default);
>+async._registerErrorHandler = function(errorHandler, zone) {
>+  if (ObjectAndStackTraceTodynamic().is(errorHandler)) {
>+    return zone.registerBinaryCallback(dart.dynamic, core.Object, core.StackTrace, errorHandler);
>+  }
>+  if (ObjectTodynamic().is(errorHandler)) {
>+    return zone.registerUnaryCallback(dart.dynamic, core.Object, errorHandler);
>+  }
>+  dart.throw(new core.ArgumentError.value(errorHandler, "onError", "Error handler must accept one Object or one Object and a StackTrace" + " as arguments, and return a a valid result"));
>+};
>+async._AsyncCallbackEntry = class _AsyncCallbackEntry extends core.Object {};
>+(async._AsyncCallbackEntry.new = function(callback) {
>+  this.next = null;
>+  this.callback = callback;
>+}).prototype = async._AsyncCallbackEntry.prototype;
>+dart.addTypeTests(async._AsyncCallbackEntry);
>+dart.setLibraryUri(async._AsyncCallbackEntry, "dart:async");
>+dart.setFieldSignature(async._AsyncCallbackEntry, () => ({
>+  __proto__: dart.getFields(async._AsyncCallbackEntry.__proto__),
>+  callback: dart.finalFieldType(VoidTovoid()),
>+  next: dart.fieldType(async._AsyncCallbackEntry)
>+}));
>+dart.defineLazy(async, {
>+  /*async._nextCallback*/get _nextCallback() {
>+    return null;
>+  },
>+  set _nextCallback(_) {},
>+  /*async._lastCallback*/get _lastCallback() {
>+    return null;
>+  },
>+  set _lastCallback(_) {},
>+  /*async._lastPriorityCallback*/get _lastPriorityCallback() {
>+    return null;
>+  },
>+  set _lastPriorityCallback(_) {},
>+  /*async._isInCallbackLoop*/get _isInCallbackLoop() {
>+    return false;
>+  },
>+  set _isInCallbackLoop(_) {}
>+});
>+async._microtaskLoop = function() {
>+  while (async._nextCallback != null) {
>+    async._lastPriorityCallback = null;
>+    let entry = async._nextCallback;
>+    async._nextCallback = entry.next;
>+    if (async._nextCallback == null) async._lastCallback = null;
>+    entry.callback();
>+  }
>+};
>+async._startMicrotaskLoop = function() {
>+  async._isInCallbackLoop = true;
>+  try {
>+    async._microtaskLoop();
>+  } finally {
>+    async._lastPriorityCallback = null;
>+    async._isInCallbackLoop = false;
>+    if (async._nextCallback != null) {
>+      async._AsyncRun._scheduleImmediate(dart.fn(async._startMicrotaskLoop, VoidTovoid()));
>+    }
>+  }
>+};
>+async._scheduleAsyncCallback = function(callback) {
>+  let newEntry = new async._AsyncCallbackEntry.new(callback);
>+  if (async._nextCallback == null) {
>+    async._nextCallback = async._lastCallback = newEntry;
>+    if (!dart.test(async._isInCallbackLoop)) {
>+      async._AsyncRun._scheduleImmediate(dart.fn(async._startMicrotaskLoop, VoidTovoid()));
>+    }
>+  } else {
>+    async._lastCallback.next = newEntry;
>+    async._lastCallback = newEntry;
>+  }
>+};
>+async._schedulePriorityAsyncCallback = function(callback) {
>+  if (async._nextCallback == null) {
>+    async._scheduleAsyncCallback(callback);
>+    async._lastPriorityCallback = async._lastCallback;
>+    return;
>+  }
>+  let entry = new async._AsyncCallbackEntry.new(callback);
>+  if (async._lastPriorityCallback == null) {
>+    entry.next = async._nextCallback;
>+    async._nextCallback = async._lastPriorityCallback = entry;
>+  } else {
>+    entry.next = async._lastPriorityCallback.next;
>+    async._lastPriorityCallback.next = entry;
>+    async._lastPriorityCallback = entry;
>+    if (entry.next == null) {
>+      async._lastCallback = entry;
>+    }
>+  }
>+};
>+const _scheduleMicrotask = dart.privateName(async, "_scheduleMicrotask");
>+async.scheduleMicrotask = function(callback) {
>+  let currentZone = async._Zone._check(async.Zone.current);
>+  if (async._rootZone === currentZone) {
>+    async._rootScheduleMicrotask(null, null, async._rootZone, callback);
>+    return;
>+  }
>+  let implementation = currentZone[_scheduleMicrotask];
>+  if (async._rootZone === implementation.zone && dart.test(async._rootZone.inSameErrorZone(currentZone))) {
>+    async._rootScheduleMicrotask(null, null, currentZone, currentZone.registerCallback(dart.void, callback));
>+    return;
>+  }
>+  async.Zone.current.scheduleMicrotask(async.Zone.current.bindCallbackGuarded(callback));
>+};
>+async._AsyncRun = class _AsyncRun extends core.Object {
>+  static _scheduleImmediate(callback) {
>+    async._AsyncRun._scheduleImmediateClosure(callback);
>+  }
>+  static _initializeScheduleImmediate() {
>+    if (dart.global.scheduleImmediate != null) {
>+      return async._AsyncRun._scheduleImmediateJSOverride;
>+    }
>+    return async._AsyncRun._scheduleImmediateWithPromise;
>+  }
>+  static _scheduleImmediateJSOverride(callback) {
>+    dart.addAsyncCallback();
>+    dart.global.scheduleImmediate(() => {
>+      dart.removeAsyncCallback();
>+      callback();
>+    });
>+  }
>+  static _scheduleImmediateWithPromise(callback) {
>+    dart.addAsyncCallback();
>+    dart.global.Promise.resolve(null).then(() => {
>+      dart.removeAsyncCallback();
>+      callback();
>+    });
>+  }
>+};
>+(async._AsyncRun.new = function() {
>+}).prototype = async._AsyncRun.prototype;
>+dart.addTypeTests(async._AsyncRun);
>+dart.setLibraryUri(async._AsyncRun, "dart:async");
>+dart.defineLazy(async._AsyncRun, {
>+  /*async._AsyncRun._scheduleImmediateClosure*/get _scheduleImmediateClosure() {
>+    return async._AsyncRun._initializeScheduleImmediate();
>+  }
>+});
>+async.StreamSubscription$ = dart.generic(T => {
>+  class StreamSubscription extends core.Object {}
>+  (StreamSubscription.new = function() {
>+  }).prototype = StreamSubscription.prototype;
>+  dart.addTypeTests(StreamSubscription);
>+  StreamSubscription.prototype[dart.isStreamSubscription] = true;
>+  dart.setLibraryUri(StreamSubscription, "dart:async");
>+  return StreamSubscription;
>+});
>+async.StreamSubscription = async.StreamSubscription$();
>+dart.addTypeTests(async.StreamSubscription, dart.isStreamSubscription);
>+const _is_EventSink_default = Symbol('_is_EventSink_default');
>+async.EventSink$ = dart.generic(T => {
>+  let SinkOfT = () => (SinkOfT = dart.constFn(core.Sink$(T)))();
>+  class EventSink extends core.Object {}
>+  (EventSink.new = function() {
>+  }).prototype = EventSink.prototype;
>+  dart.addTypeTests(EventSink);
>+  EventSink.prototype[_is_EventSink_default] = true;
>+  EventSink[dart.implements] = () => [SinkOfT()];
>+  dart.setLibraryUri(EventSink, "dart:async");
>+  return EventSink;
>+});
>+async.EventSink = async.EventSink$();
>+dart.addTypeTests(async.EventSink, _is_EventSink_default);
>+const _stream = dart.privateName(async, "_stream");
>+const _is_StreamView_default = Symbol('_is_StreamView_default');
>+async.StreamView$ = dart.generic(T => {
>+  let StreamOfT = () => (StreamOfT = dart.constFn(async.Stream$(T)))();
>+  class StreamView extends async.Stream$(T) {
>+    get isBroadcast() {
>+      return this[_stream].isBroadcast;
>+    }
>+    asBroadcastStream(opts) {
>+      let onListen = opts && 'onListen' in opts ? opts.onListen : null;
>+      let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
>+      return this[_stream].asBroadcastStream({onListen: onListen, onCancel: onCancel});
>+    }
>+    listen(onData, opts) {
>+      let onError = opts && 'onError' in opts ? opts.onError : null;
>+      let onDone = opts && 'onDone' in opts ? opts.onDone : null;
>+      let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
>+      return this[_stream].listen(onData, {onError: onError, onDone: onDone, cancelOnError: cancelOnError});
>+    }
>+  }
>+  (StreamView.new = function(stream) {
>+    this[_stream] = stream;
>+    StreamView.__proto__._internal.call(this);
>+  }).prototype = StreamView.prototype;
>+  dart.addTypeTests(StreamView);
>+  StreamView.prototype[_is_StreamView_default] = true;
>+  dart.setMethodSignature(StreamView, () => ({
>+    __proto__: dart.getMethods(StreamView.__proto__),
>+    listen: dart.fnType(async.StreamSubscription$(T), [dart.fnType(dart.void, [T])], {onError: core.Function, onDone: dart.fnType(dart.void, []), cancelOnError: core.bool})
>+  }));
>+  dart.setLibraryUri(StreamView, "dart:async");
>+  dart.setFieldSignature(StreamView, () => ({
>+    __proto__: dart.getFields(StreamView.__proto__),
>+    [_stream]: dart.finalFieldType(StreamOfT())
>+  }));
>+  return StreamView;
>+});
>+async.StreamView = async.StreamView$();
>+dart.addTypeTests(async.StreamView, _is_StreamView_default);
>+const _is_StreamConsumer_default = Symbol('_is_StreamConsumer_default');
>+async.StreamConsumer$ = dart.generic(S => {
>+  class StreamConsumer extends core.Object {}
>+  (StreamConsumer.new = function() {
>+  }).prototype = StreamConsumer.prototype;
>+  dart.addTypeTests(StreamConsumer);
>+  StreamConsumer.prototype[_is_StreamConsumer_default] = true;
>+  dart.setLibraryUri(StreamConsumer, "dart:async");
>+  return StreamConsumer;
>+});
>+async.StreamConsumer = async.StreamConsumer$();
>+dart.addTypeTests(async.StreamConsumer, _is_StreamConsumer_default);
>+const _is_StreamSink_default = Symbol('_is_StreamSink_default');
>+async.StreamSink$ = dart.generic(S => {
>+  let EventSinkOfS = () => (EventSinkOfS = dart.constFn(async.EventSink$(S)))();
>+  let StreamConsumerOfS = () => (StreamConsumerOfS = dart.constFn(async.StreamConsumer$(S)))();
>+  class StreamSink extends core.Object {}
>+  (StreamSink.new = function() {
>+  }).prototype = StreamSink.prototype;
>+  dart.addTypeTests(StreamSink);
>+  StreamSink.prototype[_is_StreamSink_default] = true;
>+  StreamSink[dart.implements] = () => [EventSinkOfS(), StreamConsumerOfS()];
>+  dart.setLibraryUri(StreamSink, "dart:async");
>+  return StreamSink;
>+});
>+async.StreamSink = async.StreamSink$();
>+dart.addTypeTests(async.StreamSink, _is_StreamSink_default);
>+const _is_StreamTransformer_default = Symbol('_is_StreamTransformer_default');
>+async.StreamTransformer$ = dart.generic((S, T) => {
>+  let _StreamSubscriptionTransformerOfS$T = () => (_StreamSubscriptionTransformerOfS$T = dart.constFn(async._StreamSubscriptionTransformer$(S, T)))();
>+  let _StreamHandlerTransformerOfS$T = () => (_StreamHandlerTransformerOfS$T = dart.constFn(async._StreamHandlerTransformer$(S, T)))();
>+  let _StreamBindTransformerOfS$T = () => (_StreamBindTransformerOfS$T = dart.constFn(async._StreamBindTransformer$(S, T)))();
>+  class StreamTransformer extends core.Object {
>+    static new(onListen) {
>+      return new (_StreamSubscriptionTransformerOfS$T()).new(onListen);
>+    }
>+    static fromHandlers(opts) {
>+      return new (_StreamHandlerTransformerOfS$T()).new(opts);
>+    }
>+    static fromBind(bind) {
>+      return new (_StreamBindTransformerOfS$T()).new(bind);
>+    }
>+    static castFrom(SS, ST, TS, TT, source) {
>+      return new (_internal.CastStreamTransformer$(SS, ST, TS, TT)).new(source);
>+    }
>+  }
>+  (StreamTransformer[dart.mixinNew] = function() {
>+  }).prototype = StreamTransformer.prototype;
>+  dart.addTypeTests(StreamTransformer);
>+  StreamTransformer.prototype[_is_StreamTransformer_default] = true;
>+  dart.setLibraryUri(StreamTransformer, "dart:async");
>+  return StreamTransformer;
>+});
>+async.StreamTransformer = async.StreamTransformer$();
>+dart.addTypeTests(async.StreamTransformer, _is_StreamTransformer_default);
>+const _is_StreamIterator_default = Symbol('_is_StreamIterator_default');
>+async.StreamIterator$ = dart.generic(T => {
>+  let _StreamIteratorOfT = () => (_StreamIteratorOfT = dart.constFn(async._StreamIterator$(T)))();
>+  class StreamIterator extends core.Object {
>+    static new(stream) {
>+      return new (_StreamIteratorOfT()).new(stream);
>+    }
>+  }
>+  (StreamIterator[dart.mixinNew] = function() {
>+  }).prototype = StreamIterator.prototype;
>+  dart.addTypeTests(StreamIterator);
>+  StreamIterator.prototype[_is_StreamIterator_default] = true;
>+  dart.setLibraryUri(StreamIterator, "dart:async");
>+  return StreamIterator;
>+});
>+async.StreamIterator = async.StreamIterator$();
>+dart.addTypeTests(async.StreamIterator, _is_StreamIterator_default);
>+const _is__ControllerEventSinkWrapper_default = Symbol('_is__ControllerEventSinkWrapper_default');
>+async._ControllerEventSinkWrapper$ = dart.generic(T => {
>+  let EventSinkOfT = () => (EventSinkOfT = dart.constFn(async.EventSink$(T)))();
>+  class _ControllerEventSinkWrapper extends core.Object {
>+    add(data) {
>+      T._check(data);
>+      this[_sink].add(data);
>+    }
>+    addError(error, stackTrace) {
>+      if (stackTrace === void 0) stackTrace = null;
>+      this[_sink].addError(error, stackTrace);
>+    }
>+    close() {
>+      this[_sink].close();
>+    }
>+  }
>+  (_ControllerEventSinkWrapper.new = function(sink) {
>+    this[_sink] = sink;
>+  }).prototype = _ControllerEventSinkWrapper.prototype;
>+  dart.addTypeTests(_ControllerEventSinkWrapper);
>+  _ControllerEventSinkWrapper.prototype[_is__ControllerEventSinkWrapper_default] = true;
>+  _ControllerEventSinkWrapper[dart.implements] = () => [EventSinkOfT()];
>+  dart.setMethodSignature(_ControllerEventSinkWrapper, () => ({
>+    __proto__: dart.getMethods(_ControllerEventSinkWrapper.__proto__),
>+    add: dart.fnType(dart.void, [core.Object]),
>+    addError: dart.fnType(dart.void, [core.Object], [core.StackTrace]),
>+    close: dart.fnType(dart.void, [])
>+  }));
>+  dart.setLibraryUri(_ControllerEventSinkWrapper, "dart:async");
>+  dart.setFieldSignature(_ControllerEventSinkWrapper, () => ({
>+    __proto__: dart.getFields(_ControllerEventSinkWrapper.__proto__),
>+    [_sink]: dart.fieldType(async.EventSink)
>+  }));
>+  return _ControllerEventSinkWrapper;
>+});
>+async._ControllerEventSinkWrapper = async._ControllerEventSinkWrapper$();
>+dart.addTypeTests(async._ControllerEventSinkWrapper, _is__ControllerEventSinkWrapper_default);
>+const _is_StreamController_default = Symbol('_is_StreamController_default');
>+async.StreamController$ = dart.generic(T => {
>+  let _SyncStreamControllerOfT = () => (_SyncStreamControllerOfT = dart.constFn(async._SyncStreamController$(T)))();
>+  let _AsyncStreamControllerOfT = () => (_AsyncStreamControllerOfT = dart.constFn(async._AsyncStreamController$(T)))();
>+  let _SyncBroadcastStreamControllerOfT = () => (_SyncBroadcastStreamControllerOfT = dart.constFn(async._SyncBroadcastStreamController$(T)))();
>+  let _AsyncBroadcastStreamControllerOfT = () => (_AsyncBroadcastStreamControllerOfT = dart.constFn(async._AsyncBroadcastStreamController$(T)))();
>+  let StreamSinkOfT = () => (StreamSinkOfT = dart.constFn(async.StreamSink$(T)))();
>+  class StreamController extends core.Object {
>+    static new(opts) {
>+      let onListen = opts && 'onListen' in opts ? opts.onListen : null;
>+      let onPause = opts && 'onPause' in opts ? opts.onPause : null;
>+      let onResume = opts && 'onResume' in opts ? opts.onResume : null;
>+      let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
>+      let sync = opts && 'sync' in opts ? opts.sync : false;
>+      return dart.test(sync) ? new (_SyncStreamControllerOfT()).new(onListen, onPause, onResume, onCancel) : new (_AsyncStreamControllerOfT()).new(onListen, onPause, onResume, onCancel);
>+    }
>+    static broadcast(opts) {
>+      let onListen = opts && 'onListen' in opts ? opts.onListen : null;
>+      let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
>+      let sync = opts && 'sync' in opts ? opts.sync : false;
>+      return dart.test(sync) ? new (_SyncBroadcastStreamControllerOfT()).new(onListen, onCancel) : new (_AsyncBroadcastStreamControllerOfT()).new(onListen, onCancel);
>+    }
>+  }
>+  (StreamController[dart.mixinNew] = function() {
>+  }).prototype = StreamController.prototype;
>+  dart.addTypeTests(StreamController);
>+  StreamController.prototype[_is_StreamController_default] = true;
>+  StreamController[dart.implements] = () => [StreamSinkOfT()];
>+  dart.setLibraryUri(StreamController, "dart:async");
>+  return StreamController;
>+});
>+async.StreamController = async.StreamController$();
>+dart.addTypeTests(async.StreamController, _is_StreamController_default);
>+const _is_SynchronousStreamController_default = Symbol('_is_SynchronousStreamController_default');
>+async.SynchronousStreamController$ = dart.generic(T => {
>+  let StreamControllerOfT = () => (StreamControllerOfT = dart.constFn(async.StreamController$(T)))();
>+  class SynchronousStreamController extends core.Object {}
>+  (SynchronousStreamController.new = function() {
>+  }).prototype = SynchronousStreamController.prototype;
>+  dart.addTypeTests(SynchronousStreamController);
>+  SynchronousStreamController.prototype[_is_SynchronousStreamController_default] = true;
>+  SynchronousStreamController[dart.implements] = () => [StreamControllerOfT()];
>+  dart.setLibraryUri(SynchronousStreamController, "dart:async");
>+  return SynchronousStreamController;
>+});
>+async.SynchronousStreamController = async.SynchronousStreamController$();
>+dart.addTypeTests(async.SynchronousStreamController, _is_SynchronousStreamController_default);
>+const _is__StreamControllerLifecycle_default = Symbol('_is__StreamControllerLifecycle_default');
>+async._StreamControllerLifecycle$ = dart.generic(T => {
>+  let StreamSubscriptionOfT = () => (StreamSubscriptionOfT = dart.constFn(async.StreamSubscription$(T)))();
>+  class _StreamControllerLifecycle extends core.Object {
>+    [_recordPause](subscription) {
>+      StreamSubscriptionOfT()._check(subscription);
>+    }
>+    [_recordResume](subscription) {
>+      StreamSubscriptionOfT()._check(subscription);
>+    }
>+    [_recordCancel](subscription) {
>+      StreamSubscriptionOfT()._check(subscription);
>+      return null;
>+    }
>+  }
>+  (_StreamControllerLifecycle.new = function() {
>+  }).prototype = _StreamControllerLifecycle.prototype;
>+  dart.addTypeTests(_StreamControllerLifecycle);
>+  _StreamControllerLifecycle.prototype[_is__StreamControllerLifecycle_default] = true;
>+  dart.setMethodSignature(_StreamControllerLifecycle, () => ({
>+    __proto__: dart.getMethods(_StreamControllerLifecycle.__proto__),
>+    [_recordPause]: dart.fnType(dart.void, [core.Object]),
>+    [_recordResume]: dart.fnType(dart.void, [core.Object]),
>+    [_recordCancel]: dart.fnType(async.Future, [core.Object])
>+  }));
>+  dart.setLibraryUri(_StreamControllerLifecycle, "dart:async");
>+  return _StreamControllerLifecycle;
>+});
>+async._StreamControllerLifecycle = async._StreamControllerLifecycle$();
>+dart.addTypeTests(async._StreamControllerLifecycle, _is__StreamControllerLifecycle_default);
>+const _is__StreamControllerBase_default = Symbol('_is__StreamControllerBase_default');
>+async._StreamControllerBase$ = dart.generic(T => {
>+  let StreamControllerOfT = () => (StreamControllerOfT = dart.constFn(async.StreamController$(T)))();
>+  let _StreamControllerLifecycleOfT = () => (_StreamControllerLifecycleOfT = dart.constFn(async._StreamControllerLifecycle$(T)))();
>+  let _EventSinkOfT = () => (_EventSinkOfT = dart.constFn(async._EventSink$(T)))();
>+  let _EventDispatchOfT = () => (_EventDispatchOfT = dart.constFn(async._EventDispatch$(T)))();
>+  class _StreamControllerBase extends core.Object {}
>+  (_StreamControllerBase.new = function() {
>+  }).prototype = _StreamControllerBase.prototype;
>+  dart.addTypeTests(_StreamControllerBase);
>+  _StreamControllerBase.prototype[_is__StreamControllerBase_default] = true;
>+  _StreamControllerBase[dart.implements] = () => [StreamControllerOfT(), _StreamControllerLifecycleOfT(), _EventSinkOfT(), _EventDispatchOfT()];
>+  dart.setLibraryUri(_StreamControllerBase, "dart:async");
>+  return _StreamControllerBase;
>+});
>+async._StreamControllerBase = async._StreamControllerBase$();
>+dart.addTypeTests(async._StreamControllerBase, _is__StreamControllerBase_default);
>+const _varData = dart.privateName(async, "_varData");
>+const _isInitialState = dart.privateName(async, "_isInitialState");
>+const _subscription = dart.privateName(async, "_subscription");
>+const _pendingEvents = dart.privateName(async, "_pendingEvents");
>+const _ensurePendingEvents = dart.privateName(async, "_ensurePendingEvents");
>+const _badEventState = dart.privateName(async, "_badEventState");
>+let const$15;
>+const _is__StreamController_default = Symbol('_is__StreamController_default');
>+async._StreamController$ = dart.generic(T => {
>+  let _ControllerStreamOfT = () => (_ControllerStreamOfT = dart.constFn(async._ControllerStream$(T)))();
>+  let _StreamSinkWrapperOfT = () => (_StreamSinkWrapperOfT = dart.constFn(async._StreamSinkWrapper$(T)))();
>+  let _PendingEventsOfT = () => (_PendingEventsOfT = dart.constFn(async._PendingEvents$(T)))();
>+  let _StreamControllerAddStreamStateOfT = () => (_StreamControllerAddStreamStateOfT = dart.constFn(async._StreamControllerAddStreamState$(T)))();
>+  let _StreamImplEventsOfT = () => (_StreamImplEventsOfT = dart.constFn(async._StreamImplEvents$(T)))();
>+  let _ControllerSubscriptionOfT = () => (_ControllerSubscriptionOfT = dart.constFn(async._ControllerSubscription$(T)))();
>+  let StreamOfT = () => (StreamOfT = dart.constFn(async.Stream$(T)))();
>+  let _DelayedDataOfT = () => (_DelayedDataOfT = dart.constFn(async._DelayedData$(T)))();
>+  let StreamSubscriptionOfT = () => (StreamSubscriptionOfT = dart.constFn(async.StreamSubscription$(T)))();
>+  let _StreamControllerBaseOfT = () => (_StreamControllerBaseOfT = dart.constFn(async._StreamControllerBase$(T)))();
>+  class _StreamController extends core.Object {
>+    get stream() {
>+      return new (_ControllerStreamOfT()).new(this);
>+    }
>+    get sink() {
>+      return new (_StreamSinkWrapperOfT()).new(this);
>+    }
>+    get [_isCanceled]() {
>+      return (dart.notNull(this[_state]) & 2) !== 0;
>+    }
>+    get hasListener() {
>+      return (dart.notNull(this[_state]) & 1) !== 0;
>+    }
>+    get [_isInitialState]() {
>+      return (dart.notNull(this[_state]) & 3) === 0;
>+    }
>+    get isClosed() {
>+      return (dart.notNull(this[_state]) & 4) !== 0;
>+    }
>+    get isPaused() {
>+      return dart.test(this.hasListener) ? this[_subscription][_isInputPaused] : !dart.test(this[_isCanceled]);
>+    }
>+    get [_isAddingStream]() {
>+      return (dart.notNull(this[_state]) & 8) !== 0;
>+    }
>+    get [_mayAddEvent]() {
>+      return dart.notNull(this[_state]) < 4;
>+    }
>+    get [_pendingEvents]() {
>+      if (!dart.test(this[_isInitialState])) dart.assertFailed(null, "dart:async/stream_controller.dart", 510, 12, "_isInitialState");
>+      if (!dart.test(this[_isAddingStream])) {
>+        return _PendingEventsOfT()._check(this[_varData]);
>+      }
>+      let state = _StreamControllerAddStreamStateOfT()._check(this[_varData]);
>+      return _PendingEventsOfT()._check(state.varData);
>+    }
>+    [_ensurePendingEvents]() {
>+      if (!dart.test(this[_isInitialState])) dart.assertFailed(null, "dart:async/stream_controller.dart", 520, 12, "_isInitialState");
>+      if (!dart.test(this[_isAddingStream])) {
>+        let t = this[_varData];
>+        t == null ? this[_varData] = new (_StreamImplEventsOfT()).new() : t;
>+        return _StreamImplEventsOfT()._check(this[_varData]);
>+      }
>+      let state = _StreamControllerAddStreamStateOfT()._check(this[_varData]);
>+      if (state.varData == null) state.varData = new (_StreamImplEventsOfT()).new();
>+      return _StreamImplEventsOfT()._check(state.varData);
>+    }
>+    get [_subscription]() {
>+      if (!dart.test(this.hasListener)) dart.assertFailed(null, "dart:async/stream_controller.dart", 534, 12, "hasListener");
>+      if (dart.test(this[_isAddingStream])) {
>+        let addState = _StreamControllerAddStreamStateOfT()._check(this[_varData]);
>+        return _ControllerSubscriptionOfT()._check(addState.varData);
>+      }
>+      return _ControllerSubscriptionOfT()._check(this[_varData]);
>+    }
>+    [_badEventState]() {
>+      if (dart.test(this.isClosed)) {
>+        return new core.StateError.new("Cannot add event after closing");
>+      }
>+      if (!dart.test(this[_isAddingStream])) dart.assertFailed(null, "dart:async/stream_controller.dart", 551, 12, "_isAddingStream");
>+      return new core.StateError.new("Cannot add event while adding a stream");
>+    }
>+    addStream(source, opts) {
>+      StreamOfT()._check(source);
>+      let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
>+      if (!dart.test(this[_mayAddEvent])) dart.throw(this[_badEventState]());
>+      if (dart.test(this[_isCanceled])) return new async._Future.immediate(null);
>+      let addState = new (_StreamControllerAddStreamStateOfT()).new(this, this[_varData], source, cancelOnError != null ? cancelOnError : false);
>+      this[_varData] = addState;
>+      this[_state] = (dart.notNull(this[_state]) | 8) >>> 0;
>+      return addState.addStreamFuture;
>+    }
>+    get done() {
>+      return this[_ensureDoneFuture]();
>+    }
>+    [_ensureDoneFuture]() {
>+      let t = this[_doneFuture];
>+      t == null ? this[_doneFuture] = dart.test(this[_isCanceled]) ? async.Future._nullFuture : new async._Future.new() : t;
>+      return this[_doneFuture];
>+    }
>+    add(value) {
>+      T._check(value);
>+      if (!dart.test(this[_mayAddEvent])) dart.throw(this[_badEventState]());
>+      this[_add](value);
>+    }
>+    addError(error, stackTrace) {
>+      if (stackTrace === void 0) stackTrace = null;
>+      if (!dart.test(this[_mayAddEvent])) dart.throw(this[_badEventState]());
>+      error = async._nonNullError(error);
>+      let replacement = async.Zone.current.errorCallback(error, stackTrace);
>+      if (replacement != null) {
>+        error = async._nonNullError(replacement.error);
>+        stackTrace = replacement.stackTrace;
>+      }
>+      this[_addError](error, stackTrace);
>+    }
>+    close() {
>+      if (dart.test(this.isClosed)) {
>+        return this[_ensureDoneFuture]();
>+      }
>+      if (!dart.test(this[_mayAddEvent])) dart.throw(this[_badEventState]());
>+      this[_closeUnchecked]();
>+      return this[_ensureDoneFuture]();
>+    }
>+    [_closeUnchecked]() {
>+      this[_state] = (dart.notNull(this[_state]) | 4) >>> 0;
>+      if (dart.test(this.hasListener)) {
>+        this[_sendDone]();
>+      } else if (dart.test(this[_isInitialState])) {
>+        this[_ensurePendingEvents]().add(const$15 || (const$15 = dart.const(new async._DelayedDone.new())));
>+      }
>+    }
>+    [_add](value) {
>+      T._check(value);
>+      if (dart.test(this.hasListener)) {
>+        this[_sendData](value);
>+      } else if (dart.test(this[_isInitialState])) {
>+        this[_ensurePendingEvents]().add(new (_DelayedDataOfT()).new(value));
>+      }
>+    }
>+    [_addError](error, stackTrace) {
>+      if (dart.test(this.hasListener)) {
>+        this[_sendError](error, stackTrace);
>+      } else if (dart.test(this[_isInitialState])) {
>+        this[_ensurePendingEvents]().add(new async._DelayedError.new(error, stackTrace));
>+      }
>+    }
>+    [_close]() {
>+      if (!dart.test(this[_isAddingStream])) dart.assertFailed(null, "dart:async/stream_controller.dart", 656, 12, "_isAddingStream");
>+      let addState = _StreamControllerAddStreamStateOfT()._check(this[_varData]);
>+      this[_varData] = addState.varData;
>+      this[_state] = (dart.notNull(this[_state]) & ~8) >>> 0;
>+      addState.complete();
>+    }
>+    [_subscribe](onData, onError, onDone, cancelOnError) {
>+      if (!dart.test(this[_isInitialState])) {
>+        dart.throw(new core.StateError.new("Stream has already been listened to."));
>+      }
>+      let subscription = new (_ControllerSubscriptionOfT()).new(this, onData, onError, onDone, cancelOnError);
>+      let pendingEvents = this[_pendingEvents];
>+      this[_state] = (dart.notNull(this[_state]) | 1) >>> 0;
>+      if (dart.test(this[_isAddingStream])) {
>+        let addState = _StreamControllerAddStreamStateOfT()._check(this[_varData]);
>+        addState.varData = subscription;
>+        addState.resume();
>+      } else {
>+        this[_varData] = subscription;
>+      }
>+      subscription[_setPendingEvents](pendingEvents);
>+      subscription[_guardCallback](dart.fn(() => {
>+        async._runGuarded(this.onListen);
>+      }, VoidToNull()));
>+      return subscription;
>+    }
>+    [_recordCancel](subscription) {
>+      StreamSubscriptionOfT()._check(subscription);
>+      let result = null;
>+      if (dart.test(this[_isAddingStream])) {
>+        let addState = _StreamControllerAddStreamStateOfT()._check(this[_varData]);
>+        result = addState.cancel();
>+      }
>+      this[_varData] = null;
>+      this[_state] = (dart.notNull(this[_state]) & ~(1 | 8) | 2) >>> 0;
>+      if (this.onCancel != null) {
>+        if (result == null) {
>+          try {
>+            result = async.Future._check(this.onCancel());
>+          } catch (e$) {
>+            let e = dart.getThrown(e$);
>+            let s = dart.stackTrace(e$);
>+            result = new async._Future.new();
>+            result[_asyncCompleteError](e, s);
>+          }
>+        } else {
>+          result = result.whenComplete(this.onCancel);
>+        }
>+      }
>+      const complete = () => {
>+        if (this[_doneFuture] != null && dart.test(this[_doneFuture][_mayComplete])) {
>+          this[_doneFuture][_asyncComplete](null);
>+        }
>+      };
>+      dart.fn(complete, VoidTovoid());
>+      if (result != null) {
>+        result = result.whenComplete(complete);
>+      } else {
>+        complete();
>+      }
>+      return result;
>+    }
>+    [_recordPause](subscription) {
>+      StreamSubscriptionOfT()._check(subscription);
>+      if (dart.test(this[_isAddingStream])) {
>+        let addState = _StreamControllerAddStreamStateOfT()._check(this[_varData]);
>+        addState.pause();
>+      }
>+      async._runGuarded(this.onPause);
>+    }
>+    [_recordResume](subscription) {
>+      StreamSubscriptionOfT()._check(subscription);
>+      if (dart.test(this[_isAddingStream])) {
>+        let addState = _StreamControllerAddStreamStateOfT()._check(this[_varData]);
>+        addState.resume();
>+      }
>+      async._runGuarded(this.onResume);
>+    }
>+  }
>+  (_StreamController.new = function(onListen, onPause, onResume, onCancel) {
>+    this[_varData] = null;
>+    this[_state] = 0;
>+    this[_doneFuture] = null;
>+    this.onListen = onListen;
>+    this.onPause = onPause;
>+    this.onResume = onResume;
>+    this.onCancel = onCancel;
>+  }).prototype = _StreamController.prototype;
>+  dart.addTypeTests(_StreamController);
>+  _StreamController.prototype[_is__StreamController_default] = true;
>+  _StreamController[dart.implements] = () => [_StreamControllerBaseOfT()];
>+  dart.setMethodSignature(_StreamController, () => ({
>+    __proto__: dart.getMethods(_StreamController.__proto__),
>+    [_ensurePendingEvents]: dart.fnType(async._StreamImplEvents$(T), []),
>+    [_badEventState]: dart.fnType(core.Error, []),
>+    addStream: dart.fnType(async.Future, [core.Object], {cancelOnError: core.bool}),
>+    [_ensureDoneFuture]: dart.fnType(async.Future, []),
>+    add: dart.fnType(dart.void, [core.Object]),
>+    addError: dart.fnType(dart.void, [core.Object], [core.StackTrace]),
>+    close: dart.fnType(async.Future, []),
>+    [_closeUnchecked]: dart.fnType(dart.void, []),
>+    [_add]: dart.fnType(dart.void, [core.Object]),
>+    [_addError]: dart.fnType(dart.void, [core.Object, core.StackTrace]),
>+    [_close]: dart.fnType(dart.void, []),
>+    [_subscribe]: dart.fnType(async.StreamSubscription$(T), [dart.fnType(dart.void, [T]), core.Function, dart.fnType(dart.void, []), core.bool]),
>+    [_recordCancel]: dart.fnType(async.Future, [core.Object]),
>+    [_recordPause]: dart.fnType(dart.void, [core.Object]),
>+    [_recordResume]: dart.fnType(dart.void, [core.Object])
>+  }));
>+  dart.setGetterSignature(_StreamController, () => ({
>+    __proto__: dart.getGetters(_StreamController.__proto__),
>+    stream: async.Stream$(T),
>+    sink: async.StreamSink$(T),
>+    [_isCanceled]: core.bool,
>+    hasListener: core.bool,
>+    [_isInitialState]: core.bool,
>+    isClosed: core.bool,
>+    isPaused: core.bool,
>+    [_isAddingStream]: core.bool,
>+    [_mayAddEvent]: core.bool,
>+    [_pendingEvents]: async._PendingEvents$(T),
>+    [_subscription]: async._ControllerSubscription$(T),
>+    done: async.Future
>+  }));
>+  dart.setLibraryUri(_StreamController, "dart:async");
>+  dart.setFieldSignature(_StreamController, () => ({
>+    __proto__: dart.getFields(_StreamController.__proto__),
>+    [_varData]: dart.fieldType(dart.dynamic),
>+    [_state]: dart.fieldType(core.int),
>+    [_doneFuture]: dart.fieldType(async._Future),
>+    onListen: dart.fieldType(VoidTovoid()),
>+    onPause: dart.fieldType(VoidTovoid()),
>+    onResume: dart.fieldType(VoidTovoid()),
>+    onCancel: dart.fieldType(VoidTodynamic())
>+  }));
>+  return _StreamController;
>+});
>+async._StreamController = async._StreamController$();
>+dart.defineLazy(async._StreamController, {
>+  /*async._StreamController._STATE_INITIAL*/get _STATE_INITIAL() {
>+    return 0;
>+  },
>+  /*async._StreamController._STATE_SUBSCRIBED*/get _STATE_SUBSCRIBED() {
>+    return 1;
>+  },
>+  /*async._StreamController._STATE_CANCELED*/get _STATE_CANCELED() {
>+    return 2;
>+  },
>+  /*async._StreamController._STATE_SUBSCRIPTION_MASK*/get _STATE_SUBSCRIPTION_MASK() {
>+    return 3;
>+  },
>+  /*async._StreamController._STATE_CLOSED*/get _STATE_CLOSED() {
>+    return 4;
>+  },
>+  /*async._StreamController._STATE_ADDSTREAM*/get _STATE_ADDSTREAM() {
>+    return 8;
>+  }
>+});
>+dart.addTypeTests(async._StreamController, _is__StreamController_default);
>+const _is__SyncStreamControllerDispatch_default = Symbol('_is__SyncStreamControllerDispatch_default');
>+async._SyncStreamControllerDispatch$ = dart.generic(T => {
>+  let _StreamControllerOfT = () => (_StreamControllerOfT = dart.constFn(async._StreamController$(T)))();
>+  let SynchronousStreamControllerOfT = () => (SynchronousStreamControllerOfT = dart.constFn(async.SynchronousStreamController$(T)))();
>+  class _SyncStreamControllerDispatch extends core.Object {
>+    [_sendData](data) {
>+      T._check(data);
>+      this[_subscription][_add](data);
>+    }
>+    [_sendError](error, stackTrace) {
>+      this[_subscription][_addError](error, stackTrace);
>+    }
>+    [_sendDone]() {
>+      this[_subscription][_close]();
>+    }
>+  }
>+  (_SyncStreamControllerDispatch.new = function() {
>+  }).prototype = _SyncStreamControllerDispatch.prototype;
>+  dart.addTypeTests(_SyncStreamControllerDispatch);
>+  _SyncStreamControllerDispatch.prototype[_is__SyncStreamControllerDispatch_default] = true;
>+  _SyncStreamControllerDispatch[dart.implements] = () => [_StreamControllerOfT(), SynchronousStreamControllerOfT()];
>+  dart.setMethodSignature(_SyncStreamControllerDispatch, () => ({
>+    __proto__: dart.getMethods(_SyncStreamControllerDispatch.__proto__),
>+    [_sendData]: dart.fnType(dart.void, [core.Object]),
>+    [_sendError]: dart.fnType(dart.void, [core.Object, core.StackTrace]),
>+    [_sendDone]: dart.fnType(dart.void, [])
>+  }));
>+  dart.setLibraryUri(_SyncStreamControllerDispatch, "dart:async");
>+  return _SyncStreamControllerDispatch;
>+});
>+async._SyncStreamControllerDispatch = async._SyncStreamControllerDispatch$();
>+dart.addTypeTests(async._SyncStreamControllerDispatch, _is__SyncStreamControllerDispatch_default);
>+let const$16;
>+const _is__AsyncStreamControllerDispatch_default = Symbol('_is__AsyncStreamControllerDispatch_default');
>+async._AsyncStreamControllerDispatch$ = dart.generic(T => {
>+  let _DelayedDataOfT = () => (_DelayedDataOfT = dart.constFn(async._DelayedData$(T)))();
>+  let _StreamControllerOfT = () => (_StreamControllerOfT = dart.constFn(async._StreamController$(T)))();
>+  class _AsyncStreamControllerDispatch extends core.Object {
>+    [_sendData](data) {
>+      T._check(data);
>+      this[_subscription][_addPending](new (_DelayedDataOfT()).new(data));
>+    }
>+    [_sendError](error, stackTrace) {
>+      this[_subscription][_addPending](new async._DelayedError.new(error, stackTrace));
>+    }
>+    [_sendDone]() {
>+      this[_subscription][_addPending](const$16 || (const$16 = dart.const(new async._DelayedDone.new())));
>+    }
>+  }
>+  (_AsyncStreamControllerDispatch.new = function() {
>+  }).prototype = _AsyncStreamControllerDispatch.prototype;
>+  dart.addTypeTests(_AsyncStreamControllerDispatch);
>+  _AsyncStreamControllerDispatch.prototype[_is__AsyncStreamControllerDispatch_default] = true;
>+  _AsyncStreamControllerDispatch[dart.implements] = () => [_StreamControllerOfT()];
>+  dart.setMethodSignature(_AsyncStreamControllerDispatch, () => ({
>+    __proto__: dart.getMethods(_AsyncStreamControllerDispatch.__proto__),
>+    [_sendData]: dart.fnType(dart.void, [core.Object]),
>+    [_sendError]: dart.fnType(dart.void, [core.Object, core.StackTrace]),
>+    [_sendDone]: dart.fnType(dart.void, [])
>+  }));
>+  dart.setLibraryUri(_AsyncStreamControllerDispatch, "dart:async");
>+  return _AsyncStreamControllerDispatch;
>+});
>+async._AsyncStreamControllerDispatch = async._AsyncStreamControllerDispatch$();
>+dart.addTypeTests(async._AsyncStreamControllerDispatch, _is__AsyncStreamControllerDispatch_default);
>+const _is__AsyncStreamController_default = Symbol('_is__AsyncStreamController_default');
>+async._AsyncStreamController$ = dart.generic(T => {
>+  const _StreamController__AsyncStreamControllerDispatch$ = class _StreamController__AsyncStreamControllerDispatch extends async._StreamController$(T) {};
>+  (_StreamController__AsyncStreamControllerDispatch$.new = function(onListen, onPause, onResume, onCancel) {
>+    _StreamController__AsyncStreamControllerDispatch$.__proto__.new.call(this, onListen, onPause, onResume, onCancel);
>+  }).prototype = _StreamController__AsyncStreamControllerDispatch$.prototype;
>+  dart.applyMixin(_StreamController__AsyncStreamControllerDispatch$, async._AsyncStreamControllerDispatch$(T));
>+  class _AsyncStreamController extends _StreamController__AsyncStreamControllerDispatch$ {}
>+  (_AsyncStreamController.new = function(onListen, onPause, onResume, onCancel) {
>+    _AsyncStreamController.__proto__.new.call(this, onListen, onPause, onResume, onCancel);
>+  }).prototype = _AsyncStreamController.prototype;
>+  dart.addTypeTests(_AsyncStreamController);
>+  _AsyncStreamController.prototype[_is__AsyncStreamController_default] = true;
>+  dart.setLibraryUri(_AsyncStreamController, "dart:async");
>+  return _AsyncStreamController;
>+});
>+async._AsyncStreamController = async._AsyncStreamController$();
>+dart.addTypeTests(async._AsyncStreamController, _is__AsyncStreamController_default);
>+const _is__SyncStreamController_default = Symbol('_is__SyncStreamController_default');
>+async._SyncStreamController$ = dart.generic(T => {
>+  const _StreamController__SyncStreamControllerDispatch$ = class _StreamController__SyncStreamControllerDispatch extends async._StreamController$(T) {};
>+  (_StreamController__SyncStreamControllerDispatch$.new = function(onListen, onPause, onResume, onCancel) {
>+    _StreamController__SyncStreamControllerDispatch$.__proto__.new.call(this, onListen, onPause, onResume, onCancel);
>+  }).prototype = _StreamController__SyncStreamControllerDispatch$.prototype;
>+  dart.applyMixin(_StreamController__SyncStreamControllerDispatch$, async._SyncStreamControllerDispatch$(T));
>+  class _SyncStreamController extends _StreamController__SyncStreamControllerDispatch$ {}
>+  (_SyncStreamController.new = function(onListen, onPause, onResume, onCancel) {
>+    _SyncStreamController.__proto__.new.call(this, onListen, onPause, onResume, onCancel);
>+  }).prototype = _SyncStreamController.prototype;
>+  dart.addTypeTests(_SyncStreamController);
>+  _SyncStreamController.prototype[_is__SyncStreamController_default] = true;
>+  dart.setLibraryUri(_SyncStreamController, "dart:async");
>+  return _SyncStreamController;
>+});
>+async._SyncStreamController = async._SyncStreamController$();
>+dart.addTypeTests(async._SyncStreamController, _is__SyncStreamController_default);
>+async._runGuarded = function(notificationHandler) {
>+  if (notificationHandler == null) return;
>+  try {
>+    notificationHandler();
>+  } catch (e$) {
>+    let e = dart.getThrown(e$);
>+    let s = dart.stackTrace(e$);
>+    async.Zone.current.handleUncaughtError(e, s);
>+  }
>+};
>+const _target = dart.privateName(async, "_target");
>+const _is__StreamSinkWrapper_default = Symbol('_is__StreamSinkWrapper_default');
>+async._StreamSinkWrapper$ = dart.generic(T => {
>+  let StreamOfT = () => (StreamOfT = dart.constFn(async.Stream$(T)))();
>+  let StreamSinkOfT = () => (StreamSinkOfT = dart.constFn(async.StreamSink$(T)))();
>+  class _StreamSinkWrapper extends core.Object {
>+    add(data) {
>+      T._check(data);
>+      this[_target].add(data);
>+    }
>+    addError(error, stackTrace) {
>+      if (stackTrace === void 0) stackTrace = null;
>+      this[_target].addError(error, stackTrace);
>+    }
>+    close() {
>+      return this[_target].close();
>+    }
>+    addStream(source) {
>+      StreamOfT()._check(source);
>+      return this[_target].addStream(source);
>+    }
>+    get done() {
>+      return this[_target].done;
>+    }
>+  }
>+  (_StreamSinkWrapper.new = function(target) {
>+    this[_target] = target;
>+  }).prototype = _StreamSinkWrapper.prototype;
>+  dart.addTypeTests(_StreamSinkWrapper);
>+  _StreamSinkWrapper.prototype[_is__StreamSinkWrapper_default] = true;
>+  _StreamSinkWrapper[dart.implements] = () => [StreamSinkOfT()];
>+  dart.setMethodSignature(_StreamSinkWrapper, () => ({
>+    __proto__: dart.getMethods(_StreamSinkWrapper.__proto__),
>+    add: dart.fnType(dart.void, [core.Object]),
>+    addError: dart.fnType(dart.void, [core.Object], [core.StackTrace]),
>+    close: dart.fnType(async.Future, []),
>+    addStream: dart.fnType(async.Future, [core.Object])
>+  }));
>+  dart.setGetterSignature(_StreamSinkWrapper, () => ({
>+    __proto__: dart.getGetters(_StreamSinkWrapper.__proto__),
>+    done: async.Future
>+  }));
>+  dart.setLibraryUri(_StreamSinkWrapper, "dart:async");
>+  dart.setFieldSignature(_StreamSinkWrapper, () => ({
>+    __proto__: dart.getFields(_StreamSinkWrapper.__proto__),
>+    [_target]: dart.finalFieldType(async.StreamController)
>+  }));
>+  return _StreamSinkWrapper;
>+});
>+async._StreamSinkWrapper = async._StreamSinkWrapper$();
>+dart.addTypeTests(async._StreamSinkWrapper, _is__StreamSinkWrapper_default);
>+const _is__AddStreamState_default = Symbol('_is__AddStreamState_default');
>+async._AddStreamState$ = dart.generic(T => {
>+  class _AddStreamState extends core.Object {
>+    static makeErrorHandler(controller) {
>+      return dart.fn((e, s) => {
>+        controller[_addError](e, s);
>+        controller[_close]();
>+      }, dynamicAndStackTraceToNull());
>+    }
>+    pause() {
>+      this.addSubscription.pause();
>+    }
>+    resume() {
>+      this.addSubscription.resume();
>+    }
>+    cancel() {
>+      let cancel = this.addSubscription.cancel();
>+      if (cancel == null) {
>+        this.addStreamFuture[_asyncComplete](null);
>+        return null;
>+      }
>+      return cancel.whenComplete(dart.fn(() => {
>+        this.addStreamFuture[_asyncComplete](null);
>+      }, VoidToNull()));
>+    }
>+    complete() {
>+      this.addStreamFuture[_asyncComplete](null);
>+    }
>+  }
>+  (_AddStreamState.new = function(controller, source, cancelOnError) {
>+    this.addStreamFuture = new async._Future.new();
>+    this.addSubscription = source.listen(dart.bind(controller, _add), {onError: core.Function._check(dart.test(cancelOnError) ? async._AddStreamState.makeErrorHandler(controller) : dart.bind(controller, _addError)), onDone: dart.bind(controller, _close), cancelOnError: cancelOnError});
>+  }).prototype = _AddStreamState.prototype;
>+  dart.addTypeTests(_AddStreamState);
>+  _AddStreamState.prototype[_is__AddStreamState_default] = true;
>+  dart.setMethodSignature(_AddStreamState, () => ({
>+    __proto__: dart.getMethods(_AddStreamState.__proto__),
>+    pause: dart.fnType(dart.void, []),
>+    resume: dart.fnType(dart.void, []),
>+    cancel: dart.fnType(async.Future, []),
>+    complete: dart.fnType(dart.void, [])
>+  }));
>+  dart.setLibraryUri(_AddStreamState, "dart:async");
>+  dart.setFieldSignature(_AddStreamState, () => ({
>+    __proto__: dart.getFields(_AddStreamState.__proto__),
>+    addStreamFuture: dart.finalFieldType(async._Future),
>+    addSubscription: dart.finalFieldType(async.StreamSubscription)
>+  }));
>+  return _AddStreamState;
>+});
>+async._AddStreamState = async._AddStreamState$();
>+dart.addTypeTests(async._AddStreamState, _is__AddStreamState_default);
>+const _is__StreamControllerAddStreamState_default = Symbol('_is__StreamControllerAddStreamState_default');
>+async._StreamControllerAddStreamState$ = dart.generic(T => {
>+  class _StreamControllerAddStreamState extends async._AddStreamState$(T) {}
>+  (_StreamControllerAddStreamState.new = function(controller, varData, source, cancelOnError) {
>+    this.varData = varData;
>+    _StreamControllerAddStreamState.__proto__.new.call(this, controller, source, cancelOnError);
>+    if (dart.test(controller.isPaused)) {
>+      this.addSubscription.pause();
>+    }
>+  }).prototype = _StreamControllerAddStreamState.prototype;
>+  dart.addTypeTests(_StreamControllerAddStreamState);
>+  _StreamControllerAddStreamState.prototype[_is__StreamControllerAddStreamState_default] = true;
>+  dart.setLibraryUri(_StreamControllerAddStreamState, "dart:async");
>+  dart.setFieldSignature(_StreamControllerAddStreamState, () => ({
>+    __proto__: dart.getFields(_StreamControllerAddStreamState.__proto__),
>+    varData: dart.fieldType(dart.dynamic)
>+  }));
>+  return _StreamControllerAddStreamState;
>+});
>+async._StreamControllerAddStreamState = async._StreamControllerAddStreamState$();
>+dart.addTypeTests(async._StreamControllerAddStreamState, _is__StreamControllerAddStreamState_default);
>+const _is__EventSink_default = Symbol('_is__EventSink_default');
>+async._EventSink$ = dart.generic(T => {
>+  class _EventSink extends core.Object {}
>+  (_EventSink.new = function() {
>+  }).prototype = _EventSink.prototype;
>+  dart.addTypeTests(_EventSink);
>+  _EventSink.prototype[_is__EventSink_default] = true;
>+  dart.setLibraryUri(_EventSink, "dart:async");
>+  return _EventSink;
>+});
>+async._EventSink = async._EventSink$();
>+dart.addTypeTests(async._EventSink, _is__EventSink_default);
>+const _is__EventDispatch_default = Symbol('_is__EventDispatch_default');
>+async._EventDispatch$ = dart.generic(T => {
>+  class _EventDispatch extends core.Object {}
>+  (_EventDispatch.new = function() {
>+  }).prototype = _EventDispatch.prototype;
>+  dart.addTypeTests(_EventDispatch);
>+  _EventDispatch.prototype[_is__EventDispatch_default] = true;
>+  dart.setLibraryUri(_EventDispatch, "dart:async");
>+  return _EventDispatch;
>+});
>+async._EventDispatch = async._EventDispatch$();
>+dart.addTypeTests(async._EventDispatch, _is__EventDispatch_default);
>+const _isUsed = dart.privateName(async, "_isUsed");
>+const _is__GeneratedStreamImpl_default = Symbol('_is__GeneratedStreamImpl_default');
>+async._GeneratedStreamImpl$ = dart.generic(T => {
>+  let _BufferingStreamSubscriptionOfT = () => (_BufferingStreamSubscriptionOfT = dart.constFn(async._BufferingStreamSubscription$(T)))();
>+  let _PendingEventsOfT = () => (_PendingEventsOfT = dart.constFn(async._PendingEvents$(T)))();
>+  let VoidTo_PendingEventsOfT = () => (VoidTo_PendingEventsOfT = dart.constFn(dart.fnType(_PendingEventsOfT(), [])))();
>+  class _GeneratedStreamImpl extends async._StreamImpl$(T) {
>+    [_createSubscription](onData, onError, onDone, cancelOnError) {
>+      if (dart.test(this[_isUsed])) dart.throw(new core.StateError.new("Stream has already been listened to."));
>+      this[_isUsed] = true;
>+      let _ = new (_BufferingStreamSubscriptionOfT()).new(onData, onError, onDone, cancelOnError);
>+      _[_setPendingEvents](this[_pending]());
>+      return _;
>+    }
>+  }
>+  (_GeneratedStreamImpl.new = function(pending) {
>+    this[_isUsed] = false;
>+    this[_pending] = pending;
>+    _GeneratedStreamImpl.__proto__.new.call(this);
>+  }).prototype = _GeneratedStreamImpl.prototype;
>+  dart.addTypeTests(_GeneratedStreamImpl);
>+  _GeneratedStreamImpl.prototype[_is__GeneratedStreamImpl_default] = true;
>+  dart.setLibraryUri(_GeneratedStreamImpl, "dart:async");
>+  dart.setFieldSignature(_GeneratedStreamImpl, () => ({
>+    __proto__: dart.getFields(_GeneratedStreamImpl.__proto__),
>+    [_pending]: dart.finalFieldType(VoidTo_PendingEventsOfT()),
>+    [_isUsed]: dart.fieldType(core.bool)
>+  }));
>+  return _GeneratedStreamImpl;
>+});
>+async._GeneratedStreamImpl = async._GeneratedStreamImpl$();
>+dart.addTypeTests(async._GeneratedStreamImpl, _is__GeneratedStreamImpl_default);
>+const _iterator$ = dart.privateName(async, "_iterator");
>+let const$17;
>+const _eventScheduled = dart.privateName(async, "_eventScheduled");
>+const _is__PendingEvents_default = Symbol('_is__PendingEvents_default');
>+async._PendingEvents$ = dart.generic(T => {
>+  let _EventDispatchOfT = () => (_EventDispatchOfT = dart.constFn(async._EventDispatch$(T)))();
>+  class _PendingEvents extends core.Object {
>+    get isScheduled() {
>+      return this[_state] === 1;
>+    }
>+    get [_eventScheduled]() {
>+      return dart.notNull(this[_state]) >= 1;
>+    }
>+    schedule(dispatch) {
>+      _EventDispatchOfT()._check(dispatch);
>+      if (dart.test(this.isScheduled)) return;
>+      if (!!dart.test(this.isEmpty)) dart.assertFailed(null, "dart:async/stream_impl.dart", 657, 12, "!isEmpty");
>+      if (dart.test(this[_eventScheduled])) {
>+        if (!(this[_state] === 3)) dart.assertFailed(null, "dart:async/stream_impl.dart", 659, 14, "_state == _STATE_CANCELED");
>+        this[_state] = 1;
>+        return;
>+      }
>+      async.scheduleMicrotask(dart.fn(() => {
>+        let oldState = this[_state];
>+        this[_state] = 0;
>+        if (oldState === 3) return;
>+        this.handleNext(dispatch);
>+      }, VoidToNull()));
>+      this[_state] = 1;
>+    }
>+    cancelSchedule() {
>+      if (dart.test(this.isScheduled)) this[_state] = 3;
>+    }
>+  }
>+  (_PendingEvents.new = function() {
>+    this[_state] = 0;
>+  }).prototype = _PendingEvents.prototype;
>+  dart.addTypeTests(_PendingEvents);
>+  _PendingEvents.prototype[_is__PendingEvents_default] = true;
>+  dart.setMethodSignature(_PendingEvents, () => ({
>+    __proto__: dart.getMethods(_PendingEvents.__proto__),
>+    schedule: dart.fnType(dart.void, [core.Object]),
>+    cancelSchedule: dart.fnType(dart.void, [])
>+  }));
>+  dart.setGetterSignature(_PendingEvents, () => ({
>+    __proto__: dart.getGetters(_PendingEvents.__proto__),
>+    isScheduled: core.bool,
>+    [_eventScheduled]: core.bool
>+  }));
>+  dart.setLibraryUri(_PendingEvents, "dart:async");
>+  dart.setFieldSignature(_PendingEvents, () => ({
>+    __proto__: dart.getFields(_PendingEvents.__proto__),
>+    [_state]: dart.fieldType(core.int)
>+  }));
>+  return _PendingEvents;
>+});
>+async._PendingEvents = async._PendingEvents$();
>+dart.defineLazy(async._PendingEvents, {
>+  /*async._PendingEvents._STATE_UNSCHEDULED*/get _STATE_UNSCHEDULED() {
>+    return 0;
>+  },
>+  /*async._PendingEvents._STATE_SCHEDULED*/get _STATE_SCHEDULED() {
>+    return 1;
>+  },
>+  /*async._PendingEvents._STATE_CANCELED*/get _STATE_CANCELED() {
>+    return 3;
>+  }
>+});
>+dart.addTypeTests(async._PendingEvents, _is__PendingEvents_default);
>+const _is__IterablePendingEvents_default = Symbol('_is__IterablePendingEvents_default');
>+async._IterablePendingEvents$ = dart.generic(T => {
>+  let _EventDispatchOfT = () => (_EventDispatchOfT = dart.constFn(async._EventDispatch$(T)))();
>+  let IteratorOfT = () => (IteratorOfT = dart.constFn(core.Iterator$(T)))();
>+  class _IterablePendingEvents extends async._PendingEvents$(T) {
>+    get isEmpty() {
>+      return this[_iterator$] == null;
>+    }
>+    handleNext(dispatch) {
>+      _EventDispatchOfT()._check(dispatch);
>+      if (this[_iterator$] == null) {
>+        dart.throw(new core.StateError.new("No events pending."));
>+      }
>+      let hasMore = null;
>+      try {
>+        hasMore = this[_iterator$].moveNext();
>+        if (dart.test(hasMore)) {
>+          dispatch[_sendData](this[_iterator$].current);
>+        } else {
>+          this[_iterator$] = null;
>+          dispatch[_sendDone]();
>+        }
>+      } catch (e$) {
>+        let e = dart.getThrown(e$);
>+        let s = dart.stackTrace(e$);
>+        if (hasMore == null) {
>+          this[_iterator$] = const$17 || (const$17 = dart.const(new (EmptyIteratorOfNull()).new()));
>+          dispatch[_sendError](e, s);
>+        } else {
>+          dispatch[_sendError](e, s);
>+        }
>+      }
>+    }
>+    clear() {
>+      if (dart.test(this.isScheduled)) this.cancelSchedule();
>+      this[_iterator$] = null;
>+    }
>+  }
>+  (_IterablePendingEvents.new = function(data) {
>+    this[_iterator$] = data[$iterator];
>+    _IterablePendingEvents.__proto__.new.call(this);
>+  }).prototype = _IterablePendingEvents.prototype;
>+  dart.addTypeTests(_IterablePendingEvents);
>+  _IterablePendingEvents.prototype[_is__IterablePendingEvents_default] = true;
>+  dart.setMethodSignature(_IterablePendingEvents, () => ({
>+    __proto__: dart.getMethods(_IterablePendingEvents.__proto__),
>+    handleNext: dart.fnType(dart.void, [core.Object]),
>+    clear: dart.fnType(dart.void, [])
>+  }));
>+  dart.setGetterSignature(_IterablePendingEvents, () => ({
>+    __proto__: dart.getGetters(_IterablePendingEvents.__proto__),
>+    isEmpty: core.bool
>+  }));
>+  dart.setLibraryUri(_IterablePendingEvents, "dart:async");
>+  dart.setFieldSignature(_IterablePendingEvents, () => ({
>+    __proto__: dart.getFields(_IterablePendingEvents.__proto__),
>+    [_iterator$]: dart.fieldType(IteratorOfT())
>+  }));
>+  return _IterablePendingEvents;
>+});
>+async._IterablePendingEvents = async._IterablePendingEvents$();
>+dart.addTypeTests(async._IterablePendingEvents, _is__IterablePendingEvents_default);
>+async._nullDataHandler = function(value) {
>+};
>+async._nullErrorHandler = function(error, stackTrace) {
>+  if (stackTrace === void 0) stackTrace = null;
>+  async.Zone.current.handleUncaughtError(error, stackTrace);
>+};
>+async._nullDoneHandler = function() {
>+};
>+const _is__DelayedEvent_default = Symbol('_is__DelayedEvent_default');
>+async._DelayedEvent$ = dart.generic(T => {
>+  class _DelayedEvent extends core.Object {}
>+  (_DelayedEvent.new = function() {
>+    this.next = null;
>+  }).prototype = _DelayedEvent.prototype;
>+  dart.addTypeTests(_DelayedEvent);
>+  _DelayedEvent.prototype[_is__DelayedEvent_default] = true;
>+  dart.setLibraryUri(_DelayedEvent, "dart:async");
>+  dart.setFieldSignature(_DelayedEvent, () => ({
>+    __proto__: dart.getFields(_DelayedEvent.__proto__),
>+    next: dart.fieldType(async._DelayedEvent)
>+  }));
>+  return _DelayedEvent;
>+});
>+async._DelayedEvent = async._DelayedEvent$();
>+dart.addTypeTests(async._DelayedEvent, _is__DelayedEvent_default);
>+const _is__DelayedData_default = Symbol('_is__DelayedData_default');
>+async._DelayedData$ = dart.generic(T => {
>+  let _EventDispatchOfT = () => (_EventDispatchOfT = dart.constFn(async._EventDispatch$(T)))();
>+  class _DelayedData extends async._DelayedEvent$(T) {
>+    perform(dispatch) {
>+      _EventDispatchOfT()._check(dispatch);
>+      dispatch[_sendData](this.value);
>+    }
>+  }
>+  (_DelayedData.new = function(value) {
>+    this.value = value;
>+    _DelayedData.__proto__.new.call(this);
>+  }).prototype = _DelayedData.prototype;
>+  dart.addTypeTests(_DelayedData);
>+  _DelayedData.prototype[_is__DelayedData_default] = true;
>+  dart.setMethodSignature(_DelayedData, () => ({
>+    __proto__: dart.getMethods(_DelayedData.__proto__),
>+    perform: dart.fnType(dart.void, [core.Object])
>+  }));
>+  dart.setLibraryUri(_DelayedData, "dart:async");
>+  dart.setFieldSignature(_DelayedData, () => ({
>+    __proto__: dart.getFields(_DelayedData.__proto__),
>+    value: dart.finalFieldType(T)
>+  }));
>+  return _DelayedData;
>+});
>+async._DelayedData = async._DelayedData$();
>+dart.addTypeTests(async._DelayedData, _is__DelayedData_default);
>+async._DelayedError = class _DelayedError extends async._DelayedEvent {
>+  perform(dispatch) {
>+    dispatch[_sendError](this.error, this.stackTrace);
>+  }
>+};
>+(async._DelayedError.new = function(error, stackTrace) {
>+  this.error = error;
>+  this.stackTrace = stackTrace;
>+  async._DelayedError.__proto__.new.call(this);
>+}).prototype = async._DelayedError.prototype;
>+dart.addTypeTests(async._DelayedError);
>+dart.setMethodSignature(async._DelayedError, () => ({
>+  __proto__: dart.getMethods(async._DelayedError.__proto__),
>+  perform: dart.fnType(dart.void, [async._EventDispatch])
>+}));
>+dart.setLibraryUri(async._DelayedError, "dart:async");
>+dart.setFieldSignature(async._DelayedError, () => ({
>+  __proto__: dart.getFields(async._DelayedError.__proto__),
>+  error: dart.finalFieldType(dart.dynamic),
>+  stackTrace: dart.finalFieldType(core.StackTrace)
>+}));
>+async._DelayedDone = class _DelayedDone extends core.Object {
>+  perform(dispatch) {
>+    dispatch[_sendDone]();
>+  }
>+  get next() {
>+    return null;
>+  }
>+  set next(_) {
>+    dart.throw(new core.StateError.new("No events after a done."));
>+  }
>+};
>+(async._DelayedDone.new = function() {
>+}).prototype = async._DelayedDone.prototype;
>+dart.addTypeTests(async._DelayedDone);
>+async._DelayedDone[dart.implements] = () => [async._DelayedEvent];
>+dart.setMethodSignature(async._DelayedDone, () => ({
>+  __proto__: dart.getMethods(async._DelayedDone.__proto__),
>+  perform: dart.fnType(dart.void, [async._EventDispatch])
>+}));
>+dart.setGetterSignature(async._DelayedDone, () => ({
>+  __proto__: dart.getGetters(async._DelayedDone.__proto__),
>+  next: async._DelayedEvent
>+}));
>+dart.setSetterSignature(async._DelayedDone, () => ({
>+  __proto__: dart.getSetters(async._DelayedDone.__proto__),
>+  next: async._DelayedEvent
>+}));
>+dart.setLibraryUri(async._DelayedDone, "dart:async");
>+const _is__StreamImplEvents_default = Symbol('_is__StreamImplEvents_default');
>+async._StreamImplEvents$ = dart.generic(T => {
>+  let _EventDispatchOfT = () => (_EventDispatchOfT = dart.constFn(async._EventDispatch$(T)))();
>+  class _StreamImplEvents extends async._PendingEvents$(T) {
>+    get isEmpty() {
>+      return this.lastPendingEvent == null;
>+    }
>+    add(event) {
>+      if (this.lastPendingEvent == null) {
>+        this.firstPendingEvent = this.lastPendingEvent = event;
>+      } else {
>+        this.lastPendingEvent = this.lastPendingEvent.next = event;
>+      }
>+    }
>+    handleNext(dispatch) {
>+      _EventDispatchOfT()._check(dispatch);
>+      if (!!dart.test(this.isScheduled)) dart.assertFailed(null, "dart:async/stream_impl.dart", 701, 12, "!isScheduled");
>+      let event = this.firstPendingEvent;
>+      this.firstPendingEvent = event.next;
>+      if (this.firstPendingEvent == null) {
>+        this.lastPendingEvent = null;
>+      }
>+      event.perform(dispatch);
>+    }
>+    clear() {
>+      if (dart.test(this.isScheduled)) this.cancelSchedule();
>+      this.firstPendingEvent = this.lastPendingEvent = null;
>+    }
>+  }
>+  (_StreamImplEvents.new = function() {
>+    this.firstPendingEvent = null;
>+    this.lastPendingEvent = null;
>+    _StreamImplEvents.__proto__.new.call(this);
>+  }).prototype = _StreamImplEvents.prototype;
>+  dart.addTypeTests(_StreamImplEvents);
>+  _StreamImplEvents.prototype[_is__StreamImplEvents_default] = true;
>+  dart.setMethodSignature(_StreamImplEvents, () => ({
>+    __proto__: dart.getMethods(_StreamImplEvents.__proto__),
>+    add: dart.fnType(dart.void, [async._DelayedEvent]),
>+    handleNext: dart.fnType(dart.void, [core.Object]),
>+    clear: dart.fnType(dart.void, [])
>+  }));
>+  dart.setGetterSignature(_StreamImplEvents, () => ({
>+    __proto__: dart.getGetters(_StreamImplEvents.__proto__),
>+    isEmpty: core.bool
>+  }));
>+  dart.setLibraryUri(_StreamImplEvents, "dart:async");
>+  dart.setFieldSignature(_StreamImplEvents, () => ({
>+    __proto__: dart.getFields(_StreamImplEvents.__proto__),
>+    firstPendingEvent: dart.fieldType(async._DelayedEvent),
>+    lastPendingEvent: dart.fieldType(async._DelayedEvent)
>+  }));
>+  return _StreamImplEvents;
>+});
>+async._StreamImplEvents = async._StreamImplEvents$();
>+dart.addTypeTests(async._StreamImplEvents, _is__StreamImplEvents_default);
>+const _schedule = dart.privateName(async, "_schedule");
>+const _isSent = dart.privateName(async, "_isSent");
>+const _isScheduled = dart.privateName(async, "_isScheduled");
>+const _is__DoneStreamSubscription_default = Symbol('_is__DoneStreamSubscription_default');
>+async._DoneStreamSubscription$ = dart.generic(T => {
>+  let StreamSubscriptionOfT = () => (StreamSubscriptionOfT = dart.constFn(async.StreamSubscription$(T)))();
>+  class _DoneStreamSubscription extends core.Object {
>+    get [_isSent]() {
>+      return (dart.notNull(this[_state]) & 1) !== 0;
>+    }
>+    get [_isScheduled]() {
>+      return (dart.notNull(this[_state]) & 2) !== 0;
>+    }
>+    get isPaused() {
>+      return dart.notNull(this[_state]) >= 4;
>+    }
>+    [_schedule]() {
>+      if (dart.test(this[_isScheduled])) return;
>+      this[_zone$].scheduleMicrotask(dart.bind(this, _sendDone));
>+      this[_state] = (dart.notNull(this[_state]) | 2) >>> 0;
>+    }
>+    onData(handleData) {}
>+    onError(handleError) {}
>+    onDone(handleDone) {
>+      this[_onDone] = handleDone;
>+    }
>+    pause(resumeSignal) {
>+      if (resumeSignal === void 0) resumeSignal = null;
>+      this[_state] = dart.notNull(this[_state]) + 4;
>+      if (resumeSignal != null) resumeSignal.whenComplete(dart.bind(this, 'resume'));
>+    }
>+    resume() {
>+      if (dart.test(this.isPaused)) {
>+        this[_state] = dart.notNull(this[_state]) - 4;
>+        if (!dart.test(this.isPaused) && !dart.test(this[_isSent])) {
>+          this[_schedule]();
>+        }
>+      }
>+    }
>+    cancel() {
>+      return async.Future._nullFuture;
>+    }
>+    asFuture(E, futureValue) {
>+      if (futureValue === void 0) futureValue = null;
>+      let result = new (async._Future$(E)).new();
>+      this[_onDone] = dart.fn(() => {
>+        result[_completeWithValue](futureValue);
>+      }, VoidToNull());
>+      return result;
>+    }
>+    [_sendDone]() {
>+      this[_state] = (dart.notNull(this[_state]) & ~2) >>> 0;
>+      if (dart.test(this.isPaused)) return;
>+      this[_state] = (dart.notNull(this[_state]) | 1) >>> 0;
>+      if (this[_onDone] != null) this[_zone$].runGuarded(this[_onDone]);
>+    }
>+  }
>+  (_DoneStreamSubscription.new = function(onDone) {
>+    this[_state] = 0;
>+    this[_onDone] = onDone;
>+    this[_zone$] = async.Zone.current;
>+    this[_schedule]();
>+  }).prototype = _DoneStreamSubscription.prototype;
>+  _DoneStreamSubscription.prototype[dart.isStreamSubscription] = true;
>+  dart.addTypeTests(_DoneStreamSubscription);
>+  _DoneStreamSubscription.prototype[_is__DoneStreamSubscription_default] = true;
>+  _DoneStreamSubscription[dart.implements] = () => [StreamSubscriptionOfT()];
>+  dart.setMethodSignature(_DoneStreamSubscription, () => ({
>+    __proto__: dart.getMethods(_DoneStreamSubscription.__proto__),
>+    [_schedule]: dart.fnType(dart.void, []),
>+    onData: dart.fnType(dart.void, [dart.fnType(dart.void, [T])]),
>+    onError: dart.fnType(dart.void, [core.Function]),
>+    onDone: dart.fnType(dart.void, [dart.fnType(dart.void, [])]),
>+    pause: dart.fnType(dart.void, [], [async.Future]),
>+    resume: dart.fnType(dart.void, []),
>+    cancel: dart.fnType(async.Future, []),
>+    asFuture: dart.gFnType(E => [async.Future$(E), [], [E]]),
>+    [_sendDone]: dart.fnType(dart.void, [])
>+  }));
>+  dart.setGetterSignature(_DoneStreamSubscription, () => ({
>+    __proto__: dart.getGetters(_DoneStreamSubscription.__proto__),
>+    [_isSent]: core.bool,
>+    [_isScheduled]: core.bool,
>+    isPaused: core.bool
>+  }));
>+  dart.setLibraryUri(_DoneStreamSubscription, "dart:async");
>+  dart.setFieldSignature(_DoneStreamSubscription, () => ({
>+    __proto__: dart.getFields(_DoneStreamSubscription.__proto__),
>+    [_zone$]: dart.finalFieldType(async.Zone),
>+    [_state]: dart.fieldType(core.int),
>+    [_onDone]: dart.fieldType(VoidTovoid())
>+  }));
>+  return _DoneStreamSubscription;
>+});
>+async._DoneStreamSubscription = async._DoneStreamSubscription$();
>+dart.defineLazy(async._DoneStreamSubscription, {
>+  /*async._DoneStreamSubscription._DONE_SENT*/get _DONE_SENT() {
>+    return 1;
>+  },
>+  /*async._DoneStreamSubscription._SCHEDULED*/get _SCHEDULED() {
>+    return 2;
>+  },
>+  /*async._DoneStreamSubscription._PAUSED*/get _PAUSED() {
>+    return 4;
>+  }
>+});
>+dart.addTypeTests(async._DoneStreamSubscription, _is__DoneStreamSubscription_default);
>+const _source$ = dart.privateName(async, "_source");
>+const _onListenHandler = dart.privateName(async, "_onListenHandler");
>+const _onCancelHandler = dart.privateName(async, "_onCancelHandler");
>+const _cancelSubscription = dart.privateName(async, "_cancelSubscription");
>+const _pauseSubscription = dart.privateName(async, "_pauseSubscription");
>+const _resumeSubscription = dart.privateName(async, "_resumeSubscription");
>+const _isSubscriptionPaused = dart.privateName(async, "_isSubscriptionPaused");
>+const _is__AsBroadcastStream_default = Symbol('_is__AsBroadcastStream_default');
>+async._AsBroadcastStream$ = dart.generic(T => {
>+  let StreamSubscriptionOfT = () => (StreamSubscriptionOfT = dart.constFn(async.StreamSubscription$(T)))();
>+  let _AsBroadcastStreamControllerOfT = () => (_AsBroadcastStreamControllerOfT = dart.constFn(async._AsBroadcastStreamController$(T)))();
>+  let _DoneStreamSubscriptionOfT = () => (_DoneStreamSubscriptionOfT = dart.constFn(async._DoneStreamSubscription$(T)))();
>+  let _BroadcastSubscriptionWrapperOfT = () => (_BroadcastSubscriptionWrapperOfT = dart.constFn(async._BroadcastSubscriptionWrapper$(T)))();
>+  let StreamOfT = () => (StreamOfT = dart.constFn(async.Stream$(T)))();
>+  let StreamSubscriptionOfTTovoid = () => (StreamSubscriptionOfTTovoid = dart.constFn(dart.fnType(dart.void, [StreamSubscriptionOfT()])))();
>+  class _AsBroadcastStream extends async.Stream$(T) {
>+    get isBroadcast() {
>+      return true;
>+    }
>+    listen(onData, opts) {
>+      let onError = opts && 'onError' in opts ? opts.onError : null;
>+      let onDone = opts && 'onDone' in opts ? opts.onDone : null;
>+      let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
>+      if (this[_controller] == null || dart.test(this[_controller].isClosed)) {
>+        return new (_DoneStreamSubscriptionOfT()).new(onDone);
>+      }
>+      let t = this[_subscription];
>+      t == null ? this[_subscription] = this[_source$].listen(dart.bind(this[_controller], 'add'), {onError: dart.bind(this[_controller], 'addError'), onDone: dart.bind(this[_controller], 'close')}) : t;
>+      cancelOnError = true === cancelOnError;
>+      return this[_controller][_subscribe](onData, onError, onDone, cancelOnError);
>+    }
>+    [_onCancel]() {
>+      let shutdown = this[_controller] == null || dart.test(this[_controller].isClosed);
>+      if (this[_onCancelHandler] != null) {
>+        this[_zone$].runUnary(dart.void, _BroadcastSubscriptionWrapperOfT(), this[_onCancelHandler], new (_BroadcastSubscriptionWrapperOfT()).new(this));
>+      }
>+      if (shutdown) {
>+        if (this[_subscription] != null) {
>+          this[_subscription].cancel();
>+          this[_subscription] = null;
>+        }
>+      }
>+    }
>+    [_onListen]() {
>+      if (this[_onListenHandler] != null) {
>+        this[_zone$].runUnary(dart.void, _BroadcastSubscriptionWrapperOfT(), this[_onListenHandler], new (_BroadcastSubscriptionWrapperOfT()).new(this));
>+      }
>+    }
>+    [_cancelSubscription]() {
>+      if (this[_subscription] == null) return;
>+      let subscription = this[_subscription];
>+      this[_subscription] = null;
>+      this[_controller] = null;
>+      subscription.cancel();
>+    }
>+    [_pauseSubscription](resumeSignal) {
>+      if (this[_subscription] == null) return;
>+      this[_subscription].pause(resumeSignal);
>+    }
>+    [_resumeSubscription]() {
>+      if (this[_subscription] == null) return;
>+      this[_subscription].resume();
>+    }
>+    get [_isSubscriptionPaused]() {
>+      if (this[_subscription] == null) return false;
>+      return this[_subscription].isPaused;
>+    }
>+  }
>+  (_AsBroadcastStream.new = function(source, onListenHandler, onCancelHandler) {
>+    this[_controller] = null;
>+    this[_subscription] = null;
>+    this[_source$] = source;
>+    this[_onListenHandler] = async.Zone.current.registerUnaryCallback(dart.dynamic, StreamSubscriptionOfT(), onListenHandler);
>+    this[_onCancelHandler] = async.Zone.current.registerUnaryCallback(dart.dynamic, StreamSubscriptionOfT(), onCancelHandler);
>+    this[_zone$] = async.Zone.current;
>+    _AsBroadcastStream.__proto__.new.call(this);
>+    this[_controller] = new (_AsBroadcastStreamControllerOfT()).new(dart.bind(this, _onListen), dart.bind(this, _onCancel));
>+  }).prototype = _AsBroadcastStream.prototype;
>+  dart.addTypeTests(_AsBroadcastStream);
>+  _AsBroadcastStream.prototype[_is__AsBroadcastStream_default] = true;
>+  dart.setMethodSignature(_AsBroadcastStream, () => ({
>+    __proto__: dart.getMethods(_AsBroadcastStream.__proto__),
>+    listen: dart.fnType(async.StreamSubscription$(T), [dart.fnType(dart.void, [T])], {onError: core.Function, onDone: dart.fnType(dart.void, []), cancelOnError: core.bool}),
>+    [_onCancel]: dart.fnType(dart.void, []),
>+    [_onListen]: dart.fnType(dart.void, []),
>+    [_cancelSubscription]: dart.fnType(dart.void, []),
>+    [_pauseSubscription]: dart.fnType(dart.void, [async.Future]),
>+    [_resumeSubscription]: dart.fnType(dart.void, [])
>+  }));
>+  dart.setGetterSignature(_AsBroadcastStream, () => ({
>+    __proto__: dart.getGetters(_AsBroadcastStream.__proto__),
>+    [_isSubscriptionPaused]: core.bool
>+  }));
>+  dart.setLibraryUri(_AsBroadcastStream, "dart:async");
>+  dart.setFieldSignature(_AsBroadcastStream, () => ({
>+    __proto__: dart.getFields(_AsBroadcastStream.__proto__),
>+    [_source$]: dart.finalFieldType(StreamOfT()),
>+    [_onListenHandler]: dart.finalFieldType(StreamSubscriptionOfTTovoid()),
>+    [_onCancelHandler]: dart.finalFieldType(StreamSubscriptionOfTTovoid()),
>+    [_zone$]: dart.finalFieldType(async.Zone),
>+    [_controller]: dart.fieldType(_AsBroadcastStreamControllerOfT()),
>+    [_subscription]: dart.fieldType(StreamSubscriptionOfT())
>+  }));
>+  return _AsBroadcastStream;
>+});
>+async._AsBroadcastStream = async._AsBroadcastStream$();
>+dart.addTypeTests(async._AsBroadcastStream, _is__AsBroadcastStream_default);
>+const _is__BroadcastSubscriptionWrapper_default = Symbol('_is__BroadcastSubscriptionWrapper_default');
>+async._BroadcastSubscriptionWrapper$ = dart.generic(T => {
>+  let StreamSubscriptionOfT = () => (StreamSubscriptionOfT = dart.constFn(async.StreamSubscription$(T)))();
>+  class _BroadcastSubscriptionWrapper extends core.Object {
>+    onData(handleData) {
>+      dart.throw(new core.UnsupportedError.new("Cannot change handlers of asBroadcastStream source subscription."));
>+    }
>+    onError(handleError) {
>+      dart.throw(new core.UnsupportedError.new("Cannot change handlers of asBroadcastStream source subscription."));
>+    }
>+    onDone(handleDone) {
>+      dart.throw(new core.UnsupportedError.new("Cannot change handlers of asBroadcastStream source subscription."));
>+    }
>+    pause(resumeSignal) {
>+      if (resumeSignal === void 0) resumeSignal = null;
>+      this[_stream][_pauseSubscription](resumeSignal);
>+    }
>+    resume() {
>+      this[_stream][_resumeSubscription]();
>+    }
>+    cancel() {
>+      this[_stream][_cancelSubscription]();
>+      return async.Future._nullFuture;
>+    }
>+    get isPaused() {
>+      return this[_stream][_isSubscriptionPaused];
>+    }
>+    asFuture(E, futureValue) {
>+      if (futureValue === void 0) futureValue = null;
>+      dart.throw(new core.UnsupportedError.new("Cannot change handlers of asBroadcastStream source subscription."));
>+    }
>+  }
>+  (_BroadcastSubscriptionWrapper.new = function(stream) {
>+    this[_stream] = stream;
>+  }).prototype = _BroadcastSubscriptionWrapper.prototype;
>+  _BroadcastSubscriptionWrapper.prototype[dart.isStreamSubscription] = true;
>+  dart.addTypeTests(_BroadcastSubscriptionWrapper);
>+  _BroadcastSubscriptionWrapper.prototype[_is__BroadcastSubscriptionWrapper_default] = true;
>+  _BroadcastSubscriptionWrapper[dart.implements] = () => [StreamSubscriptionOfT()];
>+  dart.setMethodSignature(_BroadcastSubscriptionWrapper, () => ({
>+    __proto__: dart.getMethods(_BroadcastSubscriptionWrapper.__proto__),
>+    onData: dart.fnType(dart.void, [dart.fnType(dart.void, [T])]),
>+    onError: dart.fnType(dart.void, [core.Function]),
>+    onDone: dart.fnType(dart.void, [dart.fnType(dart.void, [])]),
>+    pause: dart.fnType(dart.void, [], [async.Future]),
>+    resume: dart.fnType(dart.void, []),
>+    cancel: dart.fnType(async.Future, []),
>+    asFuture: dart.gFnType(E => [async.Future$(E), [], [E]])
>+  }));
>+  dart.setGetterSignature(_BroadcastSubscriptionWrapper, () => ({
>+    __proto__: dart.getGetters(_BroadcastSubscriptionWrapper.__proto__),
>+    isPaused: core.bool
>+  }));
>+  dart.setLibraryUri(_BroadcastSubscriptionWrapper, "dart:async");
>+  dart.setFieldSignature(_BroadcastSubscriptionWrapper, () => ({
>+    __proto__: dart.getFields(_BroadcastSubscriptionWrapper.__proto__),
>+    [_stream]: dart.finalFieldType(async._AsBroadcastStream)
>+  }));
>+  return _BroadcastSubscriptionWrapper;
>+});
>+async._BroadcastSubscriptionWrapper = async._BroadcastSubscriptionWrapper$();
>+dart.addTypeTests(async._BroadcastSubscriptionWrapper, _is__BroadcastSubscriptionWrapper_default);
>+const _stateData = dart.privateName(async, "_stateData");
>+const _initializeOrDone = dart.privateName(async, "_initializeOrDone");
>+const _is__StreamIterator_default = Symbol('_is__StreamIterator_default');
>+async._StreamIterator$ = dart.generic(T => {
>+  let StreamOfT = () => (StreamOfT = dart.constFn(async.Stream$(T)))();
>+  let StreamSubscriptionOfT = () => (StreamSubscriptionOfT = dart.constFn(async.StreamSubscription$(T)))();
>+  let StreamIteratorOfT = () => (StreamIteratorOfT = dart.constFn(async.StreamIterator$(T)))();
>+  class _StreamIterator extends core.Object {
>+    get current() {
>+      if (this[_subscription] != null && dart.test(this[_isPaused])) {
>+        return T._check(this[_stateData]);
>+      }
>+      return null;
>+    }
>+    moveNext() {
>+      if (this[_subscription] != null) {
>+        if (dart.test(this[_isPaused])) {
>+          let future = new (_FutureOfbool()).new();
>+          this[_stateData] = future;
>+          this[_isPaused] = false;
>+          this[_subscription].resume();
>+          return future;
>+        }
>+        dart.throw(new core.StateError.new("Already waiting for next."));
>+      }
>+      return this[_initializeOrDone]();
>+    }
>+    [_initializeOrDone]() {
>+      if (!(this[_subscription] == null)) dart.assertFailed(null, "dart:async/stream_impl.dart", 1000, 12, "_subscription == null");
>+      let stateData = this[_stateData];
>+      if (stateData != null) {
>+        let stream = StreamOfT()._check(stateData);
>+        this[_subscription] = stream.listen(dart.bind(this, _onData$), {onError: dart.bind(this, _onError), onDone: dart.bind(this, _onDone), cancelOnError: true});
>+        let future = new (_FutureOfbool()).new();
>+        this[_stateData] = future;
>+        return future;
>+      }
>+      return async.Future._falseFuture;
>+    }
>+    cancel() {
>+      let subscription = StreamSubscriptionOfT()._check(this[_subscription]);
>+      let stateData = this[_stateData];
>+      this[_stateData] = null;
>+      if (subscription != null) {
>+        this[_subscription] = null;
>+        if (!dart.test(this[_isPaused])) {
>+          let future = _FutureOfbool()._check(stateData);
>+          future[_asyncComplete](false);
>+        }
>+        return subscription.cancel();
>+      }
>+      return async.Future._nullFuture;
>+    }
>+    [_onData$](data) {
>+      T._check(data);
>+      if (!(this[_subscription] != null && !dart.test(this[_isPaused]))) dart.assertFailed(null, "dart:async/stream_impl.dart", 1029, 12, "_subscription != null && !_isPaused");
>+      let moveNextFuture = _FutureOfbool()._check(this[_stateData]);
>+      this[_stateData] = data;
>+      this[_isPaused] = true;
>+      moveNextFuture[_complete](true);
>+      if (this[_subscription] != null && dart.test(this[_isPaused])) this[_subscription].pause();
>+    }
>+    [_onError](error, stackTrace) {
>+      if (stackTrace === void 0) stackTrace = null;
>+      if (!(this[_subscription] != null && !dart.test(this[_isPaused]))) dart.assertFailed(null, "dart:async/stream_impl.dart", 1038, 12, "_subscription != null && !_isPaused");
>+      let moveNextFuture = _FutureOfbool()._check(this[_stateData]);
>+      this[_subscription] = null;
>+      this[_stateData] = null;
>+      moveNextFuture[_completeError](error, stackTrace);
>+    }
>+    [_onDone]() {
>+      if (!(this[_subscription] != null && !dart.test(this[_isPaused]))) dart.assertFailed(null, "dart:async/stream_impl.dart", 1046, 12, "_subscription != null && !_isPaused");
>+      let moveNextFuture = _FutureOfbool()._check(this[_stateData]);
>+      this[_subscription] = null;
>+      this[_stateData] = null;
>+      moveNextFuture[_complete](false);
>+    }
>+  }
>+  (_StreamIterator.new = function(stream) {
>+    this[_subscription] = null;
>+    this[_isPaused] = false;
>+    this[_stateData] = stream != null ? stream : dart.throw(new core.ArgumentError.notNull("stream"));
>+  }).prototype = _StreamIterator.prototype;
>+  dart.addTypeTests(_StreamIterator);
>+  _StreamIterator.prototype[_is__StreamIterator_default] = true;
>+  _StreamIterator[dart.implements] = () => [StreamIteratorOfT()];
>+  dart.setMethodSignature(_StreamIterator, () => ({
>+    __proto__: dart.getMethods(_StreamIterator.__proto__),
>+    moveNext: dart.fnType(async.Future$(core.bool), []),
>+    [_initializeOrDone]: dart.fnType(async.Future$(core.bool), []),
>+    cancel: dart.fnType(async.Future, []),
>+    [_onData$]: dart.fnType(dart.void, [core.Object]),
>+    [_onError]: dart.fnType(dart.void, [core.Object], [core.StackTrace]),
>+    [_onDone]: dart.fnType(dart.void, [])
>+  }));
>+  dart.setGetterSignature(_StreamIterator, () => ({
>+    __proto__: dart.getGetters(_StreamIterator.__proto__),
>+    current: T
>+  }));
>+  dart.setLibraryUri(_StreamIterator, "dart:async");
>+  dart.setFieldSignature(_StreamIterator, () => ({
>+    __proto__: dart.getFields(_StreamIterator.__proto__),
>+    [_subscription]: dart.fieldType(async.StreamSubscription),
>+    [_stateData]: dart.fieldType(core.Object),
>+    [_isPaused]: dart.fieldType(core.bool)
>+  }));
>+  return _StreamIterator;
>+});
>+async._StreamIterator = async._StreamIterator$();
>+dart.addTypeTests(async._StreamIterator, _is__StreamIterator_default);
>+const _is__EmptyStream_default = Symbol('_is__EmptyStream_default');
>+async._EmptyStream$ = dart.generic(T => {
>+  let _DoneStreamSubscriptionOfT = () => (_DoneStreamSubscriptionOfT = dart.constFn(async._DoneStreamSubscription$(T)))();
>+  class _EmptyStream extends async.Stream$(T) {
>+    get isBroadcast() {
>+      return true;
>+    }
>+    listen(onData, opts) {
>+      let onError = opts && 'onError' in opts ? opts.onError : null;
>+      let onDone = opts && 'onDone' in opts ? opts.onDone : null;
>+      let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
>+      return new (_DoneStreamSubscriptionOfT()).new(onDone);
>+    }
>+  }
>+  (_EmptyStream.new = function() {
>+    _EmptyStream.__proto__._internal.call(this);
>+  }).prototype = _EmptyStream.prototype;
>+  dart.addTypeTests(_EmptyStream);
>+  _EmptyStream.prototype[_is__EmptyStream_default] = true;
>+  dart.setMethodSignature(_EmptyStream, () => ({
>+    __proto__: dart.getMethods(_EmptyStream.__proto__),
>+    listen: dart.fnType(async.StreamSubscription$(T), [dart.fnType(dart.void, [T])], {onError: core.Function, onDone: dart.fnType(dart.void, []), cancelOnError: core.bool})
>+  }));
>+  dart.setLibraryUri(_EmptyStream, "dart:async");
>+  return _EmptyStream;
>+});
>+async._EmptyStream = async._EmptyStream$();
>+dart.addTypeTests(async._EmptyStream, _is__EmptyStream_default);
>+async._runUserCode = function(T, userCode, onSuccess, onError) {
>+  try {
>+    onSuccess(userCode());
>+  } catch (e$) {
>+    let e = dart.getThrown(e$);
>+    let s = dart.stackTrace(e$);
>+    let replacement = async.Zone.current.errorCallback(e, s);
>+    if (replacement == null) {
>+      onError(e, s);
>+    } else {
>+      let error = async._nonNullError(replacement.error);
>+      let stackTrace = replacement.stackTrace;
>+      onError(error, stackTrace);
>+    }
>+  }
>+};
>+async._cancelAndError = function(subscription, future, error, stackTrace) {
>+  let cancelFuture = subscription.cancel();
>+  if (cancelFuture != null && !(cancelFuture == async.Future._nullFuture)) {
>+    cancelFuture.whenComplete(dart.fn(() => future[_completeError](error, stackTrace), VoidTovoid()));
>+  } else {
>+    future[_completeError](error, stackTrace);
>+  }
>+};
>+async._cancelAndErrorWithReplacement = function(subscription, future, error, stackTrace) {
>+  let replacement = async.Zone.current.errorCallback(error, stackTrace);
>+  if (replacement != null) {
>+    error = async._nonNullError(replacement.error);
>+    stackTrace = replacement.stackTrace;
>+  }
>+  async._cancelAndError(subscription, future, error, stackTrace);
>+};
>+async._cancelAndErrorClosure = function(subscription, future) {
>+  return dart.fn((error, stackTrace) => {
>+    async._cancelAndError(subscription, future, error, stackTrace);
>+  }, dynamicAndStackTraceToNull());
>+};
>+async._cancelAndValue = function(subscription, future, value) {
>+  let cancelFuture = subscription.cancel();
>+  if (cancelFuture != null && !(cancelFuture == async.Future._nullFuture)) {
>+    cancelFuture.whenComplete(dart.fn(() => future[_complete](value), VoidTovoid()));
>+  } else {
>+    future[_complete](value);
>+  }
>+};
>+const _handleData$ = dart.privateName(async, "_handleData");
>+const _handleError$ = dart.privateName(async, "_handleError");
>+const _handleDone = dart.privateName(async, "_handleDone");
>+const _is__ForwardingStream_default = Symbol('_is__ForwardingStream_default');
>+async._ForwardingStream$ = dart.generic((S, T) => {
>+  let _ForwardingStreamSubscriptionOfS$T = () => (_ForwardingStreamSubscriptionOfS$T = dart.constFn(async._ForwardingStreamSubscription$(S, T)))();
>+  let StreamOfS = () => (StreamOfS = dart.constFn(async.Stream$(S)))();
>+  let _EventSinkOfT = () => (_EventSinkOfT = dart.constFn(async._EventSink$(T)))();
>+  class _ForwardingStream extends async.Stream$(T) {
>+    get isBroadcast() {
>+      return this[_source$].isBroadcast;
>+    }
>+    listen(onData, opts) {
>+      let onError = opts && 'onError' in opts ? opts.onError : null;
>+      let onDone = opts && 'onDone' in opts ? opts.onDone : null;
>+      let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
>+      cancelOnError = true === cancelOnError;
>+      return this[_createSubscription](onData, onError, onDone, cancelOnError);
>+    }
>+    [_createSubscription](onData, onError, onDone, cancelOnError) {
>+      return new (_ForwardingStreamSubscriptionOfS$T()).new(this, onData, onError, onDone, cancelOnError);
>+    }
>+    [_handleData$](data, sink) {
>+      S._check(data);
>+      _EventSinkOfT()._check(sink);
>+      sink[_add](T._check(data));
>+    }
>+    [_handleError$](error, stackTrace, sink) {
>+      _EventSinkOfT()._check(sink);
>+      sink[_addError](error, stackTrace);
>+    }
>+    [_handleDone](sink) {
>+      _EventSinkOfT()._check(sink);
>+      sink[_close]();
>+    }
>+  }
>+  (_ForwardingStream.new = function(source) {
>+    this[_source$] = source;
>+    _ForwardingStream.__proto__.new.call(this);
>+  }).prototype = _ForwardingStream.prototype;
>+  dart.addTypeTests(_ForwardingStream);
>+  _ForwardingStream.prototype[_is__ForwardingStream_default] = true;
>+  dart.setMethodSignature(_ForwardingStream, () => ({
>+    __proto__: dart.getMethods(_ForwardingStream.__proto__),
>+    listen: dart.fnType(async.StreamSubscription$(T), [dart.fnType(dart.void, [T])], {onError: core.Function, onDone: dart.fnType(dart.void, []), cancelOnError: core.bool}),
>+    [_createSubscription]: dart.fnType(async.StreamSubscription$(T), [dart.fnType(dart.void, [T]), core.Function, dart.fnType(dart.void, []), core.bool]),
>+    [_handleData$]: dart.fnType(dart.void, [core.Object, core.Object]),
>+    [_handleError$]: dart.fnType(dart.void, [dart.dynamic, core.StackTrace, core.Object]),
>+    [_handleDone]: dart.fnType(dart.void, [core.Object])
>+  }));
>+  dart.setGetterSignature(_ForwardingStream, () => ({
>+    __proto__: dart.getGetters(_ForwardingStream.__proto__),
>+    isBroadcast: core.bool
>+  }));
>+  dart.setLibraryUri(_ForwardingStream, "dart:async");
>+  dart.setFieldSignature(_ForwardingStream, () => ({
>+    __proto__: dart.getFields(_ForwardingStream.__proto__),
>+    [_source$]: dart.finalFieldType(StreamOfS())
>+  }));
>+  return _ForwardingStream;
>+});
>+async._ForwardingStream = async._ForwardingStream$();
>+dart.addTypeTests(async._ForwardingStream, _is__ForwardingStream_default);
>+const _is__ForwardingStreamSubscription_default = Symbol('_is__ForwardingStreamSubscription_default');
>+async._ForwardingStreamSubscription$ = dart.generic((S, T) => {
>+  let _ForwardingStreamOfS$T = () => (_ForwardingStreamOfS$T = dart.constFn(async._ForwardingStream$(S, T)))();
>+  let StreamSubscriptionOfS = () => (StreamSubscriptionOfS = dart.constFn(async.StreamSubscription$(S)))();
>+  class _ForwardingStreamSubscription extends async._BufferingStreamSubscription$(T) {
>+    [_add](data) {
>+      T._check(data);
>+      if (dart.test(this[_isClosed])) return;
>+      super[_add](data);
>+    }
>+    [_addError](error, stackTrace) {
>+      if (dart.test(this[_isClosed])) return;
>+      super[_addError](error, stackTrace);
>+    }
>+    [_onPause]() {
>+      if (this[_subscription] == null) return;
>+      this[_subscription].pause();
>+    }
>+    [_onResume]() {
>+      if (this[_subscription] == null) return;
>+      this[_subscription].resume();
>+    }
>+    [_onCancel]() {
>+      if (this[_subscription] != null) {
>+        let subscription = this[_subscription];
>+        this[_subscription] = null;
>+        return subscription.cancel();
>+      }
>+      return null;
>+    }
>+    [_handleData$](data) {
>+      S._check(data);
>+      this[_stream][_handleData$](data, this);
>+    }
>+    [_handleError$](error, stackTrace) {
>+      this[_stream][_handleError$](error, stackTrace, this);
>+    }
>+    [_handleDone]() {
>+      this[_stream][_handleDone](this);
>+    }
>+  }
>+  (_ForwardingStreamSubscription.new = function(stream, onData, onError, onDone, cancelOnError) {
>+    this[_subscription] = null;
>+    this[_stream] = stream;
>+    _ForwardingStreamSubscription.__proto__.new.call(this, onData, onError, onDone, cancelOnError);
>+    this[_subscription] = this[_stream][_source$].listen(dart.bind(this, _handleData$), {onError: dart.bind(this, _handleError$), onDone: dart.bind(this, _handleDone)});
>+  }).prototype = _ForwardingStreamSubscription.prototype;
>+  dart.addTypeTests(_ForwardingStreamSubscription);
>+  _ForwardingStreamSubscription.prototype[_is__ForwardingStreamSubscription_default] = true;
>+  dart.setMethodSignature(_ForwardingStreamSubscription, () => ({
>+    __proto__: dart.getMethods(_ForwardingStreamSubscription.__proto__),
>+    [_add]: dart.fnType(dart.void, [core.Object]),
>+    [_addError]: dart.fnType(dart.void, [core.Object, core.StackTrace]),
>+    [_onPause]: dart.fnType(dart.void, []),
>+    [_onResume]: dart.fnType(dart.void, []),
>+    [_onCancel]: dart.fnType(async.Future, []),
>+    [_handleData$]: dart.fnType(dart.void, [core.Object]),
>+    [_handleError$]: dart.fnType(dart.void, [dart.dynamic, core.StackTrace]),
>+    [_handleDone]: dart.fnType(dart.void, [])
>+  }));
>+  dart.setLibraryUri(_ForwardingStreamSubscription, "dart:async");
>+  dart.setFieldSignature(_ForwardingStreamSubscription, () => ({
>+    __proto__: dart.getFields(_ForwardingStreamSubscription.__proto__),
>+    [_stream]: dart.finalFieldType(_ForwardingStreamOfS$T()),
>+    [_subscription]: dart.fieldType(StreamSubscriptionOfS())
>+  }));
>+  return _ForwardingStreamSubscription;
>+});
>+async._ForwardingStreamSubscription = async._ForwardingStreamSubscription$();
>+dart.addTypeTests(async._ForwardingStreamSubscription, _is__ForwardingStreamSubscription_default);
>+async._addErrorWithReplacement = function(sink, error, stackTrace) {
>+  let replacement = async.Zone.current.errorCallback(error, stackTrace);
>+  if (replacement != null) {
>+    error = async._nonNullError(replacement.error);
>+    stackTrace = replacement.stackTrace;
>+  }
>+  sink[_addError](error, stackTrace);
>+};
>+const _test = dart.privateName(async, "_test");
>+const _is__WhereStream_default = Symbol('_is__WhereStream_default');
>+async._WhereStream$ = dart.generic(T => {
>+  let _EventSinkOfT = () => (_EventSinkOfT = dart.constFn(async._EventSink$(T)))();
>+  let TTobool = () => (TTobool = dart.constFn(dart.fnType(core.bool, [T])))();
>+  class _WhereStream extends async._ForwardingStream$(T, T) {
>+    [_handleData$](inputEvent, sink) {
>+      T._check(inputEvent);
>+      _EventSinkOfT()._check(sink);
>+      let satisfies = null;
>+      try {
>+        satisfies = this[_test](inputEvent);
>+      } catch (e$) {
>+        let e = dart.getThrown(e$);
>+        let s = dart.stackTrace(e$);
>+        async._addErrorWithReplacement(sink, e, s);
>+        return;
>+      }
>+      if (dart.test(satisfies)) {
>+        sink[_add](inputEvent);
>+      }
>+    }
>+  }
>+  (_WhereStream.new = function(source, test) {
>+    this[_test] = test;
>+    _WhereStream.__proto__.new.call(this, source);
>+  }).prototype = _WhereStream.prototype;
>+  dart.addTypeTests(_WhereStream);
>+  _WhereStream.prototype[_is__WhereStream_default] = true;
>+  dart.setMethodSignature(_WhereStream, () => ({
>+    __proto__: dart.getMethods(_WhereStream.__proto__),
>+    [_handleData$]: dart.fnType(dart.void, [core.Object, core.Object])
>+  }));
>+  dart.setLibraryUri(_WhereStream, "dart:async");
>+  dart.setFieldSignature(_WhereStream, () => ({
>+    __proto__: dart.getFields(_WhereStream.__proto__),
>+    [_test]: dart.finalFieldType(TTobool())
>+  }));
>+  return _WhereStream;
>+});
>+async._WhereStream = async._WhereStream$();
>+dart.addTypeTests(async._WhereStream, _is__WhereStream_default);
>+const _transform = dart.privateName(async, "_transform");
>+const _is__MapStream_default = Symbol('_is__MapStream_default');
>+async._MapStream$ = dart.generic((S, T) => {
>+  let SToT = () => (SToT = dart.constFn(dart.fnType(T, [S])))();
>+  let _EventSinkOfT = () => (_EventSinkOfT = dart.constFn(async._EventSink$(T)))();
>+  class _MapStream extends async._ForwardingStream$(S, T) {
>+    [_handleData$](inputEvent, sink) {
>+      S._check(inputEvent);
>+      _EventSinkOfT()._check(sink);
>+      let outputEvent = null;
>+      try {
>+        outputEvent = this[_transform](inputEvent);
>+      } catch (e$) {
>+        let e = dart.getThrown(e$);
>+        let s = dart.stackTrace(e$);
>+        async._addErrorWithReplacement(sink, e, s);
>+        return;
>+      }
>+      sink[_add](outputEvent);
>+    }
>+  }
>+  (_MapStream.new = function(source, transform) {
>+    this[_transform] = transform;
>+    _MapStream.__proto__.new.call(this, source);
>+  }).prototype = _MapStream.prototype;
>+  dart.addTypeTests(_MapStream);
>+  _MapStream.prototype[_is__MapStream_default] = true;
>+  dart.setMethodSignature(_MapStream, () => ({
>+    __proto__: dart.getMethods(_MapStream.__proto__),
>+    [_handleData$]: dart.fnType(dart.void, [core.Object, core.Object])
>+  }));
>+  dart.setLibraryUri(_MapStream, "dart:async");
>+  dart.setFieldSignature(_MapStream, () => ({
>+    __proto__: dart.getFields(_MapStream.__proto__),
>+    [_transform]: dart.finalFieldType(SToT())
>+  }));
>+  return _MapStream;
>+});
>+async._MapStream = async._MapStream$();
>+dart.addTypeTests(async._MapStream, _is__MapStream_default);
>+const _expand = dart.privateName(async, "_expand");
>+const _is__ExpandStream_default = Symbol('_is__ExpandStream_default');
>+async._ExpandStream$ = dart.generic((S, T) => {
>+  let SToIterableOfT = () => (SToIterableOfT = dart.constFn(dart.fnType(IterableOfT(), [S])))();
>+  let _EventSinkOfT = () => (_EventSinkOfT = dart.constFn(async._EventSink$(T)))();
>+  let IterableOfT = () => (IterableOfT = dart.constFn(core.Iterable$(T)))();
>+  class _ExpandStream extends async._ForwardingStream$(S, T) {
>+    [_handleData$](inputEvent, sink) {
>+      S._check(inputEvent);
>+      _EventSinkOfT()._check(sink);
>+      try {
>+        for (let value of this[_expand](inputEvent)) {
>+          sink[_add](value);
>+        }
>+      } catch (e$) {
>+        let e = dart.getThrown(e$);
>+        let s = dart.stackTrace(e$);
>+        async._addErrorWithReplacement(sink, e, s);
>+      }
>+    }
>+  }
>+  (_ExpandStream.new = function(source, expand) {
>+    this[_expand] = expand;
>+    _ExpandStream.__proto__.new.call(this, source);
>+  }).prototype = _ExpandStream.prototype;
>+  dart.addTypeTests(_ExpandStream);
>+  _ExpandStream.prototype[_is__ExpandStream_default] = true;
>+  dart.setMethodSignature(_ExpandStream, () => ({
>+    __proto__: dart.getMethods(_ExpandStream.__proto__),
>+    [_handleData$]: dart.fnType(dart.void, [core.Object, core.Object])
>+  }));
>+  dart.setLibraryUri(_ExpandStream, "dart:async");
>+  dart.setFieldSignature(_ExpandStream, () => ({
>+    __proto__: dart.getFields(_ExpandStream.__proto__),
>+    [_expand]: dart.finalFieldType(SToIterableOfT())
>+  }));
>+  return _ExpandStream;
>+});
>+async._ExpandStream = async._ExpandStream$();
>+dart.addTypeTests(async._ExpandStream, _is__ExpandStream_default);
>+const _is__HandleErrorStream_default = Symbol('_is__HandleErrorStream_default');
>+async._HandleErrorStream$ = dart.generic(T => {
>+  let _EventSinkOfT = () => (_EventSinkOfT = dart.constFn(async._EventSink$(T)))();
>+  class _HandleErrorStream extends async._ForwardingStream$(T, T) {
>+    [_handleError$](error, stackTrace, sink) {
>+      _EventSinkOfT()._check(sink);
>+      let matches = true;
>+      if (this[_test] != null) {
>+        try {
>+          matches = this[_test](error);
>+        } catch (e$) {
>+          let e = dart.getThrown(e$);
>+          let s = dart.stackTrace(e$);
>+          async._addErrorWithReplacement(sink, e, s);
>+          return;
>+        }
>+      }
>+      if (dart.test(matches)) {
>+        try {
>+          async._invokeErrorHandler(this[_transform], error, stackTrace);
>+        } catch (e$0) {
>+          let e = dart.getThrown(e$0);
>+          let s = dart.stackTrace(e$0);
>+          if (core.identical(e, error)) {
>+            sink[_addError](error, stackTrace);
>+          } else {
>+            async._addErrorWithReplacement(sink, e, s);
>+          }
>+          return;
>+        }
>+      } else {
>+        sink[_addError](error, stackTrace);
>+      }
>+    }
>+  }
>+  (_HandleErrorStream.new = function(source, onError, test) {
>+    this[_transform] = onError;
>+    this[_test] = test;
>+    _HandleErrorStream.__proto__.new.call(this, source);
>+  }).prototype = _HandleErrorStream.prototype;
>+  dart.addTypeTests(_HandleErrorStream);
>+  _HandleErrorStream.prototype[_is__HandleErrorStream_default] = true;
>+  dart.setMethodSignature(_HandleErrorStream, () => ({
>+    __proto__: dart.getMethods(_HandleErrorStream.__proto__),
>+    [_handleError$]: dart.fnType(dart.void, [core.Object, core.StackTrace, core.Object])
>+  }));
>+  dart.setLibraryUri(_HandleErrorStream, "dart:async");
>+  dart.setFieldSignature(_HandleErrorStream, () => ({
>+    __proto__: dart.getFields(_HandleErrorStream.__proto__),
>+    [_transform]: dart.finalFieldType(core.Function),
>+    [_test]: dart.finalFieldType(dynamicTobool())
>+  }));
>+  return _HandleErrorStream;
>+});
>+async._HandleErrorStream = async._HandleErrorStream$();
>+dart.addTypeTests(async._HandleErrorStream, _is__HandleErrorStream_default);
>+const _count = dart.privateName(async, "_count");
>+const _is__TakeStream_default = Symbol('_is__TakeStream_default');
>+async._TakeStream$ = dart.generic(T => {
>+  let _DoneStreamSubscriptionOfT = () => (_DoneStreamSubscriptionOfT = dart.constFn(async._DoneStreamSubscription$(T)))();
>+  let _StateStreamSubscriptionOfT = () => (_StateStreamSubscriptionOfT = dart.constFn(async._StateStreamSubscription$(T)))();
>+  let _EventSinkOfT = () => (_EventSinkOfT = dart.constFn(async._EventSink$(T)))();
>+  class _TakeStream extends async._ForwardingStream$(T, T) {
>+    [_createSubscription](onData, onError, onDone, cancelOnError) {
>+      if (this[_count] === 0) {
>+        this[_source$].listen(null).cancel();
>+        return new (_DoneStreamSubscriptionOfT()).new(onDone);
>+      }
>+      return new (_StateStreamSubscriptionOfT()).new(this, onData, onError, onDone, cancelOnError, this[_count]);
>+    }
>+    [_handleData$](inputEvent, sink) {
>+      T._check(inputEvent);
>+      _EventSinkOfT()._check(sink);
>+      let subscription = _StateStreamSubscriptionOfT()._check(sink);
>+      let count = subscription[_count];
>+      if (dart.notNull(count) > 0) {
>+        sink[_add](inputEvent);
>+        count = dart.notNull(count) - 1;
>+        subscription[_count] = count;
>+        if (count === 0) {
>+          sink[_close]();
>+        }
>+      }
>+    }
>+  }
>+  (_TakeStream.new = function(source, count) {
>+    this[_count] = count;
>+    _TakeStream.__proto__.new.call(this, source);
>+    core.ArgumentError.checkNotNull(count, "count");
>+  }).prototype = _TakeStream.prototype;
>+  dart.addTypeTests(_TakeStream);
>+  _TakeStream.prototype[_is__TakeStream_default] = true;
>+  dart.setMethodSignature(_TakeStream, () => ({
>+    __proto__: dart.getMethods(_TakeStream.__proto__),
>+    [_createSubscription]: dart.fnType(async.StreamSubscription$(T), [dart.fnType(dart.void, [T]), core.Function, dart.fnType(dart.void, []), core.bool]),
>+    [_handleData$]: dart.fnType(dart.void, [core.Object, core.Object])
>+  }));
>+  dart.setLibraryUri(_TakeStream, "dart:async");
>+  dart.setFieldSignature(_TakeStream, () => ({
>+    __proto__: dart.getFields(_TakeStream.__proto__),
>+    [_count]: dart.finalFieldType(core.int)
>+  }));
>+  return _TakeStream;
>+});
>+async._TakeStream = async._TakeStream$();
>+dart.addTypeTests(async._TakeStream, _is__TakeStream_default);
>+const _sharedState = dart.privateName(async, "_sharedState");
>+const _flag = dart.privateName(async, "_flag");
>+const _value = dart.privateName(async, "_value");
>+const _is__StateStreamSubscription_default = Symbol('_is__StateStreamSubscription_default');
>+async._StateStreamSubscription$ = dart.generic(T => {
>+  class _StateStreamSubscription extends async._ForwardingStreamSubscription$(T, T) {
>+    get [_flag]() {
>+      return core.bool._check(this[_sharedState]);
>+    }
>+    set [_flag](flag) {
>+      this[_sharedState] = flag;
>+    }
>+    get [_count]() {
>+      return core.int._check(this[_sharedState]);
>+    }
>+    set [_count](count) {
>+      this[_sharedState] = count;
>+    }
>+    get [_value]() {
>+      return this[_sharedState];
>+    }
>+    set [_value](value) {
>+      this[_sharedState] = value;
>+    }
>+  }
>+  (_StateStreamSubscription.new = function(stream, onData, onError, onDone, cancelOnError, sharedState) {
>+    this[_sharedState] = sharedState;
>+    _StateStreamSubscription.__proto__.new.call(this, stream, onData, onError, onDone, cancelOnError);
>+  }).prototype = _StateStreamSubscription.prototype;
>+  dart.addTypeTests(_StateStreamSubscription);
>+  _StateStreamSubscription.prototype[_is__StateStreamSubscription_default] = true;
>+  dart.setGetterSignature(_StateStreamSubscription, () => ({
>+    __proto__: dart.getGetters(_StateStreamSubscription.__proto__),
>+    [_flag]: core.bool,
>+    [_count]: core.int,
>+    [_value]: core.Object
>+  }));
>+  dart.setSetterSignature(_StateStreamSubscription, () => ({
>+    __proto__: dart.getSetters(_StateStreamSubscription.__proto__),
>+    [_flag]: core.bool,
>+    [_count]: core.int,
>+    [_value]: core.Object
>+  }));
>+  dart.setLibraryUri(_StateStreamSubscription, "dart:async");
>+  dart.setFieldSignature(_StateStreamSubscription, () => ({
>+    __proto__: dart.getFields(_StateStreamSubscription.__proto__),
>+    [_sharedState]: dart.fieldType(dart.dynamic)
>+  }));
>+  return _StateStreamSubscription;
>+});
>+async._StateStreamSubscription = async._StateStreamSubscription$();
>+dart.addTypeTests(async._StateStreamSubscription, _is__StateStreamSubscription_default);
>+const _is__TakeWhileStream_default = Symbol('_is__TakeWhileStream_default');
>+async._TakeWhileStream$ = dart.generic(T => {
>+  let _EventSinkOfT = () => (_EventSinkOfT = dart.constFn(async._EventSink$(T)))();
>+  let TTobool = () => (TTobool = dart.constFn(dart.fnType(core.bool, [T])))();
>+  class _TakeWhileStream extends async._ForwardingStream$(T, T) {
>+    [_handleData$](inputEvent, sink) {
>+      T._check(inputEvent);
>+      _EventSinkOfT()._check(sink);
>+      let satisfies = null;
>+      try {
>+        satisfies = this[_test](inputEvent);
>+      } catch (e$) {
>+        let e = dart.getThrown(e$);
>+        let s = dart.stackTrace(e$);
>+        async._addErrorWithReplacement(sink, e, s);
>+        sink[_close]();
>+        return;
>+      }
>+      if (dart.test(satisfies)) {
>+        sink[_add](inputEvent);
>+      } else {
>+        sink[_close]();
>+      }
>+    }
>+  }
>+  (_TakeWhileStream.new = function(source, test) {
>+    this[_test] = test;
>+    _TakeWhileStream.__proto__.new.call(this, source);
>+  }).prototype = _TakeWhileStream.prototype;
>+  dart.addTypeTests(_TakeWhileStream);
>+  _TakeWhileStream.prototype[_is__TakeWhileStream_default] = true;
>+  dart.setMethodSignature(_TakeWhileStream, () => ({
>+    __proto__: dart.getMethods(_TakeWhileStream.__proto__),
>+    [_handleData$]: dart.fnType(dart.void, [core.Object, core.Object])
>+  }));
>+  dart.setLibraryUri(_TakeWhileStream, "dart:async");
>+  dart.setFieldSignature(_TakeWhileStream, () => ({
>+    __proto__: dart.getFields(_TakeWhileStream.__proto__),
>+    [_test]: dart.finalFieldType(TTobool())
>+  }));
>+  return _TakeWhileStream;
>+});
>+async._TakeWhileStream = async._TakeWhileStream$();
>+dart.addTypeTests(async._TakeWhileStream, _is__TakeWhileStream_default);
>+const _is__SkipStream_default = Symbol('_is__SkipStream_default');
>+async._SkipStream$ = dart.generic(T => {
>+  let _StateStreamSubscriptionOfT = () => (_StateStreamSubscriptionOfT = dart.constFn(async._StateStreamSubscription$(T)))();
>+  let _EventSinkOfT = () => (_EventSinkOfT = dart.constFn(async._EventSink$(T)))();
>+  class _SkipStream extends async._ForwardingStream$(T, T) {
>+    [_createSubscription](onData, onError, onDone, cancelOnError) {
>+      return new (_StateStreamSubscriptionOfT()).new(this, onData, onError, onDone, cancelOnError, this[_count]);
>+    }
>+    [_handleData$](inputEvent, sink) {
>+      T._check(inputEvent);
>+      _EventSinkOfT()._check(sink);
>+      let subscription = _StateStreamSubscriptionOfT()._check(sink);
>+      let count = subscription[_count];
>+      if (dart.notNull(count) > 0) {
>+        subscription[_count] = dart.notNull(count) - 1;
>+        return;
>+      }
>+      sink[_add](inputEvent);
>+    }
>+  }
>+  (_SkipStream.new = function(source, count) {
>+    this[_count] = count;
>+    _SkipStream.__proto__.new.call(this, source);
>+    core.ArgumentError.checkNotNull(count, "count");
>+    core.RangeError.checkNotNegative(count, "count");
>+  }).prototype = _SkipStream.prototype;
>+  dart.addTypeTests(_SkipStream);
>+  _SkipStream.prototype[_is__SkipStream_default] = true;
>+  dart.setMethodSignature(_SkipStream, () => ({
>+    __proto__: dart.getMethods(_SkipStream.__proto__),
>+    [_createSubscription]: dart.fnType(async.StreamSubscription$(T), [dart.fnType(dart.void, [T]), core.Function, dart.fnType(dart.void, []), core.bool]),
>+    [_handleData$]: dart.fnType(dart.void, [core.Object, core.Object])
>+  }));
>+  dart.setLibraryUri(_SkipStream, "dart:async");
>+  dart.setFieldSignature(_SkipStream, () => ({
>+    __proto__: dart.getFields(_SkipStream.__proto__),
>+    [_count]: dart.finalFieldType(core.int)
>+  }));
>+  return _SkipStream;
>+});
>+async._SkipStream = async._SkipStream$();
>+dart.addTypeTests(async._SkipStream, _is__SkipStream_default);
>+const _is__SkipWhileStream_default = Symbol('_is__SkipWhileStream_default');
>+async._SkipWhileStream$ = dart.generic(T => {
>+  let _StateStreamSubscriptionOfT = () => (_StateStreamSubscriptionOfT = dart.constFn(async._StateStreamSubscription$(T)))();
>+  let _EventSinkOfT = () => (_EventSinkOfT = dart.constFn(async._EventSink$(T)))();
>+  let TTobool = () => (TTobool = dart.constFn(dart.fnType(core.bool, [T])))();
>+  class _SkipWhileStream extends async._ForwardingStream$(T, T) {
>+    [_createSubscription](onData, onError, onDone, cancelOnError) {
>+      return new (_StateStreamSubscriptionOfT()).new(this, onData, onError, onDone, cancelOnError, false);
>+    }
>+    [_handleData$](inputEvent, sink) {
>+      T._check(inputEvent);
>+      _EventSinkOfT()._check(sink);
>+      let subscription = _StateStreamSubscriptionOfT()._check(sink);
>+      let hasFailed = subscription[_flag];
>+      if (dart.test(hasFailed)) {
>+        sink[_add](inputEvent);
>+        return;
>+      }
>+      let satisfies = null;
>+      try {
>+        satisfies = this[_test](inputEvent);
>+      } catch (e$) {
>+        let e = dart.getThrown(e$);
>+        let s = dart.stackTrace(e$);
>+        async._addErrorWithReplacement(sink, e, s);
>+        subscription[_flag] = true;
>+        return;
>+      }
>+      if (!dart.test(satisfies)) {
>+        subscription[_flag] = true;
>+        sink[_add](inputEvent);
>+      }
>+    }
>+  }
>+  (_SkipWhileStream.new = function(source, test) {
>+    this[_test] = test;
>+    _SkipWhileStream.__proto__.new.call(this, source);
>+  }).prototype = _SkipWhileStream.prototype;
>+  dart.addTypeTests(_SkipWhileStream);
>+  _SkipWhileStream.prototype[_is__SkipWhileStream_default] = true;
>+  dart.setMethodSignature(_SkipWhileStream, () => ({
>+    __proto__: dart.getMethods(_SkipWhileStream.__proto__),
>+    [_createSubscription]: dart.fnType(async.StreamSubscription$(T), [dart.fnType(dart.void, [T]), core.Function, dart.fnType(dart.void, []), core.bool]),
>+    [_handleData$]: dart.fnType(dart.void, [core.Object, core.Object])
>+  }));
>+  dart.setLibraryUri(_SkipWhileStream, "dart:async");
>+  dart.setFieldSignature(_SkipWhileStream, () => ({
>+    __proto__: dart.getFields(_SkipWhileStream.__proto__),
>+    [_test]: dart.finalFieldType(TTobool())
>+  }));
>+  return _SkipWhileStream;
>+});
>+async._SkipWhileStream = async._SkipWhileStream$();
>+dart.addTypeTests(async._SkipWhileStream, _is__SkipWhileStream_default);
>+const _equals$ = dart.privateName(async, "_equals");
>+const _is__DistinctStream_default = Symbol('_is__DistinctStream_default');
>+async._DistinctStream$ = dart.generic(T => {
>+  let _StateStreamSubscriptionOfT = () => (_StateStreamSubscriptionOfT = dart.constFn(async._StateStreamSubscription$(T)))();
>+  let _EventSinkOfT = () => (_EventSinkOfT = dart.constFn(async._EventSink$(T)))();
>+  let TAndTTobool = () => (TAndTTobool = dart.constFn(dart.fnType(core.bool, [T, T])))();
>+  class _DistinctStream extends async._ForwardingStream$(T, T) {
>+    [_createSubscription](onData, onError, onDone, cancelOnError) {
>+      return new (_StateStreamSubscriptionOfT()).new(this, onData, onError, onDone, cancelOnError, async._DistinctStream._SENTINEL);
>+    }
>+    [_handleData$](inputEvent, sink) {
>+      T._check(inputEvent);
>+      _EventSinkOfT()._check(sink);
>+      let subscription = _StateStreamSubscriptionOfT()._check(sink);
>+      let previous = subscription[_value];
>+      if (core.identical(previous, async._DistinctStream._SENTINEL)) {
>+        subscription[_value] = inputEvent;
>+        sink[_add](inputEvent);
>+      } else {
>+        let previousEvent = T._check(previous);
>+        let isEqual = null;
>+        try {
>+          if (this[_equals$] == null) {
>+            isEqual = dart.equals(previousEvent, inputEvent);
>+          } else {
>+            isEqual = this[_equals$](previousEvent, inputEvent);
>+          }
>+        } catch (e$) {
>+          let e = dart.getThrown(e$);
>+          let s = dart.stackTrace(e$);
>+          async._addErrorWithReplacement(sink, e, s);
>+          return;
>+        }
>+        if (!dart.test(isEqual)) {
>+          sink[_add](inputEvent);
>+          subscription[_value] = inputEvent;
>+        }
>+      }
>+    }
>+  }
>+  (_DistinctStream.new = function(source, equals) {
>+    this[_equals$] = equals;
>+    _DistinctStream.__proto__.new.call(this, source);
>+  }).prototype = _DistinctStream.prototype;
>+  dart.addTypeTests(_DistinctStream);
>+  _DistinctStream.prototype[_is__DistinctStream_default] = true;
>+  dart.setMethodSignature(_DistinctStream, () => ({
>+    __proto__: dart.getMethods(_DistinctStream.__proto__),
>+    [_createSubscription]: dart.fnType(async.StreamSubscription$(T), [dart.fnType(dart.void, [T]), core.Function, dart.fnType(dart.void, []), core.bool]),
>+    [_handleData$]: dart.fnType(dart.void, [core.Object, core.Object])
>+  }));
>+  dart.setLibraryUri(_DistinctStream, "dart:async");
>+  dart.setFieldSignature(_DistinctStream, () => ({
>+    __proto__: dart.getFields(_DistinctStream.__proto__),
>+    [_equals$]: dart.finalFieldType(TAndTTobool())
>+  }));
>+  return _DistinctStream;
>+});
>+async._DistinctStream = async._DistinctStream$();
>+dart.defineLazy(async._DistinctStream, {
>+  /*async._DistinctStream._SENTINEL*/get _SENTINEL() {
>+    return new core.Object.new();
>+  }
>+});
>+dart.addTypeTests(async._DistinctStream, _is__DistinctStream_default);
>+const _is__EventSinkWrapper_default = Symbol('_is__EventSinkWrapper_default');
>+async._EventSinkWrapper$ = dart.generic(T => {
>+  let EventSinkOfT = () => (EventSinkOfT = dart.constFn(async.EventSink$(T)))();
>+  class _EventSinkWrapper extends core.Object {
>+    add(data) {
>+      T._check(data);
>+      this[_sink][_add](data);
>+    }
>+    addError(error, stackTrace) {
>+      if (stackTrace === void 0) stackTrace = null;
>+      this[_sink][_addError](error, stackTrace);
>+    }
>+    close() {
>+      this[_sink][_close]();
>+    }
>+  }
>+  (_EventSinkWrapper.new = function(sink) {
>+    this[_sink] = sink;
>+  }).prototype = _EventSinkWrapper.prototype;
>+  dart.addTypeTests(_EventSinkWrapper);
>+  _EventSinkWrapper.prototype[_is__EventSinkWrapper_default] = true;
>+  _EventSinkWrapper[dart.implements] = () => [EventSinkOfT()];
>+  dart.setMethodSignature(_EventSinkWrapper, () => ({
>+    __proto__: dart.getMethods(_EventSinkWrapper.__proto__),
>+    add: dart.fnType(dart.void, [core.Object]),
>+    addError: dart.fnType(dart.void, [core.Object], [core.StackTrace]),
>+    close: dart.fnType(dart.void, [])
>+  }));
>+  dart.setLibraryUri(_EventSinkWrapper, "dart:async");
>+  dart.setFieldSignature(_EventSinkWrapper, () => ({
>+    __proto__: dart.getFields(_EventSinkWrapper.__proto__),
>+    [_sink]: dart.fieldType(async._EventSink)
>+  }));
>+  return _EventSinkWrapper;
>+});
>+async._EventSinkWrapper = async._EventSinkWrapper$();
>+dart.addTypeTests(async._EventSinkWrapper, _is__EventSinkWrapper_default);
>+const _transformerSink = dart.privateName(async, "_transformerSink");
>+const _isSubscribed = dart.privateName(async, "_isSubscribed");
>+const _is__SinkTransformerStreamSubscription_default = Symbol('_is__SinkTransformerStreamSubscription_default');
>+async._SinkTransformerStreamSubscription$ = dart.generic((S, T) => {
>+  let EventSinkOfS = () => (EventSinkOfS = dart.constFn(async.EventSink$(S)))();
>+  let StreamSubscriptionOfS = () => (StreamSubscriptionOfS = dart.constFn(async.StreamSubscription$(S)))();
>+  let _EventSinkWrapperOfT = () => (_EventSinkWrapperOfT = dart.constFn(async._EventSinkWrapper$(T)))();
>+  class _SinkTransformerStreamSubscription extends async._BufferingStreamSubscription$(T) {
>+    get [_isSubscribed]() {
>+      return this[_subscription] != null;
>+    }
>+    [_add](data) {
>+      T._check(data);
>+      if (dart.test(this[_isClosed])) {
>+        dart.throw(new core.StateError.new("Stream is already closed"));
>+      }
>+      super[_add](data);
>+    }
>+    [_addError](error, stackTrace) {
>+      if (dart.test(this[_isClosed])) {
>+        dart.throw(new core.StateError.new("Stream is already closed"));
>+      }
>+      super[_addError](error, stackTrace);
>+    }
>+    [_close]() {
>+      if (dart.test(this[_isClosed])) {
>+        dart.throw(new core.StateError.new("Stream is already closed"));
>+      }
>+      super[_close]();
>+    }
>+    [_onPause]() {
>+      if (dart.test(this[_isSubscribed])) this[_subscription].pause();
>+    }
>+    [_onResume]() {
>+      if (dart.test(this[_isSubscribed])) this[_subscription].resume();
>+    }
>+    [_onCancel]() {
>+      if (dart.test(this[_isSubscribed])) {
>+        let subscription = this[_subscription];
>+        this[_subscription] = null;
>+        return subscription.cancel();
>+      }
>+      return null;
>+    }
>+    [_handleData$](data) {
>+      S._check(data);
>+      try {
>+        this[_transformerSink].add(data);
>+      } catch (e$) {
>+        let e = dart.getThrown(e$);
>+        let s = dart.stackTrace(e$);
>+        this[_addError](e, s);
>+      }
>+    }
>+    [_handleError$](error, stackTrace) {
>+      if (stackTrace === void 0) stackTrace = null;
>+      try {
>+        this[_transformerSink].addError(error, stackTrace);
>+      } catch (e$) {
>+        let e = dart.getThrown(e$);
>+        let s = dart.stackTrace(e$);
>+        if (core.identical(e, error)) {
>+          this[_addError](error, stackTrace);
>+        } else {
>+          this[_addError](e, s);
>+        }
>+      }
>+    }
>+    [_handleDone]() {
>+      try {
>+        this[_subscription] = null;
>+        this[_transformerSink].close();
>+      } catch (e$) {
>+        let e = dart.getThrown(e$);
>+        let s = dart.stackTrace(e$);
>+        this[_addError](e, s);
>+      }
>+    }
>+  }
>+  (_SinkTransformerStreamSubscription.new = function(source, mapper, onData, onError, onDone, cancelOnError) {
>+    this[_transformerSink] = null;
>+    this[_subscription] = null;
>+    _SinkTransformerStreamSubscription.__proto__.new.call(this, onData, onError, onDone, cancelOnError);
>+    let eventSink = new (_EventSinkWrapperOfT()).new(this);
>+    this[_transformerSink] = mapper(eventSink);
>+    this[_subscription] = source.listen(dart.bind(this, _handleData$), {onError: dart.bind(this, _handleError$), onDone: dart.bind(this, _handleDone)});
>+  }).prototype = _SinkTransformerStreamSubscription.prototype;
>+  dart.addTypeTests(_SinkTransformerStreamSubscription);
>+  _SinkTransformerStreamSubscription.prototype[_is__SinkTransformerStreamSubscription_default] = true;
>+  dart.setMethodSignature(_SinkTransformerStreamSubscription, () => ({
>+    __proto__: dart.getMethods(_SinkTransformerStreamSubscription.__proto__),
>+    [_add]: dart.fnType(dart.void, [core.Object]),
>+    [_addError]: dart.fnType(dart.void, [core.Object, core.StackTrace]),
>+    [_close]: dart.fnType(dart.void, []),
>+    [_onPause]: dart.fnType(dart.void, []),
>+    [_onResume]: dart.fnType(dart.void, []),
>+    [_onCancel]: dart.fnType(async.Future, []),
>+    [_handleData$]: dart.fnType(dart.void, [core.Object]),
>+    [_handleError$]: dart.fnType(dart.void, [dart.dynamic], [core.StackTrace]),
>+    [_handleDone]: dart.fnType(dart.void, [])
>+  }));
>+  dart.setGetterSignature(_SinkTransformerStreamSubscription, () => ({
>+    __proto__: dart.getGetters(_SinkTransformerStreamSubscription.__proto__),
>+    [_isSubscribed]: core.bool
>+  }));
>+  dart.setLibraryUri(_SinkTransformerStreamSubscription, "dart:async");
>+  dart.setFieldSignature(_SinkTransformerStreamSubscription, () => ({
>+    __proto__: dart.getFields(_SinkTransformerStreamSubscription.__proto__),
>+    [_transformerSink]: dart.fieldType(EventSinkOfS()),
>+    [_subscription]: dart.fieldType(StreamSubscriptionOfS())
>+  }));
>+  return _SinkTransformerStreamSubscription;
>+});
>+async._SinkTransformerStreamSubscription = async._SinkTransformerStreamSubscription$();
>+dart.addTypeTests(async._SinkTransformerStreamSubscription, _is__SinkTransformerStreamSubscription_default);
>+const _sinkMapper = dart.privateName(async, "_sinkMapper");
>+const _is__StreamSinkTransformer_default = Symbol('_is__StreamSinkTransformer_default');
>+async._StreamSinkTransformer$ = dart.generic((S, T) => {
>+  let StreamOfS = () => (StreamOfS = dart.constFn(async.Stream$(S)))();
>+  let _BoundSinkStreamOfS$T = () => (_BoundSinkStreamOfS$T = dart.constFn(async._BoundSinkStream$(S, T)))();
>+  let EventSinkOfS = () => (EventSinkOfS = dart.constFn(async.EventSink$(S)))();
>+  let EventSinkOfTToEventSinkOfS = () => (EventSinkOfTToEventSinkOfS = dart.constFn(dart.fnType(EventSinkOfS(), [EventSinkOfT()])))();
>+  let EventSinkOfT = () => (EventSinkOfT = dart.constFn(async.EventSink$(T)))();
>+  class _StreamSinkTransformer extends async.StreamTransformerBase$(S, T) {
>+    bind(stream) {
>+      StreamOfS()._check(stream);
>+      return new (_BoundSinkStreamOfS$T()).new(stream, this[_sinkMapper]);
>+    }
>+  }
>+  (_StreamSinkTransformer.new = function(sinkMapper) {
>+    this[_sinkMapper] = sinkMapper;
>+    _StreamSinkTransformer.__proto__.new.call(this);
>+  }).prototype = _StreamSinkTransformer.prototype;
>+  dart.addTypeTests(_StreamSinkTransformer);
>+  _StreamSinkTransformer.prototype[_is__StreamSinkTransformer_default] = true;
>+  dart.setMethodSignature(_StreamSinkTransformer, () => ({
>+    __proto__: dart.getMethods(_StreamSinkTransformer.__proto__),
>+    bind: dart.fnType(async.Stream$(T), [core.Object])
>+  }));
>+  dart.setLibraryUri(_StreamSinkTransformer, "dart:async");
>+  dart.setFieldSignature(_StreamSinkTransformer, () => ({
>+    __proto__: dart.getFields(_StreamSinkTransformer.__proto__),
>+    [_sinkMapper]: dart.finalFieldType(EventSinkOfTToEventSinkOfS())
>+  }));
>+  return _StreamSinkTransformer;
>+});
>+async._StreamSinkTransformer = async._StreamSinkTransformer$();
>+dart.addTypeTests(async._StreamSinkTransformer, _is__StreamSinkTransformer_default);
>+const _is__BoundSinkStream_default = Symbol('_is__BoundSinkStream_default');
>+async._BoundSinkStream$ = dart.generic((S, T) => {
>+  let _SinkTransformerStreamSubscriptionOfS$T = () => (_SinkTransformerStreamSubscriptionOfS$T = dart.constFn(async._SinkTransformerStreamSubscription$(S, T)))();
>+  let EventSinkOfS = () => (EventSinkOfS = dart.constFn(async.EventSink$(S)))();
>+  let EventSinkOfTToEventSinkOfS = () => (EventSinkOfTToEventSinkOfS = dart.constFn(dart.fnType(EventSinkOfS(), [EventSinkOfT()])))();
>+  let StreamOfS = () => (StreamOfS = dart.constFn(async.Stream$(S)))();
>+  let EventSinkOfT = () => (EventSinkOfT = dart.constFn(async.EventSink$(T)))();
>+  class _BoundSinkStream extends async.Stream$(T) {
>+    get isBroadcast() {
>+      return this[_stream].isBroadcast;
>+    }
>+    listen(onData, opts) {
>+      let onError = opts && 'onError' in opts ? opts.onError : null;
>+      let onDone = opts && 'onDone' in opts ? opts.onDone : null;
>+      let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
>+      cancelOnError = true === cancelOnError;
>+      let subscription = new (_SinkTransformerStreamSubscriptionOfS$T()).new(this[_stream], this[_sinkMapper], onData, onError, onDone, cancelOnError);
>+      return subscription;
>+    }
>+  }
>+  (_BoundSinkStream.new = function(stream, sinkMapper) {
>+    this[_stream] = stream;
>+    this[_sinkMapper] = sinkMapper;
>+    _BoundSinkStream.__proto__.new.call(this);
>+  }).prototype = _BoundSinkStream.prototype;
>+  dart.addTypeTests(_BoundSinkStream);
>+  _BoundSinkStream.prototype[_is__BoundSinkStream_default] = true;
>+  dart.setMethodSignature(_BoundSinkStream, () => ({
>+    __proto__: dart.getMethods(_BoundSinkStream.__proto__),
>+    listen: dart.fnType(async.StreamSubscription$(T), [dart.fnType(dart.void, [T])], {onError: core.Function, onDone: dart.fnType(dart.void, []), cancelOnError: core.bool})
>+  }));
>+  dart.setGetterSignature(_BoundSinkStream, () => ({
>+    __proto__: dart.getGetters(_BoundSinkStream.__proto__),
>+    isBroadcast: core.bool
>+  }));
>+  dart.setLibraryUri(_BoundSinkStream, "dart:async");
>+  dart.setFieldSignature(_BoundSinkStream, () => ({
>+    __proto__: dart.getFields(_BoundSinkStream.__proto__),
>+    [_sinkMapper]: dart.finalFieldType(EventSinkOfTToEventSinkOfS()),
>+    [_stream]: dart.finalFieldType(StreamOfS())
>+  }));
>+  return _BoundSinkStream;
>+});
>+async._BoundSinkStream = async._BoundSinkStream$();
>+dart.addTypeTests(async._BoundSinkStream, _is__BoundSinkStream_default);
>+const _is__HandlerEventSink_default = Symbol('_is__HandlerEventSink_default');
>+async._HandlerEventSink$ = dart.generic((S, T) => {
>+  let EventSinkOfS = () => (EventSinkOfS = dart.constFn(async.EventSink$(S)))();
>+  let SAndEventSinkOfTTovoid = () => (SAndEventSinkOfTTovoid = dart.constFn(dart.fnType(dart.void, [S, EventSinkOfT()])))();
>+  let EventSinkOfT = () => (EventSinkOfT = dart.constFn(async.EventSink$(T)))();
>+  let ObjectAndStackTraceAndEventSinkOfTTovoid = () => (ObjectAndStackTraceAndEventSinkOfTTovoid = dart.constFn(dart.fnType(dart.void, [core.Object, core.StackTrace, EventSinkOfT()])))();
>+  let EventSinkOfTTovoid = () => (EventSinkOfTTovoid = dart.constFn(dart.fnType(dart.void, [EventSinkOfT()])))();
>+  class _HandlerEventSink extends core.Object {
>+    get [_isClosed]() {
>+      return this[_sink] == null;
>+    }
>+    add(data) {
>+      S._check(data);
>+      if (dart.test(this[_isClosed])) {
>+        dart.throw(new core.StateError.new("Sink is closed"));
>+      }
>+      if (this[_handleData$] != null) {
>+        this[_handleData$](data, this[_sink]);
>+      } else {
>+        this[_sink].add(T.as(data));
>+      }
>+    }
>+    addError(error, stackTrace) {
>+      if (stackTrace === void 0) stackTrace = null;
>+      if (dart.test(this[_isClosed])) {
>+        dart.throw(new core.StateError.new("Sink is closed"));
>+      }
>+      if (this[_handleError$] != null) {
>+        this[_handleError$](error, stackTrace, this[_sink]);
>+      } else {
>+        this[_sink].addError(error, stackTrace);
>+      }
>+    }
>+    close() {
>+      if (dart.test(this[_isClosed])) return;
>+      let sink = this[_sink];
>+      this[_sink] = null;
>+      if (this[_handleDone] != null) {
>+        this[_handleDone](sink);
>+      } else {
>+        sink.close();
>+      }
>+    }
>+  }
>+  (_HandlerEventSink.new = function(handleData, handleError, handleDone, sink) {
>+    this[_handleData$] = handleData;
>+    this[_handleError$] = handleError;
>+    this[_handleDone] = handleDone;
>+    this[_sink] = sink;
>+    if (this[_sink] == null) {
>+      dart.throw(new core.ArgumentError.new("The provided sink must not be null."));
>+    }
>+  }).prototype = _HandlerEventSink.prototype;
>+  dart.addTypeTests(_HandlerEventSink);
>+  _HandlerEventSink.prototype[_is__HandlerEventSink_default] = true;
>+  _HandlerEventSink[dart.implements] = () => [EventSinkOfS()];
>+  dart.setMethodSignature(_HandlerEventSink, () => ({
>+    __proto__: dart.getMethods(_HandlerEventSink.__proto__),
>+    add: dart.fnType(dart.void, [core.Object]),
>+    addError: dart.fnType(dart.void, [core.Object], [core.StackTrace]),
>+    close: dart.fnType(dart.void, [])
>+  }));
>+  dart.setGetterSignature(_HandlerEventSink, () => ({
>+    __proto__: dart.getGetters(_HandlerEventSink.__proto__),
>+    [_isClosed]: core.bool
>+  }));
>+  dart.setLibraryUri(_HandlerEventSink, "dart:async");
>+  dart.setFieldSignature(_HandlerEventSink, () => ({
>+    __proto__: dart.getFields(_HandlerEventSink.__proto__),
>+    [_handleData$]: dart.finalFieldType(SAndEventSinkOfTTovoid()),
>+    [_handleError$]: dart.finalFieldType(ObjectAndStackTraceAndEventSinkOfTTovoid()),
>+    [_handleDone]: dart.finalFieldType(EventSinkOfTTovoid()),
>+    [_sink]: dart.fieldType(EventSinkOfT())
>+  }));
>+  return _HandlerEventSink;
>+});
>+async._HandlerEventSink = async._HandlerEventSink$();
>+dart.addTypeTests(async._HandlerEventSink, _is__HandlerEventSink_default);
>+const _is__StreamHandlerTransformer_default = Symbol('_is__StreamHandlerTransformer_default');
>+async._StreamHandlerTransformer$ = dart.generic((S, T) => {
>+  let _HandlerEventSinkOfS$T = () => (_HandlerEventSinkOfS$T = dart.constFn(async._HandlerEventSink$(S, T)))();
>+  let EventSinkOfTTo_HandlerEventSinkOfS$T = () => (EventSinkOfTTo_HandlerEventSinkOfS$T = dart.constFn(dart.fnType(_HandlerEventSinkOfS$T(), [EventSinkOfT()])))();
>+  let StreamOfS = () => (StreamOfS = dart.constFn(async.Stream$(S)))();
>+  let EventSinkOfT = () => (EventSinkOfT = dart.constFn(async.EventSink$(T)))();
>+  class _StreamHandlerTransformer extends async._StreamSinkTransformer$(S, T) {
>+    bind(stream) {
>+      StreamOfS()._check(stream);
>+      return super.bind(stream);
>+    }
>+  }
>+  (_StreamHandlerTransformer.new = function(opts) {
>+    let handleData = opts && 'handleData' in opts ? opts.handleData : null;
>+    let handleError = opts && 'handleError' in opts ? opts.handleError : null;
>+    let handleDone = opts && 'handleDone' in opts ? opts.handleDone : null;
>+    _StreamHandlerTransformer.__proto__.new.call(this, dart.fn(outputSink => new (_HandlerEventSinkOfS$T()).new(handleData, handleError, handleDone, outputSink), EventSinkOfTTo_HandlerEventSinkOfS$T()));
>+  }).prototype = _StreamHandlerTransformer.prototype;
>+  dart.addTypeTests(_StreamHandlerTransformer);
>+  _StreamHandlerTransformer.prototype[_is__StreamHandlerTransformer_default] = true;
>+  dart.setMethodSignature(_StreamHandlerTransformer, () => ({
>+    __proto__: dart.getMethods(_StreamHandlerTransformer.__proto__),
>+    bind: dart.fnType(async.Stream$(T), [core.Object])
>+  }));
>+  dart.setLibraryUri(_StreamHandlerTransformer, "dart:async");
>+  return _StreamHandlerTransformer;
>+});
>+async._StreamHandlerTransformer = async._StreamHandlerTransformer$();
>+dart.addTypeTests(async._StreamHandlerTransformer, _is__StreamHandlerTransformer_default);
>+const _bind = dart.privateName(async, "_bind");
>+const _is__StreamBindTransformer_default = Symbol('_is__StreamBindTransformer_default');
>+async._StreamBindTransformer$ = dart.generic((S, T) => {
>+  let StreamOfS = () => (StreamOfS = dart.constFn(async.Stream$(S)))();
>+  let StreamOfSToStreamOfT = () => (StreamOfSToStreamOfT = dart.constFn(dart.fnType(StreamOfT(), [StreamOfS()])))();
>+  let StreamOfT = () => (StreamOfT = dart.constFn(async.Stream$(T)))();
>+  class _StreamBindTransformer extends async.StreamTransformerBase$(S, T) {
>+    bind(stream) {
>+      StreamOfS()._check(stream);
>+      return this[_bind](stream);
>+    }
>+  }
>+  (_StreamBindTransformer.new = function(bind) {
>+    this[_bind] = bind;
>+    _StreamBindTransformer.__proto__.new.call(this);
>+  }).prototype = _StreamBindTransformer.prototype;
>+  dart.addTypeTests(_StreamBindTransformer);
>+  _StreamBindTransformer.prototype[_is__StreamBindTransformer_default] = true;
>+  dart.setMethodSignature(_StreamBindTransformer, () => ({
>+    __proto__: dart.getMethods(_StreamBindTransformer.__proto__),
>+    bind: dart.fnType(async.Stream$(T), [core.Object])
>+  }));
>+  dart.setLibraryUri(_StreamBindTransformer, "dart:async");
>+  dart.setFieldSignature(_StreamBindTransformer, () => ({
>+    __proto__: dart.getFields(_StreamBindTransformer.__proto__),
>+    [_bind]: dart.finalFieldType(StreamOfSToStreamOfT())
>+  }));
>+  return _StreamBindTransformer;
>+});
>+async._StreamBindTransformer = async._StreamBindTransformer$();
>+dart.addTypeTests(async._StreamBindTransformer, _is__StreamBindTransformer_default);
>+const _is__StreamSubscriptionTransformer_default = Symbol('_is__StreamSubscriptionTransformer_default');
>+async._StreamSubscriptionTransformer$ = dart.generic((S, T) => {
>+  let StreamOfS = () => (StreamOfS = dart.constFn(async.Stream$(S)))();
>+  let _BoundSubscriptionStreamOfS$T = () => (_BoundSubscriptionStreamOfS$T = dart.constFn(async._BoundSubscriptionStream$(S, T)))();
>+  let StreamOfSAndboolToStreamSubscriptionOfT = () => (StreamOfSAndboolToStreamSubscriptionOfT = dart.constFn(dart.fnType(StreamSubscriptionOfT(), [StreamOfS(), core.bool])))();
>+  let StreamSubscriptionOfT = () => (StreamSubscriptionOfT = dart.constFn(async.StreamSubscription$(T)))();
>+  class _StreamSubscriptionTransformer extends async.StreamTransformerBase$(S, T) {
>+    bind(stream) {
>+      StreamOfS()._check(stream);
>+      return new (_BoundSubscriptionStreamOfS$T()).new(stream, this[_onListen]);
>+    }
>+  }
>+  (_StreamSubscriptionTransformer.new = function(onListen) {
>+    this[_onListen] = onListen;
>+    _StreamSubscriptionTransformer.__proto__.new.call(this);
>+  }).prototype = _StreamSubscriptionTransformer.prototype;
>+  dart.addTypeTests(_StreamSubscriptionTransformer);
>+  _StreamSubscriptionTransformer.prototype[_is__StreamSubscriptionTransformer_default] = true;
>+  dart.setMethodSignature(_StreamSubscriptionTransformer, () => ({
>+    __proto__: dart.getMethods(_StreamSubscriptionTransformer.__proto__),
>+    bind: dart.fnType(async.Stream$(T), [core.Object])
>+  }));
>+  dart.setLibraryUri(_StreamSubscriptionTransformer, "dart:async");
>+  dart.setFieldSignature(_StreamSubscriptionTransformer, () => ({
>+    __proto__: dart.getFields(_StreamSubscriptionTransformer.__proto__),
>+    [_onListen]: dart.finalFieldType(StreamOfSAndboolToStreamSubscriptionOfT())
>+  }));
>+  return _StreamSubscriptionTransformer;
>+});
>+async._StreamSubscriptionTransformer = async._StreamSubscriptionTransformer$();
>+dart.addTypeTests(async._StreamSubscriptionTransformer, _is__StreamSubscriptionTransformer_default);
>+const _is__BoundSubscriptionStream_default = Symbol('_is__BoundSubscriptionStream_default');
>+async._BoundSubscriptionStream$ = dart.generic((S, T) => {
>+  let StreamOfS = () => (StreamOfS = dart.constFn(async.Stream$(S)))();
>+  let StreamOfSAndboolToStreamSubscriptionOfT = () => (StreamOfSAndboolToStreamSubscriptionOfT = dart.constFn(dart.fnType(StreamSubscriptionOfT(), [StreamOfS(), core.bool])))();
>+  let StreamSubscriptionOfT = () => (StreamSubscriptionOfT = dart.constFn(async.StreamSubscription$(T)))();
>+  class _BoundSubscriptionStream extends async.Stream$(T) {
>+    get isBroadcast() {
>+      return this[_stream].isBroadcast;
>+    }
>+    listen(onData, opts) {
>+      let onError = opts && 'onError' in opts ? opts.onError : null;
>+      let onDone = opts && 'onDone' in opts ? opts.onDone : null;
>+      let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
>+      cancelOnError = true === cancelOnError;
>+      let result = this[_onListen](this[_stream], cancelOnError);
>+      result.onData(onData);
>+      result.onError(onError);
>+      result.onDone(onDone);
>+      return result;
>+    }
>+  }
>+  (_BoundSubscriptionStream.new = function(stream, onListen) {
>+    this[_stream] = stream;
>+    this[_onListen] = onListen;
>+    _BoundSubscriptionStream.__proto__.new.call(this);
>+  }).prototype = _BoundSubscriptionStream.prototype;
>+  dart.addTypeTests(_BoundSubscriptionStream);
>+  _BoundSubscriptionStream.prototype[_is__BoundSubscriptionStream_default] = true;
>+  dart.setMethodSignature(_BoundSubscriptionStream, () => ({
>+    __proto__: dart.getMethods(_BoundSubscriptionStream.__proto__),
>+    listen: dart.fnType(async.StreamSubscription$(T), [dart.fnType(dart.void, [T])], {onError: core.Function, onDone: dart.fnType(dart.void, []), cancelOnError: core.bool})
>+  }));
>+  dart.setGetterSignature(_BoundSubscriptionStream, () => ({
>+    __proto__: dart.getGetters(_BoundSubscriptionStream.__proto__),
>+    isBroadcast: core.bool
>+  }));
>+  dart.setLibraryUri(_BoundSubscriptionStream, "dart:async");
>+  dart.setFieldSignature(_BoundSubscriptionStream, () => ({
>+    __proto__: dart.getFields(_BoundSubscriptionStream.__proto__),
>+    [_onListen]: dart.finalFieldType(StreamOfSAndboolToStreamSubscriptionOfT()),
>+    [_stream]: dart.finalFieldType(StreamOfS())
>+  }));
>+  return _BoundSubscriptionStream;
>+});
>+async._BoundSubscriptionStream = async._BoundSubscriptionStream$();
>+dart.addTypeTests(async._BoundSubscriptionStream, _is__BoundSubscriptionStream_default);
>+async.Timer = class Timer extends core.Object {
>+  static new(duration, callback) {
>+    if (dart.equals(async.Zone.current, async.Zone.root)) {
>+      return async.Zone.current.createTimer(duration, callback);
>+    }
>+    return async.Zone.current.createTimer(duration, async.Zone.current.bindCallbackGuarded(callback));
>+  }
>+  static periodic(duration, callback) {
>+    if (dart.equals(async.Zone.current, async.Zone.root)) {
>+      return async.Zone.current.createPeriodicTimer(duration, callback);
>+    }
>+    let boundCallback = async.Zone.current.bindUnaryCallbackGuarded(async.Timer, callback);
>+    return async.Zone.current.createPeriodicTimer(duration, boundCallback);
>+  }
>+  static run(callback) {
>+    async.Timer.new(core.Duration.zero, callback);
>+  }
>+  static _createTimer(duration, callback) {
>+    let milliseconds = duration.inMilliseconds;
>+    if (dart.notNull(milliseconds) < 0) milliseconds = 0;
>+    return new _isolate_helper.TimerImpl.new(milliseconds, callback);
>+  }
>+  static _createPeriodicTimer(duration, callback) {
>+    let milliseconds = duration.inMilliseconds;
>+    if (dart.notNull(milliseconds) < 0) milliseconds = 0;
>+    return new _isolate_helper.TimerImpl.periodic(milliseconds, callback);
>+  }
>+};
>+(async.Timer[dart.mixinNew] = function() {
>+}).prototype = async.Timer.prototype;
>+dart.addTypeTests(async.Timer);
>+dart.setLibraryUri(async.Timer, "dart:async");
>+async.AsyncError = class AsyncError extends core.Object {
>+  get error() {
>+    return this[error$];
>+  }
>+  set error(value) {
>+    super.error = value;
>+  }
>+  get stackTrace() {
>+    return this[stackTrace$];
>+  }
>+  set stackTrace(value) {
>+    super.stackTrace = value;
>+  }
>+  toString() {
>+    return dart.str(this.error);
>+  }
>+};
>+(async.AsyncError.new = function(error, stackTrace) {
>+  this[error$] = error;
>+  this[stackTrace$] = stackTrace;
>+}).prototype = async.AsyncError.prototype;
>+dart.addTypeTests(async.AsyncError);
>+const error$ = Symbol("AsyncError.error");
>+const stackTrace$ = Symbol("AsyncError.stackTrace");
>+async.AsyncError[dart.implements] = () => [core.Error];
>+dart.setLibraryUri(async.AsyncError, "dart:async");
>+dart.setFieldSignature(async.AsyncError, () => ({
>+  __proto__: dart.getFields(async.AsyncError.__proto__),
>+  error: dart.finalFieldType(core.Object),
>+  stackTrace: dart.finalFieldType(core.StackTrace)
>+}));
>+dart.defineExtensionMethods(async.AsyncError, ['toString']);
>+dart.defineExtensionAccessors(async.AsyncError, ['stackTrace']);
>+const _is__ZoneFunction_default = Symbol('_is__ZoneFunction_default');
>+async._ZoneFunction$ = dart.generic(T => {
>+  class _ZoneFunction extends core.Object {}
>+  (_ZoneFunction.new = function(zone, func) {
>+    this.zone = zone;
>+    this.function = func;
>+  }).prototype = _ZoneFunction.prototype;
>+  dart.addTypeTests(_ZoneFunction);
>+  _ZoneFunction.prototype[_is__ZoneFunction_default] = true;
>+  dart.setLibraryUri(_ZoneFunction, "dart:async");
>+  dart.setFieldSignature(_ZoneFunction, () => ({
>+    __proto__: dart.getFields(_ZoneFunction.__proto__),
>+    zone: dart.finalFieldType(async._Zone),
>+    function: dart.finalFieldType(T)
>+  }));
>+  return _ZoneFunction;
>+});
>+async._ZoneFunction = async._ZoneFunction$();
>+dart.addTypeTests(async._ZoneFunction, _is__ZoneFunction_default);
>+async.ZoneSpecification = class ZoneSpecification extends core.Object {
>+  static new(opts) {
>+    return new async._ZoneSpecification.new(opts);
>+  }
>+  static from(other, opts) {
>+    let handleUncaughtError = opts && 'handleUncaughtError' in opts ? opts.handleUncaughtError : null;
>+    let run = opts && 'run' in opts ? opts.run : null;
>+    let runUnary = opts && 'runUnary' in opts ? opts.runUnary : null;
>+    let runBinary = opts && 'runBinary' in opts ? opts.runBinary : null;
>+    let registerCallback = opts && 'registerCallback' in opts ? opts.registerCallback : null;
>+    let registerUnaryCallback = opts && 'registerUnaryCallback' in opts ? opts.registerUnaryCallback : null;
>+    let registerBinaryCallback = opts && 'registerBinaryCallback' in opts ? opts.registerBinaryCallback : null;
>+    let errorCallback = opts && 'errorCallback' in opts ? opts.errorCallback : null;
>+    let scheduleMicrotask = opts && 'scheduleMicrotask' in opts ? opts.scheduleMicrotask : null;
>+    let createTimer = opts && 'createTimer' in opts ? opts.createTimer : null;
>+    let createPeriodicTimer = opts && 'createPeriodicTimer' in opts ? opts.createPeriodicTimer : null;
>+    let print = opts && 'print' in opts ? opts.print : null;
>+    let fork = opts && 'fork' in opts ? opts.fork : null;
>+    return async.ZoneSpecification.new({handleUncaughtError: handleUncaughtError != null ? handleUncaughtError : other.handleUncaughtError, run: run != null ? run : other.run, runUnary: runUnary != null ? runUnary : other.runUnary, runBinary: runBinary != null ? runBinary : other.runBinary, registerCallback: registerCallback != null ? registerCallback : other.registerCallback, registerUnaryCallback: registerUnaryCallback != null ? registerUnaryCallback : other.registerUnaryCallback, registerBinaryCallback: registerBinaryCallback != null ? registerBinaryCallback : other.registerBinaryCallback, errorCallback: errorCallback != null ? errorCallback : other.errorCallback, scheduleMicrotask: scheduleMicrotask != null ? scheduleMicrotask : other.scheduleMicrotask, createTimer: createTimer != null ? createTimer : other.createTimer, createPeriodicTimer: createPeriodicTimer != null ? createPeriodicTimer : other.createPeriodicTimer, print: print != null ? print : other.print, fork: fork != null ? fork : other.fork});
>+  }
>+};
>+(async.ZoneSpecification[dart.mixinNew] = function() {
>+}).prototype = async.ZoneSpecification.prototype;
>+dart.addTypeTests(async.ZoneSpecification);
>+dart.setLibraryUri(async.ZoneSpecification, "dart:async");
>+async._ZoneSpecification = class _ZoneSpecification extends core.Object {};
>+(async._ZoneSpecification.new = function(opts) {
>+  let handleUncaughtError = opts && 'handleUncaughtError' in opts ? opts.handleUncaughtError : null;
>+  let run = opts && 'run' in opts ? opts.run : null;
>+  let runUnary = opts && 'runUnary' in opts ? opts.runUnary : null;
>+  let runBinary = opts && 'runBinary' in opts ? opts.runBinary : null;
>+  let registerCallback = opts && 'registerCallback' in opts ? opts.registerCallback : null;
>+  let registerUnaryCallback = opts && 'registerUnaryCallback' in opts ? opts.registerUnaryCallback : null;
>+  let registerBinaryCallback = opts && 'registerBinaryCallback' in opts ? opts.registerBinaryCallback : null;
>+  let errorCallback = opts && 'errorCallback' in opts ? opts.errorCallback : null;
>+  let scheduleMicrotask = opts && 'scheduleMicrotask' in opts ? opts.scheduleMicrotask : null;
>+  let createTimer = opts && 'createTimer' in opts ? opts.createTimer : null;
>+  let createPeriodicTimer = opts && 'createPeriodicTimer' in opts ? opts.createPeriodicTimer : null;
>+  let print = opts && 'print' in opts ? opts.print : null;
>+  let fork = opts && 'fork' in opts ? opts.fork : null;
>+  this.handleUncaughtError = handleUncaughtError;
>+  this.run = run;
>+  this.runUnary = runUnary;
>+  this.runBinary = runBinary;
>+  this.registerCallback = registerCallback;
>+  this.registerUnaryCallback = registerUnaryCallback;
>+  this.registerBinaryCallback = registerBinaryCallback;
>+  this.errorCallback = errorCallback;
>+  this.scheduleMicrotask = scheduleMicrotask;
>+  this.createTimer = createTimer;
>+  this.createPeriodicTimer = createPeriodicTimer;
>+  this.print = print;
>+  this.fork = fork;
>+}).prototype = async._ZoneSpecification.prototype;
>+dart.addTypeTests(async._ZoneSpecification);
>+async._ZoneSpecification[dart.implements] = () => [async.ZoneSpecification];
>+dart.setLibraryUri(async._ZoneSpecification, "dart:async");
>+dart.setFieldSignature(async._ZoneSpecification, () => ({
>+  __proto__: dart.getFields(async._ZoneSpecification.__proto__),
>+  handleUncaughtError: dart.finalFieldType(ZoneAndZoneDelegateAndZone__Tovoid()),
>+  run: dart.finalFieldType(ZoneAndZoneDelegateAndZone__ToR()),
>+  runUnary: dart.finalFieldType(ZoneAndZoneDelegateAndZone__ToR$()),
>+  runBinary: dart.finalFieldType(ZoneAndZoneDelegateAndZone__ToR$0()),
>+  registerCallback: dart.finalFieldType(ZoneAndZoneDelegateAndZone__ToFn()),
>+  registerUnaryCallback: dart.finalFieldType(ZoneAndZoneDelegateAndZone__ToFn$()),
>+  registerBinaryCallback: dart.finalFieldType(ZoneAndZoneDelegateAndZone__ToFn$0()),
>+  errorCallback: dart.finalFieldType(ZoneAndZoneDelegateAndZone__ToAsyncError()),
>+  scheduleMicrotask: dart.finalFieldType(ZoneAndZoneDelegateAndZone__Tovoid$()),
>+  createTimer: dart.finalFieldType(ZoneAndZoneDelegateAndZone__ToTimer()),
>+  createPeriodicTimer: dart.finalFieldType(ZoneAndZoneDelegateAndZone__ToTimer$()),
>+  print: dart.finalFieldType(ZoneAndZoneDelegateAndZone__Tovoid$0()),
>+  fork: dart.finalFieldType(ZoneAndZoneDelegateAndZone__ToZone())
>+}));
>+async.ZoneDelegate = class ZoneDelegate extends core.Object {};
>+(async.ZoneDelegate.new = function() {
>+}).prototype = async.ZoneDelegate.prototype;
>+dart.addTypeTests(async.ZoneDelegate);
>+dart.setLibraryUri(async.ZoneDelegate, "dart:async");
>+async.Zone = class Zone extends core.Object {
>+  static get current() {
>+    return async.Zone._current;
>+  }
>+  static _enter(zone) {
>+    if (!(zone != null)) dart.assertFailed(null, "dart:async/zone.dart", 658, 12, "zone != null");
>+    if (!!(zone == async.Zone._current)) dart.assertFailed(null, "dart:async/zone.dart", 659, 12, "!identical(zone, _current)");
>+    let previous = async.Zone._current;
>+    async.Zone._current = zone;
>+    return previous;
>+  }
>+  static _leave(previous) {
>+    if (!(previous != null)) dart.assertFailed(null, "dart:async/zone.dart", 671, 12, "previous != null");
>+    async.Zone._current = previous;
>+  }
>+};
>+(async.Zone.__ = function() {
>+}).prototype = async.Zone.prototype;
>+dart.addTypeTests(async.Zone);
>+dart.setLibraryUri(async.Zone, "dart:async");
>+dart.defineLazy(async.Zone, {
>+  /*async.Zone.root*/get root() {
>+    return async._rootZone;
>+  },
>+  /*async.Zone._current*/get _current() {
>+    return async._rootZone;
>+  },
>+  set _current(_) {}
>+});
>+const _delegate = dart.privateName(async, "_delegate");
>+async._parentDelegate = function(zone) {
>+  if (zone.parent == null) return null;
>+  return zone.parent[_delegate];
>+};
>+const _delegationTarget = dart.privateName(async, "_delegationTarget");
>+const _handleUncaughtError = dart.privateName(async, "_handleUncaughtError");
>+const _run = dart.privateName(async, "_run");
>+const _runUnary = dart.privateName(async, "_runUnary");
>+const _runBinary = dart.privateName(async, "_runBinary");
>+const _registerCallback = dart.privateName(async, "_registerCallback");
>+const _registerUnaryCallback = dart.privateName(async, "_registerUnaryCallback");
>+const _registerBinaryCallback = dart.privateName(async, "_registerBinaryCallback");
>+const _errorCallback = dart.privateName(async, "_errorCallback");
>+const _createTimer = dart.privateName(async, "_createTimer");
>+const _createPeriodicTimer = dart.privateName(async, "_createPeriodicTimer");
>+const _print = dart.privateName(async, "_print");
>+const _fork = dart.privateName(async, "_fork");
>+async._ZoneDelegate = class _ZoneDelegate extends core.Object {
>+  handleUncaughtError(zone, error, stackTrace) {
>+    let implementation = this[_delegationTarget][_handleUncaughtError];
>+    let implZone = implementation.zone;
>+    let handler = implementation.function;
>+    return handler(implZone, async._parentDelegate(implZone), zone, error, stackTrace);
>+  }
>+  run(R, zone, f) {
>+    let implementation = this[_delegationTarget][_run];
>+    let implZone = implementation.zone;
>+    let handler = ZoneAndZoneDelegateAndZone__ToR()._check(implementation.function);
>+    return handler(R, implZone, async._parentDelegate(implZone), zone, f);
>+  }
>+  runUnary(R, T, zone, f, arg) {
>+    let implementation = this[_delegationTarget][_runUnary];
>+    let implZone = implementation.zone;
>+    let handler = ZoneAndZoneDelegateAndZone__ToR$()._check(implementation.function);
>+    return handler(R, T, implZone, async._parentDelegate(implZone), zone, f, arg);
>+  }
>+  runBinary(R, T1, T2, zone, f, arg1, arg2) {
>+    let implementation = this[_delegationTarget][_runBinary];
>+    let implZone = implementation.zone;
>+    let handler = ZoneAndZoneDelegateAndZone__ToR$0()._check(implementation.function);
>+    return handler(R, T1, T2, implZone, async._parentDelegate(implZone), zone, f, arg1, arg2);
>+  }
>+  registerCallback(R, zone, f) {
>+    let implementation = this[_delegationTarget][_registerCallback];
>+    let implZone = implementation.zone;
>+    let handler = ZoneAndZoneDelegateAndZone__ToFn()._check(implementation.function);
>+    return handler(R, implZone, async._parentDelegate(implZone), zone, f);
>+  }
>+  registerUnaryCallback(R, T, zone, f) {
>+    let implementation = this[_delegationTarget][_registerUnaryCallback];
>+    let implZone = implementation.zone;
>+    let handler = ZoneAndZoneDelegateAndZone__ToFn$()._check(implementation.function);
>+    return handler(R, T, implZone, async._parentDelegate(implZone), zone, f);
>+  }
>+  registerBinaryCallback(R, T1, T2, zone, f) {
>+    let implementation = this[_delegationTarget][_registerBinaryCallback];
>+    let implZone = implementation.zone;
>+    let handler = ZoneAndZoneDelegateAndZone__ToFn$0()._check(implementation.function);
>+    return handler(R, T1, T2, implZone, async._parentDelegate(implZone), zone, f);
>+  }
>+  errorCallback(zone, error, stackTrace) {
>+    let implementation = this[_delegationTarget][_errorCallback];
>+    let implZone = implementation.zone;
>+    if (implZone === async._rootZone) return null;
>+    let handler = implementation.function;
>+    return handler(implZone, async._parentDelegate(implZone), zone, error, stackTrace);
>+  }
>+  scheduleMicrotask(zone, f) {
>+    let implementation = this[_delegationTarget][_scheduleMicrotask];
>+    let implZone = implementation.zone;
>+    let handler = implementation.function;
>+    handler(implZone, async._parentDelegate(implZone), zone, f);
>+  }
>+  createTimer(zone, duration, f) {
>+    let implementation = this[_delegationTarget][_createTimer];
>+    let implZone = implementation.zone;
>+    let handler = implementation.function;
>+    return handler(implZone, async._parentDelegate(implZone), zone, duration, f);
>+  }
>+  createPeriodicTimer(zone, period, f) {
>+    let implementation = this[_delegationTarget][_createPeriodicTimer];
>+    let implZone = implementation.zone;
>+    let handler = implementation.function;
>+    return handler(implZone, async._parentDelegate(implZone), zone, period, f);
>+  }
>+  print(zone, line) {
>+    let implementation = this[_delegationTarget][_print];
>+    let implZone = implementation.zone;
>+    let handler = implementation.function;
>+    handler(implZone, async._parentDelegate(implZone), zone, line);
>+  }
>+  fork(zone, specification, zoneValues) {
>+    let implementation = this[_delegationTarget][_fork];
>+    let implZone = implementation.zone;
>+    let handler = implementation.function;
>+    return handler(implZone, async._parentDelegate(implZone), zone, specification, zoneValues);
>+  }
>+};
>+(async._ZoneDelegate.new = function(delegationTarget) {
>+  this[_delegationTarget] = delegationTarget;
>+}).prototype = async._ZoneDelegate.prototype;
>+dart.addTypeTests(async._ZoneDelegate);
>+async._ZoneDelegate[dart.implements] = () => [async.ZoneDelegate];
>+dart.setMethodSignature(async._ZoneDelegate, () => ({
>+  __proto__: dart.getMethods(async._ZoneDelegate.__proto__),
>+  handleUncaughtError: dart.fnType(dart.void, [async.Zone, dart.dynamic, core.StackTrace]),
>+  run: dart.gFnType(R => [R, [async.Zone, dart.fnType(R, [])]]),
>+  runUnary: dart.gFnType((R, T) => [R, [async.Zone, dart.fnType(R, [T]), T]]),
>+  runBinary: dart.gFnType((R, T1, T2) => [R, [async.Zone, dart.fnType(R, [T1, T2]), T1, T2]]),
>+  registerCallback: dart.gFnType(R => [dart.fnType(R, []), [async.Zone, dart.fnType(R, [])]]),
>+  registerUnaryCallback: dart.gFnType((R, T) => [dart.fnType(R, [T]), [async.Zone, dart.fnType(R, [T])]]),
>+  registerBinaryCallback: dart.gFnType((R, T1, T2) => [dart.fnType(R, [T1, T2]), [async.Zone, dart.fnType(R, [T1, T2])]]),
>+  errorCallback: dart.fnType(async.AsyncError, [async.Zone, core.Object, core.StackTrace]),
>+  scheduleMicrotask: dart.fnType(dart.void, [async.Zone, dart.fnType(dart.dynamic, [])]),
>+  createTimer: dart.fnType(async.Timer, [async.Zone, core.Duration, dart.fnType(dart.void, [])]),
>+  createPeriodicTimer: dart.fnType(async.Timer, [async.Zone, core.Duration, dart.fnType(dart.void, [async.Timer])]),
>+  print: dart.fnType(dart.void, [async.Zone, core.String]),
>+  fork: dart.fnType(async.Zone, [async.Zone, async.ZoneSpecification, core.Map])
>+}));
>+dart.setLibraryUri(async._ZoneDelegate, "dart:async");
>+dart.setFieldSignature(async._ZoneDelegate, () => ({
>+  __proto__: dart.getFields(async._ZoneDelegate.__proto__),
>+  [_delegationTarget]: dart.finalFieldType(async._Zone)
>+}));
>+async._Zone = class _Zone extends core.Object {
>+  inSameErrorZone(otherZone) {
>+    return this === otherZone || this.errorZone == otherZone.errorZone;
>+  }
>+};
>+(async._Zone.new = function() {
>+}).prototype = async._Zone.prototype;
>+dart.addTypeTests(async._Zone);
>+async._Zone[dart.implements] = () => [async.Zone];
>+dart.setMethodSignature(async._Zone, () => ({
>+  __proto__: dart.getMethods(async._Zone.__proto__),
>+  inSameErrorZone: dart.fnType(core.bool, [async.Zone])
>+}));
>+dart.setLibraryUri(async._Zone, "dart:async");
>+const _map$ = dart.privateName(async, "_map");
>+const _delegateCache = dart.privateName(async, "_delegateCache");
>+async._CustomZone = class _CustomZone extends async._Zone {
>+  get [_delegate]() {
>+    if (this[_delegateCache] != null) return this[_delegateCache];
>+    this[_delegateCache] = new async._ZoneDelegate.new(this);
>+    return this[_delegateCache];
>+  }
>+  get errorZone() {
>+    return this[_handleUncaughtError].zone;
>+  }
>+  runGuarded(f) {
>+    try {
>+      this.run(dart.void, f);
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      let s = dart.stackTrace(e$);
>+      this.handleUncaughtError(e, s);
>+    }
>+  }
>+  runUnaryGuarded(T, f, arg) {
>+    try {
>+      this.runUnary(dart.void, T, f, arg);
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      let s = dart.stackTrace(e$);
>+      this.handleUncaughtError(e, s);
>+    }
>+  }
>+  runBinaryGuarded(T1, T2, f, arg1, arg2) {
>+    try {
>+      this.runBinary(dart.void, T1, T2, f, arg1, arg2);
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      let s = dart.stackTrace(e$);
>+      this.handleUncaughtError(e, s);
>+    }
>+  }
>+  bindCallback(R, f) {
>+    let registered = this.registerCallback(R, f);
>+    return dart.fn(() => this.run(R, registered), dart.fnType(R, []));
>+  }
>+  bindUnaryCallback(R, T, f) {
>+    let registered = this.registerUnaryCallback(R, T, f);
>+    return dart.fn(arg => this.runUnary(R, T, registered, arg), dart.fnType(R, [T]));
>+  }
>+  bindBinaryCallback(R, T1, T2, f) {
>+    let registered = this.registerBinaryCallback(R, T1, T2, f);
>+    return dart.fn((arg1, arg2) => this.runBinary(R, T1, T2, registered, arg1, arg2), dart.fnType(R, [T1, T2]));
>+  }
>+  bindCallbackGuarded(f) {
>+    let registered = this.registerCallback(dart.void, f);
>+    return dart.fn(() => this.runGuarded(registered), VoidTovoid());
>+  }
>+  bindUnaryCallbackGuarded(T, f) {
>+    let registered = this.registerUnaryCallback(dart.void, T, f);
>+    return dart.fn(arg => this.runUnaryGuarded(T, registered, arg), dart.fnType(dart.void, [T]));
>+  }
>+  bindBinaryCallbackGuarded(T1, T2, f) {
>+    let registered = this.registerBinaryCallback(dart.void, T1, T2, f);
>+    return dart.fn((arg1, arg2) => this.runBinaryGuarded(T1, T2, registered, arg1, arg2), dart.fnType(dart.void, [T1, T2]));
>+  }
>+  _get(key) {
>+    let result = this[_map$][$_get](key);
>+    if (result != null || dart.test(this[_map$][$containsKey](key))) return result;
>+    if (this.parent != null) {
>+      let value = this.parent._get(key);
>+      if (value != null) {
>+        this[_map$][$_set](key, value);
>+      }
>+      return value;
>+    }
>+    if (!this._equals(async._rootZone)) dart.assertFailed(null, "dart:async/zone.dart", 992, 12, "this == _rootZone");
>+    return null;
>+  }
>+  handleUncaughtError(error, stackTrace) {
>+    let implementation = this[_handleUncaughtError];
>+    if (!(implementation != null)) dart.assertFailed(null, "dart:async/zone.dart", 1000, 12, "implementation != null");
>+    let parentDelegate = async._parentDelegate(implementation.zone);
>+    let handler = implementation.function;
>+    return handler(implementation.zone, parentDelegate, this, error, stackTrace);
>+  }
>+  fork(opts) {
>+    let specification = opts && 'specification' in opts ? opts.specification : null;
>+    let zoneValues = opts && 'zoneValues' in opts ? opts.zoneValues : null;
>+    let implementation = this[_fork];
>+    if (!(implementation != null)) dart.assertFailed(null, "dart:async/zone.dart", 1009, 12, "implementation != null");
>+    let parentDelegate = async._parentDelegate(implementation.zone);
>+    let handler = implementation.function;
>+    return handler(implementation.zone, parentDelegate, this, specification, zoneValues);
>+  }
>+  run(R, f) {
>+    let implementation = this[_run];
>+    if (!(implementation != null)) dart.assertFailed(null, "dart:async/zone.dart", 1018, 12, "implementation != null");
>+    let parentDelegate = async._parentDelegate(implementation.zone);
>+    let handler = ZoneAndZoneDelegateAndZone__ToR()._check(implementation.function);
>+    return handler(R, implementation.zone, parentDelegate, this, f);
>+  }
>+  runUnary(R, T, f, arg) {
>+    let implementation = this[_runUnary];
>+    if (!(implementation != null)) dart.assertFailed(null, "dart:async/zone.dart", 1026, 12, "implementation != null");
>+    let parentDelegate = async._parentDelegate(implementation.zone);
>+    let handler = ZoneAndZoneDelegateAndZone__ToR$()._check(implementation.function);
>+    return handler(R, T, implementation.zone, parentDelegate, this, f, arg);
>+  }
>+  runBinary(R, T1, T2, f, arg1, arg2) {
>+    let implementation = this[_runBinary];
>+    if (!(implementation != null)) dart.assertFailed(null, "dart:async/zone.dart", 1034, 12, "implementation != null");
>+    let parentDelegate = async._parentDelegate(implementation.zone);
>+    let handler = ZoneAndZoneDelegateAndZone__ToR$0()._check(implementation.function);
>+    return handler(R, T1, T2, implementation.zone, parentDelegate, this, f, arg1, arg2);
>+  }
>+  registerCallback(R, callback) {
>+    let implementation = this[_registerCallback];
>+    if (!(implementation != null)) dart.assertFailed(null, "dart:async/zone.dart", 1042, 12, "implementation != null");
>+    let parentDelegate = async._parentDelegate(implementation.zone);
>+    let handler = ZoneAndZoneDelegateAndZone__ToFn()._check(implementation.function);
>+    return handler(R, implementation.zone, parentDelegate, this, callback);
>+  }
>+  registerUnaryCallback(R, T, callback) {
>+    let implementation = this[_registerUnaryCallback];
>+    if (!(implementation != null)) dart.assertFailed(null, "dart:async/zone.dart", 1050, 12, "implementation != null");
>+    let parentDelegate = async._parentDelegate(implementation.zone);
>+    let handler = ZoneAndZoneDelegateAndZone__ToFn$()._check(implementation.function);
>+    return handler(R, T, implementation.zone, parentDelegate, this, callback);
>+  }
>+  registerBinaryCallback(R, T1, T2, callback) {
>+    let implementation = this[_registerBinaryCallback];
>+    if (!(implementation != null)) dart.assertFailed(null, "dart:async/zone.dart", 1059, 12, "implementation != null");
>+    let parentDelegate = async._parentDelegate(implementation.zone);
>+    let handler = ZoneAndZoneDelegateAndZone__ToFn$0()._check(implementation.function);
>+    return handler(R, T1, T2, implementation.zone, parentDelegate, this, callback);
>+  }
>+  errorCallback(error, stackTrace) {
>+    let implementation = this[_errorCallback];
>+    if (!(implementation != null)) dart.assertFailed(null, "dart:async/zone.dart", 1067, 12, "implementation != null");
>+    let implementationZone = implementation.zone;
>+    if (implementationZone === async._rootZone) return null;
>+    let parentDelegate = async._parentDelegate(async._Zone._check(implementationZone));
>+    let handler = implementation.function;
>+    return handler(implementationZone, parentDelegate, this, error, stackTrace);
>+  }
>+  scheduleMicrotask(f) {
>+    let implementation = this[_scheduleMicrotask];
>+    if (!(implementation != null)) dart.assertFailed(null, "dart:async/zone.dart", 1077, 12, "implementation != null");
>+    let parentDelegate = async._parentDelegate(implementation.zone);
>+    let handler = implementation.function;
>+    return handler(implementation.zone, parentDelegate, this, f);
>+  }
>+  createTimer(duration, f) {
>+    let implementation = this[_createTimer];
>+    if (!(implementation != null)) dart.assertFailed(null, "dart:async/zone.dart", 1085, 12, "implementation != null");
>+    let parentDelegate = async._parentDelegate(implementation.zone);
>+    let handler = implementation.function;
>+    return handler(implementation.zone, parentDelegate, this, duration, f);
>+  }
>+  createPeriodicTimer(duration, f) {
>+    let implementation = this[_createPeriodicTimer];
>+    if (!(implementation != null)) dart.assertFailed(null, "dart:async/zone.dart", 1093, 12, "implementation != null");
>+    let parentDelegate = async._parentDelegate(implementation.zone);
>+    let handler = implementation.function;
>+    return handler(implementation.zone, parentDelegate, this, duration, f);
>+  }
>+  print(line) {
>+    let implementation = this[_print];
>+    if (!(implementation != null)) dart.assertFailed(null, "dart:async/zone.dart", 1101, 12, "implementation != null");
>+    let parentDelegate = async._parentDelegate(implementation.zone);
>+    let handler = implementation.function;
>+    return handler(implementation.zone, parentDelegate, this, line);
>+  }
>+};
>+(async._CustomZone.new = function(parent, specification, map) {
>+  this[_run] = null;
>+  this[_runUnary] = null;
>+  this[_runBinary] = null;
>+  this[_registerCallback] = null;
>+  this[_registerUnaryCallback] = null;
>+  this[_registerBinaryCallback] = null;
>+  this[_errorCallback] = null;
>+  this[_scheduleMicrotask] = null;
>+  this[_createTimer] = null;
>+  this[_createPeriodicTimer] = null;
>+  this[_print] = null;
>+  this[_fork] = null;
>+  this[_handleUncaughtError] = null;
>+  this[_delegateCache] = null;
>+  this.parent = parent;
>+  this[_map$] = map;
>+  async._CustomZone.__proto__.new.call(this);
>+  this[_run] = specification.run != null ? new (_ZoneFunctionOfFunction()).new(this, specification.run) : this.parent[_run];
>+  this[_runUnary] = specification.runUnary != null ? new (_ZoneFunctionOfFunction()).new(this, specification.runUnary) : this.parent[_runUnary];
>+  this[_runBinary] = specification.runBinary != null ? new (_ZoneFunctionOfFunction()).new(this, specification.runBinary) : this.parent[_runBinary];
>+  this[_registerCallback] = specification.registerCallback != null ? new (_ZoneFunctionOfFunction()).new(this, specification.registerCallback) : this.parent[_registerCallback];
>+  this[_registerUnaryCallback] = specification.registerUnaryCallback != null ? new (_ZoneFunctionOfFunction()).new(this, specification.registerUnaryCallback) : this.parent[_registerUnaryCallback];
>+  this[_registerBinaryCallback] = specification.registerBinaryCallback != null ? new (_ZoneFunctionOfFunction()).new(this, specification.registerBinaryCallback) : this.parent[_registerBinaryCallback];
>+  this[_errorCallback] = specification.errorCallback != null ? new (_ZoneFunctionOfZoneAndZoneDelegateAndZone__ToAsyncError()).new(this, specification.errorCallback) : this.parent[_errorCallback];
>+  this[_scheduleMicrotask] = specification.scheduleMicrotask != null ? new (_ZoneFunctionOfZoneAndZoneDelegateAndZone__Tovoid()).new(this, specification.scheduleMicrotask) : this.parent[_scheduleMicrotask];
>+  this[_createTimer] = specification.createTimer != null ? new (_ZoneFunctionOfZoneAndZoneDelegateAndZone__ToTimer()).new(this, specification.createTimer) : this.parent[_createTimer];
>+  this[_createPeriodicTimer] = specification.createPeriodicTimer != null ? new (_ZoneFunctionOfZoneAndZoneDelegateAndZone__ToTimer$()).new(this, specification.createPeriodicTimer) : this.parent[_createPeriodicTimer];
>+  this[_print] = specification.print != null ? new (_ZoneFunctionOfZoneAndZoneDelegateAndZone__Tovoid$()).new(this, specification.print) : this.parent[_print];
>+  this[_fork] = specification.fork != null ? new (_ZoneFunctionOfZoneAndZoneDelegateAndZone__ToZone()).new(this, specification.fork) : this.parent[_fork];
>+  this[_handleUncaughtError] = specification.handleUncaughtError != null ? new (_ZoneFunctionOfZoneAndZoneDelegateAndZone__Tovoid$0()).new(this, specification.handleUncaughtError) : this.parent[_handleUncaughtError];
>+}).prototype = async._CustomZone.prototype;
>+dart.addTypeTests(async._CustomZone);
>+dart.setMethodSignature(async._CustomZone, () => ({
>+  __proto__: dart.getMethods(async._CustomZone.__proto__),
>+  runGuarded: dart.fnType(dart.void, [dart.fnType(dart.void, [])]),
>+  runUnaryGuarded: dart.gFnType(T => [dart.void, [dart.fnType(dart.void, [T]), T]]),
>+  runBinaryGuarded: dart.gFnType((T1, T2) => [dart.void, [dart.fnType(dart.void, [T1, T2]), T1, T2]]),
>+  bindCallback: dart.gFnType(R => [dart.fnType(R, []), [dart.fnType(R, [])]]),
>+  bindUnaryCallback: dart.gFnType((R, T) => [dart.fnType(R, [T]), [dart.fnType(R, [T])]]),
>+  bindBinaryCallback: dart.gFnType((R, T1, T2) => [dart.fnType(R, [T1, T2]), [dart.fnType(R, [T1, T2])]]),
>+  bindCallbackGuarded: dart.fnType(dart.fnType(dart.void, []), [dart.fnType(dart.void, [])]),
>+  bindUnaryCallbackGuarded: dart.gFnType(T => [dart.fnType(dart.void, [T]), [dart.fnType(dart.void, [T])]]),
>+  bindBinaryCallbackGuarded: dart.gFnType((T1, T2) => [dart.fnType(dart.void, [T1, T2]), [dart.fnType(dart.void, [T1, T2])]]),
>+  _get: dart.fnType(dart.dynamic, [core.Object]),
>+  handleUncaughtError: dart.fnType(dart.void, [dart.dynamic, core.StackTrace]),
>+  fork: dart.fnType(async.Zone, [], {specification: async.ZoneSpecification, zoneValues: core.Map}),
>+  run: dart.gFnType(R => [R, [dart.fnType(R, [])]]),
>+  runUnary: dart.gFnType((R, T) => [R, [dart.fnType(R, [T]), T]]),
>+  runBinary: dart.gFnType((R, T1, T2) => [R, [dart.fnType(R, [T1, T2]), T1, T2]]),
>+  registerCallback: dart.gFnType(R => [dart.fnType(R, []), [dart.fnType(R, [])]]),
>+  registerUnaryCallback: dart.gFnType((R, T) => [dart.fnType(R, [T]), [dart.fnType(R, [T])]]),
>+  registerBinaryCallback: dart.gFnType((R, T1, T2) => [dart.fnType(R, [T1, T2]), [dart.fnType(R, [T1, T2])]]),
>+  errorCallback: dart.fnType(async.AsyncError, [core.Object, core.StackTrace]),
>+  scheduleMicrotask: dart.fnType(dart.void, [dart.fnType(dart.void, [])]),
>+  createTimer: dart.fnType(async.Timer, [core.Duration, dart.fnType(dart.void, [])]),
>+  createPeriodicTimer: dart.fnType(async.Timer, [core.Duration, dart.fnType(dart.void, [async.Timer])]),
>+  print: dart.fnType(dart.void, [core.String])
>+}));
>+dart.setGetterSignature(async._CustomZone, () => ({
>+  __proto__: dart.getGetters(async._CustomZone.__proto__),
>+  [_delegate]: async.ZoneDelegate,
>+  errorZone: async.Zone
>+}));
>+dart.setLibraryUri(async._CustomZone, "dart:async");
>+dart.setFieldSignature(async._CustomZone, () => ({
>+  __proto__: dart.getFields(async._CustomZone.__proto__),
>+  [_run]: dart.fieldType(_ZoneFunctionOfFunction()),
>+  [_runUnary]: dart.fieldType(_ZoneFunctionOfFunction()),
>+  [_runBinary]: dart.fieldType(_ZoneFunctionOfFunction()),
>+  [_registerCallback]: dart.fieldType(_ZoneFunctionOfFunction()),
>+  [_registerUnaryCallback]: dart.fieldType(_ZoneFunctionOfFunction()),
>+  [_registerBinaryCallback]: dart.fieldType(_ZoneFunctionOfFunction()),
>+  [_errorCallback]: dart.fieldType(_ZoneFunctionOfZoneAndZoneDelegateAndZone__ToAsyncError()),
>+  [_scheduleMicrotask]: dart.fieldType(_ZoneFunctionOfZoneAndZoneDelegateAndZone__Tovoid()),
>+  [_createTimer]: dart.fieldType(_ZoneFunctionOfZoneAndZoneDelegateAndZone__ToTimer()),
>+  [_createPeriodicTimer]: dart.fieldType(_ZoneFunctionOfZoneAndZoneDelegateAndZone__ToTimer$()),
>+  [_print]: dart.fieldType(_ZoneFunctionOfZoneAndZoneDelegateAndZone__Tovoid$()),
>+  [_fork]: dart.fieldType(_ZoneFunctionOfZoneAndZoneDelegateAndZone__ToZone()),
>+  [_handleUncaughtError]: dart.fieldType(_ZoneFunctionOfZoneAndZoneDelegateAndZone__Tovoid$0()),
>+  [_delegateCache]: dart.fieldType(async.ZoneDelegate),
>+  parent: dart.finalFieldType(async._Zone),
>+  [_map$]: dart.finalFieldType(core.Map)
>+}));
>+async._rootHandleUncaughtError = function(self, parent, zone, error, stackTrace) {
>+  async._schedulePriorityAsyncCallback(dart.fn(() => {
>+    let t = error;
>+    t == null ? error = new core.NullThrownError.new() : t;
>+    if (stackTrace == null) dart.throw(error);
>+    async._rethrow(error, stackTrace);
>+  }, VoidToNull()));
>+};
>+async._rethrow = function(error, stackTrace) {
>+  throw dart.createErrorWithStack(error, stackTrace);
>+};
>+async._rootRun = function(R, self, parent, zone, f) {
>+  if (dart.equals(async.Zone._current, zone)) return f();
>+  let old = async.Zone._enter(zone);
>+  try {
>+    return f();
>+  } finally {
>+    async.Zone._leave(old);
>+  }
>+};
>+async._rootRunUnary = function(R, T, self, parent, zone, f, arg) {
>+  if (dart.equals(async.Zone._current, zone)) return f(arg);
>+  let old = async.Zone._enter(zone);
>+  try {
>+    return f(arg);
>+  } finally {
>+    async.Zone._leave(old);
>+  }
>+};
>+async._rootRunBinary = function(R, T1, T2, self, parent, zone, f, arg1, arg2) {
>+  if (dart.equals(async.Zone._current, zone)) return f(arg1, arg2);
>+  let old = async.Zone._enter(zone);
>+  try {
>+    return f(arg1, arg2);
>+  } finally {
>+    async.Zone._leave(old);
>+  }
>+};
>+async._rootRegisterCallback = function(R, self, parent, zone, f) {
>+  return f;
>+};
>+async._rootRegisterUnaryCallback = function(R, T, self, parent, zone, f) {
>+  return f;
>+};
>+async._rootRegisterBinaryCallback = function(R, T1, T2, self, parent, zone, f) {
>+  return f;
>+};
>+async._rootErrorCallback = function(self, parent, zone, error, stackTrace) {
>+  return null;
>+};
>+async._rootScheduleMicrotask = function(self, parent, zone, f) {
>+  if (!(async._rootZone === zone)) {
>+    let hasErrorHandler = !dart.test(async._rootZone.inSameErrorZone(zone));
>+    if (hasErrorHandler) {
>+      f = zone.bindCallbackGuarded(f);
>+    } else {
>+      f = zone.bindCallback(dart.void, f);
>+    }
>+    zone = async._rootZone;
>+  }
>+  async._scheduleAsyncCallback(f);
>+};
>+async._rootCreateTimer = function(self, parent, zone, duration, callback) {
>+  if (!(async._rootZone === zone)) {
>+    callback = zone.bindCallback(dart.void, callback);
>+  }
>+  return async.Timer._createTimer(duration, callback);
>+};
>+async._rootCreatePeriodicTimer = function(self, parent, zone, duration, callback) {
>+  if (!(async._rootZone === zone)) {
>+    callback = zone.bindUnaryCallback(dart.dynamic, async.Timer, callback);
>+  }
>+  return async.Timer._createPeriodicTimer(duration, callback);
>+};
>+async._rootPrint = function(self, parent, zone, line) {
>+  _internal.printToConsole(line);
>+};
>+async._printToZone = function(line) {
>+  async.Zone.current.print(line);
>+};
>+let const$18;
>+async._rootFork = function(self, parent, zone, specification, zoneValues) {
>+  _internal.printToZone = dart.fn(async._printToZone, StringTovoid());
>+  if (specification == null) {
>+    specification = const$18 || (const$18 = dart.const(async.ZoneSpecification.new()));
>+  } else if (!async._ZoneSpecification.is(specification)) {
>+    dart.throw(new core.ArgumentError.new("ZoneSpecifications must be instantiated" + " with the provided constructor."));
>+  }
>+  let valueMap = null;
>+  if (zoneValues == null) {
>+    if (async._Zone.is(zone)) {
>+      valueMap = zone[_map$];
>+    } else {
>+      valueMap = new _js_helper.LinkedMap.new();
>+    }
>+  } else {
>+    valueMap = collection.HashMap.from(zoneValues);
>+  }
>+  return new async._CustomZone.new(async._Zone._check(zone), specification, valueMap);
>+};
>+let const$19;
>+let const$20;
>+let const$21;
>+let const$22;
>+let const$23;
>+let const$24;
>+let const$25;
>+let const$26;
>+let const$27;
>+let const$28;
>+let const$29;
>+let const$30;
>+let const$31;
>+async._RootZone = class _RootZone extends async._Zone {
>+  get [_run]() {
>+    return const$19 || (const$19 = dart.const(new (_ZoneFunctionOfFunction()).new(async._rootZone, dart.fn(async._rootRun, ZoneAndZoneDelegateAndZone__ToR()))));
>+  }
>+  get [_runUnary]() {
>+    return const$20 || (const$20 = dart.const(new (_ZoneFunctionOfFunction()).new(async._rootZone, dart.fn(async._rootRunUnary, ZoneAndZoneDelegateAndZone__ToR$()))));
>+  }
>+  get [_runBinary]() {
>+    return const$21 || (const$21 = dart.const(new (_ZoneFunctionOfFunction()).new(async._rootZone, dart.fn(async._rootRunBinary, ZoneAndZoneDelegateAndZone__ToR$0()))));
>+  }
>+  get [_registerCallback]() {
>+    return const$22 || (const$22 = dart.const(new (_ZoneFunctionOfFunction()).new(async._rootZone, dart.fn(async._rootRegisterCallback, ZoneAndZoneDelegateAndZone__ToFn()))));
>+  }
>+  get [_registerUnaryCallback]() {
>+    return const$23 || (const$23 = dart.const(new (_ZoneFunctionOfFunction()).new(async._rootZone, dart.fn(async._rootRegisterUnaryCallback, ZoneAndZoneDelegateAndZone__ToFn$()))));
>+  }
>+  get [_registerBinaryCallback]() {
>+    return const$24 || (const$24 = dart.const(new (_ZoneFunctionOfFunction()).new(async._rootZone, dart.fn(async._rootRegisterBinaryCallback, ZoneAndZoneDelegateAndZone__ToFn$0()))));
>+  }
>+  get [_errorCallback]() {
>+    return const$25 || (const$25 = dart.const(new (_ZoneFunctionOfZoneAndZoneDelegateAndZone__ToAsyncError()).new(async._rootZone, dart.fn(async._rootErrorCallback, ZoneAndZoneDelegateAndZone__ToAsyncError()))));
>+  }
>+  get [_scheduleMicrotask]() {
>+    return const$26 || (const$26 = dart.const(new (_ZoneFunctionOfZoneAndZoneDelegateAndZone__Tovoid()).new(async._rootZone, dart.fn(async._rootScheduleMicrotask, ZoneAndZoneDelegateAndZone__Tovoid$()))));
>+  }
>+  get [_createTimer]() {
>+    return const$27 || (const$27 = dart.const(new (_ZoneFunctionOfZoneAndZoneDelegateAndZone__ToTimer()).new(async._rootZone, dart.fn(async._rootCreateTimer, ZoneAndZoneDelegateAndZone__ToTimer()))));
>+  }
>+  get [_createPeriodicTimer]() {
>+    return const$28 || (const$28 = dart.const(new (_ZoneFunctionOfZoneAndZoneDelegateAndZone__ToTimer$()).new(async._rootZone, dart.fn(async._rootCreatePeriodicTimer, ZoneAndZoneDelegateAndZone__ToTimer$()))));
>+  }
>+  get [_print]() {
>+    return const$29 || (const$29 = dart.const(new (_ZoneFunctionOfZoneAndZoneDelegateAndZone__Tovoid$()).new(async._rootZone, dart.fn(async._rootPrint, ZoneAndZoneDelegateAndZone__Tovoid$0()))));
>+  }
>+  get [_fork]() {
>+    return const$30 || (const$30 = dart.const(new (_ZoneFunctionOfZoneAndZoneDelegateAndZone__ToZone()).new(async._rootZone, dart.fn(async._rootFork, ZoneAndZoneDelegateAndZone__ToZone()))));
>+  }
>+  get [_handleUncaughtError]() {
>+    return const$31 || (const$31 = dart.const(new (_ZoneFunctionOfZoneAndZoneDelegateAndZone__Tovoid$0()).new(async._rootZone, dart.fn(async._rootHandleUncaughtError, ZoneAndZoneDelegateAndZone__Tovoid$1()))));
>+  }
>+  get parent() {
>+    return null;
>+  }
>+  get [_map$]() {
>+    return async._RootZone._rootMap;
>+  }
>+  get [_delegate]() {
>+    if (async._RootZone._rootDelegate != null) return async._RootZone._rootDelegate;
>+    return async._RootZone._rootDelegate = new async._ZoneDelegate.new(this);
>+  }
>+  get errorZone() {
>+    return this;
>+  }
>+  runGuarded(f) {
>+    try {
>+      if (async._rootZone === async.Zone._current) {
>+        f();
>+        return;
>+      }
>+      async._rootRun(dart.void, null, null, this, f);
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      let s = dart.stackTrace(e$);
>+      this.handleUncaughtError(e, s);
>+    }
>+  }
>+  runUnaryGuarded(T, f, arg) {
>+    try {
>+      if (async._rootZone === async.Zone._current) {
>+        f(arg);
>+        return;
>+      }
>+      async._rootRunUnary(dart.void, T, null, null, this, f, arg);
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      let s = dart.stackTrace(e$);
>+      this.handleUncaughtError(e, s);
>+    }
>+  }
>+  runBinaryGuarded(T1, T2, f, arg1, arg2) {
>+    try {
>+      if (async._rootZone === async.Zone._current) {
>+        f(arg1, arg2);
>+        return;
>+      }
>+      async._rootRunBinary(dart.void, T1, T2, null, null, this, f, arg1, arg2);
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      let s = dart.stackTrace(e$);
>+      this.handleUncaughtError(e, s);
>+    }
>+  }
>+  bindCallback(R, f) {
>+    return dart.fn(() => this.run(R, f), dart.fnType(R, []));
>+  }
>+  bindUnaryCallback(R, T, f) {
>+    return dart.fn(arg => this.runUnary(R, T, f, arg), dart.fnType(R, [T]));
>+  }
>+  bindBinaryCallback(R, T1, T2, f) {
>+    return dart.fn((arg1, arg2) => this.runBinary(R, T1, T2, f, arg1, arg2), dart.fnType(R, [T1, T2]));
>+  }
>+  bindCallbackGuarded(f) {
>+    return dart.fn(() => this.runGuarded(f), VoidTovoid());
>+  }
>+  bindUnaryCallbackGuarded(T, f) {
>+    return dart.fn(arg => this.runUnaryGuarded(T, f, arg), dart.fnType(dart.void, [T]));
>+  }
>+  bindBinaryCallbackGuarded(T1, T2, f) {
>+    return dart.fn((arg1, arg2) => this.runBinaryGuarded(T1, T2, f, arg1, arg2), dart.fnType(dart.void, [T1, T2]));
>+  }
>+  _get(key) {
>+    return null;
>+  }
>+  handleUncaughtError(error, stackTrace) {
>+    async._rootHandleUncaughtError(null, null, this, error, stackTrace);
>+  }
>+  fork(opts) {
>+    let specification = opts && 'specification' in opts ? opts.specification : null;
>+    let zoneValues = opts && 'zoneValues' in opts ? opts.zoneValues : null;
>+    return async._rootFork(null, null, this, specification, zoneValues);
>+  }
>+  run(R, f) {
>+    if (async.Zone._current === async._rootZone) return f();
>+    return async._rootRun(R, null, null, this, f);
>+  }
>+  runUnary(R, T, f, arg) {
>+    if (async.Zone._current === async._rootZone) return f(arg);
>+    return async._rootRunUnary(R, T, null, null, this, f, arg);
>+  }
>+  runBinary(R, T1, T2, f, arg1, arg2) {
>+    if (async.Zone._current === async._rootZone) return f(arg1, arg2);
>+    return async._rootRunBinary(R, T1, T2, null, null, this, f, arg1, arg2);
>+  }
>+  registerCallback(R, f) {
>+    return f;
>+  }
>+  registerUnaryCallback(R, T, f) {
>+    return f;
>+  }
>+  registerBinaryCallback(R, T1, T2, f) {
>+    return f;
>+  }
>+  errorCallback(error, stackTrace) {
>+    return null;
>+  }
>+  scheduleMicrotask(f) {
>+    async._rootScheduleMicrotask(null, null, this, f);
>+  }
>+  createTimer(duration, f) {
>+    return async.Timer._createTimer(duration, f);
>+  }
>+  createPeriodicTimer(duration, f) {
>+    return async.Timer._createPeriodicTimer(duration, f);
>+  }
>+  print(line) {
>+    _internal.printToConsole(line);
>+  }
>+};
>+(async._RootZone.new = function() {
>+  async._RootZone.__proto__.new.call(this);
>+}).prototype = async._RootZone.prototype;
>+dart.addTypeTests(async._RootZone);
>+dart.setMethodSignature(async._RootZone, () => ({
>+  __proto__: dart.getMethods(async._RootZone.__proto__),
>+  runGuarded: dart.fnType(dart.void, [dart.fnType(dart.void, [])]),
>+  runUnaryGuarded: dart.gFnType(T => [dart.void, [dart.fnType(dart.void, [T]), T]]),
>+  runBinaryGuarded: dart.gFnType((T1, T2) => [dart.void, [dart.fnType(dart.void, [T1, T2]), T1, T2]]),
>+  bindCallback: dart.gFnType(R => [dart.fnType(R, []), [dart.fnType(R, [])]]),
>+  bindUnaryCallback: dart.gFnType((R, T) => [dart.fnType(R, [T]), [dart.fnType(R, [T])]]),
>+  bindBinaryCallback: dart.gFnType((R, T1, T2) => [dart.fnType(R, [T1, T2]), [dart.fnType(R, [T1, T2])]]),
>+  bindCallbackGuarded: dart.fnType(dart.fnType(dart.void, []), [dart.fnType(dart.void, [])]),
>+  bindUnaryCallbackGuarded: dart.gFnType(T => [dart.fnType(dart.void, [T]), [dart.fnType(dart.void, [T])]]),
>+  bindBinaryCallbackGuarded: dart.gFnType((T1, T2) => [dart.fnType(dart.void, [T1, T2]), [dart.fnType(dart.void, [T1, T2])]]),
>+  _get: dart.fnType(dart.dynamic, [core.Object]),
>+  handleUncaughtError: dart.fnType(dart.void, [dart.dynamic, core.StackTrace]),
>+  fork: dart.fnType(async.Zone, [], {specification: async.ZoneSpecification, zoneValues: core.Map}),
>+  run: dart.gFnType(R => [R, [dart.fnType(R, [])]]),
>+  runUnary: dart.gFnType((R, T) => [R, [dart.fnType(R, [T]), T]]),
>+  runBinary: dart.gFnType((R, T1, T2) => [R, [dart.fnType(R, [T1, T2]), T1, T2]]),
>+  registerCallback: dart.gFnType(R => [dart.fnType(R, []), [dart.fnType(R, [])]]),
>+  registerUnaryCallback: dart.gFnType((R, T) => [dart.fnType(R, [T]), [dart.fnType(R, [T])]]),
>+  registerBinaryCallback: dart.gFnType((R, T1, T2) => [dart.fnType(R, [T1, T2]), [dart.fnType(R, [T1, T2])]]),
>+  errorCallback: dart.fnType(async.AsyncError, [core.Object, core.StackTrace]),
>+  scheduleMicrotask: dart.fnType(dart.void, [dart.fnType(dart.void, [])]),
>+  createTimer: dart.fnType(async.Timer, [core.Duration, dart.fnType(dart.void, [])]),
>+  createPeriodicTimer: dart.fnType(async.Timer, [core.Duration, dart.fnType(dart.void, [async.Timer])]),
>+  print: dart.fnType(dart.void, [core.String])
>+}));
>+dart.setGetterSignature(async._RootZone, () => ({
>+  __proto__: dart.getGetters(async._RootZone.__proto__),
>+  [_run]: async._ZoneFunction$(core.Function),
>+  [_runUnary]: async._ZoneFunction$(core.Function),
>+  [_runBinary]: async._ZoneFunction$(core.Function),
>+  [_registerCallback]: async._ZoneFunction$(core.Function),
>+  [_registerUnaryCallback]: async._ZoneFunction$(core.Function),
>+  [_registerBinaryCallback]: async._ZoneFunction$(core.Function),
>+  [_errorCallback]: async._ZoneFunction$(dart.fnType(async.AsyncError, [async.Zone, async.ZoneDelegate, async.Zone, core.Object, core.StackTrace])),
>+  [_scheduleMicrotask]: async._ZoneFunction$(dart.fnType(dart.void, [async.Zone, async.ZoneDelegate, async.Zone, dart.fnType(dart.void, [])])),
>+  [_createTimer]: async._ZoneFunction$(dart.fnType(async.Timer, [async.Zone, async.ZoneDelegate, async.Zone, core.Duration, dart.fnType(dart.void, [])])),
>+  [_createPeriodicTimer]: async._ZoneFunction$(dart.fnType(async.Timer, [async.Zone, async.ZoneDelegate, async.Zone, core.Duration, dart.fnType(dart.void, [async.Timer])])),
>+  [_print]: async._ZoneFunction$(dart.fnType(dart.void, [async.Zone, async.ZoneDelegate, async.Zone, core.String])),
>+  [_fork]: async._ZoneFunction$(dart.fnType(async.Zone, [async.Zone, async.ZoneDelegate, async.Zone, async.ZoneSpecification, core.Map])),
>+  [_handleUncaughtError]: async._ZoneFunction$(dart.fnType(dart.void, [async.Zone, async.ZoneDelegate, async.Zone, core.Object, core.StackTrace])),
>+  parent: async._Zone,
>+  [_map$]: core.Map,
>+  [_delegate]: async.ZoneDelegate,
>+  errorZone: async.Zone
>+}));
>+dart.setLibraryUri(async._RootZone, "dart:async");
>+dart.defineLazy(async._RootZone, {
>+  /*async._RootZone._rootMap*/get _rootMap() {
>+    return new _js_helper.LinkedMap.new();
>+  },
>+  /*async._RootZone._rootDelegate*/get _rootDelegate() {
>+    return null;
>+  },
>+  set _rootDelegate(_) {}
>+});
>+dart.defineLazy(async, {
>+  /*async._rootZone*/get _rootZone() {
>+    return dart.const(new async._RootZone.new());
>+  }
>+});
>+async.runZoned = function(R, body, opts) {
>+  let zoneValues = opts && 'zoneValues' in opts ? opts.zoneValues : null;
>+  let zoneSpecification = opts && 'zoneSpecification' in opts ? opts.zoneSpecification : null;
>+  let onError = opts && 'onError' in opts ? opts.onError : null;
>+  if (onError == null) {
>+    return async._runZoned(R, body, zoneValues, zoneSpecification);
>+  }
>+  let unaryOnError = null;
>+  let binaryOnError = null;
>+  if (ObjectAndStackTraceTovoid().is(onError)) {
>+    binaryOnError = onError;
>+  } else if (ObjectTovoid().is(onError)) {
>+    unaryOnError = onError;
>+  } else {
>+    dart.throw(new core.ArgumentError.new("onError callback must take either an Object " + "(the error), or both an Object (the error) and a StackTrace."));
>+  }
>+  let errorHandler = (self, parent, zone, error, stackTrace) => {
>+    try {
>+      if (binaryOnError != null) {
>+        self.parent.runBinary(dart.void, core.Object, core.StackTrace, binaryOnError, error, stackTrace);
>+      } else {
>+        if (!(unaryOnError != null)) dart.assertFailed(null, "dart:async/zone.dart", 1483, 16, "unaryOnError != null");
>+        self.parent.runUnary(dart.void, core.Object, unaryOnError, error);
>+      }
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      let s = dart.stackTrace(e$);
>+      if (core.identical(e, error)) {
>+        parent.handleUncaughtError(zone, error, stackTrace);
>+      } else {
>+        parent.handleUncaughtError(zone, e, s);
>+      }
>+    }
>+  };
>+  dart.fn(errorHandler, ZoneAndZoneDelegateAndZone__ToNull());
>+  if (zoneSpecification == null) {
>+    zoneSpecification = async.ZoneSpecification.new({handleUncaughtError: errorHandler});
>+  } else {
>+    zoneSpecification = async.ZoneSpecification.from(zoneSpecification, {handleUncaughtError: errorHandler});
>+  }
>+  try {
>+    return async._runZoned(R, body, zoneValues, zoneSpecification);
>+  } catch (e$) {
>+    let e = dart.getThrown(e$);
>+    let stackTrace = dart.stackTrace(e$);
>+    if (binaryOnError != null) {
>+      binaryOnError(e, stackTrace);
>+    } else {
>+      if (!(unaryOnError != null)) dart.assertFailed(null, "dart:async/zone.dart", 1507, 14, "unaryOnError != null");
>+      unaryOnError(e);
>+    }
>+  }
>+  return null;
>+};
>+async._runZoned = function(R, body, zoneValues, specification) {
>+  return async.Zone.current.fork({specification: specification, zoneValues: zoneValues}).run(R, body);
>+};
>+const _map$0 = dart.privateName(collection, "_map");
>+const _keyMap$ = dart.privateName(collection, "_keyMap");
>+const _modifications$ = dart.privateName(collection, "_modifications");
>+const _newSet = dart.privateName(collection, "_newSet");
>+const _newSimilarSet = dart.privateName(collection, "_newSimilarSet");
>+const _is__SetBase_default = Symbol('_is__SetBase_default');
>+collection._SetBase$ = dart.generic(E => {
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  let FollowedByIterableOfE = () => (FollowedByIterableOfE = dart.constFn(_internal.FollowedByIterable$(E)))();
>+  let SetOfE = () => (SetOfE = dart.constFn(core.Set$(E)))();
>+  let JSArrayOfE = () => (JSArrayOfE = dart.constFn(_interceptors.JSArray$(E)))();
>+  let ListOfE = () => (ListOfE = dart.constFn(core.List$(E)))();
>+  let WhereIterableOfE = () => (WhereIterableOfE = dart.constFn(_internal.WhereIterable$(E)))();
>+  let EAndEToE = () => (EAndEToE = dart.constFn(dart.fnType(E, [E, E])))();
>+  let TakeIterableOfE = () => (TakeIterableOfE = dart.constFn(_internal.TakeIterable$(E)))();
>+  let TakeWhileIterableOfE = () => (TakeWhileIterableOfE = dart.constFn(_internal.TakeWhileIterable$(E)))();
>+  let SkipIterableOfE = () => (SkipIterableOfE = dart.constFn(_internal.SkipIterable$(E)))();
>+  let SkipWhileIterableOfE = () => (SkipWhileIterableOfE = dart.constFn(_internal.SkipWhileIterable$(E)))();
>+  let VoidToE = () => (VoidToE = dart.constFn(dart.fnType(E, [])))();
>+  class _SetBase extends core.Object {
>+    cast(R) {
>+      return core.Set.castFrom(E, R, this, {newSet: dart.bind(this, _newSimilarSet)});
>+    }
>+    difference(other) {
>+      let result = this[_newSet]();
>+      for (let element of this) {
>+        if (!dart.test(other.contains(element))) result.add(element);
>+      }
>+      return result;
>+    }
>+    intersection(other) {
>+      let result = this[_newSet]();
>+      for (let element of this) {
>+        if (dart.test(other.contains(element))) result.add(element);
>+      }
>+      return result;
>+    }
>+    toSet() {
>+      let _ = this[_newSet]();
>+      _.addAll(this);
>+      return _;
>+    }
>+    get isEmpty() {
>+      return this[$length] === 0;
>+    }
>+    get isNotEmpty() {
>+      return this[$length] !== 0;
>+    }
>+    followedBy(other) {
>+      IterableOfE()._check(other);
>+      return FollowedByIterableOfE().firstEfficient(this, other);
>+    }
>+    whereType(T) {
>+      return new (_internal.WhereTypeIterable$(T)).new(this);
>+    }
>+    clear() {
>+      this.removeAll(this.toList());
>+    }
>+    addAll(elements) {
>+      IterableOfE()._check(elements);
>+      for (let element of elements)
>+        this.add(element);
>+    }
>+    removeAll(elements) {
>+      for (let element of elements)
>+        this.remove(element);
>+    }
>+    retainAll(elements) {
>+      let toRemove = this.toSet();
>+      for (let o of elements) {
>+        toRemove.remove(o);
>+      }
>+      this.removeAll(toRemove);
>+    }
>+    removeWhere(test) {
>+      let toRemove = [];
>+      for (let element of this) {
>+        if (dart.test(test(element))) toRemove[$add](element);
>+      }
>+      this.removeAll(toRemove);
>+    }
>+    retainWhere(test) {
>+      let toRemove = [];
>+      for (let element of this) {
>+        if (!dart.test(test(element))) toRemove[$add](element);
>+      }
>+      this.removeAll(toRemove);
>+    }
>+    containsAll(other) {
>+      for (let o of other) {
>+        if (!dart.test(this.contains(o))) return false;
>+      }
>+      return true;
>+    }
>+    union(other) {
>+      SetOfE()._check(other);
>+      let _ = this.toSet();
>+      _.addAll(other);
>+      return _;
>+    }
>+    toList(opts) {
>+      let growable = opts && 'growable' in opts ? opts.growable : true;
>+      let result = dart.test(growable) ? (() => {
>+        let _ = JSArrayOfE().of([]);
>+        _[$length] = this[$length];
>+        return _;
>+      })() : ListOfE().new(this[$length]);
>+      let i = 0;
>+      for (let element of this)
>+        result[$_set](i++, element);
>+      return result;
>+    }
>+    map(T, f) {
>+      return new (_internal.EfficientLengthMappedIterable$(E, T)).new(this, f);
>+    }
>+    get single() {
>+      if (dart.notNull(this[$length]) > 1) dart.throw(_internal.IterableElementError.tooMany());
>+      let it = this.iterator;
>+      if (!dart.test(it.moveNext())) dart.throw(_internal.IterableElementError.noElement());
>+      let result = it.current;
>+      return result;
>+    }
>+    toString() {
>+      return collection.IterableBase.iterableToFullString(this, "{", "}");
>+    }
>+    where(f) {
>+      return new (WhereIterableOfE()).new(this, f);
>+    }
>+    expand(T, f) {
>+      return new (_internal.ExpandIterable$(E, T)).new(this, f);
>+    }
>+    forEach(f) {
>+      for (let element of this)
>+        f(element);
>+    }
>+    reduce(combine) {
>+      EAndEToE()._check(combine);
>+      let iterator = this.iterator;
>+      if (!dart.test(iterator.moveNext())) {
>+        dart.throw(_internal.IterableElementError.noElement());
>+      }
>+      let value = iterator.current;
>+      while (dart.test(iterator.moveNext())) {
>+        value = combine(value, iterator.current);
>+      }
>+      return value;
>+    }
>+    fold(T, initialValue, combine) {
>+      let value = initialValue;
>+      for (let element of this)
>+        value = combine(value, element);
>+      return value;
>+    }
>+    every(f) {
>+      for (let element of this) {
>+        if (!dart.test(f(element))) return false;
>+      }
>+      return true;
>+    }
>+    join(separator) {
>+      if (separator === void 0) separator = "";
>+      let iterator = this.iterator;
>+      if (!dart.test(iterator.moveNext())) return "";
>+      let buffer = new core.StringBuffer.new();
>+      if (separator == null || separator === "") {
>+        do {
>+          buffer.write(iterator.current);
>+        } while (dart.test(iterator.moveNext()));
>+      } else {
>+        buffer.write(iterator.current);
>+        while (dart.test(iterator.moveNext())) {
>+          buffer.write(separator);
>+          buffer.write(iterator.current);
>+        }
>+      }
>+      return buffer.toString();
>+    }
>+    any(test) {
>+      for (let element of this) {
>+        if (dart.test(test(element))) return true;
>+      }
>+      return false;
>+    }
>+    take(n) {
>+      return TakeIterableOfE().new(this, n);
>+    }
>+    takeWhile(test) {
>+      return new (TakeWhileIterableOfE()).new(this, test);
>+    }
>+    skip(n) {
>+      return SkipIterableOfE().new(this, n);
>+    }
>+    skipWhile(test) {
>+      return new (SkipWhileIterableOfE()).new(this, test);
>+    }
>+    get first() {
>+      let it = this.iterator;
>+      if (!dart.test(it.moveNext())) {
>+        dart.throw(_internal.IterableElementError.noElement());
>+      }
>+      return it.current;
>+    }
>+    get last() {
>+      let it = this.iterator;
>+      if (!dart.test(it.moveNext())) {
>+        dart.throw(_internal.IterableElementError.noElement());
>+      }
>+      let result = null;
>+      do {
>+        result = it.current;
>+      } while (dart.test(it.moveNext()));
>+      return result;
>+    }
>+    firstWhere(test, opts) {
>+      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+      VoidToE()._check(orElse);
>+      for (let element of this) {
>+        if (dart.test(test(element))) return element;
>+      }
>+      if (orElse != null) return orElse();
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    lastWhere(test, opts) {
>+      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+      VoidToE()._check(orElse);
>+      let result = null;
>+      let foundMatching = false;
>+      for (let element of this) {
>+        if (dart.test(test(element))) {
>+          result = element;
>+          foundMatching = true;
>+        }
>+      }
>+      if (foundMatching) return result;
>+      if (orElse != null) return orElse();
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    singleWhere(test, opts) {
>+      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+      VoidToE()._check(orElse);
>+      let result = null;
>+      let foundMatching = false;
>+      for (let element of this) {
>+        if (dart.test(test(element))) {
>+          if (foundMatching) {
>+            dart.throw(_internal.IterableElementError.tooMany());
>+          }
>+          result = element;
>+          foundMatching = true;
>+        }
>+      }
>+      if (foundMatching) return result;
>+      if (orElse != null) return orElse();
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    elementAt(index) {
>+      core.ArgumentError.checkNotNull(index, "index");
>+      core.RangeError.checkNotNegative(index, "index");
>+      let elementIndex = 0;
>+      for (let element of this) {
>+        if (index === elementIndex) return element;
>+        elementIndex++;
>+      }
>+      dart.throw(core.RangeError.index(index, this, "index", null, elementIndex));
>+    }
>+  }
>+  (_SetBase.new = function() {
>+  }).prototype = _SetBase.prototype;
>+  dart.addTypeTests(_SetBase);
>+  _SetBase.prototype[_is__SetBase_default] = true;
>+  _SetBase[dart.implements] = () => [SetOfE()];
>+  dart.setMethodSignature(_SetBase, () => ({
>+    __proto__: dart.getMethods(_SetBase.__proto__),
>+    cast: dart.gFnType(R => [core.Set$(R), []]),
>+    [$cast]: dart.gFnType(R => [core.Set$(R), []]),
>+    difference: dart.fnType(core.Set$(E), [core.Set$(core.Object)]),
>+    intersection: dart.fnType(core.Set$(E), [core.Set$(core.Object)]),
>+    toSet: dart.fnType(core.Set$(E), []),
>+    [$toSet]: dart.fnType(core.Set$(E), []),
>+    followedBy: dart.fnType(core.Iterable$(E), [core.Object]),
>+    [$followedBy]: dart.fnType(core.Iterable$(E), [core.Object]),
>+    whereType: dart.gFnType(T => [core.Iterable$(T), []]),
>+    [$whereType]: dart.gFnType(T => [core.Iterable$(T), []]),
>+    clear: dart.fnType(dart.void, []),
>+    addAll: dart.fnType(dart.void, [core.Object]),
>+    removeAll: dart.fnType(dart.void, [core.Iterable$(core.Object)]),
>+    retainAll: dart.fnType(dart.void, [core.Iterable$(core.Object)]),
>+    removeWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [E])]),
>+    retainWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [E])]),
>+    containsAll: dart.fnType(core.bool, [core.Iterable$(core.Object)]),
>+    union: dart.fnType(core.Set$(E), [core.Object]),
>+    toList: dart.fnType(core.List$(E), [], {growable: core.bool}),
>+    [$toList]: dart.fnType(core.List$(E), [], {growable: core.bool}),
>+    map: dart.gFnType(T => [core.Iterable$(T), [dart.fnType(T, [E])]]),
>+    [$map]: dart.gFnType(T => [core.Iterable$(T), [dart.fnType(T, [E])]]),
>+    toString: dart.fnType(core.String, []),
>+    [$toString]: dart.fnType(core.String, []),
>+    where: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    [$where]: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    expand: dart.gFnType(T => [core.Iterable$(T), [dart.fnType(core.Iterable$(T), [E])]]),
>+    [$expand]: dart.gFnType(T => [core.Iterable$(T), [dart.fnType(core.Iterable$(T), [E])]]),
>+    forEach: dart.fnType(dart.void, [dart.fnType(dart.void, [E])]),
>+    [$forEach]: dart.fnType(dart.void, [dart.fnType(dart.void, [E])]),
>+    reduce: dart.fnType(E, [core.Object]),
>+    [$reduce]: dart.fnType(E, [core.Object]),
>+    fold: dart.gFnType(T => [T, [T, dart.fnType(T, [T, E])]]),
>+    [$fold]: dart.gFnType(T => [T, [T, dart.fnType(T, [T, E])]]),
>+    every: dart.fnType(core.bool, [dart.fnType(core.bool, [E])]),
>+    [$every]: dart.fnType(core.bool, [dart.fnType(core.bool, [E])]),
>+    join: dart.fnType(core.String, [], [core.String]),
>+    [$join]: dart.fnType(core.String, [], [core.String]),
>+    any: dart.fnType(core.bool, [dart.fnType(core.bool, [E])]),
>+    [$any]: dart.fnType(core.bool, [dart.fnType(core.bool, [E])]),
>+    take: dart.fnType(core.Iterable$(E), [core.int]),
>+    [$take]: dart.fnType(core.Iterable$(E), [core.int]),
>+    takeWhile: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    [$takeWhile]: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    skip: dart.fnType(core.Iterable$(E), [core.int]),
>+    [$skip]: dart.fnType(core.Iterable$(E), [core.int]),
>+    skipWhile: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    [$skipWhile]: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    firstWhere: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    [$firstWhere]: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    lastWhere: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    [$lastWhere]: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    singleWhere: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    [$singleWhere]: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    elementAt: dart.fnType(E, [core.int]),
>+    [$elementAt]: dart.fnType(E, [core.int])
>+  }));
>+  dart.setGetterSignature(_SetBase, () => ({
>+    __proto__: dart.getGetters(_SetBase.__proto__),
>+    isEmpty: core.bool,
>+    [$isEmpty]: core.bool,
>+    isNotEmpty: core.bool,
>+    [$isNotEmpty]: core.bool,
>+    single: E,
>+    [$single]: E,
>+    first: E,
>+    [$first]: E,
>+    last: E,
>+    [$last]: E
>+  }));
>+  dart.setLibraryUri(_SetBase, "dart:collection");
>+  dart.defineExtensionMethods(_SetBase, [
>+    'cast',
>+    'toSet',
>+    'followedBy',
>+    'whereType',
>+    'toList',
>+    'map',
>+    'toString',
>+    'where',
>+    'expand',
>+    'forEach',
>+    'reduce',
>+    'fold',
>+    'every',
>+    'join',
>+    'any',
>+    'take',
>+    'takeWhile',
>+    'skip',
>+    'skipWhile',
>+    'firstWhere',
>+    'lastWhere',
>+    'singleWhere',
>+    'elementAt'
>+  ]);
>+  dart.defineExtensionAccessors(_SetBase, [
>+    'isEmpty',
>+    'isNotEmpty',
>+    'single',
>+    'first',
>+    'last'
>+  ]);
>+  return _SetBase;
>+});
>+collection._SetBase = collection._SetBase$();
>+dart.addTypeTests(collection._SetBase, _is__SetBase_default);
>+const _is__InternalSet_default = Symbol('_is__InternalSet_default');
>+collection._InternalSet$ = dart.generic(E => {
>+  let DartIteratorOfE = () => (DartIteratorOfE = dart.constFn(_js_helper.DartIterator$(E)))();
>+  class _InternalSet extends collection._SetBase$(E) {
>+    get length() {
>+      return this[_map$0].size;
>+    }
>+    get isEmpty() {
>+      return this[_map$0].size == 0;
>+    }
>+    get isNotEmpty() {
>+      return this[_map$0].size != 0;
>+    }
>+    get iterator() {
>+      return new (DartIteratorOfE()).new(this[Symbol.iterator]());
>+    }
>+    [Symbol.iterator]() {
>+      let self = this;
>+      let iterator = self[_map$0].values();
>+      let modifications = self[_modifications$];
>+      return {
>+        next() {
>+          if (modifications != self[_modifications$]) {
>+            throw new core.ConcurrentModificationError.new(self);
>+          }
>+          return iterator.next();
>+        }
>+      };
>+    }
>+  }
>+  (_InternalSet.new = function() {
>+    _InternalSet.__proto__.new.call(this);
>+  }).prototype = _InternalSet.prototype;
>+  dart.addTypeTests(_InternalSet);
>+  _InternalSet.prototype[_is__InternalSet_default] = true;
>+  dart.setMethodSignature(_InternalSet, () => ({
>+    __proto__: dart.getMethods(_InternalSet.__proto__),
>+    [Symbol.iterator]: dart.fnType(dart.dynamic, [])
>+  }));
>+  dart.setGetterSignature(_InternalSet, () => ({
>+    __proto__: dart.getGetters(_InternalSet.__proto__),
>+    length: core.int,
>+    [$length]: core.int,
>+    iterator: core.Iterator$(E),
>+    [$iterator]: core.Iterator$(E)
>+  }));
>+  dart.setLibraryUri(_InternalSet, "dart:collection");
>+  dart.defineExtensionAccessors(_InternalSet, ['length', 'isEmpty', 'isNotEmpty', 'iterator']);
>+  return _InternalSet;
>+});
>+collection._InternalSet = collection._InternalSet$();
>+dart.addTypeTests(collection._InternalSet, _is__InternalSet_default);
>+const _is__HashSet_default = Symbol('_is__HashSet_default');
>+collection._HashSet$ = dart.generic(E => {
>+  let _HashSetOfE = () => (_HashSetOfE = dart.constFn(collection._HashSet$(E)))();
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  let HashSetOfE = () => (HashSetOfE = dart.constFn(collection.HashSet$(E)))();
>+  let LinkedHashSetOfE = () => (LinkedHashSetOfE = dart.constFn(collection.LinkedHashSet$(E)))();
>+  class _HashSet extends collection._InternalSet$(E) {
>+    [_newSet]() {
>+      return new (_HashSetOfE()).new();
>+    }
>+    [_newSimilarSet](R) {
>+      return new (collection._HashSet$(R)).new();
>+    }
>+    contains(key) {
>+      if (key == null) {
>+        key = null;
>+      } else if (key[$_equals] !== dart.identityEquals) {
>+        let k = key;
>+        let buckets = this[_keyMap$].get(k[$hashCode] & 0x3ffffff);
>+        if (buckets != null) {
>+          for (let i = 0, n = buckets.length; i < n; i++) {
>+            k = buckets[i];
>+            if (k[$_equals](key)) return true;
>+          }
>+        }
>+        return false;
>+      }
>+      return this[_map$0].has(key);
>+    }
>+    lookup(key) {
>+      if (key == null) return null;
>+      if (key[$_equals] !== dart.identityEquals) {
>+        let k = key;
>+        let buckets = this[_keyMap$].get(k[$hashCode] & 0x3ffffff);
>+        if (buckets != null) {
>+          for (let i = 0, n = buckets.length; i < n; i++) {
>+            k = buckets[i];
>+            if (k[$_equals](key)) return k;
>+          }
>+        }
>+        return null;
>+      }
>+      return this[_map$0].has(key) ? key : null;
>+    }
>+    add(key) {
>+      E._check(key);
>+      let map = this[_map$0];
>+      if (key == null) {
>+        if (dart.test(map.has(null))) return false;
>+        key = null;
>+      } else if (key[$_equals] !== dart.identityEquals) {
>+        let keyMap = this[_keyMap$];
>+        let k = key;
>+        let hash = k[$hashCode] & 0x3ffffff;
>+        let buckets = keyMap.get(hash);
>+        if (buckets == null) {
>+          keyMap.set(hash, [key]);
>+        } else {
>+          for (let i = 0, n = buckets.length; i < n; i++) {
>+            k = buckets[i];
>+            if (k[$_equals](key)) return false;
>+          }
>+          buckets.push(key);
>+        }
>+      } else if (dart.test(map.has(key))) {
>+        return false;
>+      }
>+      map.add(key);
>+      this[_modifications$] = this[_modifications$] + 1 & 67108863;
>+      return true;
>+    }
>+    addAll(objects) {
>+      IterableOfE()._check(objects);
>+      let map = this[_map$0];
>+      let length = map.size;
>+      for (let key of objects) {
>+        if (key == null) {
>+          key = null;
>+        } else if (key[$_equals] !== dart.identityEquals) {
>+          key = _js_helper.putLinkedMapKey(key, this[_keyMap$]);
>+        }
>+        map.add(key);
>+      }
>+      if (length !== map.size) {
>+        this[_modifications$] = this[_modifications$] + 1 & 67108863;
>+      }
>+    }
>+    remove(key) {
>+      if (key == null) {
>+        key = null;
>+      } else if (key[$_equals] !== dart.identityEquals) {
>+        let k = key;
>+        let hash = k[$hashCode] & 0x3ffffff;
>+        let buckets = this[_keyMap$].get(hash);
>+        if (buckets == null) return false;
>+        for (let i = 0, n = buckets.length;;) {
>+          k = buckets[i];
>+          if (k[$_equals](key)) {
>+            key = k;
>+            if (n === 1) {
>+              this[_keyMap$].delete(hash);
>+            } else {
>+              buckets.splice(i, 1);
>+            }
>+            break;
>+          }
>+          if (++i >= n) return false;
>+        }
>+      }
>+      let map = this[_map$0];
>+      if (map.delete(key)) {
>+        this[_modifications$] = this[_modifications$] + 1 & 67108863;
>+        return true;
>+      }
>+      return false;
>+    }
>+    clear() {
>+      let map = this[_map$0];
>+      if (map.size > 0) {
>+        map.clear();
>+        this[_keyMap$].clear();
>+        this[_modifications$] = this[_modifications$] + 1 & 67108863;
>+      }
>+    }
>+  }
>+  (_HashSet.new = function() {
>+    this[_map$0] = new Set();
>+    this[_keyMap$] = new Map();
>+    this[_modifications$] = 0;
>+    _HashSet.__proto__.new.call(this);
>+  }).prototype = _HashSet.prototype;
>+  dart.addTypeTests(_HashSet);
>+  _HashSet.prototype[_is__HashSet_default] = true;
>+  _HashSet[dart.implements] = () => [HashSetOfE(), LinkedHashSetOfE()];
>+  dart.setMethodSignature(_HashSet, () => ({
>+    __proto__: dart.getMethods(_HashSet.__proto__),
>+    [_newSet]: dart.fnType(core.Set$(E), []),
>+    [_newSimilarSet]: dart.gFnType(R => [core.Set$(R), []]),
>+    contains: dart.fnType(core.bool, [core.Object]),
>+    [$contains]: dart.fnType(core.bool, [core.Object]),
>+    lookup: dart.fnType(E, [core.Object]),
>+    add: dart.fnType(core.bool, [core.Object]),
>+    addAll: dart.fnType(dart.void, [core.Object]),
>+    remove: dart.fnType(core.bool, [core.Object])
>+  }));
>+  dart.setLibraryUri(_HashSet, "dart:collection");
>+  dart.setFieldSignature(_HashSet, () => ({
>+    __proto__: dart.getFields(_HashSet.__proto__),
>+    [_map$0]: dart.finalFieldType(dart.dynamic),
>+    [_keyMap$]: dart.finalFieldType(dart.dynamic),
>+    [_modifications$]: dart.fieldType(core.int)
>+  }));
>+  dart.defineExtensionMethods(_HashSet, ['contains']);
>+  return _HashSet;
>+});
>+collection._HashSet = collection._HashSet$();
>+dart.addTypeTests(collection._HashSet, _is__HashSet_default);
>+const _is__ImmutableSet_default = Symbol('_is__ImmutableSet_default');
>+collection._ImmutableSet$ = dart.generic(E => {
>+  class _ImmutableSet extends collection._HashSet$(E) {
>+    add(other) {
>+      return dart.throw(collection._ImmutableSet._unsupported());
>+    }
>+    addAll(other) {
>+      return dart.throw(collection._ImmutableSet._unsupported());
>+    }
>+    clear() {
>+      return dart.throw(collection._ImmutableSet._unsupported());
>+    }
>+    remove(key) {
>+      return dart.throw(collection._ImmutableSet._unsupported());
>+    }
>+    static _unsupported() {
>+      return new core.UnsupportedError.new("Cannot modify unmodifiable set");
>+    }
>+  }
>+  (_ImmutableSet.from = function(entries) {
>+    _ImmutableSet.__proto__.new.call(this);
>+    let map = this[_map$0];
>+    for (let key of entries) {
>+      if (key == null) {
>+        key = null;
>+      } else if (key[$_equals] !== dart.identityEquals) {
>+        key = _js_helper.putLinkedMapKey(key, this[_keyMap$]);
>+      }
>+      map.add(key);
>+    }
>+  }).prototype = _ImmutableSet.prototype;
>+  dart.addTypeTests(_ImmutableSet);
>+  _ImmutableSet.prototype[_is__ImmutableSet_default] = true;
>+  dart.setMethodSignature(_ImmutableSet, () => ({
>+    __proto__: dart.getMethods(_ImmutableSet.__proto__),
>+    add: dart.fnType(core.bool, [core.Object]),
>+    addAll: dart.fnType(dart.void, [core.Object])
>+  }));
>+  dart.setLibraryUri(_ImmutableSet, "dart:collection");
>+  return _ImmutableSet;
>+});
>+collection._ImmutableSet = collection._ImmutableSet$();
>+dart.addTypeTests(collection._ImmutableSet, _is__ImmutableSet_default);
>+const _is__IdentityHashSet_default = Symbol('_is__IdentityHashSet_default');
>+collection._IdentityHashSet$ = dart.generic(E => {
>+  let _IdentityHashSetOfE = () => (_IdentityHashSetOfE = dart.constFn(collection._IdentityHashSet$(E)))();
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  let HashSetOfE = () => (HashSetOfE = dart.constFn(collection.HashSet$(E)))();
>+  let LinkedHashSetOfE = () => (LinkedHashSetOfE = dart.constFn(collection.LinkedHashSet$(E)))();
>+  class _IdentityHashSet extends collection._InternalSet$(E) {
>+    [_newSet]() {
>+      return new (_IdentityHashSetOfE()).new();
>+    }
>+    [_newSimilarSet](R) {
>+      return new (collection._IdentityHashSet$(R)).new();
>+    }
>+    contains(element) {
>+      return this[_map$0].has(element);
>+    }
>+    lookup(element) {
>+      return E._check(dart.test(this[_map$0].has(element)) ? element : null);
>+    }
>+    add(element) {
>+      E._check(element);
>+      let map = this[_map$0];
>+      if (map.has(element)) return false;
>+      map.add(element);
>+      this[_modifications$] = this[_modifications$] + 1 & 67108863;
>+      return true;
>+    }
>+    addAll(objects) {
>+      IterableOfE()._check(objects);
>+      let map = this[_map$0];
>+      let length = map.size;
>+      for (let key of objects) {
>+        map.add(key);
>+      }
>+      if (length !== map.size) {
>+        this[_modifications$] = this[_modifications$] + 1 & 67108863;
>+      }
>+    }
>+    remove(element) {
>+      if (this[_map$0].delete(element)) {
>+        this[_modifications$] = this[_modifications$] + 1 & 67108863;
>+        return true;
>+      }
>+      return false;
>+    }
>+    clear() {
>+      let map = this[_map$0];
>+      if (map.size > 0) {
>+        map.clear();
>+        this[_modifications$] = this[_modifications$] + 1 & 67108863;
>+      }
>+    }
>+  }
>+  (_IdentityHashSet.new = function() {
>+    this[_map$0] = new Set();
>+    this[_modifications$] = 0;
>+    _IdentityHashSet.__proto__.new.call(this);
>+  }).prototype = _IdentityHashSet.prototype;
>+  dart.addTypeTests(_IdentityHashSet);
>+  _IdentityHashSet.prototype[_is__IdentityHashSet_default] = true;
>+  _IdentityHashSet[dart.implements] = () => [HashSetOfE(), LinkedHashSetOfE()];
>+  dart.setMethodSignature(_IdentityHashSet, () => ({
>+    __proto__: dart.getMethods(_IdentityHashSet.__proto__),
>+    [_newSet]: dart.fnType(core.Set$(E), []),
>+    [_newSimilarSet]: dart.gFnType(R => [core.Set$(R), []]),
>+    contains: dart.fnType(core.bool, [core.Object]),
>+    [$contains]: dart.fnType(core.bool, [core.Object]),
>+    lookup: dart.fnType(E, [core.Object]),
>+    add: dart.fnType(core.bool, [core.Object]),
>+    addAll: dart.fnType(dart.void, [core.Object]),
>+    remove: dart.fnType(core.bool, [core.Object])
>+  }));
>+  dart.setLibraryUri(_IdentityHashSet, "dart:collection");
>+  dart.setFieldSignature(_IdentityHashSet, () => ({
>+    __proto__: dart.getFields(_IdentityHashSet.__proto__),
>+    [_map$0]: dart.finalFieldType(dart.dynamic),
>+    [_modifications$]: dart.fieldType(core.int)
>+  }));
>+  dart.defineExtensionMethods(_IdentityHashSet, ['contains']);
>+  return _IdentityHashSet;
>+});
>+collection._IdentityHashSet = collection._IdentityHashSet$();
>+dart.addTypeTests(collection._IdentityHashSet, _is__IdentityHashSet_default);
>+const _validKey$ = dart.privateName(collection, "_validKey");
>+const _equals$0 = dart.privateName(collection, "_equals");
>+const _hashCode$ = dart.privateName(collection, "_hashCode");
>+const _is__CustomHashSet_default = Symbol('_is__CustomHashSet_default');
>+collection._CustomHashSet$ = dart.generic(E => {
>+  let _CustomHashSetOfE = () => (_CustomHashSetOfE = dart.constFn(collection._CustomHashSet$(E)))();
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  let HashSetOfE = () => (HashSetOfE = dart.constFn(collection.HashSet$(E)))();
>+  let LinkedHashSetOfE = () => (LinkedHashSetOfE = dart.constFn(collection.LinkedHashSet$(E)))();
>+  let EAndETobool = () => (EAndETobool = dart.constFn(dart.fnType(core.bool, [E, E])))();
>+  let EToint = () => (EToint = dart.constFn(dart.fnType(core.int, [E])))();
>+  class _CustomHashSet extends collection._InternalSet$(E) {
>+    [_newSet]() {
>+      return new (_CustomHashSetOfE()).new(this[_equals$0], this[_hashCode$]);
>+    }
>+    [_newSimilarSet](R) {
>+      return new (collection._HashSet$(R)).new();
>+    }
>+    contains(key) {
>+      if (E.is(key)) {
>+        let buckets = this[_keyMap$].get(this[_hashCode$](key) & 0x3ffffff);
>+        if (buckets != null) {
>+          let equals = this[_equals$0];
>+          for (let i = 0, n = buckets.length; i < n; i++) {
>+            let k = buckets[i];
>+            if (dart.test(equals(k, key))) return true;
>+          }
>+        }
>+      }
>+      return false;
>+    }
>+    lookup(key) {
>+      if (E.is(key)) {
>+        let buckets = this[_keyMap$].get(this[_hashCode$](key) & 0x3ffffff);
>+        if (buckets != null) {
>+          let equals = this[_equals$0];
>+          for (let i = 0, n = buckets.length; i < n; i++) {
>+            let k = buckets[i];
>+            if (dart.test(equals(k, key))) return k;
>+          }
>+        }
>+      }
>+      return null;
>+    }
>+    add(key) {
>+      E._check(key);
>+      let keyMap = this[_keyMap$];
>+      let hash = this[_hashCode$](key) & 0x3ffffff;
>+      let buckets = keyMap.get(hash);
>+      if (buckets == null) {
>+        keyMap.set(hash, [key]);
>+      } else {
>+        let equals = this[_equals$0];
>+        for (let i = 0, n = buckets.length; i < n; i++) {
>+          let k = buckets[i];
>+          if (dart.test(equals(k, key))) return false;
>+        }
>+        buckets.push(key);
>+      }
>+      this[_map$0].add(key);
>+      this[_modifications$] = this[_modifications$] + 1 & 67108863;
>+      return true;
>+    }
>+    addAll(objects) {
>+      IterableOfE()._check(objects);
>+      for (let element of objects)
>+        this.add(element);
>+    }
>+    remove(key) {
>+      if (E.is(key)) {
>+        let hash = this[_hashCode$](key) & 0x3ffffff;
>+        let keyMap = this[_keyMap$];
>+        let buckets = keyMap.get(hash);
>+        if (buckets == null) return false;
>+        let equals = this[_equals$0];
>+        for (let i = 0, n = buckets.length; i < n; i++) {
>+          let k = buckets[i];
>+          if (dart.test(equals(k, key))) {
>+            if (n === 1) {
>+              keyMap.delete(hash);
>+            } else {
>+              buckets.splice(i, 1);
>+            }
>+            this[_map$0].delete(k);
>+            this[_modifications$] = this[_modifications$] + 1 & 67108863;
>+            return true;
>+          }
>+        }
>+      }
>+      return false;
>+    }
>+    clear() {
>+      let map = this[_map$0];
>+      if (map.size > 0) {
>+        map.clear();
>+        this[_keyMap$].clear();
>+        this[_modifications$] = this[_modifications$] + 1 & 67108863;
>+      }
>+    }
>+  }
>+  (_CustomHashSet.new = function(equals, hashCode) {
>+    this[_modifications$] = 0;
>+    this[_map$0] = new Set();
>+    this[_keyMap$] = new Map();
>+    this[_equals$0] = equals;
>+    this[_hashCode$] = hashCode;
>+    _CustomHashSet.__proto__.new.call(this);
>+  }).prototype = _CustomHashSet.prototype;
>+  dart.addTypeTests(_CustomHashSet);
>+  _CustomHashSet.prototype[_is__CustomHashSet_default] = true;
>+  _CustomHashSet[dart.implements] = () => [HashSetOfE(), LinkedHashSetOfE()];
>+  dart.setMethodSignature(_CustomHashSet, () => ({
>+    __proto__: dart.getMethods(_CustomHashSet.__proto__),
>+    [_newSet]: dart.fnType(core.Set$(E), []),
>+    [_newSimilarSet]: dart.gFnType(R => [core.Set$(R), []]),
>+    contains: dart.fnType(core.bool, [core.Object]),
>+    [$contains]: dart.fnType(core.bool, [core.Object]),
>+    lookup: dart.fnType(E, [core.Object]),
>+    add: dart.fnType(core.bool, [core.Object]),
>+    addAll: dart.fnType(dart.void, [core.Object]),
>+    remove: dart.fnType(core.bool, [core.Object])
>+  }));
>+  dart.setLibraryUri(_CustomHashSet, "dart:collection");
>+  dart.setFieldSignature(_CustomHashSet, () => ({
>+    __proto__: dart.getFields(_CustomHashSet.__proto__),
>+    [_equals$0]: dart.fieldType(EAndETobool()),
>+    [_hashCode$]: dart.fieldType(EToint()),
>+    [_modifications$]: dart.fieldType(core.int),
>+    [_map$0]: dart.finalFieldType(dart.dynamic),
>+    [_keyMap$]: dart.finalFieldType(dart.dynamic)
>+  }));
>+  dart.defineExtensionMethods(_CustomHashSet, ['contains']);
>+  return _CustomHashSet;
>+});
>+collection._CustomHashSet = collection._CustomHashSet$();
>+dart.addTypeTests(collection._CustomHashSet, _is__CustomHashSet_default);
>+const _is__CustomKeyHashSet_default = Symbol('_is__CustomKeyHashSet_default');
>+collection._CustomKeyHashSet$ = dart.generic(E => {
>+  let _CustomKeyHashSetOfE = () => (_CustomKeyHashSetOfE = dart.constFn(collection._CustomKeyHashSet$(E)))();
>+  class _CustomKeyHashSet extends collection._CustomHashSet$(E) {
>+    [_newSet]() {
>+      return new (_CustomKeyHashSetOfE()).new(this[_equals$0], this[_hashCode$], this[_validKey$]);
>+    }
>+    [_newSimilarSet](R) {
>+      return new (collection._HashSet$(R)).new();
>+    }
>+    contains(element) {
>+      if (!dart.test(this[_validKey$](element))) return false;
>+      return super.contains(element);
>+    }
>+    lookup(element) {
>+      if (!dart.test(this[_validKey$](element))) return null;
>+      return super.lookup(element);
>+    }
>+    remove(element) {
>+      if (!dart.test(this[_validKey$](element))) return false;
>+      return super.remove(element);
>+    }
>+  }
>+  (_CustomKeyHashSet.new = function(equals, hashCode, validKey) {
>+    this[_validKey$] = validKey;
>+    _CustomKeyHashSet.__proto__.new.call(this, equals, hashCode);
>+  }).prototype = _CustomKeyHashSet.prototype;
>+  dart.addTypeTests(_CustomKeyHashSet);
>+  _CustomKeyHashSet.prototype[_is__CustomKeyHashSet_default] = true;
>+  dart.setLibraryUri(_CustomKeyHashSet, "dart:collection");
>+  dart.setFieldSignature(_CustomKeyHashSet, () => ({
>+    __proto__: dart.getFields(_CustomKeyHashSet.__proto__),
>+    [_validKey$]: dart.fieldType(ObjectTobool())
>+  }));
>+  dart.defineExtensionMethods(_CustomKeyHashSet, ['contains']);
>+  return _CustomKeyHashSet;
>+});
>+collection._CustomKeyHashSet = collection._CustomKeyHashSet$();
>+dart.addTypeTests(collection._CustomKeyHashSet, _is__CustomKeyHashSet_default);
>+const _source$0 = dart.privateName(collection, "_source");
>+const _is_UnmodifiableListView_default = Symbol('_is_UnmodifiableListView_default');
>+collection.UnmodifiableListView$ = dart.generic(E => {
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  class UnmodifiableListView extends _internal.UnmodifiableListBase$(E) {
>+    cast(R) {
>+      return new (collection.UnmodifiableListView$(R)).new(core.Iterable$(R)._check(this[_source$0][$cast](R)));
>+    }
>+    get length() {
>+      return this[_source$0][$length];
>+    }
>+    set length(value) {
>+      super.length = value;
>+    }
>+    _get(index) {
>+      return this[_source$0][$elementAt](index);
>+    }
>+  }
>+  (UnmodifiableListView.new = function(source) {
>+    this[_source$0] = source;
>+  }).prototype = UnmodifiableListView.prototype;
>+  dart.addTypeTests(UnmodifiableListView);
>+  UnmodifiableListView.prototype[_is_UnmodifiableListView_default] = true;
>+  dart.setMethodSignature(UnmodifiableListView, () => ({
>+    __proto__: dart.getMethods(UnmodifiableListView.__proto__),
>+    _get: dart.fnType(E, [core.int]),
>+    [$_get]: dart.fnType(E, [core.int])
>+  }));
>+  dart.setGetterSignature(UnmodifiableListView, () => ({
>+    __proto__: dart.getGetters(UnmodifiableListView.__proto__),
>+    length: core.int,
>+    [$length]: core.int
>+  }));
>+  dart.setLibraryUri(UnmodifiableListView, "dart:collection");
>+  dart.setFieldSignature(UnmodifiableListView, () => ({
>+    __proto__: dart.getFields(UnmodifiableListView.__proto__),
>+    [_source$0]: dart.finalFieldType(IterableOfE())
>+  }));
>+  dart.defineExtensionMethods(UnmodifiableListView, ['cast', '_get']);
>+  dart.defineExtensionAccessors(UnmodifiableListView, ['length']);
>+  return UnmodifiableListView;
>+});
>+collection.UnmodifiableListView = collection.UnmodifiableListView$();
>+dart.addTypeTests(collection.UnmodifiableListView, _is_UnmodifiableListView_default);
>+collection._defaultEquals = function(a, b) {
>+  return dart.equals(a, b);
>+};
>+collection._defaultHashCode = function(a) {
>+  return dart.hashCode(a);
>+};
>+const _is_HashMap_default = Symbol('_is_HashMap_default');
>+collection.HashMap$ = dart.generic((K, V) => {
>+  let IdentityMapOfK$V = () => (IdentityMapOfK$V = dart.constFn(_js_helper.IdentityMap$(K, V)))();
>+  let LinkedMapOfK$V = () => (LinkedMapOfK$V = dart.constFn(_js_helper.LinkedMap$(K, V)))();
>+  let CustomHashMapOfK$V = () => (CustomHashMapOfK$V = dart.constFn(_js_helper.CustomHashMap$(K, V)))();
>+  let CustomKeyHashMapOfK$V = () => (CustomKeyHashMapOfK$V = dart.constFn(_js_helper.CustomKeyHashMap$(K, V)))();
>+  let HashMapOfK$V = () => (HashMapOfK$V = dart.constFn(collection.HashMap$(K, V)))();
>+  let MapOfK$V = () => (MapOfK$V = dart.constFn(core.Map$(K, V)))();
>+  class HashMap extends core.Object {
>+    static new(opts) {
>+      let equals = opts && 'equals' in opts ? opts.equals : null;
>+      let hashCode = opts && 'hashCode' in opts ? opts.hashCode : null;
>+      let isValidKey = opts && 'isValidKey' in opts ? opts.isValidKey : null;
>+      if (isValidKey == null) {
>+        if (hashCode == null) {
>+          if (equals == null) {
>+            if (dart.wrapType(K) === dart.wrapType(core.String) || dart.wrapType(K) === dart.wrapType(core.int)) {
>+              return new (IdentityMapOfK$V()).new();
>+            }
>+            return new (LinkedMapOfK$V()).new();
>+          }
>+          hashCode = dart.hashCode;
>+        } else if (dart.fn(core.identityHashCode, ObjectToint()) === hashCode && dart.fn(core.identical, ObjectAndObjectTobool()) === equals) {
>+          return new (IdentityMapOfK$V()).new();
>+        }
>+        return new (CustomHashMapOfK$V()).new(equals != null ? equals : dart.equals, hashCode);
>+      }
>+      return new (CustomKeyHashMapOfK$V()).new(equals != null ? equals : dart.equals, hashCode != null ? hashCode : dart.hashCode, isValidKey);
>+    }
>+    static identity() {
>+      return new (IdentityMapOfK$V()).new();
>+    }
>+    static from(other) {
>+      let result = new (LinkedMapOfK$V()).new();
>+      other[$forEach](dart.fn((k, v) => {
>+        result[$_set](K._check(k), V._check(v));
>+      }, dynamicAnddynamicToNull()));
>+      return HashMapOfK$V()._check(result);
>+    }
>+    static of(other) {
>+      let _ = new (LinkedMapOfK$V()).new();
>+      _.addAll(other);
>+      return _;
>+    }
>+    static fromIterable(iterable, opts) {
>+      let key = opts && 'key' in opts ? opts.key : null;
>+      let value = opts && 'value' in opts ? opts.value : null;
>+      let map = new (LinkedMapOfK$V()).new();
>+      collection.MapBase._fillMapWithMappedIterable(map, iterable, key, value);
>+      return HashMapOfK$V()._check(map);
>+    }
>+    static fromIterables(keys, values) {
>+      let map = new (LinkedMapOfK$V()).new();
>+      collection.MapBase._fillMapWithIterables(map, keys, values);
>+      return HashMapOfK$V()._check(map);
>+    }
>+    static fromEntries(entries) {
>+      let _ = new (LinkedMapOfK$V()).new();
>+      _.addEntries(entries);
>+      return _;
>+    }
>+  }
>+  (HashMap[dart.mixinNew] = function() {
>+  }).prototype = HashMap.prototype;
>+  HashMap.prototype[dart.isMap] = true;
>+  dart.addTypeTests(HashMap);
>+  HashMap.prototype[_is_HashMap_default] = true;
>+  HashMap[dart.implements] = () => [MapOfK$V()];
>+  dart.setLibraryUri(HashMap, "dart:collection");
>+  return HashMap;
>+});
>+collection.HashMap = collection.HashMap$();
>+dart.addTypeTests(collection.HashMap, _is_HashMap_default);
>+const _is_HashSet_default = Symbol('_is_HashSet_default');
>+collection.HashSet$ = dart.generic(E => {
>+  let _IdentityHashSetOfE = () => (_IdentityHashSetOfE = dart.constFn(collection._IdentityHashSet$(E)))();
>+  let _HashSetOfE = () => (_HashSetOfE = dart.constFn(collection._HashSet$(E)))();
>+  let _CustomHashSetOfE = () => (_CustomHashSetOfE = dart.constFn(collection._CustomHashSet$(E)))();
>+  let _CustomKeyHashSetOfE = () => (_CustomKeyHashSetOfE = dart.constFn(collection._CustomKeyHashSet$(E)))();
>+  let SetOfE = () => (SetOfE = dart.constFn(core.Set$(E)))();
>+  class HashSet extends core.Object {
>+    static new(opts) {
>+      let equals = opts && 'equals' in opts ? opts.equals : null;
>+      let hashCode = opts && 'hashCode' in opts ? opts.hashCode : null;
>+      let isValidKey = opts && 'isValidKey' in opts ? opts.isValidKey : null;
>+      if (isValidKey == null) {
>+        if (hashCode == null) {
>+          if (equals == null) {
>+            if (dart.wrapType(E) === dart.wrapType(core.String) || dart.wrapType(E) === dart.wrapType(core.int)) {
>+              return new (_IdentityHashSetOfE()).new();
>+            }
>+            return new (_HashSetOfE()).new();
>+          }
>+          hashCode = dart.hashCode;
>+        } else if (dart.fn(core.identityHashCode, ObjectToint()) === hashCode && dart.fn(core.identical, ObjectAndObjectTobool()) === equals) {
>+          return new (_IdentityHashSetOfE()).new();
>+        }
>+        return new (_CustomHashSetOfE()).new(equals != null ? equals : dart.equals, hashCode != null ? hashCode : dart.hashCode);
>+      }
>+      return new (_CustomKeyHashSetOfE()).new(equals != null ? equals : dart.equals, hashCode != null ? hashCode : dart.hashCode, isValidKey);
>+    }
>+    static identity() {
>+      return new (_IdentityHashSetOfE()).new();
>+    }
>+    static from(elements) {
>+      let result = new (_HashSetOfE()).new();
>+      for (let e of elements) {
>+        result.add(E._check(e));
>+      }
>+      return result;
>+    }
>+    static of(elements) {
>+      let _ = new (_HashSetOfE()).new();
>+      _.addAll(elements);
>+      return _;
>+    }
>+    [Symbol.iterator]() {
>+      return new dart.JsIterator(this.iterator);
>+    }
>+  }
>+  (HashSet[dart.mixinNew] = function() {
>+  }).prototype = HashSet.prototype;
>+  dart.addTypeTests(HashSet);
>+  HashSet.prototype[_is_HashSet_default] = true;
>+  HashSet[dart.implements] = () => [SetOfE()];
>+  dart.setLibraryUri(HashSet, "dart:collection");
>+  return HashSet;
>+});
>+collection.HashSet = collection.HashSet$();
>+dart.addTypeTests(collection.HashSet, _is_HashSet_default);
>+const _is_IterableMixin_default = Symbol('_is_IterableMixin_default');
>+collection.IterableMixin$ = dart.generic(E => {
>+  let WhereIterableOfE = () => (WhereIterableOfE = dart.constFn(_internal.WhereIterable$(E)))();
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  let EfficientLengthIterableOfE = () => (EfficientLengthIterableOfE = dart.constFn(_internal.EfficientLengthIterable$(E)))();
>+  let FollowedByIterableOfE = () => (FollowedByIterableOfE = dart.constFn(_internal.FollowedByIterable$(E)))();
>+  let EAndEToE = () => (EAndEToE = dart.constFn(dart.fnType(E, [E, E])))();
>+  let ListOfE = () => (ListOfE = dart.constFn(core.List$(E)))();
>+  let SetOfE = () => (SetOfE = dart.constFn(core.Set$(E)))();
>+  let TakeIterableOfE = () => (TakeIterableOfE = dart.constFn(_internal.TakeIterable$(E)))();
>+  let TakeWhileIterableOfE = () => (TakeWhileIterableOfE = dart.constFn(_internal.TakeWhileIterable$(E)))();
>+  let SkipIterableOfE = () => (SkipIterableOfE = dart.constFn(_internal.SkipIterable$(E)))();
>+  let SkipWhileIterableOfE = () => (SkipWhileIterableOfE = dart.constFn(_internal.SkipWhileIterable$(E)))();
>+  let VoidToE = () => (VoidToE = dart.constFn(dart.fnType(E, [])))();
>+  class IterableMixin extends core.Object {
>+    cast(R) {
>+      return core.Iterable.castFrom(E, R, this);
>+    }
>+    map(T, f) {
>+      return _internal.MappedIterable$(E, T).new(this, f);
>+    }
>+    where(f) {
>+      return new (WhereIterableOfE()).new(this, f);
>+    }
>+    whereType(T) {
>+      return new (_internal.WhereTypeIterable$(T)).new(this);
>+    }
>+    expand(T, f) {
>+      return new (_internal.ExpandIterable$(E, T)).new(this, f);
>+    }
>+    followedBy(other) {
>+      IterableOfE()._check(other);
>+      let self = this;
>+      if (EfficientLengthIterableOfE().is(self)) {
>+        return FollowedByIterableOfE().firstEfficient(self, other);
>+      }
>+      return new (FollowedByIterableOfE()).new(this, other);
>+    }
>+    contains(element) {
>+      for (let e of this) {
>+        if (dart.equals(e, element)) return true;
>+      }
>+      return false;
>+    }
>+    forEach(f) {
>+      for (let element of this)
>+        f(element);
>+    }
>+    reduce(combine) {
>+      EAndEToE()._check(combine);
>+      let iterator = this.iterator;
>+      if (!dart.test(iterator.moveNext())) {
>+        dart.throw(_internal.IterableElementError.noElement());
>+      }
>+      let value = iterator.current;
>+      while (dart.test(iterator.moveNext())) {
>+        value = combine(value, iterator.current);
>+      }
>+      return value;
>+    }
>+    fold(T, initialValue, combine) {
>+      let value = initialValue;
>+      for (let element of this)
>+        value = combine(value, element);
>+      return value;
>+    }
>+    every(f) {
>+      for (let element of this) {
>+        if (!dart.test(f(element))) return false;
>+      }
>+      return true;
>+    }
>+    join(separator) {
>+      if (separator === void 0) separator = "";
>+      let iterator = this.iterator;
>+      if (!dart.test(iterator.moveNext())) return "";
>+      let buffer = new core.StringBuffer.new();
>+      if (separator == null || separator === "") {
>+        do {
>+          buffer.write(dart.str(iterator.current));
>+        } while (dart.test(iterator.moveNext()));
>+      } else {
>+        buffer.write(dart.str(iterator.current));
>+        while (dart.test(iterator.moveNext())) {
>+          buffer.write(separator);
>+          buffer.write(dart.str(iterator.current));
>+        }
>+      }
>+      return buffer.toString();
>+    }
>+    any(test) {
>+      for (let element of this) {
>+        if (dart.test(test(element))) return true;
>+      }
>+      return false;
>+    }
>+    toList(opts) {
>+      let growable = opts && 'growable' in opts ? opts.growable : true;
>+      return ListOfE().from(this, {growable: growable});
>+    }
>+    toSet() {
>+      return SetOfE().from(this);
>+    }
>+    get length() {
>+      if (!!_internal.EfficientLengthIterable.is(this)) dart.assertFailed(null, "dart:collection/iterable.dart", 103, 12, "this is! EfficientLengthIterable");
>+      let count = 0;
>+      let it = this[$iterator];
>+      while (dart.test(it.moveNext())) {
>+        count++;
>+      }
>+      return count;
>+    }
>+    get isEmpty() {
>+      return !dart.test(this[$iterator].moveNext());
>+    }
>+    get isNotEmpty() {
>+      return !dart.test(this.isEmpty);
>+    }
>+    take(count) {
>+      return TakeIterableOfE().new(this, count);
>+    }
>+    takeWhile(test) {
>+      return new (TakeWhileIterableOfE()).new(this, test);
>+    }
>+    skip(count) {
>+      return SkipIterableOfE().new(this, count);
>+    }
>+    skipWhile(test) {
>+      return new (SkipWhileIterableOfE()).new(this, test);
>+    }
>+    get first() {
>+      let it = this[$iterator];
>+      if (!dart.test(it.moveNext())) {
>+        dart.throw(_internal.IterableElementError.noElement());
>+      }
>+      return it.current;
>+    }
>+    get last() {
>+      let it = this[$iterator];
>+      if (!dart.test(it.moveNext())) {
>+        dart.throw(_internal.IterableElementError.noElement());
>+      }
>+      let result = null;
>+      do {
>+        result = it.current;
>+      } while (dart.test(it.moveNext()));
>+      return result;
>+    }
>+    get single() {
>+      let it = this[$iterator];
>+      if (!dart.test(it.moveNext())) dart.throw(_internal.IterableElementError.noElement());
>+      let result = it.current;
>+      if (dart.test(it.moveNext())) dart.throw(_internal.IterableElementError.tooMany());
>+      return result;
>+    }
>+    firstWhere(test, opts) {
>+      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+      VoidToE()._check(orElse);
>+      for (let element of this) {
>+        if (dart.test(test(element))) return element;
>+      }
>+      if (orElse != null) return orElse();
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    lastWhere(test, opts) {
>+      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+      VoidToE()._check(orElse);
>+      let result = null;
>+      let foundMatching = false;
>+      for (let element of this) {
>+        if (dart.test(test(element))) {
>+          result = element;
>+          foundMatching = true;
>+        }
>+      }
>+      if (foundMatching) return result;
>+      if (orElse != null) return orElse();
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    singleWhere(test, opts) {
>+      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+      VoidToE()._check(orElse);
>+      let result = null;
>+      let foundMatching = false;
>+      for (let element of this) {
>+        if (dart.test(test(element))) {
>+          if (foundMatching) {
>+            dart.throw(_internal.IterableElementError.tooMany());
>+          }
>+          result = element;
>+          foundMatching = true;
>+        }
>+      }
>+      if (foundMatching) return result;
>+      if (orElse != null) return orElse();
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    elementAt(index) {
>+      core.ArgumentError.checkNotNull(index, "index");
>+      core.RangeError.checkNotNegative(index, "index");
>+      let elementIndex = 0;
>+      for (let element of this) {
>+        if (index === elementIndex) return element;
>+        elementIndex++;
>+      }
>+      dart.throw(core.RangeError.index(index, this, "index", null, elementIndex));
>+    }
>+    toString() {
>+      return collection.IterableBase.iterableToShortString(this, "(", ")");
>+    }
>+    [Symbol.iterator]() {
>+      return new dart.JsIterator(this.iterator);
>+    }
>+  }
>+  (IterableMixin.new = function() {
>+  }).prototype = IterableMixin.prototype;
>+  IterableMixin.prototype[dart.isIterable] = true;
>+  dart.addTypeTests(IterableMixin);
>+  IterableMixin.prototype[_is_IterableMixin_default] = true;
>+  IterableMixin[dart.implements] = () => [IterableOfE()];
>+  dart.setMethodSignature(IterableMixin, () => ({
>+    __proto__: dart.getMethods(IterableMixin.__proto__),
>+    cast: dart.gFnType(R => [core.Iterable$(R), []]),
>+    [$cast]: dart.gFnType(R => [core.Iterable$(R), []]),
>+    map: dart.gFnType(T => [core.Iterable$(T), [dart.fnType(T, [E])]]),
>+    [$map]: dart.gFnType(T => [core.Iterable$(T), [dart.fnType(T, [E])]]),
>+    where: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    [$where]: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    whereType: dart.gFnType(T => [core.Iterable$(T), []]),
>+    [$whereType]: dart.gFnType(T => [core.Iterable$(T), []]),
>+    expand: dart.gFnType(T => [core.Iterable$(T), [dart.fnType(core.Iterable$(T), [E])]]),
>+    [$expand]: dart.gFnType(T => [core.Iterable$(T), [dart.fnType(core.Iterable$(T), [E])]]),
>+    followedBy: dart.fnType(core.Iterable$(E), [core.Object]),
>+    [$followedBy]: dart.fnType(core.Iterable$(E), [core.Object]),
>+    contains: dart.fnType(core.bool, [core.Object]),
>+    [$contains]: dart.fnType(core.bool, [core.Object]),
>+    forEach: dart.fnType(dart.void, [dart.fnType(dart.void, [E])]),
>+    [$forEach]: dart.fnType(dart.void, [dart.fnType(dart.void, [E])]),
>+    reduce: dart.fnType(E, [core.Object]),
>+    [$reduce]: dart.fnType(E, [core.Object]),
>+    fold: dart.gFnType(T => [T, [T, dart.fnType(T, [T, E])]]),
>+    [$fold]: dart.gFnType(T => [T, [T, dart.fnType(T, [T, E])]]),
>+    every: dart.fnType(core.bool, [dart.fnType(core.bool, [E])]),
>+    [$every]: dart.fnType(core.bool, [dart.fnType(core.bool, [E])]),
>+    join: dart.fnType(core.String, [], [core.String]),
>+    [$join]: dart.fnType(core.String, [], [core.String]),
>+    any: dart.fnType(core.bool, [dart.fnType(core.bool, [E])]),
>+    [$any]: dart.fnType(core.bool, [dart.fnType(core.bool, [E])]),
>+    toList: dart.fnType(core.List$(E), [], {growable: core.bool}),
>+    [$toList]: dart.fnType(core.List$(E), [], {growable: core.bool}),
>+    toSet: dart.fnType(core.Set$(E), []),
>+    [$toSet]: dart.fnType(core.Set$(E), []),
>+    take: dart.fnType(core.Iterable$(E), [core.int]),
>+    [$take]: dart.fnType(core.Iterable$(E), [core.int]),
>+    takeWhile: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    [$takeWhile]: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    skip: dart.fnType(core.Iterable$(E), [core.int]),
>+    [$skip]: dart.fnType(core.Iterable$(E), [core.int]),
>+    skipWhile: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    [$skipWhile]: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    firstWhere: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    [$firstWhere]: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    lastWhere: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    [$lastWhere]: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    singleWhere: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    [$singleWhere]: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    elementAt: dart.fnType(E, [core.int]),
>+    [$elementAt]: dart.fnType(E, [core.int]),
>+    toString: dart.fnType(core.String, []),
>+    [$toString]: dart.fnType(core.String, [])
>+  }));
>+  dart.setGetterSignature(IterableMixin, () => ({
>+    __proto__: dart.getGetters(IterableMixin.__proto__),
>+    length: core.int,
>+    [$length]: core.int,
>+    isEmpty: core.bool,
>+    [$isEmpty]: core.bool,
>+    isNotEmpty: core.bool,
>+    [$isNotEmpty]: core.bool,
>+    first: E,
>+    [$first]: E,
>+    last: E,
>+    [$last]: E,
>+    single: E,
>+    [$single]: E
>+  }));
>+  dart.setLibraryUri(IterableMixin, "dart:collection");
>+  dart.defineExtensionMethods(IterableMixin, [
>+    'cast',
>+    'map',
>+    'where',
>+    'whereType',
>+    'expand',
>+    'followedBy',
>+    'contains',
>+    'forEach',
>+    'reduce',
>+    'fold',
>+    'every',
>+    'join',
>+    'any',
>+    'toList',
>+    'toSet',
>+    'take',
>+    'takeWhile',
>+    'skip',
>+    'skipWhile',
>+    'firstWhere',
>+    'lastWhere',
>+    'singleWhere',
>+    'elementAt',
>+    'toString'
>+  ]);
>+  dart.defineExtensionAccessors(IterableMixin, [
>+    'length',
>+    'isEmpty',
>+    'isNotEmpty',
>+    'first',
>+    'last',
>+    'single'
>+  ]);
>+  return IterableMixin;
>+});
>+collection.IterableMixin = collection.IterableMixin$();
>+dart.addTypeTests(collection.IterableMixin, _is_IterableMixin_default);
>+dart.defineLazy(collection, {
>+  /*collection._toStringVisiting*/get _toStringVisiting() {
>+    return [];
>+  }
>+});
>+collection._isToStringVisiting = function(o) {
>+  for (let i = 0; i < dart.notNull(collection._toStringVisiting[$length]); i++) {
>+    if (core.identical(o, collection._toStringVisiting[$_get](i))) return true;
>+  }
>+  return false;
>+};
>+collection._iterablePartsToStrings = function(iterable, parts) {
>+  let lengthLimit = 80;
>+  let headCount = 3;
>+  let tailCount = 2;
>+  let maxCount = 100;
>+  let overhead = 2;
>+  let ellipsisSize = 3;
>+  let length = 0;
>+  let count = 0;
>+  let it = iterable[$iterator];
>+  while (length < lengthLimit || count < headCount) {
>+    if (!dart.test(it.moveNext())) return;
>+    let next = dart.str(it.current);
>+    parts[$add](next);
>+    length = length + (next.length + overhead);
>+    count++;
>+  }
>+  let penultimateString = null;
>+  let ultimateString = null;
>+  let penultimate = null;
>+  let ultimate = null;
>+  if (!dart.test(it.moveNext())) {
>+    if (count <= headCount + tailCount) return;
>+    ultimateString = parts[$removeLast]();
>+    penultimateString = parts[$removeLast]();
>+  } else {
>+    penultimate = it.current;
>+    count++;
>+    if (!dart.test(it.moveNext())) {
>+      if (count <= headCount + 1) {
>+        parts[$add](dart.str(penultimate));
>+        return;
>+      }
>+      ultimateString = dart.str(penultimate);
>+      penultimateString = parts[$removeLast]();
>+      length = length + (ultimateString.length + overhead);
>+    } else {
>+      ultimate = it.current;
>+      count++;
>+      if (!(count < maxCount)) dart.assertFailed(null, "dart:collection/iterable.dart", 351, 14, "count < maxCount");
>+      while (dart.test(it.moveNext())) {
>+        penultimate = ultimate;
>+        ultimate = it.current;
>+        count++;
>+        if (count > maxCount) {
>+          while (length > lengthLimit - ellipsisSize - overhead && count > headCount) {
>+            length = length - (parts[$removeLast]().length + overhead);
>+            count--;
>+          }
>+          parts[$add]("...");
>+          return;
>+        }
>+      }
>+      penultimateString = dart.str(penultimate);
>+      ultimateString = dart.str(ultimate);
>+      length = length + (ultimateString.length + penultimateString.length + 2 * overhead);
>+    }
>+  }
>+  let elision = null;
>+  if (count > dart.notNull(parts[$length]) + tailCount) {
>+    elision = "...";
>+    length = length + (ellipsisSize + overhead);
>+  }
>+  while (length > lengthLimit && dart.notNull(parts[$length]) > headCount) {
>+    length = length - (parts[$removeLast]().length + overhead);
>+    if (elision == null) {
>+      elision = "...";
>+      length = length + (ellipsisSize + overhead);
>+    }
>+  }
>+  if (elision != null) {
>+    parts[$add](elision);
>+  }
>+  parts[$add](penultimateString);
>+  parts[$add](ultimateString);
>+};
>+const _iterator$0 = dart.privateName(collection, "_iterator");
>+const _state$ = dart.privateName(collection, "_state");
>+const _move = dart.privateName(collection, "_move");
>+const _is_HasNextIterator_default = Symbol('_is_HasNextIterator_default');
>+collection.HasNextIterator$ = dart.generic(E => {
>+  let IteratorOfE = () => (IteratorOfE = dart.constFn(core.Iterator$(E)))();
>+  class HasNextIterator extends core.Object {
>+    get hasNext() {
>+      if (this[_state$] === 2) this[_move]();
>+      return this[_state$] === 0;
>+    }
>+    next() {
>+      if (!dart.test(this.hasNext)) dart.throw(new core.StateError.new("No more elements"));
>+      if (!(this[_state$] === 0)) dart.assertFailed(null, "dart:collection/iterator.dart", 30, 12, "_state == _HAS_NEXT_AND_NEXT_IN_CURRENT");
>+      let result = this[_iterator$0].current;
>+      this[_move]();
>+      return result;
>+    }
>+    [_move]() {
>+      if (dart.test(this[_iterator$0].moveNext())) {
>+        this[_state$] = 0;
>+      } else {
>+        this[_state$] = 1;
>+      }
>+    }
>+  }
>+  (HasNextIterator.new = function(iterator) {
>+    this[_state$] = 2;
>+    this[_iterator$0] = iterator;
>+  }).prototype = HasNextIterator.prototype;
>+  dart.addTypeTests(HasNextIterator);
>+  HasNextIterator.prototype[_is_HasNextIterator_default] = true;
>+  dart.setMethodSignature(HasNextIterator, () => ({
>+    __proto__: dart.getMethods(HasNextIterator.__proto__),
>+    next: dart.fnType(E, []),
>+    [_move]: dart.fnType(dart.void, [])
>+  }));
>+  dart.setGetterSignature(HasNextIterator, () => ({
>+    __proto__: dart.getGetters(HasNextIterator.__proto__),
>+    hasNext: core.bool
>+  }));
>+  dart.setLibraryUri(HasNextIterator, "dart:collection");
>+  dart.setFieldSignature(HasNextIterator, () => ({
>+    __proto__: dart.getFields(HasNextIterator.__proto__),
>+    [_iterator$0]: dart.fieldType(IteratorOfE()),
>+    [_state$]: dart.fieldType(core.int)
>+  }));
>+  return HasNextIterator;
>+});
>+collection.HasNextIterator = collection.HasNextIterator$();
>+dart.defineLazy(collection.HasNextIterator, {
>+  /*collection.HasNextIterator._HAS_NEXT_AND_NEXT_IN_CURRENT*/get _HAS_NEXT_AND_NEXT_IN_CURRENT() {
>+    return 0;
>+  },
>+  /*collection.HasNextIterator._NO_NEXT*/get _NO_NEXT() {
>+    return 1;
>+  },
>+  /*collection.HasNextIterator._NOT_MOVED_YET*/get _NOT_MOVED_YET() {
>+    return 2;
>+  }
>+});
>+dart.addTypeTests(collection.HasNextIterator, _is_HasNextIterator_default);
>+const _is_LinkedHashMap_default = Symbol('_is_LinkedHashMap_default');
>+collection.LinkedHashMap$ = dart.generic((K, V) => {
>+  let IdentityMapOfK$V = () => (IdentityMapOfK$V = dart.constFn(_js_helper.IdentityMap$(K, V)))();
>+  let LinkedMapOfK$V = () => (LinkedMapOfK$V = dart.constFn(_js_helper.LinkedMap$(K, V)))();
>+  let CustomHashMapOfK$V = () => (CustomHashMapOfK$V = dart.constFn(_js_helper.CustomHashMap$(K, V)))();
>+  let CustomKeyHashMapOfK$V = () => (CustomKeyHashMapOfK$V = dart.constFn(_js_helper.CustomKeyHashMap$(K, V)))();
>+  let LinkedHashMapOfK$V = () => (LinkedHashMapOfK$V = dart.constFn(collection.LinkedHashMap$(K, V)))();
>+  let MapOfK$V = () => (MapOfK$V = dart.constFn(core.Map$(K, V)))();
>+  class LinkedHashMap extends core.Object {
>+    static new(opts) {
>+      let equals = opts && 'equals' in opts ? opts.equals : null;
>+      let hashCode = opts && 'hashCode' in opts ? opts.hashCode : null;
>+      let isValidKey = opts && 'isValidKey' in opts ? opts.isValidKey : null;
>+      if (isValidKey == null) {
>+        if (hashCode == null) {
>+          if (equals == null) {
>+            if (dart.wrapType(K) === dart.wrapType(core.String) || dart.wrapType(K) === dart.wrapType(core.int)) {
>+              return new (IdentityMapOfK$V()).new();
>+            }
>+            return new (LinkedMapOfK$V()).new();
>+          }
>+          hashCode = dart.hashCode;
>+        } else if (dart.fn(core.identityHashCode, ObjectToint()) === hashCode && dart.fn(core.identical, ObjectAndObjectTobool()) === equals) {
>+          return new (IdentityMapOfK$V()).new();
>+        }
>+        return new (CustomHashMapOfK$V()).new(equals != null ? equals : dart.equals, hashCode);
>+      }
>+      return new (CustomKeyHashMapOfK$V()).new(equals != null ? equals : dart.equals, hashCode != null ? hashCode : dart.hashCode, isValidKey);
>+    }
>+    static identity() {
>+      return new (IdentityMapOfK$V()).new();
>+    }
>+    static from(other) {
>+      let result = new (LinkedMapOfK$V()).new();
>+      other[$forEach](dart.fn((k, v) => {
>+        result._set(K._check(k), V._check(v));
>+      }, dynamicAnddynamicToNull()));
>+      return result;
>+    }
>+    static of(other) {
>+      let _ = new (LinkedMapOfK$V()).new();
>+      _.addAll(other);
>+      return _;
>+    }
>+    static fromIterable(iterable, opts) {
>+      let key = opts && 'key' in opts ? opts.key : null;
>+      let value = opts && 'value' in opts ? opts.value : null;
>+      let map = new (LinkedMapOfK$V()).new();
>+      collection.MapBase._fillMapWithMappedIterable(map, iterable, key, value);
>+      return map;
>+    }
>+    static fromIterables(keys, values) {
>+      let map = new (LinkedMapOfK$V()).new();
>+      collection.MapBase._fillMapWithIterables(map, keys, values);
>+      return map;
>+    }
>+    static fromEntries(entries) {
>+      return LinkedHashMapOfK$V()._check((() => {
>+        let _ = new (LinkedMapOfK$V()).new();
>+        _[$addEntries](entries);
>+        return _;
>+      })());
>+    }
>+  }
>+  (LinkedHashMap[dart.mixinNew] = function() {
>+  }).prototype = LinkedHashMap.prototype;
>+  LinkedHashMap.prototype[dart.isMap] = true;
>+  dart.addTypeTests(LinkedHashMap);
>+  LinkedHashMap.prototype[_is_LinkedHashMap_default] = true;
>+  LinkedHashMap[dart.implements] = () => [MapOfK$V()];
>+  dart.setLibraryUri(LinkedHashMap, "dart:collection");
>+  return LinkedHashMap;
>+});
>+collection.LinkedHashMap = collection.LinkedHashMap$();
>+dart.addTypeTests(collection.LinkedHashMap, _is_LinkedHashMap_default);
>+const _is_LinkedHashSet_default = Symbol('_is_LinkedHashSet_default');
>+collection.LinkedHashSet$ = dart.generic(E => {
>+  let _IdentityHashSetOfE = () => (_IdentityHashSetOfE = dart.constFn(collection._IdentityHashSet$(E)))();
>+  let _HashSetOfE = () => (_HashSetOfE = dart.constFn(collection._HashSet$(E)))();
>+  let _CustomHashSetOfE = () => (_CustomHashSetOfE = dart.constFn(collection._CustomHashSet$(E)))();
>+  let _CustomKeyHashSetOfE = () => (_CustomKeyHashSetOfE = dart.constFn(collection._CustomKeyHashSet$(E)))();
>+  let SetOfE = () => (SetOfE = dart.constFn(core.Set$(E)))();
>+  class LinkedHashSet extends core.Object {
>+    static new(opts) {
>+      let equals = opts && 'equals' in opts ? opts.equals : null;
>+      let hashCode = opts && 'hashCode' in opts ? opts.hashCode : null;
>+      let isValidKey = opts && 'isValidKey' in opts ? opts.isValidKey : null;
>+      if (isValidKey == null) {
>+        if (hashCode == null) {
>+          if (equals == null) {
>+            if (dart.wrapType(E) === dart.wrapType(core.String) || dart.wrapType(E) === dart.wrapType(core.int)) {
>+              return new (_IdentityHashSetOfE()).new();
>+            }
>+            return new (_HashSetOfE()).new();
>+          }
>+          hashCode = dart.hashCode;
>+        } else if (dart.fn(core.identityHashCode, ObjectToint()) === hashCode && dart.fn(core.identical, ObjectAndObjectTobool()) === equals) {
>+          return new (_IdentityHashSetOfE()).new();
>+        }
>+        return new (_CustomHashSetOfE()).new(equals != null ? equals : dart.equals, hashCode != null ? hashCode : dart.hashCode);
>+      }
>+      return new (_CustomKeyHashSetOfE()).new(equals != null ? equals : dart.equals, hashCode != null ? hashCode : dart.hashCode, isValidKey);
>+    }
>+    static identity() {
>+      return new (_IdentityHashSetOfE()).new();
>+    }
>+    static from(elements) {
>+      let result = new (_HashSetOfE()).new();
>+      for (let element of elements) {
>+        result.add(E._check(element));
>+      }
>+      return result;
>+    }
>+    static of(elements) {
>+      let _ = new (_HashSetOfE()).new();
>+      _.addAll(elements);
>+      return _;
>+    }
>+    [Symbol.iterator]() {
>+      return new dart.JsIterator(this.iterator);
>+    }
>+  }
>+  (LinkedHashSet[dart.mixinNew] = function() {
>+  }).prototype = LinkedHashSet.prototype;
>+  dart.addTypeTests(LinkedHashSet);
>+  LinkedHashSet.prototype[_is_LinkedHashSet_default] = true;
>+  LinkedHashSet[dart.implements] = () => [SetOfE()];
>+  dart.setLibraryUri(LinkedHashSet, "dart:collection");
>+  return LinkedHashSet;
>+});
>+collection.LinkedHashSet = collection.LinkedHashSet$();
>+dart.addTypeTests(collection.LinkedHashSet, _is_LinkedHashSet_default);
>+const _modificationCount = dart.privateName(collection, "_modificationCount");
>+const _length$0 = dart.privateName(collection, "_length");
>+const _first$ = dart.privateName(collection, "_first");
>+const _insertBefore = dart.privateName(collection, "_insertBefore");
>+const _list$ = dart.privateName(collection, "_list");
>+const _unlink = dart.privateName(collection, "_unlink");
>+const _next$0 = dart.privateName(collection, "_next");
>+const _previous$0 = dart.privateName(collection, "_previous");
>+const _is_LinkedList_default$ = Symbol('_is_LinkedList_default');
>+collection.LinkedList$ = dart.generic(E => {
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  let _LinkedListIteratorOfE = () => (_LinkedListIteratorOfE = dart.constFn(collection._LinkedListIterator$(E)))();
>+  class LinkedList extends core.Iterable$(E) {
>+    addFirst(entry) {
>+      E._check(entry);
>+      this[_insertBefore](this[_first$], entry, {updateFirst: true});
>+      this[_first$] = entry;
>+    }
>+    add(entry) {
>+      E._check(entry);
>+      this[_insertBefore](this[_first$], entry, {updateFirst: false});
>+    }
>+    addAll(entries) {
>+      IterableOfE()._check(entries);
>+      entries[$forEach](dart.bind(this, 'add'));
>+    }
>+    remove(entry) {
>+      E._check(entry);
>+      if (!dart.equals(entry[_list$], this)) return false;
>+      this[_unlink](entry);
>+      return true;
>+    }
>+    get iterator() {
>+      return new (_LinkedListIteratorOfE()).new(this);
>+    }
>+    get length() {
>+      return this[_length$0];
>+    }
>+    clear() {
>+      this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
>+      if (dart.test(this.isEmpty)) return;
>+      let next = this[_first$];
>+      do {
>+        let entry = next;
>+        next = entry[_next$0];
>+        entry[_next$0] = entry[_previous$0] = entry[_list$] = null;
>+      } while (!(next == this[_first$]));
>+      this[_first$] = null;
>+      this[_length$0] = 0;
>+    }
>+    get first() {
>+      if (dart.test(this.isEmpty)) {
>+        dart.throw(new core.StateError.new("No such element"));
>+      }
>+      return this[_first$];
>+    }
>+    get last() {
>+      if (dart.test(this.isEmpty)) {
>+        dart.throw(new core.StateError.new("No such element"));
>+      }
>+      return this[_first$][_previous$0];
>+    }
>+    get single() {
>+      if (dart.test(this.isEmpty)) {
>+        dart.throw(new core.StateError.new("No such element"));
>+      }
>+      if (dart.notNull(this[_length$0]) > 1) {
>+        dart.throw(new core.StateError.new("Too many elements"));
>+      }
>+      return this[_first$];
>+    }
>+    forEach(action) {
>+      let modificationCount = this[_modificationCount];
>+      if (dart.test(this.isEmpty)) return;
>+      let current = this[_first$];
>+      do {
>+        action(current);
>+        if (modificationCount != this[_modificationCount]) {
>+          dart.throw(new core.ConcurrentModificationError.new(this));
>+        }
>+        current = current[_next$0];
>+      } while (!(current == this[_first$]));
>+    }
>+    get isEmpty() {
>+      return this[_length$0] === 0;
>+    }
>+    [_insertBefore](entry, newEntry, opts) {
>+      E._check(entry);
>+      E._check(newEntry);
>+      let updateFirst = opts && 'updateFirst' in opts ? opts.updateFirst : null;
>+      if (newEntry.list != null) {
>+        dart.throw(new core.StateError.new("LinkedListEntry is already in a LinkedList"));
>+      }
>+      this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
>+      newEntry[_list$] = this;
>+      if (dart.test(this.isEmpty)) {
>+        if (!(entry == null)) dart.assertFailed(null, "dart:collection/linked_list.dart", 139, 14, "entry == null");
>+        newEntry[_previous$0] = newEntry[_next$0] = newEntry;
>+        this[_first$] = newEntry;
>+        this[_length$0] = dart.notNull(this[_length$0]) + 1;
>+        return;
>+      }
>+      let predecessor = entry[_previous$0];
>+      let successor = entry;
>+      newEntry[_previous$0] = predecessor;
>+      newEntry[_next$0] = successor;
>+      predecessor[_next$0] = newEntry;
>+      successor[_previous$0] = newEntry;
>+      if (dart.test(updateFirst) && entry == this[_first$]) {
>+        this[_first$] = newEntry;
>+      }
>+      this[_length$0] = dart.notNull(this[_length$0]) + 1;
>+    }
>+    [_unlink](entry) {
>+      E._check(entry);
>+      this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
>+      entry[_next$0][_previous$0] = entry[_previous$0];
>+      let next = entry[_previous$0][_next$0] = entry[_next$0];
>+      this[_length$0] = dart.notNull(this[_length$0]) - 1;
>+      entry[_list$] = entry[_next$0] = entry[_previous$0] = null;
>+      if (dart.test(this.isEmpty)) {
>+        this[_first$] = null;
>+      } else if (entry == this[_first$]) {
>+        this[_first$] = next;
>+      }
>+    }
>+  }
>+  (LinkedList.new = function() {
>+    this[_modificationCount] = 0;
>+    this[_length$0] = 0;
>+    this[_first$] = null;
>+    LinkedList.__proto__.new.call(this);
>+  }).prototype = LinkedList.prototype;
>+  dart.addTypeTests(LinkedList);
>+  LinkedList.prototype[_is_LinkedList_default$] = true;
>+  dart.setMethodSignature(LinkedList, () => ({
>+    __proto__: dart.getMethods(LinkedList.__proto__),
>+    addFirst: dart.fnType(dart.void, [core.Object]),
>+    add: dart.fnType(dart.void, [core.Object]),
>+    addAll: dart.fnType(dart.void, [core.Object]),
>+    remove: dart.fnType(core.bool, [core.Object]),
>+    clear: dart.fnType(dart.void, []),
>+    [_insertBefore]: dart.fnType(dart.void, [core.Object, core.Object], {updateFirst: core.bool}),
>+    [_unlink]: dart.fnType(dart.void, [core.Object])
>+  }));
>+  dart.setGetterSignature(LinkedList, () => ({
>+    __proto__: dart.getGetters(LinkedList.__proto__),
>+    iterator: core.Iterator$(E),
>+    [$iterator]: core.Iterator$(E)
>+  }));
>+  dart.setLibraryUri(LinkedList, "dart:collection");
>+  dart.setFieldSignature(LinkedList, () => ({
>+    __proto__: dart.getFields(LinkedList.__proto__),
>+    [_modificationCount]: dart.fieldType(core.int),
>+    [_length$0]: dart.fieldType(core.int),
>+    [_first$]: dart.fieldType(E)
>+  }));
>+  dart.defineExtensionMethods(LinkedList, ['forEach']);
>+  dart.defineExtensionAccessors(LinkedList, [
>+    'iterator',
>+    'length',
>+    'first',
>+    'last',
>+    'single',
>+    'isEmpty'
>+  ]);
>+  return LinkedList;
>+});
>+collection.LinkedList = collection.LinkedList$();
>+dart.addTypeTests(collection.LinkedList, _is_LinkedList_default$);
>+const _visitedFirst = dart.privateName(collection, "_visitedFirst");
>+const _current$1 = dart.privateName(collection, "_current");
>+const _is__LinkedListIterator_default$ = Symbol('_is__LinkedListIterator_default');
>+collection._LinkedListIterator$ = dart.generic(E => {
>+  let IteratorOfE = () => (IteratorOfE = dart.constFn(core.Iterator$(E)))();
>+  let LinkedListOfE = () => (LinkedListOfE = dart.constFn(collection.LinkedList$(E)))();
>+  let LinkedListEntryOfE = () => (LinkedListEntryOfE = dart.constFn(collection.LinkedListEntry$(E)))();
>+  class _LinkedListIterator extends core.Object {
>+    get current() {
>+      return this[_current$1];
>+    }
>+    moveNext() {
>+      if (this[_modificationCount] != this[_list$][_modificationCount]) {
>+        dart.throw(new core.ConcurrentModificationError.new(this));
>+      }
>+      if (dart.test(this[_list$].isEmpty) || dart.test(this[_visitedFirst]) && this[_next$0] == this[_list$].first) {
>+        this[_current$1] = null;
>+        return false;
>+      }
>+      this[_visitedFirst] = true;
>+      this[_current$1] = E._check(this[_next$0]);
>+      this[_next$0] = this[_next$0][_next$0];
>+      return true;
>+    }
>+  }
>+  (_LinkedListIterator.new = function(list) {
>+    this[_current$1] = null;
>+    this[_list$] = list;
>+    this[_modificationCount] = list[_modificationCount];
>+    this[_next$0] = list[_first$];
>+    this[_visitedFirst] = false;
>+  }).prototype = _LinkedListIterator.prototype;
>+  dart.addTypeTests(_LinkedListIterator);
>+  _LinkedListIterator.prototype[_is__LinkedListIterator_default$] = true;
>+  _LinkedListIterator[dart.implements] = () => [IteratorOfE()];
>+  dart.setMethodSignature(_LinkedListIterator, () => ({
>+    __proto__: dart.getMethods(_LinkedListIterator.__proto__),
>+    moveNext: dart.fnType(core.bool, [])
>+  }));
>+  dart.setGetterSignature(_LinkedListIterator, () => ({
>+    __proto__: dart.getGetters(_LinkedListIterator.__proto__),
>+    current: E
>+  }));
>+  dart.setLibraryUri(_LinkedListIterator, "dart:collection");
>+  dart.setFieldSignature(_LinkedListIterator, () => ({
>+    __proto__: dart.getFields(_LinkedListIterator.__proto__),
>+    [_list$]: dart.finalFieldType(LinkedListOfE()),
>+    [_modificationCount]: dart.finalFieldType(core.int),
>+    [_current$1]: dart.fieldType(E),
>+    [_next$0]: dart.fieldType(LinkedListEntryOfE()),
>+    [_visitedFirst]: dart.fieldType(core.bool)
>+  }));
>+  return _LinkedListIterator;
>+});
>+collection._LinkedListIterator = collection._LinkedListIterator$();
>+dart.addTypeTests(collection._LinkedListIterator, _is__LinkedListIterator_default$);
>+const _is_LinkedListEntry_default$ = Symbol('_is_LinkedListEntry_default');
>+collection.LinkedListEntry$ = dart.generic(E => {
>+  let LinkedListOfE = () => (LinkedListOfE = dart.constFn(collection.LinkedList$(E)))();
>+  class LinkedListEntry extends core.Object {
>+    get list() {
>+      return this[_list$];
>+    }
>+    unlink() {
>+      this[_list$][_unlink](E._check(this));
>+    }
>+    get next() {
>+      if (this[_list$] == null || this[_list$].first == this[_next$0]) return null;
>+      return this[_next$0];
>+    }
>+    get previous() {
>+      if (this[_list$] == null || this === this[_list$].first) return null;
>+      return this[_previous$0];
>+    }
>+    insertAfter(entry) {
>+      E._check(entry);
>+      this[_list$][_insertBefore](this[_next$0], entry, {updateFirst: false});
>+    }
>+    insertBefore(entry) {
>+      E._check(entry);
>+      this[_list$][_insertBefore](E._check(this), entry, {updateFirst: true});
>+    }
>+  }
>+  (LinkedListEntry.new = function() {
>+    this[_list$] = null;
>+    this[_next$0] = null;
>+    this[_previous$0] = null;
>+  }).prototype = LinkedListEntry.prototype;
>+  dart.addTypeTests(LinkedListEntry);
>+  LinkedListEntry.prototype[_is_LinkedListEntry_default$] = true;
>+  dart.setMethodSignature(LinkedListEntry, () => ({
>+    __proto__: dart.getMethods(LinkedListEntry.__proto__),
>+    unlink: dart.fnType(dart.void, []),
>+    insertAfter: dart.fnType(dart.void, [core.Object]),
>+    insertBefore: dart.fnType(dart.void, [core.Object])
>+  }));
>+  dart.setGetterSignature(LinkedListEntry, () => ({
>+    __proto__: dart.getGetters(LinkedListEntry.__proto__),
>+    list: collection.LinkedList$(E),
>+    next: E,
>+    previous: E
>+  }));
>+  dart.setLibraryUri(LinkedListEntry, "dart:collection");
>+  dart.setFieldSignature(LinkedListEntry, () => ({
>+    __proto__: dart.getFields(LinkedListEntry.__proto__),
>+    [_list$]: dart.fieldType(LinkedListOfE()),
>+    [_next$0]: dart.fieldType(E),
>+    [_previous$0]: dart.fieldType(E)
>+  }));
>+  return LinkedListEntry;
>+});
>+collection.LinkedListEntry = collection.LinkedListEntry$();
>+dart.addTypeTests(collection.LinkedListEntry, _is_LinkedListEntry_default$);
>+const _is__MapBaseValueIterable_default = Symbol('_is__MapBaseValueIterable_default');
>+collection._MapBaseValueIterable$ = dart.generic((K, V) => {
>+  let _MapBaseValueIteratorOfK$V = () => (_MapBaseValueIteratorOfK$V = dart.constFn(collection._MapBaseValueIterator$(K, V)))();
>+  let MapOfK$V = () => (MapOfK$V = dart.constFn(core.Map$(K, V)))();
>+  class _MapBaseValueIterable extends _internal.EfficientLengthIterable$(V) {
>+    get length() {
>+      return this[_map$0][$length];
>+    }
>+    get isEmpty() {
>+      return this[_map$0][$isEmpty];
>+    }
>+    get isNotEmpty() {
>+      return this[_map$0][$isNotEmpty];
>+    }
>+    get first() {
>+      return this[_map$0][$_get](this[_map$0][$keys][$first]);
>+    }
>+    get single() {
>+      return this[_map$0][$_get](this[_map$0][$keys][$single]);
>+    }
>+    get last() {
>+      return this[_map$0][$_get](this[_map$0][$keys][$last]);
>+    }
>+    get iterator() {
>+      return new (_MapBaseValueIteratorOfK$V()).new(this[_map$0]);
>+    }
>+  }
>+  (_MapBaseValueIterable.new = function(map) {
>+    this[_map$0] = map;
>+    _MapBaseValueIterable.__proto__.new.call(this);
>+  }).prototype = _MapBaseValueIterable.prototype;
>+  dart.addTypeTests(_MapBaseValueIterable);
>+  _MapBaseValueIterable.prototype[_is__MapBaseValueIterable_default] = true;
>+  dart.setGetterSignature(_MapBaseValueIterable, () => ({
>+    __proto__: dart.getGetters(_MapBaseValueIterable.__proto__),
>+    length: core.int,
>+    [$length]: core.int,
>+    isEmpty: core.bool,
>+    [$isEmpty]: core.bool,
>+    isNotEmpty: core.bool,
>+    [$isNotEmpty]: core.bool,
>+    first: V,
>+    [$first]: V,
>+    single: V,
>+    [$single]: V,
>+    last: V,
>+    [$last]: V,
>+    iterator: core.Iterator$(V),
>+    [$iterator]: core.Iterator$(V)
>+  }));
>+  dart.setLibraryUri(_MapBaseValueIterable, "dart:collection");
>+  dart.setFieldSignature(_MapBaseValueIterable, () => ({
>+    __proto__: dart.getFields(_MapBaseValueIterable.__proto__),
>+    [_map$0]: dart.finalFieldType(MapOfK$V())
>+  }));
>+  dart.defineExtensionAccessors(_MapBaseValueIterable, [
>+    'length',
>+    'isEmpty',
>+    'isNotEmpty',
>+    'first',
>+    'single',
>+    'last',
>+    'iterator'
>+  ]);
>+  return _MapBaseValueIterable;
>+});
>+collection._MapBaseValueIterable = collection._MapBaseValueIterable$();
>+dart.addTypeTests(collection._MapBaseValueIterable, _is__MapBaseValueIterable_default);
>+const _keys = dart.privateName(collection, "_keys");
>+const _is__MapBaseValueIterator_default = Symbol('_is__MapBaseValueIterator_default');
>+collection._MapBaseValueIterator$ = dart.generic((K, V) => {
>+  let IteratorOfK = () => (IteratorOfK = dart.constFn(core.Iterator$(K)))();
>+  let MapOfK$V = () => (MapOfK$V = dart.constFn(core.Map$(K, V)))();
>+  let IteratorOfV = () => (IteratorOfV = dart.constFn(core.Iterator$(V)))();
>+  class _MapBaseValueIterator extends core.Object {
>+    moveNext() {
>+      if (dart.test(this[_keys].moveNext())) {
>+        this[_current$1] = this[_map$0][$_get](this[_keys].current);
>+        return true;
>+      }
>+      this[_current$1] = null;
>+      return false;
>+    }
>+    get current() {
>+      return this[_current$1];
>+    }
>+  }
>+  (_MapBaseValueIterator.new = function(map) {
>+    this[_current$1] = null;
>+    this[_map$0] = map;
>+    this[_keys] = map[$keys][$iterator];
>+  }).prototype = _MapBaseValueIterator.prototype;
>+  dart.addTypeTests(_MapBaseValueIterator);
>+  _MapBaseValueIterator.prototype[_is__MapBaseValueIterator_default] = true;
>+  _MapBaseValueIterator[dart.implements] = () => [IteratorOfV()];
>+  dart.setMethodSignature(_MapBaseValueIterator, () => ({
>+    __proto__: dart.getMethods(_MapBaseValueIterator.__proto__),
>+    moveNext: dart.fnType(core.bool, [])
>+  }));
>+  dart.setGetterSignature(_MapBaseValueIterator, () => ({
>+    __proto__: dart.getGetters(_MapBaseValueIterator.__proto__),
>+    current: V
>+  }));
>+  dart.setLibraryUri(_MapBaseValueIterator, "dart:collection");
>+  dart.setFieldSignature(_MapBaseValueIterator, () => ({
>+    __proto__: dart.getFields(_MapBaseValueIterator.__proto__),
>+    [_keys]: dart.finalFieldType(IteratorOfK()),
>+    [_map$0]: dart.finalFieldType(MapOfK$V()),
>+    [_current$1]: dart.fieldType(V)
>+  }));
>+  return _MapBaseValueIterator;
>+});
>+collection._MapBaseValueIterator = collection._MapBaseValueIterator$();
>+dart.addTypeTests(collection._MapBaseValueIterator, _is__MapBaseValueIterator_default);
>+const _is_MapView_default = Symbol('_is_MapView_default');
>+collection.MapView$ = dart.generic((K, V) => {
>+  let MapOfK$V = () => (MapOfK$V = dart.constFn(core.Map$(K, V)))();
>+  let MapEntryOfK$V = () => (MapEntryOfK$V = dart.constFn(core.MapEntry$(K, V)))();
>+  let IterableOfMapEntryOfK$V = () => (IterableOfMapEntryOfK$V = dart.constFn(core.Iterable$(MapEntryOfK$V())))();
>+  let KAndVToV = () => (KAndVToV = dart.constFn(dart.fnType(V, [K, V])))();
>+  let VoidToV = () => (VoidToV = dart.constFn(dart.fnType(V, [])))();
>+  let VToV = () => (VToV = dart.constFn(dart.fnType(V, [V])))();
>+  class MapView extends core.Object {
>+    cast(RK, RV) {
>+      return core.Map$(RK, RV)._check(this[_map$0][$cast](RK, RV));
>+    }
>+    _get(key) {
>+      return this[_map$0][$_get](key);
>+    }
>+    _set(key, value) {
>+      K._check(key);
>+      V._check(value);
>+      this[_map$0][$_set](key, value);
>+      return value;
>+    }
>+    addAll(other) {
>+      MapOfK$V()._check(other);
>+      this[_map$0][$addAll](other);
>+    }
>+    clear() {
>+      this[_map$0][$clear]();
>+    }
>+    putIfAbsent(key, ifAbsent) {
>+      K._check(key);
>+      VoidToV()._check(ifAbsent);
>+      return this[_map$0][$putIfAbsent](key, ifAbsent);
>+    }
>+    containsKey(key) {
>+      return this[_map$0][$containsKey](key);
>+    }
>+    containsValue(value) {
>+      return this[_map$0][$containsValue](value);
>+    }
>+    forEach(action) {
>+      this[_map$0][$forEach](action);
>+    }
>+    get isEmpty() {
>+      return this[_map$0][$isEmpty];
>+    }
>+    get isNotEmpty() {
>+      return this[_map$0][$isNotEmpty];
>+    }
>+    get length() {
>+      return this[_map$0][$length];
>+    }
>+    get keys() {
>+      return this[_map$0][$keys];
>+    }
>+    remove(key) {
>+      return this[_map$0][$remove](key);
>+    }
>+    toString() {
>+      return dart.toString(this[_map$0]);
>+    }
>+    get values() {
>+      return this[_map$0][$values];
>+    }
>+    get entries() {
>+      return this[_map$0][$entries];
>+    }
>+    addEntries(entries) {
>+      IterableOfMapEntryOfK$V()._check(entries);
>+      this[_map$0][$addEntries](entries);
>+    }
>+    map(K2, V2, transform) {
>+      return core.Map$(K2, V2)._check(this[_map$0][$map](K2, V2, transform));
>+    }
>+    update(key, update, opts) {
>+      K._check(key);
>+      VToV()._check(update);
>+      let ifAbsent = opts && 'ifAbsent' in opts ? opts.ifAbsent : null;
>+      VoidToV()._check(ifAbsent);
>+      return this[_map$0][$update](key, update, {ifAbsent: ifAbsent});
>+    }
>+    updateAll(update) {
>+      KAndVToV()._check(update);
>+      this[_map$0][$updateAll](update);
>+    }
>+    removeWhere(test) {
>+      this[_map$0][$removeWhere](test);
>+    }
>+  }
>+  (MapView.new = function(map) {
>+    this[_map$0] = map;
>+  }).prototype = MapView.prototype;
>+  MapView.prototype[dart.isMap] = true;
>+  dart.addTypeTests(MapView);
>+  MapView.prototype[_is_MapView_default] = true;
>+  MapView[dart.implements] = () => [MapOfK$V()];
>+  dart.setMethodSignature(MapView, () => ({
>+    __proto__: dart.getMethods(MapView.__proto__),
>+    cast: dart.gFnType((RK, RV) => [core.Map$(RK, RV), []]),
>+    [$cast]: dart.gFnType((RK, RV) => [core.Map$(RK, RV), []]),
>+    _get: dart.fnType(V, [core.Object]),
>+    [$_get]: dart.fnType(V, [core.Object]),
>+    _set: dart.fnType(dart.void, [core.Object, core.Object]),
>+    [$_set]: dart.fnType(dart.void, [core.Object, core.Object]),
>+    addAll: dart.fnType(dart.void, [core.Object]),
>+    [$addAll]: dart.fnType(dart.void, [core.Object]),
>+    clear: dart.fnType(dart.void, []),
>+    [$clear]: dart.fnType(dart.void, []),
>+    putIfAbsent: dart.fnType(V, [core.Object, core.Object]),
>+    [$putIfAbsent]: dart.fnType(V, [core.Object, core.Object]),
>+    containsKey: dart.fnType(core.bool, [core.Object]),
>+    [$containsKey]: dart.fnType(core.bool, [core.Object]),
>+    containsValue: dart.fnType(core.bool, [core.Object]),
>+    [$containsValue]: dart.fnType(core.bool, [core.Object]),
>+    forEach: dart.fnType(dart.void, [dart.fnType(dart.void, [K, V])]),
>+    [$forEach]: dart.fnType(dart.void, [dart.fnType(dart.void, [K, V])]),
>+    remove: dart.fnType(V, [core.Object]),
>+    [$remove]: dart.fnType(V, [core.Object]),
>+    toString: dart.fnType(core.String, []),
>+    [$toString]: dart.fnType(core.String, []),
>+    addEntries: dart.fnType(dart.void, [core.Object]),
>+    [$addEntries]: dart.fnType(dart.void, [core.Object]),
>+    map: dart.gFnType((K2, V2) => [core.Map$(K2, V2), [dart.fnType(core.MapEntry$(K2, V2), [K, V])]]),
>+    [$map]: dart.gFnType((K2, V2) => [core.Map$(K2, V2), [dart.fnType(core.MapEntry$(K2, V2), [K, V])]]),
>+    update: dart.fnType(V, [core.Object, core.Object], {ifAbsent: core.Object}),
>+    [$update]: dart.fnType(V, [core.Object, core.Object], {ifAbsent: core.Object}),
>+    updateAll: dart.fnType(dart.void, [core.Object]),
>+    [$updateAll]: dart.fnType(dart.void, [core.Object]),
>+    removeWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [K, V])]),
>+    [$removeWhere]: dart.fnType(dart.void, [dart.fnType(core.bool, [K, V])])
>+  }));
>+  dart.setGetterSignature(MapView, () => ({
>+    __proto__: dart.getGetters(MapView.__proto__),
>+    isEmpty: core.bool,
>+    [$isEmpty]: core.bool,
>+    isNotEmpty: core.bool,
>+    [$isNotEmpty]: core.bool,
>+    length: core.int,
>+    [$length]: core.int,
>+    keys: core.Iterable$(K),
>+    [$keys]: core.Iterable$(K),
>+    values: core.Iterable$(V),
>+    [$values]: core.Iterable$(V),
>+    entries: core.Iterable$(core.MapEntry$(K, V)),
>+    [$entries]: core.Iterable$(core.MapEntry$(K, V))
>+  }));
>+  dart.setLibraryUri(MapView, "dart:collection");
>+  dart.setFieldSignature(MapView, () => ({
>+    __proto__: dart.getFields(MapView.__proto__),
>+    [_map$0]: dart.finalFieldType(MapOfK$V())
>+  }));
>+  dart.defineExtensionMethods(MapView, [
>+    'cast',
>+    '_get',
>+    '_set',
>+    'addAll',
>+    'clear',
>+    'putIfAbsent',
>+    'containsKey',
>+    'containsValue',
>+    'forEach',
>+    'remove',
>+    'toString',
>+    'addEntries',
>+    'map',
>+    'update',
>+    'updateAll',
>+    'removeWhere'
>+  ]);
>+  dart.defineExtensionAccessors(MapView, [
>+    'isEmpty',
>+    'isNotEmpty',
>+    'length',
>+    'keys',
>+    'values',
>+    'entries'
>+  ]);
>+  return MapView;
>+});
>+collection.MapView = collection.MapView$();
>+dart.addTypeTests(collection.MapView, _is_MapView_default);
>+const _is_UnmodifiableMapView_default = Symbol('_is_UnmodifiableMapView_default');
>+collection.UnmodifiableMapView$ = dart.generic((K, V) => {
>+  const MapView__UnmodifiableMapMixin$ = class MapView__UnmodifiableMapMixin extends collection.MapView$(K, V) {};
>+  (MapView__UnmodifiableMapMixin$.new = function(map) {
>+    MapView__UnmodifiableMapMixin$.__proto__.new.call(this, map);
>+  }).prototype = MapView__UnmodifiableMapMixin$.prototype;
>+  dart.applyMixin(MapView__UnmodifiableMapMixin$, collection._UnmodifiableMapMixin$(K, V));
>+  class UnmodifiableMapView extends MapView__UnmodifiableMapMixin$ {
>+    cast(RK, RV) {
>+      return new (collection.UnmodifiableMapView$(RK, RV)).new(core.Map$(RK, RV)._check(this[_map$0][$cast](RK, RV)));
>+    }
>+  }
>+  (UnmodifiableMapView.new = function(map) {
>+    UnmodifiableMapView.__proto__.new.call(this, map);
>+  }).prototype = UnmodifiableMapView.prototype;
>+  dart.addTypeTests(UnmodifiableMapView);
>+  UnmodifiableMapView.prototype[_is_UnmodifiableMapView_default] = true;
>+  dart.setLibraryUri(UnmodifiableMapView, "dart:collection");
>+  dart.defineExtensionMethods(UnmodifiableMapView, ['cast']);
>+  return UnmodifiableMapView;
>+});
>+collection.UnmodifiableMapView = collection.UnmodifiableMapView$();
>+dart.addTypeTests(collection.UnmodifiableMapView, _is_UnmodifiableMapView_default);
>+const _is_Queue_default = Symbol('_is_Queue_default');
>+collection.Queue$ = dart.generic(E => {
>+  let ListQueueOfE = () => (ListQueueOfE = dart.constFn(collection.ListQueue$(E)))();
>+  let EfficientLengthIterableOfE = () => (EfficientLengthIterableOfE = dart.constFn(_internal.EfficientLengthIterable$(E)))();
>+  class Queue extends core.Object {
>+    static new() {
>+      return new (ListQueueOfE()).new();
>+    }
>+    static from(elements) {
>+      return ListQueueOfE().from(elements);
>+    }
>+    static of(elements) {
>+      return ListQueueOfE().of(elements);
>+    }
>+    static castFrom(S, T, source) {
>+      return new (_internal.CastQueue$(S, T)).new(source);
>+    }
>+  }
>+  (Queue[dart.mixinNew] = function() {
>+  }).prototype = Queue.prototype;
>+  dart.addTypeTests(Queue);
>+  Queue.prototype[_is_Queue_default] = true;
>+  Queue[dart.implements] = () => [EfficientLengthIterableOfE()];
>+  dart.setLibraryUri(Queue, "dart:collection");
>+  return Queue;
>+});
>+collection.Queue = collection.Queue$();
>+dart.addTypeTests(collection.Queue, _is_Queue_default);
>+const _previousLink = dart.privateName(collection, "_previousLink");
>+const _nextLink = dart.privateName(collection, "_nextLink");
>+const _link = dart.privateName(collection, "_link");
>+const _is__DoubleLink_default = Symbol('_is__DoubleLink_default');
>+collection._DoubleLink$ = dart.generic(Link => {
>+  class _DoubleLink extends core.Object {
>+    get [_previousLink]() {
>+      return this[_previousLink$];
>+    }
>+    set [_previousLink](value) {
>+      this[_previousLink$] = Link._check(value);
>+    }
>+    get [_nextLink]() {
>+      return this[_nextLink$];
>+    }
>+    set [_nextLink](value) {
>+      this[_nextLink$] = Link._check(value);
>+    }
>+    [_link](previous, next) {
>+      Link._check(previous);
>+      Link._check(next);
>+      this[_nextLink] = next;
>+      this[_previousLink] = previous;
>+      if (previous != null) previous[_nextLink] = Link._check(this);
>+      if (next != null) next[_previousLink] = Link._check(this);
>+    }
>+    [_unlink]() {
>+      if (this[_previousLink] != null) this[_previousLink][_nextLink] = this[_nextLink];
>+      if (this[_nextLink] != null) this[_nextLink][_previousLink] = this[_previousLink];
>+      this[_nextLink] = null;
>+      this[_previousLink] = null;
>+    }
>+  }
>+  (_DoubleLink.new = function() {
>+    this[_previousLink$] = null;
>+    this[_nextLink$] = null;
>+  }).prototype = _DoubleLink.prototype;
>+  dart.addTypeTests(_DoubleLink);
>+  _DoubleLink.prototype[_is__DoubleLink_default] = true;
>+  const _previousLink$ = Symbol("_DoubleLink._previousLink");
>+  const _nextLink$ = Symbol("_DoubleLink._nextLink");
>+  dart.setMethodSignature(_DoubleLink, () => ({
>+    __proto__: dart.getMethods(_DoubleLink.__proto__),
>+    [_link]: dart.fnType(dart.void, [core.Object, core.Object]),
>+    [_unlink]: dart.fnType(dart.void, [])
>+  }));
>+  dart.setLibraryUri(_DoubleLink, "dart:collection");
>+  dart.setFieldSignature(_DoubleLink, () => ({
>+    __proto__: dart.getFields(_DoubleLink.__proto__),
>+    [_previousLink]: dart.fieldType(Link),
>+    [_nextLink]: dart.fieldType(Link)
>+  }));
>+  return _DoubleLink;
>+});
>+collection._DoubleLink = collection._DoubleLink$();
>+dart.addTypeTests(collection._DoubleLink, _is__DoubleLink_default);
>+const _is_DoubleLinkedQueueEntry_default = Symbol('_is_DoubleLinkedQueueEntry_default');
>+collection.DoubleLinkedQueueEntry$ = dart.generic(E => {
>+  let DoubleLinkedQueueEntryOfE = () => (DoubleLinkedQueueEntryOfE = dart.constFn(collection.DoubleLinkedQueueEntry$(E)))();
>+  class DoubleLinkedQueueEntry extends collection._DoubleLink {
>+    get element() {
>+      return this[element$];
>+    }
>+    set element(value) {
>+      this[element$] = E._check(value);
>+    }
>+    append(e) {
>+      E._check(e);
>+      new (DoubleLinkedQueueEntryOfE()).new(e)[_link](this, this[_nextLink]);
>+    }
>+    prepend(e) {
>+      E._check(e);
>+      new (DoubleLinkedQueueEntryOfE()).new(e)[_link](this[_previousLink], this);
>+    }
>+    remove() {
>+      this[_unlink]();
>+      return this.element;
>+    }
>+    previousEntry() {
>+      return this[_previousLink];
>+    }
>+    nextEntry() {
>+      return this[_nextLink];
>+    }
>+  }
>+  (DoubleLinkedQueueEntry.new = function(element) {
>+    this[element$] = element;
>+    DoubleLinkedQueueEntry.__proto__.new.call(this);
>+  }).prototype = DoubleLinkedQueueEntry.prototype;
>+  dart.addTypeTests(DoubleLinkedQueueEntry);
>+  DoubleLinkedQueueEntry.prototype[_is_DoubleLinkedQueueEntry_default] = true;
>+  const element$ = Symbol("DoubleLinkedQueueEntry.element");
>+  dart.setMethodSignature(DoubleLinkedQueueEntry, () => ({
>+    __proto__: dart.getMethods(DoubleLinkedQueueEntry.__proto__),
>+    append: dart.fnType(dart.void, [core.Object]),
>+    prepend: dart.fnType(dart.void, [core.Object]),
>+    remove: dart.fnType(E, []),
>+    previousEntry: dart.fnType(collection.DoubleLinkedQueueEntry$(E), []),
>+    nextEntry: dart.fnType(collection.DoubleLinkedQueueEntry$(E), [])
>+  }));
>+  dart.setLibraryUri(DoubleLinkedQueueEntry, "dart:collection");
>+  dart.setFieldSignature(DoubleLinkedQueueEntry, () => ({
>+    __proto__: dart.getFields(DoubleLinkedQueueEntry.__proto__),
>+    element: dart.fieldType(E)
>+  }));
>+  return DoubleLinkedQueueEntry;
>+}, E => {
>+  dart.setBaseClass(collection.DoubleLinkedQueueEntry$(E), collection._DoubleLink$(collection.DoubleLinkedQueueEntry$(E)));
>+});
>+collection.DoubleLinkedQueueEntry = collection.DoubleLinkedQueueEntry$();
>+dart.addTypeTests(collection.DoubleLinkedQueueEntry, _is_DoubleLinkedQueueEntry_default);
>+const _queue = dart.privateName(collection, "_queue");
>+const _append = dart.privateName(collection, "_append");
>+const _prepend = dart.privateName(collection, "_prepend");
>+const _element = dart.privateName(collection, "_element");
>+const _asNonSentinelEntry = dart.privateName(collection, "_asNonSentinelEntry");
>+const _is__DoubleLinkedQueueEntry_default = Symbol('_is__DoubleLinkedQueueEntry_default');
>+collection._DoubleLinkedQueueEntry$ = dart.generic(E => {
>+  let _DoubleLinkedQueueElementOfE = () => (_DoubleLinkedQueueElementOfE = dart.constFn(collection._DoubleLinkedQueueElement$(E)))();
>+  let _DoubleLinkedQueueEntryOfE = () => (_DoubleLinkedQueueEntryOfE = dart.constFn(collection._DoubleLinkedQueueEntry$(E)))();
>+  let DoubleLinkedQueueOfE = () => (DoubleLinkedQueueOfE = dart.constFn(collection.DoubleLinkedQueue$(E)))();
>+  class _DoubleLinkedQueueEntry extends collection.DoubleLinkedQueueEntry$(E) {
>+    [_append](e) {
>+      E._check(e);
>+      new (_DoubleLinkedQueueElementOfE()).new(e, this[_queue])[_link](this, this[_nextLink]);
>+    }
>+    [_prepend](e) {
>+      E._check(e);
>+      new (_DoubleLinkedQueueElementOfE()).new(e, this[_queue])[_link](this[_previousLink], this);
>+    }
>+    get [_element]() {
>+      return this.element;
>+    }
>+    nextEntry() {
>+      let entry = _DoubleLinkedQueueEntryOfE()._check(this[_nextLink]);
>+      return entry[_asNonSentinelEntry]();
>+    }
>+    previousEntry() {
>+      let entry = _DoubleLinkedQueueEntryOfE()._check(this[_previousLink]);
>+      return entry[_asNonSentinelEntry]();
>+    }
>+  }
>+  (_DoubleLinkedQueueEntry.new = function(element, queue) {
>+    this[_queue] = queue;
>+    _DoubleLinkedQueueEntry.__proto__.new.call(this, element);
>+  }).prototype = _DoubleLinkedQueueEntry.prototype;
>+  dart.addTypeTests(_DoubleLinkedQueueEntry);
>+  _DoubleLinkedQueueEntry.prototype[_is__DoubleLinkedQueueEntry_default] = true;
>+  dart.setMethodSignature(_DoubleLinkedQueueEntry, () => ({
>+    __proto__: dart.getMethods(_DoubleLinkedQueueEntry.__proto__),
>+    [_append]: dart.fnType(dart.void, [core.Object]),
>+    [_prepend]: dart.fnType(dart.void, [core.Object])
>+  }));
>+  dart.setGetterSignature(_DoubleLinkedQueueEntry, () => ({
>+    __proto__: dart.getGetters(_DoubleLinkedQueueEntry.__proto__),
>+    [_element]: E
>+  }));
>+  dart.setLibraryUri(_DoubleLinkedQueueEntry, "dart:collection");
>+  dart.setFieldSignature(_DoubleLinkedQueueEntry, () => ({
>+    __proto__: dart.getFields(_DoubleLinkedQueueEntry.__proto__),
>+    [_queue]: dart.fieldType(DoubleLinkedQueueOfE())
>+  }));
>+  return _DoubleLinkedQueueEntry;
>+});
>+collection._DoubleLinkedQueueEntry = collection._DoubleLinkedQueueEntry$();
>+dart.addTypeTests(collection._DoubleLinkedQueueEntry, _is__DoubleLinkedQueueEntry_default);
>+const _elementCount = dart.privateName(collection, "_elementCount");
>+const _remove = dart.privateName(collection, "_remove");
>+const _is__DoubleLinkedQueueElement_default = Symbol('_is__DoubleLinkedQueueElement_default');
>+collection._DoubleLinkedQueueElement$ = dart.generic(E => {
>+  class _DoubleLinkedQueueElement extends collection._DoubleLinkedQueueEntry$(E) {
>+    append(e) {
>+      E._check(e);
>+      this[_append](e);
>+      if (this[_queue] != null) {
>+        let o = this[_queue];
>+        o[_elementCount] = dart.notNull(o[_elementCount]) + 1;
>+      }
>+    }
>+    prepend(e) {
>+      E._check(e);
>+      this[_prepend](e);
>+      if (this[_queue] != null) {
>+        let o = this[_queue];
>+        o[_elementCount] = dart.notNull(o[_elementCount]) + 1;
>+      }
>+    }
>+    [_remove]() {
>+      this[_queue] = null;
>+      this[_unlink]();
>+      return this.element;
>+    }
>+    remove() {
>+      if (this[_queue] != null) {
>+        let o = this[_queue];
>+        o[_elementCount] = dart.notNull(o[_elementCount]) - 1;
>+      }
>+      return this[_remove]();
>+    }
>+    [_asNonSentinelEntry]() {
>+      return this;
>+    }
>+  }
>+  (_DoubleLinkedQueueElement.new = function(element, queue) {
>+    _DoubleLinkedQueueElement.__proto__.new.call(this, element, queue);
>+  }).prototype = _DoubleLinkedQueueElement.prototype;
>+  dart.addTypeTests(_DoubleLinkedQueueElement);
>+  _DoubleLinkedQueueElement.prototype[_is__DoubleLinkedQueueElement_default] = true;
>+  dart.setMethodSignature(_DoubleLinkedQueueElement, () => ({
>+    __proto__: dart.getMethods(_DoubleLinkedQueueElement.__proto__),
>+    append: dart.fnType(dart.void, [core.Object]),
>+    prepend: dart.fnType(dart.void, [core.Object]),
>+    [_remove]: dart.fnType(E, []),
>+    [_asNonSentinelEntry]: dart.fnType(collection._DoubleLinkedQueueElement$(E), [])
>+  }));
>+  dart.setLibraryUri(_DoubleLinkedQueueElement, "dart:collection");
>+  return _DoubleLinkedQueueElement;
>+});
>+collection._DoubleLinkedQueueElement = collection._DoubleLinkedQueueElement$();
>+dart.addTypeTests(collection._DoubleLinkedQueueElement, _is__DoubleLinkedQueueElement_default);
>+const _is__DoubleLinkedQueueSentinel_default = Symbol('_is__DoubleLinkedQueueSentinel_default');
>+collection._DoubleLinkedQueueSentinel$ = dart.generic(E => {
>+  class _DoubleLinkedQueueSentinel extends collection._DoubleLinkedQueueEntry$(E) {
>+    [_asNonSentinelEntry]() {
>+      return null;
>+    }
>+    [_remove]() {
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    get [_element]() {
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+  }
>+  (_DoubleLinkedQueueSentinel.new = function(queue) {
>+    _DoubleLinkedQueueSentinel.__proto__.new.call(this, null, queue);
>+    this[_previousLink] = this;
>+    this[_nextLink] = this;
>+  }).prototype = _DoubleLinkedQueueSentinel.prototype;
>+  dart.addTypeTests(_DoubleLinkedQueueSentinel);
>+  _DoubleLinkedQueueSentinel.prototype[_is__DoubleLinkedQueueSentinel_default] = true;
>+  dart.setMethodSignature(_DoubleLinkedQueueSentinel, () => ({
>+    __proto__: dart.getMethods(_DoubleLinkedQueueSentinel.__proto__),
>+    [_asNonSentinelEntry]: dart.fnType(collection.DoubleLinkedQueueEntry$(E), []),
>+    [_remove]: dart.fnType(E, [])
>+  }));
>+  dart.setLibraryUri(_DoubleLinkedQueueSentinel, "dart:collection");
>+  return _DoubleLinkedQueueSentinel;
>+});
>+collection._DoubleLinkedQueueSentinel = collection._DoubleLinkedQueueSentinel$();
>+dart.addTypeTests(collection._DoubleLinkedQueueSentinel, _is__DoubleLinkedQueueSentinel_default);
>+const _sentinel = dart.privateName(collection, "_sentinel");
>+const _is_DoubleLinkedQueue_default = Symbol('_is_DoubleLinkedQueue_default');
>+collection.DoubleLinkedQueue$ = dart.generic(E => {
>+  let _DoubleLinkedQueueSentinelOfE = () => (_DoubleLinkedQueueSentinelOfE = dart.constFn(collection._DoubleLinkedQueueSentinel$(E)))();
>+  let DoubleLinkedQueueOfE = () => (DoubleLinkedQueueOfE = dart.constFn(collection.DoubleLinkedQueue$(E)))();
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  let _DoubleLinkedQueueEntryOfE = () => (_DoubleLinkedQueueEntryOfE = dart.constFn(collection._DoubleLinkedQueueEntry$(E)))();
>+  let _DoubleLinkedQueueElementOfE = () => (_DoubleLinkedQueueElementOfE = dart.constFn(collection._DoubleLinkedQueueElement$(E)))();
>+  let _DoubleLinkedQueueIteratorOfE = () => (_DoubleLinkedQueueIteratorOfE = dart.constFn(collection._DoubleLinkedQueueIterator$(E)))();
>+  let QueueOfE = () => (QueueOfE = dart.constFn(collection.Queue$(E)))();
>+  class DoubleLinkedQueue extends core.Iterable$(E) {
>+    static from(elements) {
>+      let list = new (DoubleLinkedQueueOfE()).new();
>+      for (let e of elements) {
>+        list.addLast(E._check(e));
>+      }
>+      return DoubleLinkedQueueOfE()._check(list);
>+    }
>+    static of(elements) {
>+      let _ = new (DoubleLinkedQueueOfE()).new();
>+      _.addAll(elements);
>+      return _;
>+    }
>+    cast(R) {
>+      return collection.Queue.castFrom(E, R, this);
>+    }
>+    get length() {
>+      return this[_elementCount];
>+    }
>+    addLast(value) {
>+      E._check(value);
>+      this[_sentinel][_prepend](value);
>+      this[_elementCount] = dart.notNull(this[_elementCount]) + 1;
>+    }
>+    addFirst(value) {
>+      E._check(value);
>+      this[_sentinel][_append](value);
>+      this[_elementCount] = dart.notNull(this[_elementCount]) + 1;
>+    }
>+    add(value) {
>+      E._check(value);
>+      this[_sentinel][_prepend](value);
>+      this[_elementCount] = dart.notNull(this[_elementCount]) + 1;
>+    }
>+    addAll(iterable) {
>+      IterableOfE()._check(iterable);
>+      for (let value of iterable) {
>+        this[_sentinel][_prepend](value);
>+        this[_elementCount] = dart.notNull(this[_elementCount]) + 1;
>+      }
>+    }
>+    removeLast() {
>+      let lastEntry = _DoubleLinkedQueueEntryOfE()._check(this[_sentinel][_previousLink]);
>+      let result = lastEntry[_remove]();
>+      this[_elementCount] = dart.notNull(this[_elementCount]) - 1;
>+      return result;
>+    }
>+    removeFirst() {
>+      let firstEntry = _DoubleLinkedQueueEntryOfE()._check(this[_sentinel][_nextLink]);
>+      let result = firstEntry[_remove]();
>+      this[_elementCount] = dart.notNull(this[_elementCount]) - 1;
>+      return result;
>+    }
>+    remove(o) {
>+      let entry = _DoubleLinkedQueueEntryOfE()._check(this[_sentinel][_nextLink]);
>+      while (!(entry == this[_sentinel])) {
>+        let equals = dart.equals(entry[_element], o);
>+        if (!(this === entry[_queue])) {
>+          dart.throw(new core.ConcurrentModificationError.new(this));
>+        }
>+        if (equals) {
>+          entry[_remove]();
>+          this[_elementCount] = dart.notNull(this[_elementCount]) - 1;
>+          return true;
>+        }
>+        entry = _DoubleLinkedQueueEntryOfE()._check(entry[_nextLink]);
>+      }
>+      return false;
>+    }
>+    [_filter](test, removeMatching) {
>+      let entry = _DoubleLinkedQueueEntryOfE()._check(this[_sentinel][_nextLink]);
>+      while (!(entry == this[_sentinel])) {
>+        let matches = test(entry[_element]);
>+        if (!(this === entry[_queue])) {
>+          dart.throw(new core.ConcurrentModificationError.new(this));
>+        }
>+        let next = _DoubleLinkedQueueEntryOfE()._check(entry[_nextLink]);
>+        if (removeMatching == matches) {
>+          entry[_remove]();
>+          this[_elementCount] = dart.notNull(this[_elementCount]) - 1;
>+        }
>+        entry = next;
>+      }
>+    }
>+    removeWhere(test) {
>+      this[_filter](test, true);
>+    }
>+    retainWhere(test) {
>+      this[_filter](test, false);
>+    }
>+    get first() {
>+      let firstEntry = _DoubleLinkedQueueEntryOfE()._check(this[_sentinel][_nextLink]);
>+      return firstEntry[_element];
>+    }
>+    get last() {
>+      let lastEntry = _DoubleLinkedQueueEntryOfE()._check(this[_sentinel][_previousLink]);
>+      return lastEntry[_element];
>+    }
>+    get single() {
>+      if (this[_sentinel][_nextLink] == this[_sentinel][_previousLink]) {
>+        let entry = _DoubleLinkedQueueEntryOfE()._check(this[_sentinel][_nextLink]);
>+        return entry[_element];
>+      }
>+      dart.throw(_internal.IterableElementError.tooMany());
>+    }
>+    firstEntry() {
>+      return this[_sentinel].nextEntry();
>+    }
>+    lastEntry() {
>+      return this[_sentinel].previousEntry();
>+    }
>+    get isEmpty() {
>+      return this[_sentinel][_nextLink] == this[_sentinel];
>+    }
>+    clear() {
>+      this[_sentinel][_nextLink] = this[_sentinel];
>+      this[_sentinel][_previousLink] = this[_sentinel];
>+      this[_elementCount] = 0;
>+    }
>+    forEachEntry(action) {
>+      let entry = _DoubleLinkedQueueEntryOfE()._check(this[_sentinel][_nextLink]);
>+      while (!(entry == this[_sentinel])) {
>+        let element = _DoubleLinkedQueueElementOfE()._check(entry);
>+        let next = _DoubleLinkedQueueEntryOfE()._check(element[_nextLink]);
>+        action(element);
>+        if (this === entry[_queue]) {
>+          next = _DoubleLinkedQueueEntryOfE()._check(entry[_nextLink]);
>+        } else if (!(this === next[_queue])) {
>+          dart.throw(new core.ConcurrentModificationError.new(this));
>+        }
>+        entry = next;
>+      }
>+    }
>+    get iterator() {
>+      return new (_DoubleLinkedQueueIteratorOfE()).new(this[_sentinel]);
>+    }
>+    toString() {
>+      return collection.IterableBase.iterableToFullString(this, "{", "}");
>+    }
>+  }
>+  (DoubleLinkedQueue.new = function() {
>+    this[_sentinel] = null;
>+    this[_elementCount] = 0;
>+    DoubleLinkedQueue.__proto__.new.call(this);
>+    this[_sentinel] = new (_DoubleLinkedQueueSentinelOfE()).new(this);
>+  }).prototype = DoubleLinkedQueue.prototype;
>+  dart.addTypeTests(DoubleLinkedQueue);
>+  DoubleLinkedQueue.prototype[_is_DoubleLinkedQueue_default] = true;
>+  DoubleLinkedQueue[dart.implements] = () => [QueueOfE()];
>+  dart.setMethodSignature(DoubleLinkedQueue, () => ({
>+    __proto__: dart.getMethods(DoubleLinkedQueue.__proto__),
>+    cast: dart.gFnType(R => [collection.Queue$(R), []]),
>+    [$cast]: dart.gFnType(R => [collection.Queue$(R), []]),
>+    addLast: dart.fnType(dart.void, [core.Object]),
>+    addFirst: dart.fnType(dart.void, [core.Object]),
>+    add: dart.fnType(dart.void, [core.Object]),
>+    addAll: dart.fnType(dart.void, [core.Object]),
>+    removeLast: dart.fnType(E, []),
>+    removeFirst: dart.fnType(E, []),
>+    remove: dart.fnType(core.bool, [core.Object]),
>+    [_filter]: dart.fnType(dart.void, [dart.fnType(core.bool, [E]), core.bool]),
>+    removeWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [E])]),
>+    retainWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [E])]),
>+    firstEntry: dart.fnType(collection.DoubleLinkedQueueEntry$(E), []),
>+    lastEntry: dart.fnType(collection.DoubleLinkedQueueEntry$(E), []),
>+    clear: dart.fnType(dart.void, []),
>+    forEachEntry: dart.fnType(dart.void, [dart.fnType(dart.void, [collection.DoubleLinkedQueueEntry$(E)])])
>+  }));
>+  dart.setGetterSignature(DoubleLinkedQueue, () => ({
>+    __proto__: dart.getGetters(DoubleLinkedQueue.__proto__),
>+    iterator: collection._DoubleLinkedQueueIterator$(E),
>+    [$iterator]: collection._DoubleLinkedQueueIterator$(E)
>+  }));
>+  dart.setLibraryUri(DoubleLinkedQueue, "dart:collection");
>+  dart.setFieldSignature(DoubleLinkedQueue, () => ({
>+    __proto__: dart.getFields(DoubleLinkedQueue.__proto__),
>+    [_sentinel]: dart.fieldType(_DoubleLinkedQueueSentinelOfE()),
>+    [_elementCount]: dart.fieldType(core.int)
>+  }));
>+  dart.defineExtensionMethods(DoubleLinkedQueue, ['cast', 'toString']);
>+  dart.defineExtensionAccessors(DoubleLinkedQueue, [
>+    'length',
>+    'first',
>+    'last',
>+    'single',
>+    'isEmpty',
>+    'iterator'
>+  ]);
>+  return DoubleLinkedQueue;
>+});
>+collection.DoubleLinkedQueue = collection.DoubleLinkedQueue$();
>+dart.addTypeTests(collection.DoubleLinkedQueue, _is_DoubleLinkedQueue_default);
>+const _nextEntry = dart.privateName(collection, "_nextEntry");
>+const _is__DoubleLinkedQueueIterator_default = Symbol('_is__DoubleLinkedQueueIterator_default');
>+collection._DoubleLinkedQueueIterator$ = dart.generic(E => {
>+  let _DoubleLinkedQueueEntryOfE = () => (_DoubleLinkedQueueEntryOfE = dart.constFn(collection._DoubleLinkedQueueEntry$(E)))();
>+  let _DoubleLinkedQueueElementOfE = () => (_DoubleLinkedQueueElementOfE = dart.constFn(collection._DoubleLinkedQueueElement$(E)))();
>+  let IteratorOfE = () => (IteratorOfE = dart.constFn(core.Iterator$(E)))();
>+  let _DoubleLinkedQueueSentinelOfE = () => (_DoubleLinkedQueueSentinelOfE = dart.constFn(collection._DoubleLinkedQueueSentinel$(E)))();
>+  class _DoubleLinkedQueueIterator extends core.Object {
>+    moveNext() {
>+      if (this[_nextEntry] == this[_sentinel]) {
>+        this[_current$1] = null;
>+        this[_nextEntry] = null;
>+        this[_sentinel] = null;
>+        return false;
>+      }
>+      let elementEntry = _DoubleLinkedQueueElementOfE()._check(this[_nextEntry]);
>+      if (!(this[_sentinel][_queue] == elementEntry[_queue])) {
>+        dart.throw(new core.ConcurrentModificationError.new(this[_sentinel][_queue]));
>+      }
>+      this[_current$1] = elementEntry[_element];
>+      this[_nextEntry] = _DoubleLinkedQueueEntryOfE()._check(elementEntry[_nextLink]);
>+      return true;
>+    }
>+    get current() {
>+      return this[_current$1];
>+    }
>+  }
>+  (_DoubleLinkedQueueIterator.new = function(sentinel) {
>+    this[_current$1] = null;
>+    this[_sentinel] = sentinel;
>+    this[_nextEntry] = _DoubleLinkedQueueEntryOfE()._check(sentinel[_nextLink]);
>+  }).prototype = _DoubleLinkedQueueIterator.prototype;
>+  dart.addTypeTests(_DoubleLinkedQueueIterator);
>+  _DoubleLinkedQueueIterator.prototype[_is__DoubleLinkedQueueIterator_default] = true;
>+  _DoubleLinkedQueueIterator[dart.implements] = () => [IteratorOfE()];
>+  dart.setMethodSignature(_DoubleLinkedQueueIterator, () => ({
>+    __proto__: dart.getMethods(_DoubleLinkedQueueIterator.__proto__),
>+    moveNext: dart.fnType(core.bool, [])
>+  }));
>+  dart.setGetterSignature(_DoubleLinkedQueueIterator, () => ({
>+    __proto__: dart.getGetters(_DoubleLinkedQueueIterator.__proto__),
>+    current: E
>+  }));
>+  dart.setLibraryUri(_DoubleLinkedQueueIterator, "dart:collection");
>+  dart.setFieldSignature(_DoubleLinkedQueueIterator, () => ({
>+    __proto__: dart.getFields(_DoubleLinkedQueueIterator.__proto__),
>+    [_sentinel]: dart.fieldType(_DoubleLinkedQueueSentinelOfE()),
>+    [_nextEntry]: dart.fieldType(_DoubleLinkedQueueEntryOfE()),
>+    [_current$1]: dart.fieldType(E)
>+  }));
>+  return _DoubleLinkedQueueIterator;
>+});
>+collection._DoubleLinkedQueueIterator = collection._DoubleLinkedQueueIterator$();
>+dart.addTypeTests(collection._DoubleLinkedQueueIterator, _is__DoubleLinkedQueueIterator_default);
>+const _head = dart.privateName(collection, "_head");
>+const _tail = dart.privateName(collection, "_tail");
>+const _table = dart.privateName(collection, "_table");
>+const _checkModification = dart.privateName(collection, "_checkModification");
>+const _writeToList = dart.privateName(collection, "_writeToList");
>+const _add$ = dart.privateName(collection, "_add");
>+const _preGrow = dart.privateName(collection, "_preGrow");
>+const _filterWhere = dart.privateName(collection, "_filterWhere");
>+const _grow = dart.privateName(collection, "_grow");
>+const _is_ListQueue_default = Symbol('_is_ListQueue_default');
>+collection.ListQueue$ = dart.generic(E => {
>+  let ListOfE = () => (ListOfE = dart.constFn(core.List$(E)))();
>+  let ListQueueOfE = () => (ListQueueOfE = dart.constFn(collection.ListQueue$(E)))();
>+  let _ListQueueIteratorOfE = () => (_ListQueueIteratorOfE = dart.constFn(collection._ListQueueIterator$(E)))();
>+  let JSArrayOfE = () => (JSArrayOfE = dart.constFn(_interceptors.JSArray$(E)))();
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  let QueueOfE = () => (QueueOfE = dart.constFn(collection.Queue$(E)))();
>+  class ListQueue extends _internal.ListIterable$(E) {
>+    static from(elements) {
>+      if (core.List.is(elements)) {
>+        let length = elements[$length];
>+        let queue = new (ListQueueOfE()).new(dart.notNull(length) + 1);
>+        if (!(dart.notNull(queue[_table][$length]) > dart.notNull(length))) dart.assertFailed(null, "dart:collection/queue.dart", 549, 14, "queue._table.length > length");
>+        for (let i = 0; i < dart.notNull(length); i++) {
>+          queue[_table][$_set](i, E._check(elements[$_get](i)));
>+        }
>+        queue[_tail] = length;
>+        return queue;
>+      } else {
>+        let capacity = 8;
>+        if (_internal.EfficientLengthIterable.is(elements)) {
>+          capacity = elements[$length];
>+        }
>+        let result = new (ListQueueOfE()).new(capacity);
>+        for (let element of elements) {
>+          result.addLast(E._check(element));
>+        }
>+        return result;
>+      }
>+    }
>+    static of(elements) {
>+      let _ = new (ListQueueOfE()).new();
>+      _.addAll(elements);
>+      return _;
>+    }
>+    cast(R) {
>+      return collection.Queue.castFrom(E, R, this);
>+    }
>+    get iterator() {
>+      return new (_ListQueueIteratorOfE()).new(this);
>+    }
>+    forEach(f) {
>+      let modificationCount = this[_modificationCount];
>+      for (let i = this[_head]; i != this[_tail]; i = (dart.notNull(i) + 1 & dart.notNull(this[_table][$length]) - 1) >>> 0) {
>+        f(this[_table][$_get](i));
>+        this[_checkModification](modificationCount);
>+      }
>+    }
>+    get isEmpty() {
>+      return this[_head] == this[_tail];
>+    }
>+    get length() {
>+      return (dart.notNull(this[_tail]) - dart.notNull(this[_head]) & dart.notNull(this[_table][$length]) - 1) >>> 0;
>+    }
>+    get first() {
>+      if (this[_head] == this[_tail]) dart.throw(_internal.IterableElementError.noElement());
>+      return this[_table][$_get](this[_head]);
>+    }
>+    get last() {
>+      if (this[_head] == this[_tail]) dart.throw(_internal.IterableElementError.noElement());
>+      return this[_table][$_get]((dart.notNull(this[_tail]) - 1 & dart.notNull(this[_table][$length]) - 1) >>> 0);
>+    }
>+    get single() {
>+      if (this[_head] == this[_tail]) dart.throw(_internal.IterableElementError.noElement());
>+      if (dart.notNull(this.length) > 1) dart.throw(_internal.IterableElementError.tooMany());
>+      return this[_table][$_get](this[_head]);
>+    }
>+    elementAt(index) {
>+      core.RangeError.checkValidIndex(index, this);
>+      return this[_table][$_get]((dart.notNull(this[_head]) + dart.notNull(index) & dart.notNull(this[_table][$length]) - 1) >>> 0);
>+    }
>+    toList(opts) {
>+      let growable = opts && 'growable' in opts ? opts.growable : true;
>+      let list = null;
>+      if (dart.test(growable)) {
>+        list = JSArrayOfE().of([]);
>+        list[$length] = this.length;
>+      } else {
>+        list = ListOfE().new(this.length);
>+      }
>+      this[_writeToList](list);
>+      return list;
>+    }
>+    add(value) {
>+      E._check(value);
>+      this[_add$](value);
>+    }
>+    addAll(elements) {
>+      IterableOfE()._check(elements);
>+      if (ListOfE().is(elements)) {
>+        let list = elements;
>+        let addCount = list[$length];
>+        let length = this.length;
>+        if (dart.notNull(length) + dart.notNull(addCount) >= dart.notNull(this[_table][$length])) {
>+          this[_preGrow](dart.notNull(length) + dart.notNull(addCount));
>+          this[_table][$setRange](length, dart.notNull(length) + dart.notNull(addCount), list, 0);
>+          this[_tail] = dart.notNull(this[_tail]) + dart.notNull(addCount);
>+        } else {
>+          let endSpace = dart.notNull(this[_table][$length]) - dart.notNull(this[_tail]);
>+          if (dart.notNull(addCount) < endSpace) {
>+            this[_table][$setRange](this[_tail], dart.notNull(this[_tail]) + dart.notNull(addCount), list, 0);
>+            this[_tail] = dart.notNull(this[_tail]) + dart.notNull(addCount);
>+          } else {
>+            let preSpace = dart.notNull(addCount) - endSpace;
>+            this[_table][$setRange](this[_tail], dart.notNull(this[_tail]) + endSpace, list, 0);
>+            this[_table][$setRange](0, preSpace, list, endSpace);
>+            this[_tail] = preSpace;
>+          }
>+        }
>+        this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
>+      } else {
>+        for (let element of elements)
>+          this[_add$](element);
>+      }
>+    }
>+    remove(value) {
>+      for (let i = this[_head]; i != this[_tail]; i = (dart.notNull(i) + 1 & dart.notNull(this[_table][$length]) - 1) >>> 0) {
>+        let element = this[_table][$_get](i);
>+        if (dart.equals(element, value)) {
>+          this[_remove](i);
>+          this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
>+          return true;
>+        }
>+      }
>+      return false;
>+    }
>+    [_filterWhere](test, removeMatching) {
>+      let modificationCount = this[_modificationCount];
>+      let i = this[_head];
>+      while (i != this[_tail]) {
>+        let element = this[_table][$_get](i);
>+        let remove = removeMatching == test(element);
>+        this[_checkModification](modificationCount);
>+        if (remove) {
>+          i = this[_remove](i);
>+          modificationCount = this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
>+        } else {
>+          i = (dart.notNull(i) + 1 & dart.notNull(this[_table][$length]) - 1) >>> 0;
>+        }
>+      }
>+    }
>+    removeWhere(test) {
>+      this[_filterWhere](test, true);
>+    }
>+    retainWhere(test) {
>+      this[_filterWhere](test, false);
>+    }
>+    clear() {
>+      if (this[_head] != this[_tail]) {
>+        for (let i = this[_head]; i != this[_tail]; i = (dart.notNull(i) + 1 & dart.notNull(this[_table][$length]) - 1) >>> 0) {
>+          this[_table][$_set](i, null);
>+        }
>+        this[_head] = this[_tail] = 0;
>+        this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
>+      }
>+    }
>+    toString() {
>+      return collection.IterableBase.iterableToFullString(this, "{", "}");
>+    }
>+    addLast(value) {
>+      E._check(value);
>+      this[_add$](value);
>+    }
>+    addFirst(value) {
>+      E._check(value);
>+      this[_head] = (dart.notNull(this[_head]) - 1 & dart.notNull(this[_table][$length]) - 1) >>> 0;
>+      this[_table][$_set](this[_head], value);
>+      if (this[_head] == this[_tail]) this[_grow]();
>+      this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
>+    }
>+    removeFirst() {
>+      if (this[_head] == this[_tail]) dart.throw(_internal.IterableElementError.noElement());
>+      this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
>+      let result = this[_table][$_get](this[_head]);
>+      this[_table][$_set](this[_head], null);
>+      this[_head] = (dart.notNull(this[_head]) + 1 & dart.notNull(this[_table][$length]) - 1) >>> 0;
>+      return result;
>+    }
>+    removeLast() {
>+      if (this[_head] == this[_tail]) dart.throw(_internal.IterableElementError.noElement());
>+      this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
>+      this[_tail] = (dart.notNull(this[_tail]) - 1 & dart.notNull(this[_table][$length]) - 1) >>> 0;
>+      let result = this[_table][$_get](this[_tail]);
>+      this[_table][$_set](this[_tail], null);
>+      return result;
>+    }
>+    static _isPowerOf2(number) {
>+      return (dart.notNull(number) & dart.notNull(number) - 1) === 0;
>+    }
>+    static _nextPowerOf2(number) {
>+      if (!(dart.notNull(number) > 0)) dart.assertFailed(null, "dart:collection/queue.dart", 759, 12, "number > 0");
>+      number = (dart.notNull(number) << 1 >>> 0) - 1;
>+      for (;;) {
>+        let nextNumber = (dart.notNull(number) & dart.notNull(number) - 1) >>> 0;
>+        if (nextNumber === 0) return number;
>+        number = nextNumber;
>+      }
>+    }
>+    [_checkModification](expectedModificationCount) {
>+      if (expectedModificationCount != this[_modificationCount]) {
>+        dart.throw(new core.ConcurrentModificationError.new(this));
>+      }
>+    }
>+    [_add$](element) {
>+      E._check(element);
>+      this[_table][$_set](this[_tail], element);
>+      this[_tail] = (dart.notNull(this[_tail]) + 1 & dart.notNull(this[_table][$length]) - 1) >>> 0;
>+      if (this[_head] == this[_tail]) this[_grow]();
>+      this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
>+    }
>+    [_remove](offset) {
>+      let mask = dart.notNull(this[_table][$length]) - 1;
>+      let startDistance = (dart.notNull(offset) - dart.notNull(this[_head]) & mask) >>> 0;
>+      let endDistance = (dart.notNull(this[_tail]) - dart.notNull(offset) & mask) >>> 0;
>+      if (startDistance < endDistance) {
>+        let i = offset;
>+        while (i != this[_head]) {
>+          let prevOffset = (dart.notNull(i) - 1 & mask) >>> 0;
>+          this[_table][$_set](i, this[_table][$_get](prevOffset));
>+          i = prevOffset;
>+        }
>+        this[_table][$_set](this[_head], null);
>+        this[_head] = (dart.notNull(this[_head]) + 1 & mask) >>> 0;
>+        return (dart.notNull(offset) + 1 & mask) >>> 0;
>+      } else {
>+        this[_tail] = (dart.notNull(this[_tail]) - 1 & mask) >>> 0;
>+        let i = offset;
>+        while (i != this[_tail]) {
>+          let nextOffset = (dart.notNull(i) + 1 & mask) >>> 0;
>+          this[_table][$_set](i, this[_table][$_get](nextOffset));
>+          i = nextOffset;
>+        }
>+        this[_table][$_set](this[_tail], null);
>+        return offset;
>+      }
>+    }
>+    [_grow]() {
>+      let newTable = ListOfE().new(dart.notNull(this[_table][$length]) * 2);
>+      let split = dart.notNull(this[_table][$length]) - dart.notNull(this[_head]);
>+      newTable[$setRange](0, split, this[_table], this[_head]);
>+      newTable[$setRange](split, split + dart.notNull(this[_head]), this[_table], 0);
>+      this[_head] = 0;
>+      this[_tail] = this[_table][$length];
>+      this[_table] = newTable;
>+    }
>+    [_writeToList](target) {
>+      ListOfE()._check(target);
>+      if (!(dart.notNull(target[$length]) >= dart.notNull(this.length))) dart.assertFailed(null, "dart:collection/queue.dart", 831, 12, "target.length >= length");
>+      if (dart.notNull(this[_head]) <= dart.notNull(this[_tail])) {
>+        let length = dart.notNull(this[_tail]) - dart.notNull(this[_head]);
>+        target[$setRange](0, length, this[_table], this[_head]);
>+        return length;
>+      } else {
>+        let firstPartSize = dart.notNull(this[_table][$length]) - dart.notNull(this[_head]);
>+        target[$setRange](0, firstPartSize, this[_table], this[_head]);
>+        target[$setRange](firstPartSize, firstPartSize + dart.notNull(this[_tail]), this[_table], 0);
>+        return dart.notNull(this[_tail]) + firstPartSize;
>+      }
>+    }
>+    [_preGrow](newElementCount) {
>+      if (!(dart.notNull(newElementCount) >= dart.notNull(this.length))) dart.assertFailed(null, "dart:collection/queue.dart", 846, 12, "newElementCount >= length");
>+      newElementCount = dart.notNull(newElementCount) + newElementCount[$rightShift](1);
>+      let newCapacity = collection.ListQueue._nextPowerOf2(newElementCount);
>+      let newTable = ListOfE().new(newCapacity);
>+      this[_tail] = this[_writeToList](newTable);
>+      this[_table] = newTable;
>+      this[_head] = 0;
>+    }
>+  }
>+  (ListQueue.new = function(initialCapacity) {
>+    if (initialCapacity === void 0) initialCapacity = null;
>+    this[_table] = null;
>+    this[_modificationCount] = 0;
>+    this[_head] = 0;
>+    this[_tail] = 0;
>+    ListQueue.__proto__.new.call(this);
>+    if (initialCapacity == null || dart.notNull(initialCapacity) < 8) {
>+      initialCapacity = 8;
>+    } else if (!dart.test(collection.ListQueue._isPowerOf2(initialCapacity))) {
>+      initialCapacity = collection.ListQueue._nextPowerOf2(initialCapacity);
>+    }
>+    if (!dart.test(collection.ListQueue._isPowerOf2(initialCapacity))) dart.assertFailed(null, "dart:collection/queue.dart", 528, 12, "_isPowerOf2(initialCapacity)");
>+    this[_table] = ListOfE().new(initialCapacity);
>+  }).prototype = ListQueue.prototype;
>+  dart.addTypeTests(ListQueue);
>+  ListQueue.prototype[_is_ListQueue_default] = true;
>+  ListQueue[dart.implements] = () => [QueueOfE()];
>+  dart.setMethodSignature(ListQueue, () => ({
>+    __proto__: dart.getMethods(ListQueue.__proto__),
>+    cast: dart.gFnType(R => [collection.Queue$(R), []]),
>+    [$cast]: dart.gFnType(R => [collection.Queue$(R), []]),
>+    elementAt: dart.fnType(E, [core.int]),
>+    [$elementAt]: dart.fnType(E, [core.int]),
>+    add: dart.fnType(dart.void, [core.Object]),
>+    addAll: dart.fnType(dart.void, [core.Object]),
>+    remove: dart.fnType(core.bool, [core.Object]),
>+    [_filterWhere]: dart.fnType(dart.void, [dart.fnType(core.bool, [E]), core.bool]),
>+    removeWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [E])]),
>+    retainWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [E])]),
>+    clear: dart.fnType(dart.void, []),
>+    addLast: dart.fnType(dart.void, [core.Object]),
>+    addFirst: dart.fnType(dart.void, [core.Object]),
>+    removeFirst: dart.fnType(E, []),
>+    removeLast: dart.fnType(E, []),
>+    [_checkModification]: dart.fnType(dart.void, [core.int]),
>+    [_add$]: dart.fnType(dart.void, [core.Object]),
>+    [_remove]: dart.fnType(core.int, [core.int]),
>+    [_grow]: dart.fnType(dart.void, []),
>+    [_writeToList]: dart.fnType(core.int, [core.Object]),
>+    [_preGrow]: dart.fnType(dart.void, [core.int])
>+  }));
>+  dart.setGetterSignature(ListQueue, () => ({
>+    __proto__: dart.getGetters(ListQueue.__proto__),
>+    length: core.int,
>+    [$length]: core.int
>+  }));
>+  dart.setLibraryUri(ListQueue, "dart:collection");
>+  dart.setFieldSignature(ListQueue, () => ({
>+    __proto__: dart.getFields(ListQueue.__proto__),
>+    [_table]: dart.fieldType(ListOfE()),
>+    [_head]: dart.fieldType(core.int),
>+    [_tail]: dart.fieldType(core.int),
>+    [_modificationCount]: dart.fieldType(core.int)
>+  }));
>+  dart.defineExtensionMethods(ListQueue, [
>+    'cast',
>+    'forEach',
>+    'elementAt',
>+    'toList',
>+    'toString'
>+  ]);
>+  dart.defineExtensionAccessors(ListQueue, [
>+    'iterator',
>+    'isEmpty',
>+    'length',
>+    'first',
>+    'last',
>+    'single'
>+  ]);
>+  return ListQueue;
>+});
>+collection.ListQueue = collection.ListQueue$();
>+dart.defineLazy(collection.ListQueue, {
>+  /*collection.ListQueue._INITIAL_CAPACITY*/get _INITIAL_CAPACITY() {
>+    return 8;
>+  }
>+});
>+dart.addTypeTests(collection.ListQueue, _is_ListQueue_default);
>+const _end = dart.privateName(collection, "_end");
>+const _position = dart.privateName(collection, "_position");
>+const _is__ListQueueIterator_default = Symbol('_is__ListQueueIterator_default');
>+collection._ListQueueIterator$ = dart.generic(E => {
>+  let IteratorOfE = () => (IteratorOfE = dart.constFn(core.Iterator$(E)))();
>+  let ListQueueOfE = () => (ListQueueOfE = dart.constFn(collection.ListQueue$(E)))();
>+  class _ListQueueIterator extends core.Object {
>+    get current() {
>+      return this[_current$1];
>+    }
>+    moveNext() {
>+      this[_queue][_checkModification](this[_modificationCount]);
>+      if (this[_position] == this[_end]) {
>+        this[_current$1] = null;
>+        return false;
>+      }
>+      this[_current$1] = this[_queue][_table][$_get](this[_position]);
>+      this[_position] = (dart.notNull(this[_position]) + 1 & dart.notNull(this[_queue][_table][$length]) - 1) >>> 0;
>+      return true;
>+    }
>+  }
>+  (_ListQueueIterator.new = function(queue) {
>+    this[_current$1] = null;
>+    this[_queue] = queue;
>+    this[_end] = queue[_tail];
>+    this[_modificationCount] = queue[_modificationCount];
>+    this[_position] = queue[_head];
>+  }).prototype = _ListQueueIterator.prototype;
>+  dart.addTypeTests(_ListQueueIterator);
>+  _ListQueueIterator.prototype[_is__ListQueueIterator_default] = true;
>+  _ListQueueIterator[dart.implements] = () => [IteratorOfE()];
>+  dart.setMethodSignature(_ListQueueIterator, () => ({
>+    __proto__: dart.getMethods(_ListQueueIterator.__proto__),
>+    moveNext: dart.fnType(core.bool, [])
>+  }));
>+  dart.setGetterSignature(_ListQueueIterator, () => ({
>+    __proto__: dart.getGetters(_ListQueueIterator.__proto__),
>+    current: E
>+  }));
>+  dart.setLibraryUri(_ListQueueIterator, "dart:collection");
>+  dart.setFieldSignature(_ListQueueIterator, () => ({
>+    __proto__: dart.getFields(_ListQueueIterator.__proto__),
>+    [_queue]: dart.finalFieldType(ListQueueOfE()),
>+    [_end]: dart.finalFieldType(core.int),
>+    [_modificationCount]: dart.finalFieldType(core.int),
>+    [_position]: dart.fieldType(core.int),
>+    [_current$1]: dart.fieldType(E)
>+  }));
>+  return _ListQueueIterator;
>+});
>+collection._ListQueueIterator = collection._ListQueueIterator$();
>+dart.addTypeTests(collection._ListQueueIterator, _is__ListQueueIterator_default);
>+const _is_SetMixin_default = Symbol('_is_SetMixin_default');
>+collection.SetMixin$ = dart.generic(E => {
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  let FollowedByIterableOfE = () => (FollowedByIterableOfE = dart.constFn(_internal.FollowedByIterable$(E)))();
>+  let SetOfE = () => (SetOfE = dart.constFn(core.Set$(E)))();
>+  let JSArrayOfE = () => (JSArrayOfE = dart.constFn(_interceptors.JSArray$(E)))();
>+  let ListOfE = () => (ListOfE = dart.constFn(core.List$(E)))();
>+  let WhereIterableOfE = () => (WhereIterableOfE = dart.constFn(_internal.WhereIterable$(E)))();
>+  let EAndEToE = () => (EAndEToE = dart.constFn(dart.fnType(E, [E, E])))();
>+  let TakeIterableOfE = () => (TakeIterableOfE = dart.constFn(_internal.TakeIterable$(E)))();
>+  let TakeWhileIterableOfE = () => (TakeWhileIterableOfE = dart.constFn(_internal.TakeWhileIterable$(E)))();
>+  let SkipIterableOfE = () => (SkipIterableOfE = dart.constFn(_internal.SkipIterable$(E)))();
>+  let SkipWhileIterableOfE = () => (SkipWhileIterableOfE = dart.constFn(_internal.SkipWhileIterable$(E)))();
>+  let VoidToE = () => (VoidToE = dart.constFn(dart.fnType(E, [])))();
>+  class SetMixin extends core.Object {
>+    [Symbol.iterator]() {
>+      return new dart.JsIterator(this.iterator);
>+    }
>+    get isEmpty() {
>+      return this.length === 0;
>+    }
>+    get isNotEmpty() {
>+      return this.length !== 0;
>+    }
>+    cast(R) {
>+      return core.Set.castFrom(E, R, this);
>+    }
>+    followedBy(other) {
>+      IterableOfE()._check(other);
>+      return FollowedByIterableOfE().firstEfficient(this, other);
>+    }
>+    whereType(T) {
>+      return new (_internal.WhereTypeIterable$(T)).new(this);
>+    }
>+    clear() {
>+      this.removeAll(this.toList());
>+    }
>+    addAll(elements) {
>+      IterableOfE()._check(elements);
>+      for (let element of elements)
>+        this.add(element);
>+    }
>+    removeAll(elements) {
>+      for (let element of elements)
>+        this.remove(element);
>+    }
>+    retainAll(elements) {
>+      let toRemove = this.toSet();
>+      for (let o of elements) {
>+        toRemove.remove(o);
>+      }
>+      this.removeAll(toRemove);
>+    }
>+    removeWhere(test) {
>+      let toRemove = [];
>+      for (let element of this) {
>+        if (dart.test(test(element))) toRemove[$add](element);
>+      }
>+      this.removeAll(toRemove);
>+    }
>+    retainWhere(test) {
>+      let toRemove = [];
>+      for (let element of this) {
>+        if (!dart.test(test(element))) toRemove[$add](element);
>+      }
>+      this.removeAll(toRemove);
>+    }
>+    containsAll(other) {
>+      for (let o of other) {
>+        if (!dart.test(this.contains(o))) return false;
>+      }
>+      return true;
>+    }
>+    union(other) {
>+      SetOfE()._check(other);
>+      let _ = this.toSet();
>+      _.addAll(other);
>+      return _;
>+    }
>+    intersection(other) {
>+      let result = this.toSet();
>+      for (let element of this) {
>+        if (!dart.test(other.contains(element))) result.remove(element);
>+      }
>+      return result;
>+    }
>+    difference(other) {
>+      let result = this.toSet();
>+      for (let element of this) {
>+        if (dart.test(other.contains(element))) result.remove(element);
>+      }
>+      return result;
>+    }
>+    toList(opts) {
>+      let growable = opts && 'growable' in opts ? opts.growable : true;
>+      let result = dart.test(growable) ? (() => {
>+        let _ = JSArrayOfE().of([]);
>+        _[$length] = this.length;
>+        return _;
>+      })() : ListOfE().new(this.length);
>+      let i = 0;
>+      for (let element of this)
>+        result[$_set](i++, element);
>+      return result;
>+    }
>+    map(T, f) {
>+      return new (_internal.EfficientLengthMappedIterable$(E, T)).new(this, f);
>+    }
>+    get single() {
>+      if (dart.notNull(this.length) > 1) dart.throw(_internal.IterableElementError.tooMany());
>+      let it = this.iterator;
>+      if (!dart.test(it.moveNext())) dart.throw(_internal.IterableElementError.noElement());
>+      let result = it.current;
>+      return result;
>+    }
>+    toString() {
>+      return collection.IterableBase.iterableToFullString(this, "{", "}");
>+    }
>+    where(f) {
>+      return new (WhereIterableOfE()).new(this, f);
>+    }
>+    expand(T, f) {
>+      return new (_internal.ExpandIterable$(E, T)).new(this, f);
>+    }
>+    forEach(f) {
>+      for (let element of this)
>+        f(element);
>+    }
>+    reduce(combine) {
>+      EAndEToE()._check(combine);
>+      let iterator = this.iterator;
>+      if (!dart.test(iterator.moveNext())) {
>+        dart.throw(_internal.IterableElementError.noElement());
>+      }
>+      let value = iterator.current;
>+      while (dart.test(iterator.moveNext())) {
>+        value = combine(value, iterator.current);
>+      }
>+      return value;
>+    }
>+    fold(T, initialValue, combine) {
>+      let value = initialValue;
>+      for (let element of this)
>+        value = combine(value, element);
>+      return value;
>+    }
>+    every(f) {
>+      for (let element of this) {
>+        if (!dart.test(f(element))) return false;
>+      }
>+      return true;
>+    }
>+    join(separator) {
>+      if (separator === void 0) separator = "";
>+      let iterator = this.iterator;
>+      if (!dart.test(iterator.moveNext())) return "";
>+      let buffer = new core.StringBuffer.new();
>+      if (separator == null || separator === "") {
>+        do {
>+          buffer.write(iterator.current);
>+        } while (dart.test(iterator.moveNext()));
>+      } else {
>+        buffer.write(iterator.current);
>+        while (dart.test(iterator.moveNext())) {
>+          buffer.write(separator);
>+          buffer.write(iterator.current);
>+        }
>+      }
>+      return buffer.toString();
>+    }
>+    any(test) {
>+      for (let element of this) {
>+        if (dart.test(test(element))) return true;
>+      }
>+      return false;
>+    }
>+    take(n) {
>+      return TakeIterableOfE().new(this, n);
>+    }
>+    takeWhile(test) {
>+      return new (TakeWhileIterableOfE()).new(this, test);
>+    }
>+    skip(n) {
>+      return SkipIterableOfE().new(this, n);
>+    }
>+    skipWhile(test) {
>+      return new (SkipWhileIterableOfE()).new(this, test);
>+    }
>+    get first() {
>+      let it = this.iterator;
>+      if (!dart.test(it.moveNext())) {
>+        dart.throw(_internal.IterableElementError.noElement());
>+      }
>+      return it.current;
>+    }
>+    get last() {
>+      let it = this.iterator;
>+      if (!dart.test(it.moveNext())) {
>+        dart.throw(_internal.IterableElementError.noElement());
>+      }
>+      let result = null;
>+      do {
>+        result = it.current;
>+      } while (dart.test(it.moveNext()));
>+      return result;
>+    }
>+    firstWhere(test, opts) {
>+      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+      VoidToE()._check(orElse);
>+      for (let element of this) {
>+        if (dart.test(test(element))) return element;
>+      }
>+      if (orElse != null) return orElse();
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    lastWhere(test, opts) {
>+      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+      VoidToE()._check(orElse);
>+      let result = null;
>+      let foundMatching = false;
>+      for (let element of this) {
>+        if (dart.test(test(element))) {
>+          result = element;
>+          foundMatching = true;
>+        }
>+      }
>+      if (foundMatching) return result;
>+      if (orElse != null) return orElse();
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    singleWhere(test, opts) {
>+      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+      VoidToE()._check(orElse);
>+      let result = null;
>+      let foundMatching = false;
>+      for (let element of this) {
>+        if (dart.test(test(element))) {
>+          if (foundMatching) {
>+            dart.throw(_internal.IterableElementError.tooMany());
>+          }
>+          result = element;
>+          foundMatching = true;
>+        }
>+      }
>+      if (foundMatching) return result;
>+      if (orElse != null) return orElse();
>+      dart.throw(_internal.IterableElementError.noElement());
>+    }
>+    elementAt(index) {
>+      core.ArgumentError.checkNotNull(index, "index");
>+      core.RangeError.checkNotNegative(index, "index");
>+      let elementIndex = 0;
>+      for (let element of this) {
>+        if (index === elementIndex) return element;
>+        elementIndex++;
>+      }
>+      dart.throw(core.RangeError.index(index, this, "index", null, elementIndex));
>+    }
>+  }
>+  (SetMixin.new = function() {
>+  }).prototype = SetMixin.prototype;
>+  dart.addTypeTests(SetMixin);
>+  SetMixin.prototype[_is_SetMixin_default] = true;
>+  SetMixin[dart.implements] = () => [SetOfE()];
>+  dart.setMethodSignature(SetMixin, () => ({
>+    __proto__: dart.getMethods(SetMixin.__proto__),
>+    cast: dart.gFnType(R => [core.Set$(R), []]),
>+    [$cast]: dart.gFnType(R => [core.Set$(R), []]),
>+    followedBy: dart.fnType(core.Iterable$(E), [core.Object]),
>+    [$followedBy]: dart.fnType(core.Iterable$(E), [core.Object]),
>+    whereType: dart.gFnType(T => [core.Iterable$(T), []]),
>+    [$whereType]: dart.gFnType(T => [core.Iterable$(T), []]),
>+    clear: dart.fnType(dart.void, []),
>+    addAll: dart.fnType(dart.void, [core.Object]),
>+    removeAll: dart.fnType(dart.void, [core.Iterable$(core.Object)]),
>+    retainAll: dart.fnType(dart.void, [core.Iterable$(core.Object)]),
>+    removeWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [E])]),
>+    retainWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [E])]),
>+    containsAll: dart.fnType(core.bool, [core.Iterable$(core.Object)]),
>+    union: dart.fnType(core.Set$(E), [core.Object]),
>+    intersection: dart.fnType(core.Set$(E), [core.Set$(core.Object)]),
>+    difference: dart.fnType(core.Set$(E), [core.Set$(core.Object)]),
>+    toList: dart.fnType(core.List$(E), [], {growable: core.bool}),
>+    [$toList]: dart.fnType(core.List$(E), [], {growable: core.bool}),
>+    map: dart.gFnType(T => [core.Iterable$(T), [dart.fnType(T, [E])]]),
>+    [$map]: dart.gFnType(T => [core.Iterable$(T), [dart.fnType(T, [E])]]),
>+    toString: dart.fnType(core.String, []),
>+    [$toString]: dart.fnType(core.String, []),
>+    where: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    [$where]: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    expand: dart.gFnType(T => [core.Iterable$(T), [dart.fnType(core.Iterable$(T), [E])]]),
>+    [$expand]: dart.gFnType(T => [core.Iterable$(T), [dart.fnType(core.Iterable$(T), [E])]]),
>+    forEach: dart.fnType(dart.void, [dart.fnType(dart.void, [E])]),
>+    [$forEach]: dart.fnType(dart.void, [dart.fnType(dart.void, [E])]),
>+    reduce: dart.fnType(E, [core.Object]),
>+    [$reduce]: dart.fnType(E, [core.Object]),
>+    fold: dart.gFnType(T => [T, [T, dart.fnType(T, [T, E])]]),
>+    [$fold]: dart.gFnType(T => [T, [T, dart.fnType(T, [T, E])]]),
>+    every: dart.fnType(core.bool, [dart.fnType(core.bool, [E])]),
>+    [$every]: dart.fnType(core.bool, [dart.fnType(core.bool, [E])]),
>+    join: dart.fnType(core.String, [], [core.String]),
>+    [$join]: dart.fnType(core.String, [], [core.String]),
>+    any: dart.fnType(core.bool, [dart.fnType(core.bool, [E])]),
>+    [$any]: dart.fnType(core.bool, [dart.fnType(core.bool, [E])]),
>+    take: dart.fnType(core.Iterable$(E), [core.int]),
>+    [$take]: dart.fnType(core.Iterable$(E), [core.int]),
>+    takeWhile: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    [$takeWhile]: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    skip: dart.fnType(core.Iterable$(E), [core.int]),
>+    [$skip]: dart.fnType(core.Iterable$(E), [core.int]),
>+    skipWhile: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    [$skipWhile]: dart.fnType(core.Iterable$(E), [dart.fnType(core.bool, [E])]),
>+    firstWhere: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    [$firstWhere]: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    lastWhere: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    [$lastWhere]: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    singleWhere: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    [$singleWhere]: dart.fnType(E, [dart.fnType(core.bool, [E])], {orElse: core.Object}),
>+    elementAt: dart.fnType(E, [core.int]),
>+    [$elementAt]: dart.fnType(E, [core.int])
>+  }));
>+  dart.setGetterSignature(SetMixin, () => ({
>+    __proto__: dart.getGetters(SetMixin.__proto__),
>+    isEmpty: core.bool,
>+    [$isEmpty]: core.bool,
>+    isNotEmpty: core.bool,
>+    [$isNotEmpty]: core.bool,
>+    single: E,
>+    [$single]: E,
>+    first: E,
>+    [$first]: E,
>+    last: E,
>+    [$last]: E
>+  }));
>+  dart.setLibraryUri(SetMixin, "dart:collection");
>+  dart.defineExtensionMethods(SetMixin, [
>+    'cast',
>+    'followedBy',
>+    'whereType',
>+    'toList',
>+    'map',
>+    'toString',
>+    'where',
>+    'expand',
>+    'forEach',
>+    'reduce',
>+    'fold',
>+    'every',
>+    'join',
>+    'any',
>+    'take',
>+    'takeWhile',
>+    'skip',
>+    'skipWhile',
>+    'firstWhere',
>+    'lastWhere',
>+    'singleWhere',
>+    'elementAt'
>+  ]);
>+  dart.defineExtensionAccessors(SetMixin, [
>+    'isEmpty',
>+    'isNotEmpty',
>+    'single',
>+    'first',
>+    'last'
>+  ]);
>+  return SetMixin;
>+});
>+collection.SetMixin = collection.SetMixin$();
>+dart.addTypeTests(collection.SetMixin, _is_SetMixin_default);
>+const _is_SetBase_default = Symbol('_is_SetBase_default');
>+collection.SetBase$ = dart.generic(E => {
>+  const Object_SetMixin$ = class Object_SetMixin extends core.Object {};
>+  (Object_SetMixin$.new = function() {
>+  }).prototype = Object_SetMixin$.prototype;
>+  dart.applyMixin(Object_SetMixin$, collection.SetMixin$(E));
>+  class SetBase extends Object_SetMixin$ {
>+    static setToString(set) {
>+      return collection.IterableBase.iterableToFullString(set, "{", "}");
>+    }
>+  }
>+  (SetBase.new = function() {
>+  }).prototype = SetBase.prototype;
>+  dart.addTypeTests(SetBase);
>+  SetBase.prototype[_is_SetBase_default] = true;
>+  dart.setLibraryUri(SetBase, "dart:collection");
>+  return SetBase;
>+});
>+collection.SetBase = collection.SetBase$();
>+dart.addTypeTests(collection.SetBase, _is_SetBase_default);
>+const _is__UnmodifiableSet_default = Symbol('_is__UnmodifiableSet_default');
>+collection._UnmodifiableSet$ = dart.generic(E => {
>+  let _HashSetOfE = () => (_HashSetOfE = dart.constFn(collection._HashSet$(E)))();
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  let MapOfE$Null = () => (MapOfE$Null = dart.constFn(core.Map$(E, core.Null)))();
>+  class _UnmodifiableSet extends collection._SetBase$(E) {
>+    [_newSet]() {
>+      return new (_HashSetOfE()).new();
>+    }
>+    [_newSimilarSet](R) {
>+      return new (collection._HashSet$(R)).new();
>+    }
>+    contains(element) {
>+      return this[_map$0][$containsKey](element);
>+    }
>+    get iterator() {
>+      return this[_map$0][$keys][$iterator];
>+    }
>+    [Symbol.iterator]() {
>+      return new dart.JsIterator(this.iterator);
>+    }
>+    get length() {
>+      return this[_map$0][$length];
>+    }
>+    lookup(element) {
>+      for (let key of this[_map$0][$keys]) {
>+        if (dart.equals(key, element)) return key;
>+      }
>+      return null;
>+    }
>+    add(value) {
>+      E._check(value);
>+      dart.throw(new core.UnsupportedError.new("Cannot change unmodifiable set"));
>+    }
>+    clear() {
>+      dart.throw(new core.UnsupportedError.new("Cannot change unmodifiable set"));
>+    }
>+    addAll(elements) {
>+      IterableOfE()._check(elements);
>+      dart.throw(new core.UnsupportedError.new("Cannot change unmodifiable set"));
>+    }
>+    removeAll(elements) {
>+      dart.throw(new core.UnsupportedError.new("Cannot change unmodifiable set"));
>+    }
>+    retainAll(elements) {
>+      dart.throw(new core.UnsupportedError.new("Cannot change unmodifiable set"));
>+    }
>+    removeWhere(test) {
>+      dart.throw(new core.UnsupportedError.new("Cannot change unmodifiable set"));
>+    }
>+    retainWhere(test) {
>+      dart.throw(new core.UnsupportedError.new("Cannot change unmodifiable set"));
>+    }
>+    remove(value) {
>+      dart.throw(new core.UnsupportedError.new("Cannot change unmodifiable set"));
>+    }
>+  }
>+  (_UnmodifiableSet.new = function(map) {
>+    this[_map$0] = map;
>+    _UnmodifiableSet.__proto__.new.call(this);
>+  }).prototype = _UnmodifiableSet.prototype;
>+  dart.addTypeTests(_UnmodifiableSet);
>+  _UnmodifiableSet.prototype[_is__UnmodifiableSet_default] = true;
>+  dart.setMethodSignature(_UnmodifiableSet, () => ({
>+    __proto__: dart.getMethods(_UnmodifiableSet.__proto__),
>+    [_newSet]: dart.fnType(core.Set$(E), []),
>+    [_newSimilarSet]: dart.gFnType(R => [core.Set$(R), []]),
>+    contains: dart.fnType(core.bool, [core.Object]),
>+    [$contains]: dart.fnType(core.bool, [core.Object]),
>+    lookup: dart.fnType(E, [core.Object]),
>+    add: dart.fnType(core.bool, [core.Object]),
>+    addAll: dart.fnType(dart.void, [core.Object]),
>+    remove: dart.fnType(core.bool, [core.Object])
>+  }));
>+  dart.setGetterSignature(_UnmodifiableSet, () => ({
>+    __proto__: dart.getGetters(_UnmodifiableSet.__proto__),
>+    iterator: core.Iterator$(E),
>+    [$iterator]: core.Iterator$(E),
>+    length: core.int,
>+    [$length]: core.int
>+  }));
>+  dart.setLibraryUri(_UnmodifiableSet, "dart:collection");
>+  dart.setFieldSignature(_UnmodifiableSet, () => ({
>+    __proto__: dart.getFields(_UnmodifiableSet.__proto__),
>+    [_map$0]: dart.finalFieldType(MapOfE$Null())
>+  }));
>+  dart.defineExtensionMethods(_UnmodifiableSet, ['contains']);
>+  dart.defineExtensionAccessors(_UnmodifiableSet, ['iterator', 'length']);
>+  return _UnmodifiableSet;
>+});
>+collection._UnmodifiableSet = collection._UnmodifiableSet$();
>+dart.addTypeTests(collection._UnmodifiableSet, _is__UnmodifiableSet_default);
>+const _is__SplayTreeNode_default = Symbol('_is__SplayTreeNode_default');
>+collection._SplayTreeNode$ = dart.generic(K => {
>+  let _SplayTreeNodeOfK = () => (_SplayTreeNodeOfK = dart.constFn(collection._SplayTreeNode$(K)))();
>+  class _SplayTreeNode extends core.Object {}
>+  (_SplayTreeNode.new = function(key) {
>+    this.left = null;
>+    this.right = null;
>+    this.key = key;
>+  }).prototype = _SplayTreeNode.prototype;
>+  dart.addTypeTests(_SplayTreeNode);
>+  _SplayTreeNode.prototype[_is__SplayTreeNode_default] = true;
>+  dart.setLibraryUri(_SplayTreeNode, "dart:collection");
>+  dart.setFieldSignature(_SplayTreeNode, () => ({
>+    __proto__: dart.getFields(_SplayTreeNode.__proto__),
>+    key: dart.finalFieldType(K),
>+    left: dart.fieldType(_SplayTreeNodeOfK()),
>+    right: dart.fieldType(_SplayTreeNodeOfK())
>+  }));
>+  return _SplayTreeNode;
>+});
>+collection._SplayTreeNode = collection._SplayTreeNode$();
>+dart.addTypeTests(collection._SplayTreeNode, _is__SplayTreeNode_default);
>+const _is__SplayTreeMapNode_default = Symbol('_is__SplayTreeMapNode_default');
>+collection._SplayTreeMapNode$ = dart.generic((K, V) => {
>+  class _SplayTreeMapNode extends collection._SplayTreeNode$(K) {}
>+  (_SplayTreeMapNode.new = function(key, value) {
>+    this.value = value;
>+    _SplayTreeMapNode.__proto__.new.call(this, key);
>+  }).prototype = _SplayTreeMapNode.prototype;
>+  dart.addTypeTests(_SplayTreeMapNode);
>+  _SplayTreeMapNode.prototype[_is__SplayTreeMapNode_default] = true;
>+  dart.setLibraryUri(_SplayTreeMapNode, "dart:collection");
>+  dart.setFieldSignature(_SplayTreeMapNode, () => ({
>+    __proto__: dart.getFields(_SplayTreeMapNode.__proto__),
>+    value: dart.fieldType(V)
>+  }));
>+  return _SplayTreeMapNode;
>+});
>+collection._SplayTreeMapNode = collection._SplayTreeMapNode$();
>+dart.addTypeTests(collection._SplayTreeMapNode, _is__SplayTreeMapNode_default);
>+const _count$ = dart.privateName(collection, "_count");
>+const _splayCount = dart.privateName(collection, "_splayCount");
>+const _root = dart.privateName(collection, "_root");
>+const _dummy = dart.privateName(collection, "_dummy");
>+const _compare = dart.privateName(collection, "_compare");
>+const _splay = dart.privateName(collection, "_splay");
>+const _splayMin = dart.privateName(collection, "_splayMin");
>+const _splayMax = dart.privateName(collection, "_splayMax");
>+const _addNewRoot = dart.privateName(collection, "_addNewRoot");
>+const _last = dart.privateName(collection, "_last");
>+const _clear = dart.privateName(collection, "_clear");
>+const _is__SplayTree_default = Symbol('_is__SplayTree_default');
>+collection._SplayTree$ = dart.generic((K, Node) => {
>+  class _SplayTree extends core.Object {
>+    [_splay](key) {
>+      K._check(key);
>+      if (this[_root] == null) return -1;
>+      let left = this[_dummy];
>+      let right = this[_dummy];
>+      let current = this[_root];
>+      let comp = null;
>+      while (true) {
>+        comp = this[_compare](current.key, key);
>+        if (dart.notNull(comp) > 0) {
>+          if (current.left == null) break;
>+          comp = this[_compare](current.left.key, key);
>+          if (dart.notNull(comp) > 0) {
>+            let tmp = current.left;
>+            current.left = tmp.right;
>+            tmp.right = current;
>+            current = Node._check(tmp);
>+            if (current.left == null) break;
>+          }
>+          right.left = current;
>+          right = current;
>+          current = Node._check(current.left);
>+        } else if (dart.notNull(comp) < 0) {
>+          if (current.right == null) break;
>+          comp = this[_compare](current.right.key, key);
>+          if (dart.notNull(comp) < 0) {
>+            let tmp = Node._check(current.right);
>+            current.right = tmp.left;
>+            tmp.left = current;
>+            current = tmp;
>+            if (current.right == null) break;
>+          }
>+          left.right = current;
>+          left = current;
>+          current = Node._check(current.right);
>+        } else {
>+          break;
>+        }
>+      }
>+      left.right = current.left;
>+      right.left = current.right;
>+      current.left = this[_dummy].right;
>+      current.right = this[_dummy].left;
>+      this[_root] = current;
>+      this[_dummy].right = null;
>+      this[_dummy].left = null;
>+      this[_splayCount] = dart.notNull(this[_splayCount]) + 1;
>+      return comp;
>+    }
>+    [_splayMin](node) {
>+      Node._check(node);
>+      let current = node;
>+      while (current.left != null) {
>+        let left = Node._check(current.left);
>+        current.left = left.right;
>+        left.right = current;
>+        current = left;
>+      }
>+      return current;
>+    }
>+    [_splayMax](node) {
>+      Node._check(node);
>+      let current = node;
>+      while (current.right != null) {
>+        let right = Node._check(current.right);
>+        current.right = right.left;
>+        right.left = current;
>+        current = right;
>+      }
>+      return current;
>+    }
>+    [_remove](key) {
>+      K._check(key);
>+      if (this[_root] == null) return null;
>+      let comp = this[_splay](key);
>+      if (comp !== 0) return null;
>+      let result = this[_root];
>+      this[_count$] = dart.notNull(this[_count$]) - 1;
>+      if (this[_root].left == null) {
>+        this[_root] = Node._check(this[_root].right);
>+      } else {
>+        let right = Node._check(this[_root].right);
>+        this[_root] = this[_splayMax](Node._check(this[_root].left));
>+        this[_root].right = right;
>+      }
>+      this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
>+      return result;
>+    }
>+    [_addNewRoot](node, comp) {
>+      Node._check(node);
>+      this[_count$] = dart.notNull(this[_count$]) + 1;
>+      this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
>+      if (this[_root] == null) {
>+        this[_root] = node;
>+        return;
>+      }
>+      if (dart.notNull(comp) < 0) {
>+        node.left = this[_root];
>+        node.right = this[_root].right;
>+        this[_root].right = null;
>+      } else {
>+        node.right = this[_root];
>+        node.left = this[_root].left;
>+        this[_root].left = null;
>+      }
>+      this[_root] = node;
>+    }
>+    get [_first$]() {
>+      if (this[_root] == null) return null;
>+      this[_root] = this[_splayMin](this[_root]);
>+      return this[_root];
>+    }
>+    get [_last]() {
>+      if (this[_root] == null) return null;
>+      this[_root] = this[_splayMax](this[_root]);
>+      return this[_root];
>+    }
>+    [_clear]() {
>+      this[_root] = null;
>+      this[_count$] = 0;
>+      this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
>+    }
>+  }
>+  (_SplayTree.new = function() {
>+    this[_count$] = 0;
>+    this[_modificationCount] = 0;
>+    this[_splayCount] = 0;
>+  }).prototype = _SplayTree.prototype;
>+  dart.addTypeTests(_SplayTree);
>+  _SplayTree.prototype[_is__SplayTree_default] = true;
>+  dart.setMethodSignature(_SplayTree, () => ({
>+    __proto__: dart.getMethods(_SplayTree.__proto__),
>+    [_splay]: dart.fnType(core.int, [core.Object]),
>+    [_splayMin]: dart.fnType(Node, [core.Object]),
>+    [_splayMax]: dart.fnType(Node, [core.Object]),
>+    [_remove]: dart.fnType(Node, [core.Object]),
>+    [_addNewRoot]: dart.fnType(dart.void, [core.Object, core.int]),
>+    [_clear]: dart.fnType(dart.void, [])
>+  }));
>+  dart.setGetterSignature(_SplayTree, () => ({
>+    __proto__: dart.getGetters(_SplayTree.__proto__),
>+    [_first$]: Node,
>+    [_last]: Node
>+  }));
>+  dart.setLibraryUri(_SplayTree, "dart:collection");
>+  dart.setFieldSignature(_SplayTree, () => ({
>+    __proto__: dart.getFields(_SplayTree.__proto__),
>+    [_count$]: dart.fieldType(core.int),
>+    [_modificationCount]: dart.fieldType(core.int),
>+    [_splayCount]: dart.fieldType(core.int)
>+  }));
>+  return _SplayTree;
>+});
>+collection._SplayTree = collection._SplayTree$();
>+dart.addTypeTests(collection._SplayTree, _is__SplayTree_default);
>+const _is__TypeTest_default = Symbol('_is__TypeTest_default');
>+collection._TypeTest$ = dart.generic(T => {
>+  class _TypeTest extends core.Object {
>+    test(v) {
>+      return T.is(v);
>+    }
>+  }
>+  (_TypeTest.new = function() {
>+  }).prototype = _TypeTest.prototype;
>+  dart.addTypeTests(_TypeTest);
>+  _TypeTest.prototype[_is__TypeTest_default] = true;
>+  dart.setMethodSignature(_TypeTest, () => ({
>+    __proto__: dart.getMethods(_TypeTest.__proto__),
>+    test: dart.fnType(core.bool, [dart.dynamic])
>+  }));
>+  dart.setLibraryUri(_TypeTest, "dart:collection");
>+  return _TypeTest;
>+});
>+collection._TypeTest = collection._TypeTest$();
>+dart.addTypeTests(collection._TypeTest, _is__TypeTest_default);
>+collection._dynamicCompare = function(a, b) {
>+  return core.Comparable.compare(core.Comparable._check(a), core.Comparable._check(b));
>+};
>+collection._defaultCompare = function(K) {
>+  let compare = dart.fn(core.Comparable.compare, ComparableAndComparableToint());
>+  if (dart.fnType(core.int, [K, K]).is(compare)) {
>+    return compare;
>+  }
>+  return dart.fn(collection._dynamicCompare, dynamicAnddynamicToint());
>+};
>+const _comparator = dart.privateName(collection, "_comparator");
>+const _is_SplayTreeMap_default = Symbol('_is_SplayTreeMap_default');
>+collection.SplayTreeMap$ = dart.generic((K, V) => {
>+  let _SplayTreeMapNodeOfK$V = () => (_SplayTreeMapNodeOfK$V = dart.constFn(collection._SplayTreeMapNode$(K, V)))();
>+  let SplayTreeMapOfK$V = () => (SplayTreeMapOfK$V = dart.constFn(collection.SplayTreeMap$(K, V)))();
>+  let MapOfK$V = () => (MapOfK$V = dart.constFn(core.Map$(K, V)))();
>+  let KAndVToNull = () => (KAndVToNull = dart.constFn(dart.fnType(core.Null, [K, V])))();
>+  let _SplayTreeNodeIteratorOfK = () => (_SplayTreeNodeIteratorOfK = dart.constFn(collection._SplayTreeNodeIterator$(K)))();
>+  let _SplayTreeKeyIterableOfK = () => (_SplayTreeKeyIterableOfK = dart.constFn(collection._SplayTreeKeyIterable$(K)))();
>+  let _SplayTreeValueIterableOfK$V = () => (_SplayTreeValueIterableOfK$V = dart.constFn(collection._SplayTreeValueIterable$(K, V)))();
>+  let KAndKToint = () => (KAndKToint = dart.constFn(dart.fnType(core.int, [K, K])))();
>+  let VoidToV = () => (VoidToV = dart.constFn(dart.fnType(V, [])))();
>+  const _SplayTree_MapMixin$ = class _SplayTree_MapMixin extends collection._SplayTree$(K, collection._SplayTreeMapNode$(K, V)) {};
>+  (_SplayTree_MapMixin$.new = function() {
>+    _SplayTree_MapMixin$.__proto__.new.call(this);
>+  }).prototype = _SplayTree_MapMixin$.prototype;
>+  dart.applyMixin(_SplayTree_MapMixin$, collection.MapMixin$(K, V));
>+  class SplayTreeMap extends _SplayTree_MapMixin$ {
>+    static from(other, compare, isValidKey) {
>+      if (compare === void 0) compare = null;
>+      if (isValidKey === void 0) isValidKey = null;
>+      let result = new (SplayTreeMapOfK$V()).new(compare, isValidKey);
>+      other[$forEach](dart.fn((k, v) => {
>+        result._set(K._check(k), V._check(v));
>+      }, dynamicAnddynamicToNull()));
>+      return result;
>+    }
>+    static of(other, compare, isValidKey) {
>+      if (compare === void 0) compare = null;
>+      if (isValidKey === void 0) isValidKey = null;
>+      let _ = new (SplayTreeMapOfK$V()).new(compare, isValidKey);
>+      _.addAll(other);
>+      return _;
>+    }
>+    static fromIterable(iterable, opts) {
>+      let key = opts && 'key' in opts ? opts.key : null;
>+      let value = opts && 'value' in opts ? opts.value : null;
>+      let compare = opts && 'compare' in opts ? opts.compare : null;
>+      let isValidKey = opts && 'isValidKey' in opts ? opts.isValidKey : null;
>+      let map = new (SplayTreeMapOfK$V()).new(compare, isValidKey);
>+      collection.MapBase._fillMapWithMappedIterable(map, iterable, key, value);
>+      return map;
>+    }
>+    static fromIterables(keys, values, compare, isValidKey) {
>+      if (compare === void 0) compare = null;
>+      if (isValidKey === void 0) isValidKey = null;
>+      let map = new (SplayTreeMapOfK$V()).new(compare, isValidKey);
>+      collection.MapBase._fillMapWithIterables(map, keys, values);
>+      return map;
>+    }
>+    [_compare](key1, key2) {
>+      K._check(key1);
>+      K._check(key2);
>+      return this[_comparator](key1, key2);
>+    }
>+    _get(key) {
>+      if (!dart.test(this[_validKey$](key))) return null;
>+      if (this[_root] != null) {
>+        let comp = this[_splay](K._check(key));
>+        if (comp === 0) {
>+          return this[_root].value;
>+        }
>+      }
>+      return null;
>+    }
>+    remove(key) {
>+      if (!dart.test(this[_validKey$](key))) return null;
>+      let mapRoot = this[_remove](K._check(key));
>+      if (mapRoot != null) return mapRoot.value;
>+      return null;
>+    }
>+    _set(key, value) {
>+      K._check(key);
>+      V._check(value);
>+      if (key == null) dart.throw(new core.ArgumentError.new(key));
>+      let comp = this[_splay](key);
>+      if (comp === 0) {
>+        this[_root].value = value;
>+        return value;
>+      }
>+      this[_addNewRoot](new (_SplayTreeMapNodeOfK$V()).new(key, value), comp);
>+      return value;
>+    }
>+    putIfAbsent(key, ifAbsent) {
>+      K._check(key);
>+      VoidToV()._check(ifAbsent);
>+      if (key == null) dart.throw(new core.ArgumentError.new(key));
>+      let comp = this[_splay](key);
>+      if (comp === 0) {
>+        return this[_root].value;
>+      }
>+      let modificationCount = this[_modificationCount];
>+      let splayCount = this[_splayCount];
>+      let value = ifAbsent();
>+      if (modificationCount != this[_modificationCount]) {
>+        dart.throw(new core.ConcurrentModificationError.new(this));
>+      }
>+      if (splayCount != this[_splayCount]) {
>+        comp = this[_splay](key);
>+        if (!(comp !== 0)) dart.assertFailed(null, "dart:collection/splay_tree.dart", 383, 14, "comp != 0");
>+      }
>+      this[_addNewRoot](new (_SplayTreeMapNodeOfK$V()).new(key, value), comp);
>+      return value;
>+    }
>+    addAll(other) {
>+      MapOfK$V()._check(other);
>+      other[$forEach](dart.fn((key, value) => {
>+        this._set(key, value);
>+      }, KAndVToNull()));
>+    }
>+    get isEmpty() {
>+      return this[_root] == null;
>+    }
>+    get isNotEmpty() {
>+      return !dart.test(this.isEmpty);
>+    }
>+    forEach(f) {
>+      let nodes = new (_SplayTreeNodeIteratorOfK()).new(this);
>+      while (dart.test(nodes.moveNext())) {
>+        let node = _SplayTreeMapNodeOfK$V()._check(nodes.current);
>+        f(node.key, node.value);
>+      }
>+    }
>+    get length() {
>+      return this[_count$];
>+    }
>+    clear() {
>+      this[_clear]();
>+    }
>+    containsKey(key) {
>+      return dart.test(this[_validKey$](key)) && this[_splay](K._check(key)) === 0;
>+    }
>+    containsValue(value) {
>+      let initialSplayCount = this[_splayCount];
>+      const visit = node => {
>+        while (node != null) {
>+          if (dart.equals(node.value, value)) return true;
>+          if (initialSplayCount != this[_splayCount]) {
>+            dart.throw(new core.ConcurrentModificationError.new(this));
>+          }
>+          if (node.right != null && dart.test(visit(collection._SplayTreeMapNode._check(node.right)))) return true;
>+          node = collection._SplayTreeMapNode._check(node.left);
>+        }
>+        return false;
>+      };
>+      dart.fn(visit, _SplayTreeMapNodeTobool());
>+      return visit(this[_root]);
>+    }
>+    get keys() {
>+      return new (_SplayTreeKeyIterableOfK()).new(this);
>+    }
>+    get values() {
>+      return new (_SplayTreeValueIterableOfK$V()).new(this);
>+    }
>+    firstKey() {
>+      if (this[_root] == null) return null;
>+      return this[_first$].key;
>+    }
>+    lastKey() {
>+      if (this[_root] == null) return null;
>+      return this[_last].key;
>+    }
>+    lastKeyBefore(key) {
>+      K._check(key);
>+      if (key == null) dart.throw(new core.ArgumentError.new(key));
>+      if (this[_root] == null) return null;
>+      let comp = this[_splay](key);
>+      if (dart.notNull(comp) < 0) return this[_root].key;
>+      let node = this[_root].left;
>+      if (node == null) return null;
>+      while (node.right != null) {
>+        node = node.right;
>+      }
>+      return node.key;
>+    }
>+    firstKeyAfter(key) {
>+      K._check(key);
>+      if (key == null) dart.throw(new core.ArgumentError.new(key));
>+      if (this[_root] == null) return null;
>+      let comp = this[_splay](key);
>+      if (dart.notNull(comp) > 0) return this[_root].key;
>+      let node = this[_root].right;
>+      if (node == null) return null;
>+      while (node.left != null) {
>+        node = node.left;
>+      }
>+      return node.key;
>+    }
>+  }
>+  (SplayTreeMap.new = function(compare, isValidKey) {
>+    if (compare === void 0) compare = null;
>+    if (isValidKey === void 0) isValidKey = null;
>+    this[_root] = null;
>+    this[_dummy] = new (_SplayTreeMapNodeOfK$V()).new(null, null);
>+    let l = compare;
>+    this[_comparator] = l != null ? l : collection._defaultCompare(K);
>+    let l$ = isValidKey;
>+    this[_validKey$] = l$ != null ? l$ : dart.fn(v => K.is(v), dynamicTobool());
>+    SplayTreeMap.__proto__.new.call(this);
>+  }).prototype = SplayTreeMap.prototype;
>+  (SplayTreeMap._internal = function() {
>+    this[_root] = null;
>+    this[_dummy] = new (_SplayTreeMapNodeOfK$V()).new(null, null);
>+    this[_comparator] = null;
>+    this[_validKey$] = null;
>+    SplayTreeMap.__proto__.new.call(this);
>+  }).prototype = SplayTreeMap.prototype;
>+  dart.addTypeTests(SplayTreeMap);
>+  SplayTreeMap.prototype[_is_SplayTreeMap_default] = true;
>+  dart.setMethodSignature(SplayTreeMap, () => ({
>+    __proto__: dart.getMethods(SplayTreeMap.__proto__),
>+    [_compare]: dart.fnType(core.int, [core.Object, core.Object]),
>+    _get: dart.fnType(V, [core.Object]),
>+    [$_get]: dart.fnType(V, [core.Object]),
>+    remove: dart.fnType(V, [core.Object]),
>+    [$remove]: dart.fnType(V, [core.Object]),
>+    _set: dart.fnType(dart.void, [core.Object, core.Object]),
>+    [$_set]: dart.fnType(dart.void, [core.Object, core.Object]),
>+    putIfAbsent: dart.fnType(V, [core.Object, core.Object]),
>+    [$putIfAbsent]: dart.fnType(V, [core.Object, core.Object]),
>+    addAll: dart.fnType(dart.void, [core.Object]),
>+    [$addAll]: dart.fnType(dart.void, [core.Object]),
>+    clear: dart.fnType(dart.void, []),
>+    [$clear]: dart.fnType(dart.void, []),
>+    firstKey: dart.fnType(K, []),
>+    lastKey: dart.fnType(K, []),
>+    lastKeyBefore: dart.fnType(K, [core.Object]),
>+    firstKeyAfter: dart.fnType(K, [core.Object])
>+  }));
>+  dart.setGetterSignature(SplayTreeMap, () => ({
>+    __proto__: dart.getGetters(SplayTreeMap.__proto__),
>+    keys: core.Iterable$(K),
>+    [$keys]: core.Iterable$(K)
>+  }));
>+  dart.setLibraryUri(SplayTreeMap, "dart:collection");
>+  dart.setFieldSignature(SplayTreeMap, () => ({
>+    __proto__: dart.getFields(SplayTreeMap.__proto__),
>+    [_root]: dart.fieldType(_SplayTreeMapNodeOfK$V()),
>+    [_dummy]: dart.finalFieldType(_SplayTreeMapNodeOfK$V()),
>+    [_comparator]: dart.fieldType(KAndKToint()),
>+    [_validKey$]: dart.fieldType(dynamicTobool())
>+  }));
>+  dart.defineExtensionMethods(SplayTreeMap, [
>+    '_get',
>+    'remove',
>+    '_set',
>+    'putIfAbsent',
>+    'addAll',
>+    'forEach',
>+    'clear',
>+    'containsKey',
>+    'containsValue'
>+  ]);
>+  dart.defineExtensionAccessors(SplayTreeMap, [
>+    'isEmpty',
>+    'isNotEmpty',
>+    'length',
>+    'keys',
>+    'values'
>+  ]);
>+  return SplayTreeMap;
>+});
>+collection.SplayTreeMap = collection.SplayTreeMap$();
>+dart.addTypeTests(collection.SplayTreeMap, _is_SplayTreeMap_default);
>+const _tree = dart.privateName(collection, "_tree");
>+const _workList = dart.privateName(collection, "_workList");
>+const _currentNode = dart.privateName(collection, "_currentNode");
>+const _findLeftMostDescendent = dart.privateName(collection, "_findLeftMostDescendent");
>+const _getValue = dart.privateName(collection, "_getValue");
>+const _rebuildWorkList = dart.privateName(collection, "_rebuildWorkList");
>+const _is__SplayTreeIterator_default = Symbol('_is__SplayTreeIterator_default');
>+collection._SplayTreeIterator$ = dart.generic((K, T) => {
>+  let _SplayTreeNodeOfK = () => (_SplayTreeNodeOfK = dart.constFn(collection._SplayTreeNode$(K)))();
>+  let JSArrayOf_SplayTreeNodeOfK = () => (JSArrayOf_SplayTreeNodeOfK = dart.constFn(_interceptors.JSArray$(_SplayTreeNodeOfK())))();
>+  let _SplayTreeOfK$_SplayTreeNodeOfK = () => (_SplayTreeOfK$_SplayTreeNodeOfK = dart.constFn(collection._SplayTree$(K, _SplayTreeNodeOfK())))();
>+  let ListOf_SplayTreeNodeOfK = () => (ListOf_SplayTreeNodeOfK = dart.constFn(core.List$(_SplayTreeNodeOfK())))();
>+  let IteratorOfT = () => (IteratorOfT = dart.constFn(core.Iterator$(T)))();
>+  class _SplayTreeIterator extends core.Object {
>+    get current() {
>+      if (this[_currentNode] == null) return null;
>+      return this[_getValue](this[_currentNode]);
>+    }
>+    [_findLeftMostDescendent](node) {
>+      _SplayTreeNodeOfK()._check(node);
>+      while (node != null) {
>+        this[_workList][$add](node);
>+        node = node.left;
>+      }
>+    }
>+    [_rebuildWorkList](currentNode) {
>+      _SplayTreeNodeOfK()._check(currentNode);
>+      if (!dart.test(this[_workList][$isNotEmpty])) dart.assertFailed(null, "dart:collection/splay_tree.dart", 555, 12, "_workList.isNotEmpty");
>+      this[_workList][$clear]();
>+      if (currentNode == null) {
>+        this[_findLeftMostDescendent](this[_tree][_root]);
>+      } else {
>+        this[_tree][_splay](currentNode.key);
>+        this[_findLeftMostDescendent](this[_tree][_root].right);
>+        if (!dart.test(this[_workList][$isNotEmpty])) dart.assertFailed(null, "dart:collection/splay_tree.dart", 562, 14, "_workList.isNotEmpty");
>+      }
>+    }
>+    moveNext() {
>+      if (this[_modificationCount] != this[_tree][_modificationCount]) {
>+        dart.throw(new core.ConcurrentModificationError.new(this[_tree]));
>+      }
>+      if (dart.test(this[_workList][$isEmpty])) {
>+        this[_currentNode] = null;
>+        return false;
>+      }
>+      if (this[_tree][_splayCount] != this[_splayCount] && this[_currentNode] != null) {
>+        this[_rebuildWorkList](this[_currentNode]);
>+      }
>+      this[_currentNode] = this[_workList][$removeLast]();
>+      this[_findLeftMostDescendent](this[_currentNode].right);
>+      return true;
>+    }
>+  }
>+  (_SplayTreeIterator.new = function(tree) {
>+    this[_workList] = JSArrayOf_SplayTreeNodeOfK().of([]);
>+    this[_currentNode] = null;
>+    this[_tree] = tree;
>+    this[_modificationCount] = tree[_modificationCount];
>+    this[_splayCount] = tree[_splayCount];
>+    this[_findLeftMostDescendent](tree[_root]);
>+  }).prototype = _SplayTreeIterator.prototype;
>+  (_SplayTreeIterator.startAt = function(tree, startKey) {
>+    this[_workList] = JSArrayOf_SplayTreeNodeOfK().of([]);
>+    this[_splayCount] = null;
>+    this[_currentNode] = null;
>+    this[_tree] = tree;
>+    this[_modificationCount] = tree[_modificationCount];
>+    if (tree[_root] == null) return;
>+    let compare = tree[_splay](startKey);
>+    this[_splayCount] = tree[_splayCount];
>+    if (dart.notNull(compare) < 0) {
>+      this[_findLeftMostDescendent](tree[_root].right);
>+    } else {
>+      this[_workList][$add](tree[_root]);
>+    }
>+  }).prototype = _SplayTreeIterator.prototype;
>+  dart.addTypeTests(_SplayTreeIterator);
>+  _SplayTreeIterator.prototype[_is__SplayTreeIterator_default] = true;
>+  _SplayTreeIterator[dart.implements] = () => [IteratorOfT()];
>+  dart.setMethodSignature(_SplayTreeIterator, () => ({
>+    __proto__: dart.getMethods(_SplayTreeIterator.__proto__),
>+    [_findLeftMostDescendent]: dart.fnType(dart.void, [core.Object]),
>+    [_rebuildWorkList]: dart.fnType(dart.void, [core.Object]),
>+    moveNext: dart.fnType(core.bool, [])
>+  }));
>+  dart.setGetterSignature(_SplayTreeIterator, () => ({
>+    __proto__: dart.getGetters(_SplayTreeIterator.__proto__),
>+    current: T
>+  }));
>+  dart.setLibraryUri(_SplayTreeIterator, "dart:collection");
>+  dart.setFieldSignature(_SplayTreeIterator, () => ({
>+    __proto__: dart.getFields(_SplayTreeIterator.__proto__),
>+    [_tree]: dart.finalFieldType(_SplayTreeOfK$_SplayTreeNodeOfK()),
>+    [_workList]: dart.finalFieldType(ListOf_SplayTreeNodeOfK()),
>+    [_modificationCount]: dart.fieldType(core.int),
>+    [_splayCount]: dart.fieldType(core.int),
>+    [_currentNode]: dart.fieldType(_SplayTreeNodeOfK())
>+  }));
>+  return _SplayTreeIterator;
>+});
>+collection._SplayTreeIterator = collection._SplayTreeIterator$();
>+dart.addTypeTests(collection._SplayTreeIterator, _is__SplayTreeIterator_default);
>+const _copyNode = dart.privateName(collection, "_copyNode");
>+const _is__SplayTreeKeyIterable_default = Symbol('_is__SplayTreeKeyIterable_default');
>+collection._SplayTreeKeyIterable$ = dart.generic(K => {
>+  let _SplayTreeKeyIteratorOfK = () => (_SplayTreeKeyIteratorOfK = dart.constFn(collection._SplayTreeKeyIterator$(K)))();
>+  let KAndKToint = () => (KAndKToint = dart.constFn(dart.fnType(core.int, [K, K])))();
>+  let SplayTreeSetOfK = () => (SplayTreeSetOfK = dart.constFn(collection.SplayTreeSet$(K)))();
>+  let _SplayTreeNodeOfK = () => (_SplayTreeNodeOfK = dart.constFn(collection._SplayTreeNode$(K)))();
>+  let _SplayTreeOfK$_SplayTreeNodeOfK = () => (_SplayTreeOfK$_SplayTreeNodeOfK = dart.constFn(collection._SplayTree$(K, _SplayTreeNodeOfK())))();
>+  class _SplayTreeKeyIterable extends _internal.EfficientLengthIterable$(K) {
>+    get length() {
>+      return this[_tree][_count$];
>+    }
>+    get isEmpty() {
>+      return this[_tree][_count$] === 0;
>+    }
>+    get iterator() {
>+      return new (_SplayTreeKeyIteratorOfK()).new(this[_tree]);
>+    }
>+    toSet() {
>+      let set = new (SplayTreeSetOfK()).new(KAndKToint()._check(this[_tree][_comparator]), this[_tree][_validKey$]);
>+      set[_count$] = this[_tree][_count$];
>+      set[_root] = set[_copyNode](this[_tree][_root]);
>+      return set;
>+    }
>+  }
>+  (_SplayTreeKeyIterable.new = function(tree) {
>+    this[_tree] = tree;
>+    _SplayTreeKeyIterable.__proto__.new.call(this);
>+  }).prototype = _SplayTreeKeyIterable.prototype;
>+  dart.addTypeTests(_SplayTreeKeyIterable);
>+  _SplayTreeKeyIterable.prototype[_is__SplayTreeKeyIterable_default] = true;
>+  dart.setGetterSignature(_SplayTreeKeyIterable, () => ({
>+    __proto__: dart.getGetters(_SplayTreeKeyIterable.__proto__),
>+    length: core.int,
>+    [$length]: core.int,
>+    iterator: core.Iterator$(K),
>+    [$iterator]: core.Iterator$(K)
>+  }));
>+  dart.setLibraryUri(_SplayTreeKeyIterable, "dart:collection");
>+  dart.setFieldSignature(_SplayTreeKeyIterable, () => ({
>+    __proto__: dart.getFields(_SplayTreeKeyIterable.__proto__),
>+    [_tree]: dart.fieldType(_SplayTreeOfK$_SplayTreeNodeOfK())
>+  }));
>+  dart.defineExtensionMethods(_SplayTreeKeyIterable, ['toSet']);
>+  dart.defineExtensionAccessors(_SplayTreeKeyIterable, ['length', 'isEmpty', 'iterator']);
>+  return _SplayTreeKeyIterable;
>+});
>+collection._SplayTreeKeyIterable = collection._SplayTreeKeyIterable$();
>+dart.addTypeTests(collection._SplayTreeKeyIterable, _is__SplayTreeKeyIterable_default);
>+const _is__SplayTreeValueIterable_default = Symbol('_is__SplayTreeValueIterable_default');
>+collection._SplayTreeValueIterable$ = dart.generic((K, V) => {
>+  let _SplayTreeValueIteratorOfK$V = () => (_SplayTreeValueIteratorOfK$V = dart.constFn(collection._SplayTreeValueIterator$(K, V)))();
>+  let SplayTreeMapOfK$V = () => (SplayTreeMapOfK$V = dart.constFn(collection.SplayTreeMap$(K, V)))();
>+  class _SplayTreeValueIterable extends _internal.EfficientLengthIterable$(V) {
>+    get length() {
>+      return this[_map$0][_count$];
>+    }
>+    get isEmpty() {
>+      return this[_map$0][_count$] === 0;
>+    }
>+    get iterator() {
>+      return new (_SplayTreeValueIteratorOfK$V()).new(this[_map$0]);
>+    }
>+  }
>+  (_SplayTreeValueIterable.new = function(map) {
>+    this[_map$0] = map;
>+    _SplayTreeValueIterable.__proto__.new.call(this);
>+  }).prototype = _SplayTreeValueIterable.prototype;
>+  dart.addTypeTests(_SplayTreeValueIterable);
>+  _SplayTreeValueIterable.prototype[_is__SplayTreeValueIterable_default] = true;
>+  dart.setGetterSignature(_SplayTreeValueIterable, () => ({
>+    __proto__: dart.getGetters(_SplayTreeValueIterable.__proto__),
>+    length: core.int,
>+    [$length]: core.int,
>+    isEmpty: core.bool,
>+    [$isEmpty]: core.bool,
>+    iterator: core.Iterator$(V),
>+    [$iterator]: core.Iterator$(V)
>+  }));
>+  dart.setLibraryUri(_SplayTreeValueIterable, "dart:collection");
>+  dart.setFieldSignature(_SplayTreeValueIterable, () => ({
>+    __proto__: dart.getFields(_SplayTreeValueIterable.__proto__),
>+    [_map$0]: dart.fieldType(SplayTreeMapOfK$V())
>+  }));
>+  dart.defineExtensionAccessors(_SplayTreeValueIterable, ['length', 'isEmpty', 'iterator']);
>+  return _SplayTreeValueIterable;
>+});
>+collection._SplayTreeValueIterable = collection._SplayTreeValueIterable$();
>+dart.addTypeTests(collection._SplayTreeValueIterable, _is__SplayTreeValueIterable_default);
>+const _is__SplayTreeKeyIterator_default = Symbol('_is__SplayTreeKeyIterator_default');
>+collection._SplayTreeKeyIterator$ = dart.generic(K => {
>+  let _SplayTreeNodeOfK = () => (_SplayTreeNodeOfK = dart.constFn(collection._SplayTreeNode$(K)))();
>+  class _SplayTreeKeyIterator extends collection._SplayTreeIterator$(K, K) {
>+    [_getValue](node) {
>+      _SplayTreeNodeOfK()._check(node);
>+      return node.key;
>+    }
>+  }
>+  (_SplayTreeKeyIterator.new = function(map) {
>+    _SplayTreeKeyIterator.__proto__.new.call(this, map);
>+  }).prototype = _SplayTreeKeyIterator.prototype;
>+  dart.addTypeTests(_SplayTreeKeyIterator);
>+  _SplayTreeKeyIterator.prototype[_is__SplayTreeKeyIterator_default] = true;
>+  dart.setMethodSignature(_SplayTreeKeyIterator, () => ({
>+    __proto__: dart.getMethods(_SplayTreeKeyIterator.__proto__),
>+    [_getValue]: dart.fnType(K, [core.Object])
>+  }));
>+  dart.setLibraryUri(_SplayTreeKeyIterator, "dart:collection");
>+  return _SplayTreeKeyIterator;
>+});
>+collection._SplayTreeKeyIterator = collection._SplayTreeKeyIterator$();
>+dart.addTypeTests(collection._SplayTreeKeyIterator, _is__SplayTreeKeyIterator_default);
>+const _is__SplayTreeValueIterator_default = Symbol('_is__SplayTreeValueIterator_default');
>+collection._SplayTreeValueIterator$ = dart.generic((K, V) => {
>+  let _SplayTreeNodeOfK = () => (_SplayTreeNodeOfK = dart.constFn(collection._SplayTreeNode$(K)))();
>+  let _SplayTreeMapNodeOfK$V = () => (_SplayTreeMapNodeOfK$V = dart.constFn(collection._SplayTreeMapNode$(K, V)))();
>+  class _SplayTreeValueIterator extends collection._SplayTreeIterator$(K, V) {
>+    [_getValue](node) {
>+      _SplayTreeNodeOfK()._check(node);
>+      let mapNode = _SplayTreeMapNodeOfK$V()._check(node);
>+      return mapNode.value;
>+    }
>+  }
>+  (_SplayTreeValueIterator.new = function(map) {
>+    _SplayTreeValueIterator.__proto__.new.call(this, map);
>+  }).prototype = _SplayTreeValueIterator.prototype;
>+  dart.addTypeTests(_SplayTreeValueIterator);
>+  _SplayTreeValueIterator.prototype[_is__SplayTreeValueIterator_default] = true;
>+  dart.setMethodSignature(_SplayTreeValueIterator, () => ({
>+    __proto__: dart.getMethods(_SplayTreeValueIterator.__proto__),
>+    [_getValue]: dart.fnType(V, [core.Object])
>+  }));
>+  dart.setLibraryUri(_SplayTreeValueIterator, "dart:collection");
>+  return _SplayTreeValueIterator;
>+});
>+collection._SplayTreeValueIterator = collection._SplayTreeValueIterator$();
>+dart.addTypeTests(collection._SplayTreeValueIterator, _is__SplayTreeValueIterator_default);
>+const _is__SplayTreeNodeIterator_default = Symbol('_is__SplayTreeNodeIterator_default');
>+collection._SplayTreeNodeIterator$ = dart.generic(K => {
>+  let _SplayTreeNodeOfK = () => (_SplayTreeNodeOfK = dart.constFn(collection._SplayTreeNode$(K)))();
>+  class _SplayTreeNodeIterator extends collection._SplayTreeIterator$(K, collection._SplayTreeNode$(K)) {
>+    [_getValue](node) {
>+      _SplayTreeNodeOfK()._check(node);
>+      return node;
>+    }
>+  }
>+  (_SplayTreeNodeIterator.new = function(tree) {
>+    _SplayTreeNodeIterator.__proto__.new.call(this, tree);
>+  }).prototype = _SplayTreeNodeIterator.prototype;
>+  (_SplayTreeNodeIterator.startAt = function(tree, startKey) {
>+    _SplayTreeNodeIterator.__proto__.startAt.call(this, tree, startKey);
>+  }).prototype = _SplayTreeNodeIterator.prototype;
>+  dart.addTypeTests(_SplayTreeNodeIterator);
>+  _SplayTreeNodeIterator.prototype[_is__SplayTreeNodeIterator_default] = true;
>+  dart.setMethodSignature(_SplayTreeNodeIterator, () => ({
>+    __proto__: dart.getMethods(_SplayTreeNodeIterator.__proto__),
>+    [_getValue]: dart.fnType(collection._SplayTreeNode$(K), [core.Object])
>+  }));
>+  dart.setLibraryUri(_SplayTreeNodeIterator, "dart:collection");
>+  return _SplayTreeNodeIterator;
>+});
>+collection._SplayTreeNodeIterator = collection._SplayTreeNodeIterator$();
>+dart.addTypeTests(collection._SplayTreeNodeIterator, _is__SplayTreeNodeIterator_default);
>+const _clone$ = dart.privateName(collection, "_clone");
>+const _is_SplayTreeSet_default = Symbol('_is_SplayTreeSet_default');
>+collection.SplayTreeSet$ = dart.generic(E => {
>+  let _SplayTreeNodeOfE = () => (_SplayTreeNodeOfE = dart.constFn(collection._SplayTreeNode$(E)))();
>+  let SplayTreeSetOfE = () => (SplayTreeSetOfE = dart.constFn(collection.SplayTreeSet$(E)))();
>+  let _SplayTreeKeyIteratorOfE = () => (_SplayTreeKeyIteratorOfE = dart.constFn(collection._SplayTreeKeyIterator$(E)))();
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  let SetOfE = () => (SetOfE = dart.constFn(core.Set$(E)))();
>+  let EAndEToint = () => (EAndEToint = dart.constFn(dart.fnType(core.int, [E, E])))();
>+  const _SplayTree_IterableMixin$ = class _SplayTree_IterableMixin extends collection._SplayTree$(E, collection._SplayTreeNode$(E)) {};
>+  (_SplayTree_IterableMixin$.new = function() {
>+    _SplayTree_IterableMixin$.__proto__.new.call(this);
>+  }).prototype = _SplayTree_IterableMixin$.prototype;
>+  dart.applyMixin(_SplayTree_IterableMixin$, collection.IterableMixin$(E));
>+  const _SplayTree_SetMixin$ = class _SplayTree_SetMixin extends _SplayTree_IterableMixin$ {};
>+  (_SplayTree_SetMixin$.new = function() {
>+    _SplayTree_SetMixin$.__proto__.new.call(this);
>+  }).prototype = _SplayTree_SetMixin$.prototype;
>+  dart.applyMixin(_SplayTree_SetMixin$, collection.SetMixin$(E));
>+  class SplayTreeSet extends _SplayTree_SetMixin$ {
>+    get [_root]() {
>+      return this[_root$];
>+    }
>+    set [_root](value) {
>+      this[_root$] = _SplayTreeNodeOfE()._check(value);
>+    }
>+    static from(elements, compare, isValidKey) {
>+      if (compare === void 0) compare = null;
>+      if (isValidKey === void 0) isValidKey = null;
>+      let result = new (SplayTreeSetOfE()).new(compare, isValidKey);
>+      for (let element of elements) {
>+        let e = E._check(element);
>+        result.add(e);
>+      }
>+      return result;
>+    }
>+    static of(elements, compare, isValidKey) {
>+      if (compare === void 0) compare = null;
>+      if (isValidKey === void 0) isValidKey = null;
>+      let _ = new (SplayTreeSetOfE()).new(compare, isValidKey);
>+      _.addAll(elements);
>+      return _;
>+    }
>+    [_newSet](T) {
>+      return new (collection.SplayTreeSet$(T)).new(dart.fn((a, b) => this[_comparator](E.as(a), E.as(b)), dart.fnType(core.int, [T, T])), this[_validKey$]);
>+    }
>+    cast(R) {
>+      return core.Set.castFrom(E, R, this, {newSet: dart.bind(this, _newSet)});
>+    }
>+    [_compare](e1, e2) {
>+      E._check(e1);
>+      E._check(e2);
>+      return this[_comparator](e1, e2);
>+    }
>+    get iterator() {
>+      return new (_SplayTreeKeyIteratorOfE()).new(this);
>+    }
>+    get length() {
>+      return this[_count$];
>+    }
>+    get isEmpty() {
>+      return this[_root] == null;
>+    }
>+    get isNotEmpty() {
>+      return this[_root] != null;
>+    }
>+    get first() {
>+      if (this[_count$] === 0) dart.throw(_internal.IterableElementError.noElement());
>+      return this[_first$].key;
>+    }
>+    get last() {
>+      if (this[_count$] === 0) dart.throw(_internal.IterableElementError.noElement());
>+      return this[_last].key;
>+    }
>+    get single() {
>+      if (this[_count$] === 0) dart.throw(_internal.IterableElementError.noElement());
>+      if (dart.notNull(this[_count$]) > 1) dart.throw(_internal.IterableElementError.tooMany());
>+      return this[_root].key;
>+    }
>+    contains(element) {
>+      return dart.test(this[_validKey$](element)) && this[_splay](E._check(element)) === 0;
>+    }
>+    add(element) {
>+      E._check(element);
>+      let compare = this[_splay](element);
>+      if (compare === 0) return false;
>+      this[_addNewRoot](new (_SplayTreeNodeOfE()).new(element), compare);
>+      return true;
>+    }
>+    remove(object) {
>+      if (!dart.test(this[_validKey$](object))) return false;
>+      return this[_remove](E._check(object)) != null;
>+    }
>+    addAll(elements) {
>+      IterableOfE()._check(elements);
>+      for (let element of elements) {
>+        let compare = this[_splay](element);
>+        if (compare !== 0) {
>+          this[_addNewRoot](new (_SplayTreeNodeOfE()).new(element), compare);
>+        }
>+      }
>+    }
>+    removeAll(elements) {
>+      for (let element of elements) {
>+        if (dart.test(this[_validKey$](element))) this[_remove](E._check(element));
>+      }
>+    }
>+    retainAll(elements) {
>+      let retainSet = new (SplayTreeSetOfE()).new(this[_comparator], this[_validKey$]);
>+      let modificationCount = this[_modificationCount];
>+      for (let object of elements) {
>+        if (modificationCount != this[_modificationCount]) {
>+          dart.throw(new core.ConcurrentModificationError.new(this));
>+        }
>+        if (dart.test(this[_validKey$](object)) && this[_splay](E._check(object)) === 0) {
>+          retainSet.add(this[_root].key);
>+        }
>+      }
>+      if (retainSet[_count$] != this[_count$]) {
>+        this[_root] = retainSet[_root];
>+        this[_count$] = retainSet[_count$];
>+        this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
>+      }
>+    }
>+    lookup(object) {
>+      if (!dart.test(this[_validKey$](object))) return null;
>+      let comp = this[_splay](E._check(object));
>+      if (comp !== 0) return null;
>+      return this[_root].key;
>+    }
>+    intersection(other) {
>+      let result = new (SplayTreeSetOfE()).new(this[_comparator], this[_validKey$]);
>+      for (let element of this) {
>+        if (dart.test(other.contains(element))) result.add(element);
>+      }
>+      return result;
>+    }
>+    difference(other) {
>+      let result = new (SplayTreeSetOfE()).new(this[_comparator], this[_validKey$]);
>+      for (let element of this) {
>+        if (!dart.test(other.contains(element))) result.add(element);
>+      }
>+      return result;
>+    }
>+    union(other) {
>+      SetOfE()._check(other);
>+      let _ = this[_clone$]();
>+      _.addAll(other);
>+      return _;
>+    }
>+    [_clone$]() {
>+      let set = new (SplayTreeSetOfE()).new(this[_comparator], this[_validKey$]);
>+      set[_count$] = this[_count$];
>+      set[_root] = this[_copyNode](this[_root]);
>+      return set;
>+    }
>+    [_copyNode](node) {
>+      _SplayTreeNodeOfE()._check(node);
>+      if (node == null) return null;
>+      let _ = new (_SplayTreeNodeOfE()).new(node.key);
>+      _.left = this[_copyNode](node.left);
>+      _.right = this[_copyNode](node.right);
>+      return _;
>+    }
>+    clear() {
>+      this[_clear]();
>+    }
>+    toSet() {
>+      return this[_clone$]();
>+    }
>+    toString() {
>+      return collection.IterableBase.iterableToFullString(this, "{", "}");
>+    }
>+  }
>+  (SplayTreeSet.new = function(compare, isValidKey) {
>+    if (compare === void 0) compare = null;
>+    if (isValidKey === void 0) isValidKey = null;
>+    this[_root$] = null;
>+    this[_dummy] = new (_SplayTreeNodeOfE()).new(null);
>+    let l = compare;
>+    this[_comparator] = l != null ? l : collection._defaultCompare(E);
>+    let l$ = isValidKey;
>+    this[_validKey$] = l$ != null ? l$ : dart.fn(v => E.is(v), dynamicTobool());
>+    SplayTreeSet.__proto__.new.call(this);
>+  }).prototype = SplayTreeSet.prototype;
>+  dart.addTypeTests(SplayTreeSet);
>+  SplayTreeSet.prototype[_is_SplayTreeSet_default] = true;
>+  const _root$ = Symbol("SplayTreeSet._root");
>+  dart.setMethodSignature(SplayTreeSet, () => ({
>+    __proto__: dart.getMethods(SplayTreeSet.__proto__),
>+    [_newSet]: dart.gFnType(T => [core.Set$(T), []]),
>+    [_compare]: dart.fnType(core.int, [core.Object, core.Object]),
>+    contains: dart.fnType(core.bool, [core.Object]),
>+    [$contains]: dart.fnType(core.bool, [core.Object]),
>+    add: dart.fnType(core.bool, [core.Object]),
>+    remove: dart.fnType(core.bool, [core.Object]),
>+    addAll: dart.fnType(dart.void, [core.Object]),
>+    lookup: dart.fnType(E, [core.Object]),
>+    union: dart.fnType(core.Set$(E), [core.Object]),
>+    [_clone$]: dart.fnType(collection.SplayTreeSet$(E), []),
>+    [_copyNode]: dart.fnType(collection._SplayTreeNode$(E), [core.Object]),
>+    toSet: dart.fnType(core.Set$(E), []),
>+    [$toSet]: dart.fnType(core.Set$(E), [])
>+  }));
>+  dart.setGetterSignature(SplayTreeSet, () => ({
>+    __proto__: dart.getGetters(SplayTreeSet.__proto__),
>+    iterator: core.Iterator$(E),
>+    [$iterator]: core.Iterator$(E),
>+    length: core.int,
>+    [$length]: core.int
>+  }));
>+  dart.setLibraryUri(SplayTreeSet, "dart:collection");
>+  dart.setFieldSignature(SplayTreeSet, () => ({
>+    __proto__: dart.getFields(SplayTreeSet.__proto__),
>+    [_root]: dart.fieldType(_SplayTreeNodeOfE()),
>+    [_dummy]: dart.finalFieldType(_SplayTreeNodeOfE()),
>+    [_comparator]: dart.fieldType(EAndEToint()),
>+    [_validKey$]: dart.fieldType(dynamicTobool())
>+  }));
>+  dart.defineExtensionMethods(SplayTreeSet, ['cast', 'contains', 'toSet', 'toString']);
>+  dart.defineExtensionAccessors(SplayTreeSet, [
>+    'iterator',
>+    'length',
>+    'isEmpty',
>+    'isNotEmpty',
>+    'first',
>+    'last',
>+    'single'
>+  ]);
>+  return SplayTreeSet;
>+});
>+collection.SplayTreeSet = collection.SplayTreeSet$();
>+dart.addTypeTests(collection.SplayTreeSet, _is_SplayTreeSet_default);
>+const _processed = dart.privateName(convert, "_processed");
>+const _computeKeys = dart.privateName(convert, "_computeKeys");
>+const _original = dart.privateName(convert, "_original");
>+convert._convertJsonToDart = function(json, reviver) {
>+  if (!(reviver != null)) dart.assertFailed(null, "dart:convert", 86, 10, "reviver != null");
>+  function walk(e) {
>+    if (e == null || typeof e != "object") {
>+      return e;
>+    }
>+    if (Object.getPrototypeOf(e) === Array.prototype) {
>+      for (let i = 0; i < e.length; i++) {
>+        let item = e[i];
>+        e[i] = reviver(i, walk(item));
>+      }
>+      return e;
>+    }
>+    let map = new convert._JsonMap.new(e);
>+    let processed = map[_processed];
>+    let keys = map[_computeKeys]();
>+    for (let i = 0; i < dart.notNull(keys[$length]); i++) {
>+      let key = keys[$_get](i);
>+      let revived = reviver(key, walk(e[key]));
>+      processed[key] = revived;
>+    }
>+    map[_original] = processed;
>+    return map;
>+  }
>+  dart.fn(walk, dynamicTodynamic());
>+  return reviver(null, walk(json));
>+};
>+convert._convertJsonToDartLazy = function(object) {
>+  if (object == null) return null;
>+  if (typeof object != "object") {
>+    return object;
>+  }
>+  if (Object.getPrototypeOf(object) !== Array.prototype) {
>+    return new convert._JsonMap.new(object);
>+  }
>+  for (let i = 0; i < object.length; i++) {
>+    let item = object[i];
>+    object[i] = convert._convertJsonToDartLazy(item);
>+  }
>+  return object;
>+};
>+const _data = dart.privateName(convert, "_data");
>+const _isUpgraded = dart.privateName(convert, "_isUpgraded");
>+const _upgradedMap = dart.privateName(convert, "_upgradedMap");
>+const _process$ = dart.privateName(convert, "_process");
>+const _upgrade = dart.privateName(convert, "_upgrade");
>+core.String = class String extends core.Object {
>+  static fromCharCodes(charCodes, start, end) {
>+    if (start === void 0) start = 0;
>+    if (end === void 0) end = null;
>+    if (_interceptors.JSArray.is(charCodes)) {
>+      return core.String._stringFromJSArray(charCodes, start, end);
>+    }
>+    if (_native_typed_data.NativeUint8List.is(charCodes)) {
>+      return core.String._stringFromUint8List(charCodes, start, end);
>+    }
>+    return core.String._stringFromIterable(charCodes, start, end);
>+  }
>+  static fromCharCode(charCode) {
>+    return _js_helper.Primitives.stringFromCharCode(charCode);
>+  }
>+  static fromEnvironment(name, opts) {
>+    let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : null;
>+    dart.throw(new core.UnsupportedError.new("String.fromEnvironment can only be used as a const constructor"));
>+  }
>+  static _stringFromJSArray(list, start, endOrNull) {
>+    let len = core.int._check(dart.dload(list, 'length'));
>+    let end = core.RangeError.checkValidRange(start, endOrNull, len);
>+    if (dart.notNull(start) > 0 || dart.notNull(end) < dart.notNull(len)) {
>+      list = dart.dsend(list, 'sublist', [start, end]);
>+    }
>+    return _js_helper.Primitives.stringFromCharCodes(JSArrayOfint()._check(list));
>+  }
>+  static _stringFromUint8List(charCodes, start, endOrNull) {
>+    let len = charCodes[$length];
>+    let end = core.RangeError.checkValidRange(start, endOrNull, len);
>+    return _js_helper.Primitives.stringFromNativeUint8List(charCodes, start, end);
>+  }
>+  static _stringFromIterable(charCodes, start, end) {
>+    if (dart.notNull(start) < 0) dart.throw(new core.RangeError.range(start, 0, charCodes[$length]));
>+    if (end != null && dart.notNull(end) < dart.notNull(start)) {
>+      dart.throw(new core.RangeError.range(end, start, charCodes[$length]));
>+    }
>+    let it = charCodes[$iterator];
>+    for (let i = 0; i < dart.notNull(start); i++) {
>+      if (!dart.test(it.moveNext())) {
>+        dart.throw(new core.RangeError.range(start, 0, i));
>+      }
>+    }
>+    let list = JSArrayOfint().of([]);
>+    if (end == null) {
>+      while (dart.test(it.moveNext()))
>+        list[$add](it.current);
>+    } else {
>+      for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
>+        if (!dart.test(it.moveNext())) {
>+          dart.throw(new core.RangeError.range(end, start, i));
>+        }
>+        list[$add](it.current);
>+      }
>+    }
>+    return _js_helper.Primitives.stringFromCharCodes(JSArrayOfint()._check(list));
>+  }
>+};
>+(core.String[dart.mixinNew] = function() {
>+}).prototype = core.String.prototype;
>+core.String.is = function is_String(o) {
>+  return typeof o == "string";
>+};
>+core.String.as = function as_String(o) {
>+  if (typeof o == "string" || o == null) return o;
>+  return dart.as(o, core.String, false);
>+};
>+core.String._check = function check_String(o) {
>+  if (typeof o == "string" || o == null) return o;
>+  return dart.as(o, core.String, true);
>+};
>+core.String[dart.implements] = () => [ComparableOfString(), core.Pattern];
>+dart.setLibraryUri(core.String, "dart:core");
>+convert._JsonMap = class _JsonMap extends collection.MapBase$(core.String, dart.dynamic) {
>+  _get(key) {
>+    if (dart.test(this[_isUpgraded])) {
>+      return this[_upgradedMap][$_get](key);
>+    } else if (!(typeof key == 'string')) {
>+      return null;
>+    } else {
>+      let result = convert._JsonMap._getProperty(this[_processed], core.String._check(key));
>+      if (dart.test(convert._JsonMap._isUnprocessed(result))) result = this[_process$](core.String._check(key));
>+      return result;
>+    }
>+  }
>+  get length() {
>+    return dart.test(this[_isUpgraded]) ? this[_upgradedMap][$length] : this[_computeKeys]()[$length];
>+  }
>+  get isEmpty() {
>+    return this.length === 0;
>+  }
>+  get isNotEmpty() {
>+    return dart.notNull(this.length) > 0;
>+  }
>+  get keys() {
>+    if (dart.test(this[_isUpgraded])) return this[_upgradedMap][$keys];
>+    return new convert._JsonMapKeyIterable.new(this);
>+  }
>+  get values() {
>+    if (dart.test(this[_isUpgraded])) return this[_upgradedMap][$values];
>+    return MappedIterableOfString$dynamic().new(this[_computeKeys](), dart.fn(each => this._get(each), dynamicTodynamic()));
>+  }
>+  _set(key, value) {
>+    core.String._check(key);
>+    if (dart.test(this[_isUpgraded])) {
>+      this[_upgradedMap][$_set](key, value);
>+    } else if (dart.test(this.containsKey(key))) {
>+      let processed = this[_processed];
>+      convert._JsonMap._setProperty(processed, key, value);
>+      let original = this[_original];
>+      if (!core.identical(original, processed)) {
>+        convert._JsonMap._setProperty(original, key, null);
>+      }
>+    } else {
>+      this[_upgrade]()[$_set](key, value);
>+    }
>+    return value;
>+  }
>+  addAll(other) {
>+    MapOfString$dynamic()._check(other);
>+    other[$forEach](dart.fn((key, value) => {
>+      this._set(key, value);
>+    }, StringAnddynamicToNull()));
>+  }
>+  containsValue(value) {
>+    if (dart.test(this[_isUpgraded])) return this[_upgradedMap][$containsValue](value);
>+    let keys = this[_computeKeys]();
>+    for (let i = 0; i < dart.notNull(keys[$length]); i++) {
>+      let key = keys[$_get](i);
>+      if (dart.equals(this._get(key), value)) return true;
>+    }
>+    return false;
>+  }
>+  containsKey(key) {
>+    if (dart.test(this[_isUpgraded])) return this[_upgradedMap][$containsKey](key);
>+    if (!(typeof key == 'string')) return false;
>+    return convert._JsonMap._hasProperty(this[_original], core.String._check(key));
>+  }
>+  putIfAbsent(key, ifAbsent) {
>+    core.String._check(key);
>+    if (dart.test(this.containsKey(key))) return this._get(key);
>+    let value = ifAbsent();
>+    this._set(key, value);
>+    return value;
>+  }
>+  remove(key) {
>+    if (!dart.test(this[_isUpgraded]) && !dart.test(this.containsKey(key))) return null;
>+    return this[_upgrade]()[$remove](key);
>+  }
>+  clear() {
>+    if (dart.test(this[_isUpgraded])) {
>+      this[_upgradedMap][$clear]();
>+    } else {
>+      if (this[_data] != null) {
>+        dart.dsend(this[_data], 'clear', []);
>+      }
>+      this[_original] = this[_processed] = null;
>+      this[_data] = new _js_helper.LinkedMap.new();
>+    }
>+  }
>+  forEach(f) {
>+    if (dart.test(this[_isUpgraded])) return this[_upgradedMap][$forEach](f);
>+    let keys = this[_computeKeys]();
>+    for (let i = 0; i < dart.notNull(keys[$length]); i++) {
>+      let key = keys[$_get](i);
>+      let value = convert._JsonMap._getProperty(this[_processed], key);
>+      if (dart.test(convert._JsonMap._isUnprocessed(value))) {
>+        value = convert._convertJsonToDartLazy(convert._JsonMap._getProperty(this[_original], key));
>+        convert._JsonMap._setProperty(this[_processed], key, value);
>+      }
>+      f(key, value);
>+      if (!core.identical(keys, this[_data])) {
>+        dart.throw(new core.ConcurrentModificationError.new(this));
>+      }
>+    }
>+  }
>+  get [_isUpgraded]() {
>+    return this[_processed] == null;
>+  }
>+  get [_upgradedMap]() {
>+    if (!dart.test(this[_isUpgraded])) dart.assertFailed(null, "dart:convert", 295, 12, "_isUpgraded");
>+    return this[_data];
>+  }
>+  [_computeKeys]() {
>+    if (!!dart.test(this[_isUpgraded])) dart.assertFailed(null, "dart:convert", 303, 12, "!_isUpgraded");
>+    let keys = core.List._check(this[_data]);
>+    if (keys == null) {
>+      keys = this[_data] = convert._JsonMap._getPropertyNames(this[_original]);
>+    }
>+    return keys;
>+  }
>+  [_upgrade]() {
>+    if (dart.test(this[_isUpgraded])) return this[_upgradedMap];
>+    let result = new (IdentityMapOfString$dynamic()).new();
>+    let keys = this[_computeKeys]();
>+    for (let i = 0; i < dart.notNull(keys[$length]); i++) {
>+      let key = keys[$_get](i);
>+      result[$_set](key, this._get(key));
>+    }
>+    if (dart.test(keys[$isEmpty])) {
>+      keys[$add](null);
>+    } else {
>+      keys[$clear]();
>+    }
>+    this[_original] = this[_processed] = null;
>+    this[_data] = result;
>+    if (!dart.test(this[_isUpgraded])) dart.assertFailed(null, "dart:convert", 336, 12, "_isUpgraded");
>+    return result;
>+  }
>+  [_process$](key) {
>+    if (!dart.test(convert._JsonMap._hasProperty(this[_original], key))) return null;
>+    let result = convert._convertJsonToDartLazy(convert._JsonMap._getProperty(this[_original], key));
>+    return convert._JsonMap._setProperty(this[_processed], key, result);
>+  }
>+  static _hasProperty(object, key) {
>+    return Object.prototype.hasOwnProperty.call(object, key);
>+  }
>+  static _getProperty(object, key) {
>+    return object[key];
>+  }
>+  static _setProperty(object, key, value) {
>+    return object[key] = value;
>+  }
>+  static _getPropertyNames(object) {
>+    return Object.keys(object);
>+  }
>+  static _isUnprocessed(object) {
>+    return typeof object == "undefined";
>+  }
>+  static _newJavaScriptObject() {
>+    return Object.create(null);
>+  }
>+};
>+(convert._JsonMap.new = function(original) {
>+  this[_processed] = convert._JsonMap._newJavaScriptObject();
>+  this[_data] = null;
>+  this[_original] = original;
>+}).prototype = convert._JsonMap.prototype;
>+dart.addTypeTests(convert._JsonMap);
>+dart.setMethodSignature(convert._JsonMap, () => ({
>+  __proto__: dart.getMethods(convert._JsonMap.__proto__),
>+  _get: dart.fnType(dart.dynamic, [core.Object]),
>+  [$_get]: dart.fnType(dart.dynamic, [core.Object]),
>+  _set: dart.fnType(dart.void, [core.Object, dart.dynamic]),
>+  [$_set]: dart.fnType(dart.void, [core.Object, dart.dynamic]),
>+  addAll: dart.fnType(dart.void, [core.Object]),
>+  [$addAll]: dart.fnType(dart.void, [core.Object]),
>+  containsValue: dart.fnType(core.bool, [core.Object]),
>+  [$containsValue]: dart.fnType(core.bool, [core.Object]),
>+  containsKey: dart.fnType(core.bool, [core.Object]),
>+  [$containsKey]: dart.fnType(core.bool, [core.Object]),
>+  putIfAbsent: dart.fnType(dart.dynamic, [core.Object, dart.fnType(dart.dynamic, [])]),
>+  [$putIfAbsent]: dart.fnType(dart.dynamic, [core.Object, dart.fnType(dart.dynamic, [])]),
>+  remove: dart.fnType(dart.dynamic, [core.Object]),
>+  [$remove]: dart.fnType(dart.dynamic, [core.Object]),
>+  clear: dart.fnType(dart.void, []),
>+  [$clear]: dart.fnType(dart.void, []),
>+  forEach: dart.fnType(dart.void, [dart.fnType(dart.void, [core.String, dart.dynamic])]),
>+  [$forEach]: dart.fnType(dart.void, [dart.fnType(dart.void, [core.String, dart.dynamic])]),
>+  [_computeKeys]: dart.fnType(core.List$(core.String), []),
>+  [_upgrade]: dart.fnType(core.Map$(core.String, dart.dynamic), []),
>+  [_process$]: dart.fnType(dart.dynamic, [core.String])
>+}));
>+dart.setGetterSignature(convert._JsonMap, () => ({
>+  __proto__: dart.getGetters(convert._JsonMap.__proto__),
>+  length: core.int,
>+  [$length]: core.int,
>+  isEmpty: core.bool,
>+  [$isEmpty]: core.bool,
>+  isNotEmpty: core.bool,
>+  [$isNotEmpty]: core.bool,
>+  keys: core.Iterable$(core.String),
>+  [$keys]: core.Iterable$(core.String),
>+  values: core.Iterable,
>+  [$values]: core.Iterable,
>+  [_isUpgraded]: core.bool,
>+  [_upgradedMap]: core.Map$(core.String, dart.dynamic)
>+}));
>+dart.setLibraryUri(convert._JsonMap, "dart:convert");
>+dart.setFieldSignature(convert._JsonMap, () => ({
>+  __proto__: dart.getFields(convert._JsonMap.__proto__),
>+  [_original]: dart.fieldType(dart.dynamic),
>+  [_processed]: dart.fieldType(dart.dynamic),
>+  [_data]: dart.fieldType(dart.dynamic)
>+}));
>+dart.defineExtensionMethods(convert._JsonMap, [
>+  '_get',
>+  '_set',
>+  'addAll',
>+  'containsValue',
>+  'containsKey',
>+  'putIfAbsent',
>+  'remove',
>+  'clear',
>+  'forEach'
>+]);
>+dart.defineExtensionAccessors(convert._JsonMap, [
>+  'length',
>+  'isEmpty',
>+  'isNotEmpty',
>+  'keys',
>+  'values'
>+]);
>+const _parent = dart.privateName(convert, "_parent");
>+convert._JsonMapKeyIterable = class _JsonMapKeyIterable extends _internal.ListIterable$(core.String) {
>+  get length() {
>+    return this[_parent].length;
>+  }
>+  elementAt(index) {
>+    return dart.test(this[_parent][_isUpgraded]) ? this[_parent].keys[$elementAt](index) : this[_parent][_computeKeys]()[$_get](index);
>+  }
>+  get iterator() {
>+    return dart.test(this[_parent][_isUpgraded]) ? this[_parent].keys[$iterator] : this[_parent][_computeKeys]()[$iterator];
>+  }
>+  contains(key) {
>+    return this[_parent].containsKey(key);
>+  }
>+};
>+(convert._JsonMapKeyIterable.new = function(parent) {
>+  this[_parent] = parent;
>+  convert._JsonMapKeyIterable.__proto__.new.call(this);
>+}).prototype = convert._JsonMapKeyIterable.prototype;
>+dart.addTypeTests(convert._JsonMapKeyIterable);
>+dart.setMethodSignature(convert._JsonMapKeyIterable, () => ({
>+  __proto__: dart.getMethods(convert._JsonMapKeyIterable.__proto__),
>+  elementAt: dart.fnType(core.String, [core.int]),
>+  [$elementAt]: dart.fnType(core.String, [core.int]),
>+  contains: dart.fnType(core.bool, [core.Object]),
>+  [$contains]: dart.fnType(core.bool, [core.Object])
>+}));
>+dart.setGetterSignature(convert._JsonMapKeyIterable, () => ({
>+  __proto__: dart.getGetters(convert._JsonMapKeyIterable.__proto__),
>+  length: core.int,
>+  [$length]: core.int,
>+  iterator: core.Iterator$(core.String),
>+  [$iterator]: core.Iterator$(core.String)
>+}));
>+dart.setLibraryUri(convert._JsonMapKeyIterable, "dart:convert");
>+dart.setFieldSignature(convert._JsonMapKeyIterable, () => ({
>+  __proto__: dart.getFields(convert._JsonMapKeyIterable.__proto__),
>+  [_parent]: dart.finalFieldType(convert._JsonMap)
>+}));
>+dart.defineExtensionMethods(convert._JsonMapKeyIterable, ['elementAt', 'contains']);
>+dart.defineExtensionAccessors(convert._JsonMapKeyIterable, ['length', 'iterator']);
>+const _reviver = dart.privateName(convert, "_reviver");
>+const _sink$ = dart.privateName(convert, "_sink");
>+const _stringSink = dart.privateName(convert, "_stringSink");
>+convert.StringConversionSinkMixin = class StringConversionSinkMixin extends core.Object {
>+  add(str) {
>+    core.String._check(str);
>+    this.addSlice(str, 0, str.length, false);
>+  }
>+  asUtf8Sink(allowMalformed) {
>+    return new convert._Utf8ConversionSink.new(this, allowMalformed);
>+  }
>+  asStringSink() {
>+    return new convert._StringConversionSinkAsStringSinkAdapter.new(this);
>+  }
>+};
>+(convert.StringConversionSinkMixin.new = function() {
>+}).prototype = convert.StringConversionSinkMixin.prototype;
>+dart.addTypeTests(convert.StringConversionSinkMixin);
>+convert.StringConversionSinkMixin[dart.implements] = () => [convert.StringConversionSink];
>+dart.setMethodSignature(convert.StringConversionSinkMixin, () => ({
>+  __proto__: dart.getMethods(convert.StringConversionSinkMixin.__proto__),
>+  add: dart.fnType(dart.void, [core.Object]),
>+  asUtf8Sink: dart.fnType(convert.ByteConversionSink, [core.bool]),
>+  asStringSink: dart.fnType(convert.ClosableStringSink, [])
>+}));
>+dart.setLibraryUri(convert.StringConversionSinkMixin, "dart:convert");
>+convert.StringConversionSinkBase = class StringConversionSinkBase extends convert.StringConversionSinkMixin {};
>+(convert.StringConversionSinkBase.new = function() {
>+}).prototype = convert.StringConversionSinkBase.prototype;
>+dart.addTypeTests(convert.StringConversionSinkBase);
>+dart.setLibraryUri(convert.StringConversionSinkBase, "dart:convert");
>+const _is__StringSinkConversionSink_default = Symbol('_is__StringSinkConversionSink_default');
>+convert._StringSinkConversionSink$ = dart.generic(TStringSink => {
>+  class _StringSinkConversionSink extends convert.StringConversionSinkBase {
>+    close() {}
>+    addSlice(str, start, end, isLast) {
>+      if (start !== 0 || end !== str.length) {
>+        for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
>+          this[_stringSink].writeCharCode(str[$codeUnitAt](i));
>+        }
>+      } else {
>+        this[_stringSink].write(str);
>+      }
>+      if (dart.test(isLast)) this.close();
>+    }
>+    add(str) {
>+      core.String._check(str);
>+      this[_stringSink].write(str);
>+    }
>+    asUtf8Sink(allowMalformed) {
>+      return new convert._Utf8StringSinkAdapter.new(this, this[_stringSink], allowMalformed);
>+    }
>+    asStringSink() {
>+      return convert.ClosableStringSink.fromStringSink(this[_stringSink], dart.bind(this, 'close'));
>+    }
>+  }
>+  (_StringSinkConversionSink.new = function(stringSink) {
>+    this[_stringSink] = stringSink;
>+  }).prototype = _StringSinkConversionSink.prototype;
>+  dart.addTypeTests(_StringSinkConversionSink);
>+  _StringSinkConversionSink.prototype[_is__StringSinkConversionSink_default] = true;
>+  dart.setMethodSignature(_StringSinkConversionSink, () => ({
>+    __proto__: dart.getMethods(_StringSinkConversionSink.__proto__),
>+    close: dart.fnType(dart.void, []),
>+    addSlice: dart.fnType(dart.void, [core.String, core.int, core.int, core.bool]),
>+    add: dart.fnType(dart.void, [core.Object]),
>+    asUtf8Sink: dart.fnType(convert.ByteConversionSink, [core.bool]),
>+    asStringSink: dart.fnType(convert.ClosableStringSink, [])
>+  }));
>+  dart.setLibraryUri(_StringSinkConversionSink, "dart:convert");
>+  dart.setFieldSignature(_StringSinkConversionSink, () => ({
>+    __proto__: dart.getFields(_StringSinkConversionSink.__proto__),
>+    [_stringSink]: dart.fieldType(TStringSink)
>+  }));
>+  return _StringSinkConversionSink;
>+});
>+convert._StringSinkConversionSink = convert._StringSinkConversionSink$();
>+dart.addTypeTests(convert._StringSinkConversionSink, _is__StringSinkConversionSink_default);
>+core.StringSink = class StringSink extends core.Object {};
>+(core.StringSink.new = function() {
>+}).prototype = core.StringSink.prototype;
>+dart.addTypeTests(core.StringSink);
>+dart.setLibraryUri(core.StringSink, "dart:core");
>+convert._JsonDecoderSink = class _JsonDecoderSink extends convert._StringSinkConversionSink$(core.StringSink) {
>+  close() {
>+    super.close();
>+    let buffer = core.StringBuffer._check(this[_stringSink]);
>+    let accumulated = dart.toString(buffer);
>+    buffer.clear();
>+    let decoded = convert._parseJson(accumulated, this[_reviver]);
>+    this[_sink$].add(decoded);
>+    this[_sink$].close();
>+  }
>+};
>+(convert._JsonDecoderSink.new = function(reviver, sink) {
>+  this[_reviver] = reviver;
>+  this[_sink$] = sink;
>+  convert._JsonDecoderSink.__proto__.new.call(this, new core.StringBuffer.new(""));
>+}).prototype = convert._JsonDecoderSink.prototype;
>+dart.addTypeTests(convert._JsonDecoderSink);
>+dart.setMethodSignature(convert._JsonDecoderSink, () => ({
>+  __proto__: dart.getMethods(convert._JsonDecoderSink.__proto__),
>+  close: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(convert._JsonDecoderSink, "dart:convert");
>+dart.setFieldSignature(convert._JsonDecoderSink, () => ({
>+  __proto__: dart.getFields(convert._JsonDecoderSink.__proto__),
>+  [_reviver]: dart.finalFieldType(ObjectAndObjectTodynamic()),
>+  [_sink$]: dart.finalFieldType(SinkOfObject())
>+}));
>+dart.defineLazy(convert, {
>+  /*convert.ascii*/get ascii() {
>+    return dart.const(new convert.AsciiCodec.new());
>+  },
>+  /*convert._asciiMask*/get _asciiMask() {
>+    return 127;
>+  }
>+});
>+const _allowInvalid = dart.privateName(convert, "_allowInvalid");
>+let const$32;
>+let const$33;
>+let const$34;
>+let const$35;
>+let const$36;
>+const _is_Codec_default = Symbol('_is_Codec_default');
>+convert.Codec$ = dart.generic((S, T) => {
>+  let _InvertedCodecOfT$S = () => (_InvertedCodecOfT$S = dart.constFn(convert._InvertedCodec$(T, S)))();
>+  class Codec extends core.Object {
>+    encode(input) {
>+      S._check(input);
>+      return this.encoder.convert(input);
>+    }
>+    decode(encoded) {
>+      T._check(encoded);
>+      return this.decoder.convert(encoded);
>+    }
>+    fuse(R, other) {
>+      convert.Codec$(T, R)._check(other);
>+      return new (convert._FusedCodec$(S, T, R)).new(this, other);
>+    }
>+    get inverted() {
>+      return new (_InvertedCodecOfT$S()).new(this);
>+    }
>+  }
>+  (Codec.new = function() {
>+  }).prototype = Codec.prototype;
>+  dart.addTypeTests(Codec);
>+  Codec.prototype[_is_Codec_default] = true;
>+  dart.setMethodSignature(Codec, () => ({
>+    __proto__: dart.getMethods(Codec.__proto__),
>+    encode: dart.fnType(T, [core.Object]),
>+    decode: dart.fnType(S, [core.Object]),
>+    fuse: dart.gFnType(R => [convert.Codec$(S, R), [core.Object]])
>+  }));
>+  dart.setGetterSignature(Codec, () => ({
>+    __proto__: dart.getGetters(Codec.__proto__),
>+    inverted: convert.Codec$(T, S)
>+  }));
>+  dart.setLibraryUri(Codec, "dart:convert");
>+  return Codec;
>+});
>+convert.Codec = convert.Codec$();
>+dart.addTypeTests(convert.Codec, _is_Codec_default);
>+core.List$ = dart.generic(E => {
>+  let JSArrayOfE = () => (JSArrayOfE = dart.constFn(_interceptors.JSArray$(E)))();
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  let ListOfE = () => (ListOfE = dart.constFn(core.List$(E)))();
>+  let EfficientLengthIterableOfE = () => (EfficientLengthIterableOfE = dart.constFn(_internal.EfficientLengthIterable$(E)))();
>+  class List extends core.Object {
>+    static new(_length) {
>+      let list = null;
>+      if (_length === void 0) {
>+        list = [];
>+      } else {
>+        let length = _length;
>+        if (_length == null || length < 0) {
>+          dart.throw(new core.ArgumentError.new("Length must be a non-negative integer: " + dart.str(_length)));
>+        }
>+        list = new Array(length);
>+        list.fill(null);
>+        _interceptors.JSArray.markFixedList(list);
>+      }
>+      return JSArrayOfE().of(list);
>+    }
>+    static filled(length, fill, opts) {
>+      if (length == null) dart.argumentError(length);
>+      let growable = opts && 'growable' in opts ? opts.growable : false;
>+      let list = JSArrayOfE().of(new Array(length));
>+      list.fill(fill);
>+      if (!dart.test(growable)) _interceptors.JSArray.markFixedList(list);
>+      return list;
>+    }
>+    static from(elements, opts) {
>+      let growable = opts && 'growable' in opts ? opts.growable : true;
>+      let list = JSArrayOfE().of([]);
>+      if (IterableOfE().is(elements)) {
>+        for (let e of elements) {
>+          list[$add](e);
>+        }
>+      } else {
>+        for (let e of elements) {
>+          list[$add](E.as(e));
>+        }
>+      }
>+      if (!dart.test(growable)) _interceptors.JSArray.markFixedList(list);
>+      return list;
>+    }
>+    static of(elements, opts) {
>+      let growable = opts && 'growable' in opts ? opts.growable : true;
>+      return ListOfE().from(elements, {growable: growable});
>+    }
>+    static generate(length, generator, opts) {
>+      let growable = opts && 'growable' in opts ? opts.growable : true;
>+      let result = null;
>+      if (dart.test(growable)) {
>+        result = JSArrayOfE().of([]);
>+        result[$length] = length;
>+      } else {
>+        result = ListOfE().new(length);
>+      }
>+      for (let i = 0; i < dart.notNull(length); i++) {
>+        result[$_set](i, generator(i));
>+      }
>+      return result;
>+    }
>+    static unmodifiable(elements) {
>+      let list = ListOfE().from(elements);
>+      _interceptors.JSArray.markUnmodifiableList(list);
>+      return list;
>+    }
>+    static castFrom(S, T, source) {
>+      return new (_internal.CastList$(S, T)).new(source);
>+    }
>+    static copyRange(T, target, at, source, start, end) {
>+      if (start === void 0) start = null;
>+      if (end === void 0) end = null;
>+      let t = start;
>+      t == null ? start = 0 : t;
>+      end = core.RangeError.checkValidRange(start, end, source[$length]);
>+      let length = dart.notNull(end) - dart.notNull(start);
>+      if (dart.notNull(target[$length]) < dart.notNull(at) + length) {
>+        dart.throw(new core.ArgumentError.value(target, "target", "Not big enough to hold " + dart.str(length) + " elements at position " + dart.str(at)));
>+      }
>+      if (!(source == target) || dart.notNull(start) >= dart.notNull(at)) {
>+        for (let i = 0; i < length; i++) {
>+          target[$_set](dart.notNull(at) + i, source[$_get](dart.notNull(start) + i));
>+        }
>+      } else {
>+        for (let i = length; --i >= 0;) {
>+          target[$_set](dart.notNull(at) + i, source[$_get](dart.notNull(start) + i));
>+        }
>+      }
>+    }
>+    static writeIterable(T, target, at, source) {
>+      core.RangeError.checkValueInInterval(at, 0, target[$length], "at");
>+      let index = at;
>+      let targetLength = target[$length];
>+      for (let element of source) {
>+        if (index == targetLength) {
>+          dart.throw(new core.IndexError.new(targetLength, target));
>+        }
>+        target[$_set](index, element);
>+        index = dart.notNull(index) + 1;
>+      }
>+    }
>+  }
>+  (List[dart.mixinNew] = function() {
>+  }).prototype = List.prototype;
>+  dart.addTypeTests(List);
>+  List.prototype[dart.isList] = true;
>+  List[dart.implements] = () => [EfficientLengthIterableOfE()];
>+  dart.setLibraryUri(List, "dart:core");
>+  return List;
>+});
>+core.List = core.List$();
>+dart.addTypeTests(core.List, dart.isList);
>+convert.Encoding = class Encoding extends convert.Codec$(core.String, core.List$(core.int)) {
>+  decodeStream(byteStream) {
>+    return FutureOfString()._check(FutureOfStringBuffer()._check(StreamOfString()._check(byteStream.transform(core.String, this.decoder)).fold(core.StringBuffer, new core.StringBuffer.new(), dart.fn((buffer, string) => {
>+      buffer.write(string);
>+      return buffer;
>+    }, StringBufferAndStringToStringBuffer()))).then(core.String, dart.fn(buffer => dart.toString(buffer), StringBufferToString())));
>+  }
>+  static getByName(name) {
>+    if (name == null) return null;
>+    name = name[$toLowerCase]();
>+    return convert.Encoding._nameToEncoding[$_get](name);
>+  }
>+};
>+(convert.Encoding.new = function() {
>+  convert.Encoding.__proto__.new.call(this);
>+}).prototype = convert.Encoding.prototype;
>+dart.addTypeTests(convert.Encoding);
>+dart.setMethodSignature(convert.Encoding, () => ({
>+  __proto__: dart.getMethods(convert.Encoding.__proto__),
>+  decodeStream: dart.fnType(async.Future$(core.String), [async.Stream$(core.List$(core.int))])
>+}));
>+dart.setLibraryUri(convert.Encoding, "dart:convert");
>+dart.defineLazy(convert.Encoding, {
>+  /*convert.Encoding._nameToEncoding*/get _nameToEncoding() {
>+    return new (IdentityMapOfString$Encoding()).from(["iso_8859-1:1987", convert.latin1, "iso-ir-100", convert.latin1, "iso_8859-1", convert.latin1, "iso-8859-1", convert.latin1, "latin1", convert.latin1, "l1", convert.latin1, "ibm819", convert.latin1, "cp819", convert.latin1, "csisolatin1", convert.latin1, "iso-ir-6", convert.ascii, "ansi_x3.4-1968", convert.ascii, "ansi_x3.4-1986", convert.ascii, "iso_646.irv:1991", convert.ascii, "iso646-us", convert.ascii, "us-ascii", convert.ascii, "us", convert.ascii, "ibm367", convert.ascii, "cp367", convert.ascii, "csascii", convert.ascii, "ascii", convert.ascii, "csutf8", convert.utf8, "utf-8", convert.utf8]);
>+  }
>+});
>+convert.AsciiCodec = class AsciiCodec extends convert.Encoding {
>+  get name() {
>+    return "us-ascii";
>+  }
>+  encode(source) {
>+    core.String._check(source);
>+    return this.encoder.convert(source);
>+  }
>+  decode(bytes, opts) {
>+    ListOfint()._check(bytes);
>+    let allowInvalid = opts && 'allowInvalid' in opts ? opts.allowInvalid : null;
>+    let t = allowInvalid;
>+    t == null ? allowInvalid = this[_allowInvalid] : t;
>+    if (dart.test(allowInvalid)) {
>+      return (const$32 || (const$32 = dart.const(new convert.AsciiDecoder.new({allowInvalid: true})))).convert(bytes);
>+    } else {
>+      return (const$33 || (const$33 = dart.const(new convert.AsciiDecoder.new({allowInvalid: false})))).convert(bytes);
>+    }
>+  }
>+  get encoder() {
>+    return const$34 || (const$34 = dart.const(new convert.AsciiEncoder.new()));
>+  }
>+  get decoder() {
>+    return dart.test(this[_allowInvalid]) ? const$35 || (const$35 = dart.const(new convert.AsciiDecoder.new({allowInvalid: true}))) : const$36 || (const$36 = dart.const(new convert.AsciiDecoder.new({allowInvalid: false})));
>+  }
>+};
>+(convert.AsciiCodec.new = function(opts) {
>+  let allowInvalid = opts && 'allowInvalid' in opts ? opts.allowInvalid : false;
>+  this[_allowInvalid] = allowInvalid;
>+  convert.AsciiCodec.__proto__.new.call(this);
>+}).prototype = convert.AsciiCodec.prototype;
>+dart.addTypeTests(convert.AsciiCodec);
>+dart.setMethodSignature(convert.AsciiCodec, () => ({
>+  __proto__: dart.getMethods(convert.AsciiCodec.__proto__),
>+  encode: dart.fnType(typed_data.Uint8List, [core.Object]),
>+  decode: dart.fnType(core.String, [core.Object], {allowInvalid: core.bool})
>+}));
>+dart.setGetterSignature(convert.AsciiCodec, () => ({
>+  __proto__: dart.getGetters(convert.AsciiCodec.__proto__),
>+  name: core.String,
>+  encoder: convert.AsciiEncoder,
>+  decoder: convert.AsciiDecoder
>+}));
>+dart.setLibraryUri(convert.AsciiCodec, "dart:convert");
>+dart.setFieldSignature(convert.AsciiCodec, () => ({
>+  __proto__: dart.getFields(convert.AsciiCodec.__proto__),
>+  [_allowInvalid]: dart.finalFieldType(core.bool)
>+}));
>+const _subsetMask = dart.privateName(convert, "_subsetMask");
>+convert._UnicodeSubsetEncoder = class _UnicodeSubsetEncoder extends convert.Converter$(core.String, core.List$(core.int)) {
>+  convert(string, start, end) {
>+    core.String._check(string);
>+    if (start === void 0) start = 0;
>+    if (end === void 0) end = null;
>+    let stringLength = string.length;
>+    end = core.RangeError.checkValidRange(start, end, stringLength);
>+    let length = dart.notNull(end) - dart.notNull(start);
>+    let result = typed_data.Uint8List.new(length);
>+    for (let i = 0; i < length; i++) {
>+      let codeUnit = string[$codeUnitAt](dart.notNull(start) + i);
>+      if ((codeUnit & ~dart.notNull(this[_subsetMask])) !== 0) {
>+        dart.throw(new core.ArgumentError.value(string, "string", "Contains invalid characters."));
>+      }
>+      result[$_set](i, codeUnit);
>+    }
>+    return result;
>+  }
>+  startChunkedConversion(sink) {
>+    SinkOfListOfint()._check(sink);
>+    return new convert._UnicodeSubsetEncoderSink.new(this[_subsetMask], convert.ByteConversionSink.is(sink) ? sink : convert.ByteConversionSink.from(sink));
>+  }
>+  bind(stream) {
>+    StreamOfString()._check(stream);
>+    return super.bind(stream);
>+  }
>+};
>+(convert._UnicodeSubsetEncoder.new = function(subsetMask) {
>+  this[_subsetMask] = subsetMask;
>+  convert._UnicodeSubsetEncoder.__proto__.new.call(this);
>+}).prototype = convert._UnicodeSubsetEncoder.prototype;
>+dart.addTypeTests(convert._UnicodeSubsetEncoder);
>+dart.setMethodSignature(convert._UnicodeSubsetEncoder, () => ({
>+  __proto__: dart.getMethods(convert._UnicodeSubsetEncoder.__proto__),
>+  convert: dart.fnType(typed_data.Uint8List, [core.Object], [core.int, core.int]),
>+  startChunkedConversion: dart.fnType(convert.StringConversionSink, [core.Object]),
>+  bind: dart.fnType(async.Stream$(core.List$(core.int)), [core.Object])
>+}));
>+dart.setLibraryUri(convert._UnicodeSubsetEncoder, "dart:convert");
>+dart.setFieldSignature(convert._UnicodeSubsetEncoder, () => ({
>+  __proto__: dart.getFields(convert._UnicodeSubsetEncoder.__proto__),
>+  [_subsetMask]: dart.finalFieldType(core.int)
>+}));
>+convert.AsciiEncoder = class AsciiEncoder extends convert._UnicodeSubsetEncoder {};
>+(convert.AsciiEncoder.new = function() {
>+  convert.AsciiEncoder.__proto__.new.call(this, 127);
>+}).prototype = convert.AsciiEncoder.prototype;
>+dart.addTypeTests(convert.AsciiEncoder);
>+dart.setLibraryUri(convert.AsciiEncoder, "dart:convert");
>+convert._UnicodeSubsetEncoderSink = class _UnicodeSubsetEncoderSink extends convert.StringConversionSinkBase {
>+  close() {
>+    this[_sink$].close();
>+  }
>+  addSlice(source, start, end, isLast) {
>+    core.RangeError.checkValidRange(start, end, source.length);
>+    for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
>+      let codeUnit = source[$codeUnitAt](i);
>+      if ((codeUnit & ~dart.notNull(this[_subsetMask])) !== 0) {
>+        dart.throw(new core.ArgumentError.new("Source contains invalid character with code point: " + dart.str(codeUnit) + "."));
>+      }
>+    }
>+    this[_sink$].add(source[$codeUnits][$sublist](start, end));
>+    if (dart.test(isLast)) {
>+      this.close();
>+    }
>+  }
>+};
>+(convert._UnicodeSubsetEncoderSink.new = function(subsetMask, sink) {
>+  this[_subsetMask] = subsetMask;
>+  this[_sink$] = sink;
>+}).prototype = convert._UnicodeSubsetEncoderSink.prototype;
>+dart.addTypeTests(convert._UnicodeSubsetEncoderSink);
>+dart.setMethodSignature(convert._UnicodeSubsetEncoderSink, () => ({
>+  __proto__: dart.getMethods(convert._UnicodeSubsetEncoderSink.__proto__),
>+  close: dart.fnType(dart.void, []),
>+  addSlice: dart.fnType(dart.void, [core.String, core.int, core.int, core.bool])
>+}));
>+dart.setLibraryUri(convert._UnicodeSubsetEncoderSink, "dart:convert");
>+dart.setFieldSignature(convert._UnicodeSubsetEncoderSink, () => ({
>+  __proto__: dart.getFields(convert._UnicodeSubsetEncoderSink.__proto__),
>+  [_sink$]: dart.finalFieldType(convert.ByteConversionSink),
>+  [_subsetMask]: dart.finalFieldType(core.int)
>+}));
>+const _convertInvalid = dart.privateName(convert, "_convertInvalid");
>+convert._UnicodeSubsetDecoder = class _UnicodeSubsetDecoder extends convert.Converter$(core.List$(core.int), core.String) {
>+  convert(bytes, start, end) {
>+    ListOfint()._check(bytes);
>+    if (start === void 0) start = 0;
>+    if (end === void 0) end = null;
>+    let byteCount = bytes[$length];
>+    core.RangeError.checkValidRange(start, end, byteCount);
>+    let t = end;
>+    t == null ? end = byteCount : t;
>+    for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
>+      let byte = bytes[$_get](i);
>+      if ((dart.notNull(byte) & ~dart.notNull(this[_subsetMask])) !== 0) {
>+        if (!dart.test(this[_allowInvalid])) {
>+          dart.throw(new core.FormatException.new("Invalid value in input: " + dart.str(byte)));
>+        }
>+        return this[_convertInvalid](bytes, start, end);
>+      }
>+    }
>+    return core.String.fromCharCodes(bytes, start, end);
>+  }
>+  [_convertInvalid](bytes, start, end) {
>+    let buffer = new core.StringBuffer.new();
>+    for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
>+      let value = bytes[$_get](i);
>+      if ((dart.notNull(value) & ~dart.notNull(this[_subsetMask])) !== 0) value = 65533;
>+      buffer.writeCharCode(value);
>+    }
>+    return buffer.toString();
>+  }
>+  bind(stream) {
>+    StreamOfListOfint()._check(stream);
>+    return super.bind(stream);
>+  }
>+};
>+(convert._UnicodeSubsetDecoder.new = function(allowInvalid, subsetMask) {
>+  this[_allowInvalid] = allowInvalid;
>+  this[_subsetMask] = subsetMask;
>+  convert._UnicodeSubsetDecoder.__proto__.new.call(this);
>+}).prototype = convert._UnicodeSubsetDecoder.prototype;
>+dart.addTypeTests(convert._UnicodeSubsetDecoder);
>+dart.setMethodSignature(convert._UnicodeSubsetDecoder, () => ({
>+  __proto__: dart.getMethods(convert._UnicodeSubsetDecoder.__proto__),
>+  convert: dart.fnType(core.String, [core.Object], [core.int, core.int]),
>+  [_convertInvalid]: dart.fnType(core.String, [core.List$(core.int), core.int, core.int]),
>+  bind: dart.fnType(async.Stream$(core.String), [core.Object])
>+}));
>+dart.setLibraryUri(convert._UnicodeSubsetDecoder, "dart:convert");
>+dart.setFieldSignature(convert._UnicodeSubsetDecoder, () => ({
>+  __proto__: dart.getFields(convert._UnicodeSubsetDecoder.__proto__),
>+  [_allowInvalid]: dart.finalFieldType(core.bool),
>+  [_subsetMask]: dart.finalFieldType(core.int)
>+}));
>+convert.AsciiDecoder = class AsciiDecoder extends convert._UnicodeSubsetDecoder {
>+  startChunkedConversion(sink) {
>+    SinkOfString()._check(sink);
>+    let stringSink = null;
>+    if (convert.StringConversionSink.is(sink)) {
>+      stringSink = sink;
>+    } else {
>+      stringSink = convert.StringConversionSink.from(sink);
>+    }
>+    if (dart.test(this[_allowInvalid])) {
>+      return new convert._ErrorHandlingAsciiDecoderSink.new(stringSink.asUtf8Sink(false));
>+    } else {
>+      return new convert._SimpleAsciiDecoderSink.new(stringSink);
>+    }
>+  }
>+};
>+(convert.AsciiDecoder.new = function(opts) {
>+  let allowInvalid = opts && 'allowInvalid' in opts ? opts.allowInvalid : false;
>+  convert.AsciiDecoder.__proto__.new.call(this, allowInvalid, 127);
>+}).prototype = convert.AsciiDecoder.prototype;
>+dart.addTypeTests(convert.AsciiDecoder);
>+dart.setMethodSignature(convert.AsciiDecoder, () => ({
>+  __proto__: dart.getMethods(convert.AsciiDecoder.__proto__),
>+  startChunkedConversion: dart.fnType(convert.ByteConversionSink, [core.Object])
>+}));
>+dart.setLibraryUri(convert.AsciiDecoder, "dart:convert");
>+const _utf8Sink = dart.privateName(convert, "_utf8Sink");
>+let const$37;
>+const _is_ChunkedConversionSink_default = Symbol('_is_ChunkedConversionSink_default');
>+convert.ChunkedConversionSink$ = dart.generic(T => {
>+  let _SimpleCallbackSinkOfT = () => (_SimpleCallbackSinkOfT = dart.constFn(convert._SimpleCallbackSink$(T)))();
>+  let SinkOfT = () => (SinkOfT = dart.constFn(core.Sink$(T)))();
>+  class ChunkedConversionSink extends core.Object {
>+    static withCallback(callback) {
>+      return new (_SimpleCallbackSinkOfT()).new(callback);
>+    }
>+  }
>+  (ChunkedConversionSink.new = function() {
>+  }).prototype = ChunkedConversionSink.prototype;
>+  dart.addTypeTests(ChunkedConversionSink);
>+  ChunkedConversionSink.prototype[_is_ChunkedConversionSink_default] = true;
>+  ChunkedConversionSink[dart.implements] = () => [SinkOfT()];
>+  dart.setLibraryUri(ChunkedConversionSink, "dart:convert");
>+  return ChunkedConversionSink;
>+});
>+convert.ChunkedConversionSink = convert.ChunkedConversionSink$();
>+dart.addTypeTests(convert.ChunkedConversionSink, _is_ChunkedConversionSink_default);
>+convert.ByteConversionSink = class ByteConversionSink extends convert.ChunkedConversionSink$(core.List$(core.int)) {
>+  static withCallback(callback) {
>+    return new convert._ByteCallbackSink.new(callback);
>+  }
>+  static from(sink) {
>+    return new convert._ByteAdapterSink.new(sink);
>+  }
>+};
>+(convert.ByteConversionSink.new = function() {
>+  convert.ByteConversionSink.__proto__.new.call(this);
>+}).prototype = convert.ByteConversionSink.prototype;
>+dart.addTypeTests(convert.ByteConversionSink);
>+dart.setLibraryUri(convert.ByteConversionSink, "dart:convert");
>+convert.ByteConversionSinkBase = class ByteConversionSinkBase extends convert.ByteConversionSink {
>+  addSlice(chunk, start, end, isLast) {
>+    this.add(chunk[$sublist](start, end));
>+    if (dart.test(isLast)) this.close();
>+  }
>+};
>+(convert.ByteConversionSinkBase.new = function() {
>+  convert.ByteConversionSinkBase.__proto__.new.call(this);
>+}).prototype = convert.ByteConversionSinkBase.prototype;
>+dart.addTypeTests(convert.ByteConversionSinkBase);
>+dart.setMethodSignature(convert.ByteConversionSinkBase, () => ({
>+  __proto__: dart.getMethods(convert.ByteConversionSinkBase.__proto__),
>+  addSlice: dart.fnType(dart.void, [core.List$(core.int), core.int, core.int, core.bool])
>+}));
>+dart.setLibraryUri(convert.ByteConversionSinkBase, "dart:convert");
>+convert._ErrorHandlingAsciiDecoderSink = class _ErrorHandlingAsciiDecoderSink extends convert.ByteConversionSinkBase {
>+  close() {
>+    this[_utf8Sink].close();
>+  }
>+  add(source) {
>+    ListOfint()._check(source);
>+    this.addSlice(source, 0, source[$length], false);
>+  }
>+  addSlice(source, start, end, isLast) {
>+    core.RangeError.checkValidRange(start, end, source[$length]);
>+    for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
>+      if ((dart.notNull(source[$_get](i)) & ~127) !== 0) {
>+        if (dart.notNull(i) > dart.notNull(start)) this[_utf8Sink].addSlice(source, start, i, false);
>+        this[_utf8Sink].add(const$37 || (const$37 = dart.constList([239, 191, 189], core.int)));
>+        start = dart.notNull(i) + 1;
>+      }
>+    }
>+    if (dart.notNull(start) < dart.notNull(end)) {
>+      this[_utf8Sink].addSlice(source, start, end, isLast);
>+    } else if (dart.test(isLast)) {
>+      this.close();
>+    }
>+  }
>+};
>+(convert._ErrorHandlingAsciiDecoderSink.new = function(utf8Sink) {
>+  this[_utf8Sink] = utf8Sink;
>+  convert._ErrorHandlingAsciiDecoderSink.__proto__.new.call(this);
>+}).prototype = convert._ErrorHandlingAsciiDecoderSink.prototype;
>+dart.addTypeTests(convert._ErrorHandlingAsciiDecoderSink);
>+dart.setMethodSignature(convert._ErrorHandlingAsciiDecoderSink, () => ({
>+  __proto__: dart.getMethods(convert._ErrorHandlingAsciiDecoderSink.__proto__),
>+  close: dart.fnType(dart.void, []),
>+  add: dart.fnType(dart.void, [core.Object])
>+}));
>+dart.setLibraryUri(convert._ErrorHandlingAsciiDecoderSink, "dart:convert");
>+dart.setFieldSignature(convert._ErrorHandlingAsciiDecoderSink, () => ({
>+  __proto__: dart.getFields(convert._ErrorHandlingAsciiDecoderSink.__proto__),
>+  [_utf8Sink]: dart.fieldType(convert.ByteConversionSink)
>+}));
>+convert._SimpleAsciiDecoderSink = class _SimpleAsciiDecoderSink extends convert.ByteConversionSinkBase {
>+  close() {
>+    this[_sink$].close();
>+  }
>+  add(source) {
>+    ListOfint()._check(source);
>+    for (let i = 0; i < dart.notNull(source[$length]); i++) {
>+      if ((dart.notNull(source[$_get](i)) & ~127) !== 0) {
>+        dart.throw(new core.FormatException.new("Source contains non-ASCII bytes."));
>+      }
>+    }
>+    this[_sink$].add(core.String.fromCharCodes(source));
>+  }
>+  addSlice(source, start, end, isLast) {
>+    let length = source[$length];
>+    core.RangeError.checkValidRange(start, end, length);
>+    if (dart.notNull(start) < dart.notNull(end)) {
>+      if (start !== 0 || end != length) {
>+        source = source[$sublist](start, end);
>+      }
>+      this.add(source);
>+    }
>+    if (dart.test(isLast)) this.close();
>+  }
>+};
>+(convert._SimpleAsciiDecoderSink.new = function(sink) {
>+  this[_sink$] = sink;
>+  convert._SimpleAsciiDecoderSink.__proto__.new.call(this);
>+}).prototype = convert._SimpleAsciiDecoderSink.prototype;
>+dart.addTypeTests(convert._SimpleAsciiDecoderSink);
>+dart.setMethodSignature(convert._SimpleAsciiDecoderSink, () => ({
>+  __proto__: dart.getMethods(convert._SimpleAsciiDecoderSink.__proto__),
>+  close: dart.fnType(dart.void, []),
>+  add: dart.fnType(dart.void, [core.Object])
>+}));
>+dart.setLibraryUri(convert._SimpleAsciiDecoderSink, "dart:convert");
>+dart.setFieldSignature(convert._SimpleAsciiDecoderSink, () => ({
>+  __proto__: dart.getFields(convert._SimpleAsciiDecoderSink.__proto__),
>+  [_sink$]: dart.fieldType(core.Sink)
>+}));
>+dart.defineLazy(convert, {
>+  /*convert.base64*/get base64() {
>+    return dart.const(new convert.Base64Codec.new());
>+  },
>+  /*convert.base64Url*/get base64Url() {
>+    return dart.const(new convert.Base64Codec.urlSafe());
>+  }
>+});
>+convert.base64Encode = function(bytes) {
>+  return convert.base64.encode(bytes);
>+};
>+convert.base64UrlEncode = function(bytes) {
>+  return convert.base64Url.encode(bytes);
>+};
>+convert.base64Decode = function(source) {
>+  return convert.base64.decode(source);
>+};
>+dart.defineLazy(convert, {
>+  /*convert._paddingChar*/get _paddingChar() {
>+    return 61;
>+  }
>+});
>+const _encoder = dart.privateName(convert, "_encoder");
>+let const$38;
>+let const$39;
>+let const$40;
>+convert.Base64Codec = class Base64Codec extends convert.Codec$(core.List$(core.int), core.String) {
>+  get encoder() {
>+    return this[_encoder];
>+  }
>+  get decoder() {
>+    return const$40 || (const$40 = dart.const(new convert.Base64Decoder.new()));
>+  }
>+  decode(encoded) {
>+    core.String._check(encoded);
>+    return this.decoder.convert(encoded);
>+  }
>+  normalize(source, start, end) {
>+    if (start === void 0) start = 0;
>+    if (end === void 0) end = null;
>+    end = core.RangeError.checkValidRange(start, end, source.length);
>+    let percent = 37;
>+    let equals = 61;
>+    let buffer = null;
>+    let sliceStart = start;
>+    let alphabet = convert._Base64Encoder._base64Alphabet;
>+    let inverseAlphabet = convert._Base64Decoder._inverseAlphabet;
>+    let firstPadding = -1;
>+    let firstPaddingSourceIndex = -1;
>+    let paddingCount = 0;
>+    for (let i = start; dart.notNull(i) < dart.notNull(end);) {
>+      let sliceEnd = i;
>+      let char = source[$codeUnitAt]((() => {
>+        let x = i;
>+        i = dart.notNull(x) + 1;
>+        return x;
>+      })());
>+      let originalChar = char;
>+      if (char === percent) {
>+        if (dart.notNull(i) + 2 <= dart.notNull(end)) {
>+          char = _internal.parseHexByte(source, i);
>+          i = dart.notNull(i) + 2;
>+          if (char === percent) char = -1;
>+        } else {
>+          char = -1;
>+        }
>+      }
>+      if (0 <= dart.notNull(char) && dart.notNull(char) <= 127) {
>+        let value = inverseAlphabet[$_get](char);
>+        if (dart.notNull(value) >= 0) {
>+          char = alphabet[$codeUnitAt](value);
>+          if (char == originalChar) continue;
>+        } else if (value === convert._Base64Decoder._padding) {
>+          if (firstPadding < 0) {
>+            firstPadding = (() => {
>+              let l = buffer == null ? null : buffer.length;
>+              return l != null ? l : 0;
>+            })() + (dart.notNull(sliceEnd) - dart.notNull(sliceStart));
>+            firstPaddingSourceIndex = sliceEnd;
>+          }
>+          paddingCount++;
>+          if (originalChar === equals) continue;
>+        }
>+        if (value !== convert._Base64Decoder._invalid) {
>+          let t = buffer;
>+          t == null ? buffer = new core.StringBuffer.new() : t;
>+          buffer.write(source[$substring](sliceStart, sliceEnd));
>+          buffer.writeCharCode(char);
>+          sliceStart = i;
>+          continue;
>+        }
>+      }
>+      dart.throw(new core.FormatException.new("Invalid base64 data", source, sliceEnd));
>+    }
>+    if (buffer != null) {
>+      buffer.write(source[$substring](sliceStart, end));
>+      if (firstPadding >= 0) {
>+        convert.Base64Codec._checkPadding(source, firstPaddingSourceIndex, end, firstPadding, paddingCount, buffer.length);
>+      } else {
>+        let endLength = (dart.notNull(buffer.length) - 1)[$modulo](4) + 1;
>+        if (endLength === 1) {
>+          dart.throw(new core.FormatException.new("Invalid base64 encoding length ", source, end));
>+        }
>+        while (endLength < 4) {
>+          buffer.write("=");
>+          endLength++;
>+        }
>+      }
>+      return source[$replaceRange](start, end, dart.toString(buffer));
>+    }
>+    let length = dart.notNull(end) - dart.notNull(start);
>+    if (firstPadding >= 0) {
>+      convert.Base64Codec._checkPadding(source, firstPaddingSourceIndex, end, firstPadding, paddingCount, length);
>+    } else {
>+      let endLength = length[$modulo](4);
>+      if (endLength === 1) {
>+        dart.throw(new core.FormatException.new("Invalid base64 encoding length ", source, end));
>+      }
>+      if (endLength > 1) {
>+        source = source[$replaceRange](end, end, endLength === 2 ? "==" : "=");
>+      }
>+    }
>+    return source;
>+  }
>+  static _checkPadding(source, sourceIndex, sourceEnd, firstPadding, paddingCount, length) {
>+    if (length[$modulo](4) !== 0) {
>+      dart.throw(new core.FormatException.new("Invalid base64 padding, padded length must be multiple of four, " + ("is " + dart.str(length)), source, sourceEnd));
>+    }
>+    if (dart.notNull(firstPadding) + dart.notNull(paddingCount) !== length) {
>+      dart.throw(new core.FormatException.new("Invalid base64 padding, '=' not at the end", source, sourceIndex));
>+    }
>+    if (dart.notNull(paddingCount) > 2) {
>+      dart.throw(new core.FormatException.new("Invalid base64 padding, more than two '=' characters", source, sourceIndex));
>+    }
>+  }
>+};
>+(convert.Base64Codec.new = function() {
>+  this[_encoder] = const$38 || (const$38 = dart.const(new convert.Base64Encoder.new()));
>+  convert.Base64Codec.__proto__.new.call(this);
>+}).prototype = convert.Base64Codec.prototype;
>+(convert.Base64Codec.urlSafe = function() {
>+  this[_encoder] = const$39 || (const$39 = dart.const(new convert.Base64Encoder.urlSafe()));
>+  convert.Base64Codec.__proto__.new.call(this);
>+}).prototype = convert.Base64Codec.prototype;
>+dart.addTypeTests(convert.Base64Codec);
>+dart.setMethodSignature(convert.Base64Codec, () => ({
>+  __proto__: dart.getMethods(convert.Base64Codec.__proto__),
>+  decode: dart.fnType(typed_data.Uint8List, [core.Object]),
>+  normalize: dart.fnType(core.String, [core.String], [core.int, core.int])
>+}));
>+dart.setGetterSignature(convert.Base64Codec, () => ({
>+  __proto__: dart.getGetters(convert.Base64Codec.__proto__),
>+  encoder: convert.Base64Encoder,
>+  decoder: convert.Base64Decoder
>+}));
>+dart.setLibraryUri(convert.Base64Codec, "dart:convert");
>+dart.setFieldSignature(convert.Base64Codec, () => ({
>+  __proto__: dart.getFields(convert.Base64Codec.__proto__),
>+  [_encoder]: dart.finalFieldType(convert.Base64Encoder)
>+}));
>+const _urlSafe = dart.privateName(convert, "_urlSafe");
>+convert.Base64Encoder = class Base64Encoder extends convert.Converter$(core.List$(core.int), core.String) {
>+  convert(input) {
>+    ListOfint()._check(input);
>+    if (dart.test(input[$isEmpty])) return "";
>+    let encoder = new convert._Base64Encoder.new(this[_urlSafe]);
>+    let buffer = encoder.encode(input, 0, input[$length], true);
>+    return core.String.fromCharCodes(buffer);
>+  }
>+  startChunkedConversion(sink) {
>+    SinkOfString()._check(sink);
>+    if (convert.StringConversionSink.is(sink)) {
>+      return new convert._Utf8Base64EncoderSink.new(sink.asUtf8Sink(false), this[_urlSafe]);
>+    }
>+    return new convert._AsciiBase64EncoderSink.new(sink, this[_urlSafe]);
>+  }
>+};
>+(convert.Base64Encoder.new = function() {
>+  this[_urlSafe] = false;
>+  convert.Base64Encoder.__proto__.new.call(this);
>+}).prototype = convert.Base64Encoder.prototype;
>+(convert.Base64Encoder.urlSafe = function() {
>+  this[_urlSafe] = true;
>+  convert.Base64Encoder.__proto__.new.call(this);
>+}).prototype = convert.Base64Encoder.prototype;
>+dart.addTypeTests(convert.Base64Encoder);
>+dart.setMethodSignature(convert.Base64Encoder, () => ({
>+  __proto__: dart.getMethods(convert.Base64Encoder.__proto__),
>+  convert: dart.fnType(core.String, [core.Object]),
>+  startChunkedConversion: dart.fnType(convert.ByteConversionSink, [core.Object])
>+}));
>+dart.setLibraryUri(convert.Base64Encoder, "dart:convert");
>+dart.setFieldSignature(convert.Base64Encoder, () => ({
>+  __proto__: dart.getFields(convert.Base64Encoder.__proto__),
>+  [_urlSafe]: dart.finalFieldType(core.bool)
>+}));
>+const _alphabet = dart.privateName(convert, "_alphabet");
>+const _state$0 = dart.privateName(convert, "_state");
>+convert._Base64Encoder = class _Base64Encoder extends core.Object {
>+  static _encodeState(count, bits) {
>+    if (!(dart.notNull(count) <= 3)) dart.assertFailed(null, "dart:convert/base64.dart", 279, 12, "count <= _countMask");
>+    return (dart.notNull(bits) << 2 | dart.notNull(count)) >>> 0;
>+  }
>+  static _stateBits(state) {
>+    return state[$rightShift](2);
>+  }
>+  static _stateCount(state) {
>+    return dart.notNull(state) & 3;
>+  }
>+  createBuffer(bufferLength) {
>+    return typed_data.Uint8List.new(bufferLength);
>+  }
>+  encode(bytes, start, end, isLast) {
>+    if (!(0 <= dart.notNull(start))) dart.assertFailed(null, "dart:convert/base64.dart", 304, 12, "0 <= start");
>+    if (!(dart.notNull(start) <= dart.notNull(end))) dart.assertFailed(null, "dart:convert/base64.dart", 305, 12, "start <= end");
>+    if (!(bytes == null || dart.notNull(end) <= dart.notNull(bytes[$length]))) dart.assertFailed(null, "dart:convert/base64.dart", 306, 12, "bytes == null || end <= bytes.length");
>+    let length = dart.notNull(end) - dart.notNull(start);
>+    let count = convert._Base64Encoder._stateCount(this[_state$0]);
>+    let byteCount = dart.notNull(count) + length;
>+    let fullChunks = (byteCount / 3)[$truncate]();
>+    let partialChunkLength = byteCount - fullChunks * 3;
>+    let bufferLength = fullChunks * 4;
>+    if (dart.test(isLast) && partialChunkLength > 0) {
>+      bufferLength = bufferLength + 4;
>+    }
>+    let output = this.createBuffer(bufferLength);
>+    this[_state$0] = convert._Base64Encoder.encodeChunk(this[_alphabet], bytes, start, end, isLast, output, 0, this[_state$0]);
>+    if (bufferLength > 0) return output;
>+    return null;
>+  }
>+  static encodeChunk(alphabet, bytes, start, end, isLast, output, outputIndex, state) {
>+    let bits = convert._Base64Encoder._stateBits(state);
>+    let expectedChars = 3 - dart.notNull(convert._Base64Encoder._stateCount(state));
>+    let byteOr = 0;
>+    for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
>+      let byte = bytes[$_get](i);
>+      byteOr = (byteOr | dart.notNull(byte)) >>> 0;
>+      bits = (dart.notNull(bits) << 8 | dart.notNull(byte)) & 16777215;
>+      expectedChars--;
>+      if (expectedChars === 0) {
>+        output[$_set]((() => {
>+          let x = outputIndex;
>+          outputIndex = dart.notNull(x) + 1;
>+          return x;
>+        })(), alphabet[$codeUnitAt](dart.notNull(bits) >> 18 & 63));
>+        output[$_set]((() => {
>+          let x = outputIndex;
>+          outputIndex = dart.notNull(x) + 1;
>+          return x;
>+        })(), alphabet[$codeUnitAt](dart.notNull(bits) >> 12 & 63));
>+        output[$_set]((() => {
>+          let x = outputIndex;
>+          outputIndex = dart.notNull(x) + 1;
>+          return x;
>+        })(), alphabet[$codeUnitAt](dart.notNull(bits) >> 6 & 63));
>+        output[$_set]((() => {
>+          let x = outputIndex;
>+          outputIndex = dart.notNull(x) + 1;
>+          return x;
>+        })(), alphabet[$codeUnitAt](dart.notNull(bits) & 63));
>+        expectedChars = 3;
>+        bits = 0;
>+      }
>+    }
>+    if (byteOr >= 0 && byteOr <= 255) {
>+      if (dart.test(isLast) && expectedChars < 3) {
>+        convert._Base64Encoder.writeFinalChunk(alphabet, output, outputIndex, 3 - expectedChars, bits);
>+        return 0;
>+      }
>+      return convert._Base64Encoder._encodeState(3 - expectedChars, bits);
>+    }
>+    let i = start;
>+    while (dart.notNull(i) < dart.notNull(end)) {
>+      let byte = bytes[$_get](i);
>+      if (dart.notNull(byte) < 0 || dart.notNull(byte) > 255) break;
>+      i = dart.notNull(i) + 1;
>+    }
>+    dart.throw(new core.ArgumentError.value(bytes, "Not a byte value at index " + dart.str(i) + ": 0x" + bytes[$_get](i)[$toRadixString](16)));
>+  }
>+  static writeFinalChunk(alphabet, output, outputIndex, count, bits) {
>+    if (!(dart.notNull(count) > 0)) dart.assertFailed(null, "dart:convert/base64.dart", 375, 12, "count > 0");
>+    if (count === 1) {
>+      output[$_set]((() => {
>+        let x = outputIndex;
>+        outputIndex = dart.notNull(x) + 1;
>+        return x;
>+      })(), alphabet[$codeUnitAt](dart.notNull(bits) >> 2 & 63));
>+      output[$_set]((() => {
>+        let x = outputIndex;
>+        outputIndex = dart.notNull(x) + 1;
>+        return x;
>+      })(), alphabet[$codeUnitAt](dart.notNull(bits) << 4 & 63));
>+      output[$_set]((() => {
>+        let x = outputIndex;
>+        outputIndex = dart.notNull(x) + 1;
>+        return x;
>+      })(), 61);
>+      output[$_set]((() => {
>+        let x = outputIndex;
>+        outputIndex = dart.notNull(x) + 1;
>+        return x;
>+      })(), 61);
>+    } else {
>+      if (!(count === 2)) dart.assertFailed(null, "dart:convert/base64.dart", 382, 14, "count == 2");
>+      output[$_set]((() => {
>+        let x = outputIndex;
>+        outputIndex = dart.notNull(x) + 1;
>+        return x;
>+      })(), alphabet[$codeUnitAt](dart.notNull(bits) >> 10 & 63));
>+      output[$_set]((() => {
>+        let x = outputIndex;
>+        outputIndex = dart.notNull(x) + 1;
>+        return x;
>+      })(), alphabet[$codeUnitAt](dart.notNull(bits) >> 4 & 63));
>+      output[$_set]((() => {
>+        let x = outputIndex;
>+        outputIndex = dart.notNull(x) + 1;
>+        return x;
>+      })(), alphabet[$codeUnitAt](dart.notNull(bits) << 2 & 63));
>+      output[$_set]((() => {
>+        let x = outputIndex;
>+        outputIndex = dart.notNull(x) + 1;
>+        return x;
>+      })(), 61);
>+    }
>+  }
>+};
>+(convert._Base64Encoder.new = function(urlSafe) {
>+  this[_state$0] = 0;
>+  this[_alphabet] = dart.test(urlSafe) ? "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_" : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
>+}).prototype = convert._Base64Encoder.prototype;
>+dart.addTypeTests(convert._Base64Encoder);
>+dart.setMethodSignature(convert._Base64Encoder, () => ({
>+  __proto__: dart.getMethods(convert._Base64Encoder.__proto__),
>+  createBuffer: dart.fnType(typed_data.Uint8List, [core.int]),
>+  encode: dart.fnType(typed_data.Uint8List, [core.List$(core.int), core.int, core.int, core.bool])
>+}));
>+dart.setLibraryUri(convert._Base64Encoder, "dart:convert");
>+dart.setFieldSignature(convert._Base64Encoder, () => ({
>+  __proto__: dart.getFields(convert._Base64Encoder.__proto__),
>+  [_state$0]: dart.fieldType(core.int),
>+  [_alphabet]: dart.finalFieldType(core.String)
>+}));
>+dart.defineLazy(convert._Base64Encoder, {
>+  /*convert._Base64Encoder._base64Alphabet*/get _base64Alphabet() {
>+    return "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
>+  },
>+  /*convert._Base64Encoder._base64UrlAlphabet*/get _base64UrlAlphabet() {
>+    return "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
>+  },
>+  /*convert._Base64Encoder._valueShift*/get _valueShift() {
>+    return 2;
>+  },
>+  /*convert._Base64Encoder._countMask*/get _countMask() {
>+    return 3;
>+  },
>+  /*convert._Base64Encoder._sixBitMask*/get _sixBitMask() {
>+    return 63;
>+  }
>+});
>+convert._BufferCachingBase64Encoder = class _BufferCachingBase64Encoder extends convert._Base64Encoder {
>+  createBuffer(bufferLength) {
>+    if (this.bufferCache == null || dart.notNull(this.bufferCache[$length]) < dart.notNull(bufferLength)) {
>+      this.bufferCache = typed_data.Uint8List.new(bufferLength);
>+    }
>+    return typed_data.Uint8List.view(this.bufferCache[$buffer], 0, bufferLength);
>+  }
>+};
>+(convert._BufferCachingBase64Encoder.new = function(urlSafe) {
>+  this.bufferCache = null;
>+  convert._BufferCachingBase64Encoder.__proto__.new.call(this, urlSafe);
>+}).prototype = convert._BufferCachingBase64Encoder.prototype;
>+dart.addTypeTests(convert._BufferCachingBase64Encoder);
>+dart.setLibraryUri(convert._BufferCachingBase64Encoder, "dart:convert");
>+dart.setFieldSignature(convert._BufferCachingBase64Encoder, () => ({
>+  __proto__: dart.getFields(convert._BufferCachingBase64Encoder.__proto__),
>+  bufferCache: dart.fieldType(typed_data.Uint8List)
>+}));
>+const _add$0 = dart.privateName(convert, "_add");
>+convert._Base64EncoderSink = class _Base64EncoderSink extends convert.ByteConversionSinkBase {
>+  add(source) {
>+    ListOfint()._check(source);
>+    this[_add$0](source, 0, source[$length], false);
>+  }
>+  close() {
>+    this[_add$0](null, 0, 0, true);
>+  }
>+  addSlice(source, start, end, isLast) {
>+    if (end == null) dart.throw(new core.ArgumentError.notNull("end"));
>+    core.RangeError.checkValidRange(start, end, source[$length]);
>+    this[_add$0](source, start, end, isLast);
>+  }
>+};
>+(convert._Base64EncoderSink.new = function() {
>+  convert._Base64EncoderSink.__proto__.new.call(this);
>+}).prototype = convert._Base64EncoderSink.prototype;
>+dart.addTypeTests(convert._Base64EncoderSink);
>+dart.setMethodSignature(convert._Base64EncoderSink, () => ({
>+  __proto__: dart.getMethods(convert._Base64EncoderSink.__proto__),
>+  add: dart.fnType(dart.void, [core.Object]),
>+  close: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(convert._Base64EncoderSink, "dart:convert");
>+convert._AsciiBase64EncoderSink = class _AsciiBase64EncoderSink extends convert._Base64EncoderSink {
>+  [_add$0](source, start, end, isLast) {
>+    let buffer = this[_encoder].encode(source, start, end, isLast);
>+    if (buffer != null) {
>+      let string = core.String.fromCharCodes(buffer);
>+      this[_sink$].add(string);
>+    }
>+    if (dart.test(isLast)) {
>+      this[_sink$].close();
>+    }
>+  }
>+};
>+(convert._AsciiBase64EncoderSink.new = function(sink, urlSafe) {
>+  this[_sink$] = sink;
>+  this[_encoder] = new convert._BufferCachingBase64Encoder.new(urlSafe);
>+  convert._AsciiBase64EncoderSink.__proto__.new.call(this);
>+}).prototype = convert._AsciiBase64EncoderSink.prototype;
>+dart.addTypeTests(convert._AsciiBase64EncoderSink);
>+dart.setMethodSignature(convert._AsciiBase64EncoderSink, () => ({
>+  __proto__: dart.getMethods(convert._AsciiBase64EncoderSink.__proto__),
>+  [_add$0]: dart.fnType(dart.void, [core.List$(core.int), core.int, core.int, core.bool])
>+}));
>+dart.setLibraryUri(convert._AsciiBase64EncoderSink, "dart:convert");
>+dart.setFieldSignature(convert._AsciiBase64EncoderSink, () => ({
>+  __proto__: dart.getFields(convert._AsciiBase64EncoderSink.__proto__),
>+  [_sink$]: dart.finalFieldType(SinkOfString()),
>+  [_encoder]: dart.finalFieldType(convert._Base64Encoder)
>+}));
>+convert._Utf8Base64EncoderSink = class _Utf8Base64EncoderSink extends convert._Base64EncoderSink {
>+  [_add$0](source, start, end, isLast) {
>+    let buffer = this[_encoder].encode(source, start, end, isLast);
>+    if (buffer != null) {
>+      this[_sink$].addSlice(buffer, 0, buffer[$length], isLast);
>+    }
>+  }
>+};
>+(convert._Utf8Base64EncoderSink.new = function(sink, urlSafe) {
>+  this[_sink$] = sink;
>+  this[_encoder] = new convert._Base64Encoder.new(urlSafe);
>+  convert._Utf8Base64EncoderSink.__proto__.new.call(this);
>+}).prototype = convert._Utf8Base64EncoderSink.prototype;
>+dart.addTypeTests(convert._Utf8Base64EncoderSink);
>+dart.setMethodSignature(convert._Utf8Base64EncoderSink, () => ({
>+  __proto__: dart.getMethods(convert._Utf8Base64EncoderSink.__proto__),
>+  [_add$0]: dart.fnType(dart.void, [core.List$(core.int), core.int, core.int, core.bool])
>+}));
>+dart.setLibraryUri(convert._Utf8Base64EncoderSink, "dart:convert");
>+dart.setFieldSignature(convert._Utf8Base64EncoderSink, () => ({
>+  __proto__: dart.getFields(convert._Utf8Base64EncoderSink.__proto__),
>+  [_sink$]: dart.finalFieldType(convert.ByteConversionSink),
>+  [_encoder]: dart.finalFieldType(convert._Base64Encoder)
>+}));
>+convert.Base64Decoder = class Base64Decoder extends convert.Converter$(core.String, core.List$(core.int)) {
>+  convert(input, start, end) {
>+    core.String._check(input);
>+    if (start === void 0) start = 0;
>+    if (end === void 0) end = null;
>+    end = core.RangeError.checkValidRange(start, end, input.length);
>+    if (start == end) return typed_data.Uint8List.new(0);
>+    let decoder = new convert._Base64Decoder.new();
>+    let buffer = decoder.decode(input, start, end);
>+    decoder.close(input, end);
>+    return buffer;
>+  }
>+  startChunkedConversion(sink) {
>+    SinkOfListOfint()._check(sink);
>+    return new convert._Base64DecoderSink.new(sink);
>+  }
>+};
>+(convert.Base64Decoder.new = function() {
>+  convert.Base64Decoder.__proto__.new.call(this);
>+}).prototype = convert.Base64Decoder.prototype;
>+dart.addTypeTests(convert.Base64Decoder);
>+dart.setMethodSignature(convert.Base64Decoder, () => ({
>+  __proto__: dart.getMethods(convert.Base64Decoder.__proto__),
>+  convert: dart.fnType(typed_data.Uint8List, [core.Object], [core.int, core.int]),
>+  startChunkedConversion: dart.fnType(convert.StringConversionSink, [core.Object])
>+}));
>+dart.setLibraryUri(convert.Base64Decoder, "dart:convert");
>+convert._Base64Decoder = class _Base64Decoder extends core.Object {
>+  static _encodeCharacterState(count, bits) {
>+    if (!(count === (dart.notNull(count) & 3))) dart.assertFailed(null, "dart:convert/base64.dart", 559, 12, "count == (count & _countMask)");
>+    return (dart.notNull(bits) << 2 | dart.notNull(count)) >>> 0;
>+  }
>+  static _stateCount(state) {
>+    if (!(dart.notNull(state) >= 0)) dart.assertFailed(null, "dart:convert/base64.dart", 565, 12, "state >= 0");
>+    return dart.notNull(state) & 3;
>+  }
>+  static _stateBits(state) {
>+    if (!(dart.notNull(state) >= 0)) dart.assertFailed(null, "dart:convert/base64.dart", 571, 12, "state >= 0");
>+    return state[$rightShift](2);
>+  }
>+  static _encodePaddingState(expectedPadding) {
>+    if (!(dart.notNull(expectedPadding) >= 0)) dart.assertFailed(null, "dart:convert/base64.dart", 577, 12, "expectedPadding >= 0");
>+    if (!(dart.notNull(expectedPadding) <= 5)) dart.assertFailed(null, "dart:convert/base64.dart", 578, 12, "expectedPadding <= 5");
>+    return -dart.notNull(expectedPadding) - 1;
>+  }
>+  static _statePadding(state) {
>+    if (!(dart.notNull(state) < 0)) dart.assertFailed(null, "dart:convert/base64.dart", 584, 12, "state < 0");
>+    return -dart.notNull(state) - 1;
>+  }
>+  static _hasSeenPadding(state) {
>+    return dart.notNull(state) < 0;
>+  }
>+  decode(input, start, end) {
>+    if (!(0 <= dart.notNull(start))) dart.assertFailed(null, "dart:convert/base64.dart", 596, 12, "0 <= start");
>+    if (!(dart.notNull(start) <= dart.notNull(end))) dart.assertFailed(null, "dart:convert/base64.dart", 597, 12, "start <= end");
>+    if (!(dart.notNull(end) <= input.length)) dart.assertFailed(null, "dart:convert/base64.dart", 598, 12, "end <= input.length");
>+    if (dart.test(convert._Base64Decoder._hasSeenPadding(this[_state$0]))) {
>+      this[_state$0] = convert._Base64Decoder._checkPadding(input, start, end, this[_state$0]);
>+      return null;
>+    }
>+    if (start == end) return typed_data.Uint8List.new(0);
>+    let buffer = convert._Base64Decoder._allocateBuffer(input, start, end, this[_state$0]);
>+    this[_state$0] = convert._Base64Decoder.decodeChunk(input, start, end, buffer, 0, this[_state$0]);
>+    return buffer;
>+  }
>+  close(input, end) {
>+    if (dart.notNull(this[_state$0]) < dart.notNull(convert._Base64Decoder._encodePaddingState(0))) {
>+      dart.throw(new core.FormatException.new("Missing padding character", input, end));
>+    }
>+    if (dart.notNull(this[_state$0]) > 0) {
>+      dart.throw(new core.FormatException.new("Invalid length, must be multiple of four", input, end));
>+    }
>+    this[_state$0] = convert._Base64Decoder._encodePaddingState(0);
>+  }
>+  static decodeChunk(input, start, end, output, outIndex, state) {
>+    if (!!dart.test(convert._Base64Decoder._hasSeenPadding(state))) dart.assertFailed(null, "dart:convert/base64.dart", 628, 12, "!_hasSeenPadding(state)");
>+    let asciiMask = 127;
>+    let asciiMax = 127;
>+    let eightBitMask = 255;
>+    let bitsPerCharacter = 6;
>+    let bits = convert._Base64Decoder._stateBits(state);
>+    let count = convert._Base64Decoder._stateCount(state);
>+    let charOr = 0;
>+    for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
>+      let char = input[$codeUnitAt](i);
>+      charOr = (charOr | char) >>> 0;
>+      let code = convert._Base64Decoder._inverseAlphabet[$_get]((char & asciiMask) >>> 0);
>+      if (dart.notNull(code) >= 0) {
>+        bits = (bits[$leftShift](bitsPerCharacter) | dart.notNull(code)) & 16777215;
>+        count = dart.notNull(count) + 1 & 3;
>+        if (count === 0) {
>+          if (!(dart.notNull(outIndex) + 3 <= dart.notNull(output[$length]))) dart.assertFailed(null, "dart:convert/base64.dart", 649, 18, "outIndex + 3 <= output.length");
>+          output[$_set]((() => {
>+            let x = outIndex;
>+            outIndex = dart.notNull(x) + 1;
>+            return x;
>+          })(), (bits[$rightShift](16) & eightBitMask) >>> 0);
>+          output[$_set]((() => {
>+            let x = outIndex;
>+            outIndex = dart.notNull(x) + 1;
>+            return x;
>+          })(), (bits[$rightShift](8) & eightBitMask) >>> 0);
>+          output[$_set]((() => {
>+            let x = outIndex;
>+            outIndex = dart.notNull(x) + 1;
>+            return x;
>+          })(), (dart.notNull(bits) & eightBitMask) >>> 0);
>+          bits = 0;
>+        }
>+        continue;
>+      } else if (code === -1 && dart.notNull(count) > 1) {
>+        if (charOr < 0 || charOr > asciiMax) break;
>+        if (count === 3) {
>+          if ((dart.notNull(bits) & 3) !== 0) {
>+            dart.throw(new core.FormatException.new("Invalid encoding before padding", input, i));
>+          }
>+          output[$_set]((() => {
>+            let x = outIndex;
>+            outIndex = dart.notNull(x) + 1;
>+            return x;
>+          })(), bits[$rightShift](10));
>+          output[$_set]((() => {
>+            let x = outIndex;
>+            outIndex = dart.notNull(x) + 1;
>+            return x;
>+          })(), bits[$rightShift](2));
>+        } else {
>+          if ((dart.notNull(bits) & 15) !== 0) {
>+            dart.throw(new core.FormatException.new("Invalid encoding before padding", input, i));
>+          }
>+          output[$_set]((() => {
>+            let x = outIndex;
>+            outIndex = dart.notNull(x) + 1;
>+            return x;
>+          })(), bits[$rightShift](4));
>+        }
>+        let expectedPadding = (3 - dart.notNull(count)) * 3;
>+        if (char === 37) {
>+          expectedPadding = expectedPadding + 2;
>+        }
>+        state = convert._Base64Decoder._encodePaddingState(expectedPadding);
>+        return convert._Base64Decoder._checkPadding(input, dart.notNull(i) + 1, end, state);
>+      }
>+      dart.throw(new core.FormatException.new("Invalid character", input, i));
>+    }
>+    if (charOr >= 0 && charOr <= asciiMax) {
>+      return convert._Base64Decoder._encodeCharacterState(count, bits);
>+    }
>+    let i = null;
>+    for (i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
>+      let char = input[$codeUnitAt](i);
>+      if (char < 0 || char > asciiMax) break;
>+    }
>+    dart.throw(new core.FormatException.new("Invalid character", input, i));
>+  }
>+  static _allocateBuffer(input, start, end, state) {
>+    if (!(dart.notNull(state) >= 0)) dart.assertFailed(null, "dart:convert/base64.dart", 699, 12, "state >= 0");
>+    let paddingStart = convert._Base64Decoder._trimPaddingChars(input, start, end);
>+    let length = dart.notNull(convert._Base64Decoder._stateCount(state)) + (dart.notNull(paddingStart) - dart.notNull(start));
>+    let bufferLength = length[$rightShift](2) * 3;
>+    let remainderLength = length & 3;
>+    if (remainderLength !== 0 && dart.notNull(paddingStart) < dart.notNull(end)) {
>+      bufferLength = bufferLength + (remainderLength - 1);
>+    }
>+    if (bufferLength > 0) return typed_data.Uint8List.new(bufferLength);
>+    return null;
>+  }
>+  static _trimPaddingChars(input, start, end) {
>+    let padding = 0;
>+    let index = end;
>+    let newEnd = end;
>+    while (dart.notNull(index) > dart.notNull(start) && padding < 2) {
>+      index = dart.notNull(index) - 1;
>+      let char = input[$codeUnitAt](index);
>+      if (char === 61) {
>+        padding++;
>+        newEnd = index;
>+        continue;
>+      }
>+      if ((char | 32) === 100) {
>+        if (index == start) break;
>+        index = dart.notNull(index) - 1;
>+        char = input[$codeUnitAt](index);
>+      }
>+      if (char === 51) {
>+        if (index == start) break;
>+        index = dart.notNull(index) - 1;
>+        char = input[$codeUnitAt](index);
>+      }
>+      if (char === 37) {
>+        padding++;
>+        newEnd = index;
>+        continue;
>+      }
>+      break;
>+    }
>+    return newEnd;
>+  }
>+  static _checkPadding(input, start, end, state) {
>+    if (!dart.test(convert._Base64Decoder._hasSeenPadding(state))) dart.assertFailed(null, "dart:convert/base64.dart", 780, 12, "_hasSeenPadding(state)");
>+    if (start == end) return state;
>+    let expectedPadding = convert._Base64Decoder._statePadding(state);
>+    if (!(dart.notNull(expectedPadding) >= 0)) dart.assertFailed(null, "dart:convert/base64.dart", 783, 12, "expectedPadding >= 0");
>+    if (!(dart.notNull(expectedPadding) < 6)) dart.assertFailed(null, "dart:convert/base64.dart", 784, 12, "expectedPadding < 6");
>+    while (dart.notNull(expectedPadding) > 0) {
>+      let char = input[$codeUnitAt](start);
>+      if (expectedPadding === 3) {
>+        if (char === 61) {
>+          expectedPadding = dart.notNull(expectedPadding) - 3;
>+          start = dart.notNull(start) + 1;
>+          break;
>+        }
>+        if (char === 37) {
>+          expectedPadding = dart.notNull(expectedPadding) - 1;
>+          start = dart.notNull(start) + 1;
>+          if (start == end) break;
>+          char = input[$codeUnitAt](start);
>+        } else {
>+          break;
>+        }
>+      }
>+      let expectedPartialPadding = expectedPadding;
>+      if (dart.notNull(expectedPartialPadding) > 3) {
>+        expectedPartialPadding = dart.notNull(expectedPartialPadding) - 3;
>+      }
>+      if (expectedPartialPadding === 2) {
>+        if (char !== 51) break;
>+        start = dart.notNull(start) + 1;
>+        expectedPadding = dart.notNull(expectedPadding) - 1;
>+        if (start == end) break;
>+        char = input[$codeUnitAt](start);
>+      }
>+      if ((char | 32) !== 100) break;
>+      start = dart.notNull(start) + 1;
>+      expectedPadding = dart.notNull(expectedPadding) - 1;
>+      if (start == end) break;
>+    }
>+    if (start != end) {
>+      dart.throw(new core.FormatException.new("Invalid padding character", input, start));
>+    }
>+    return convert._Base64Decoder._encodePaddingState(expectedPadding);
>+  }
>+};
>+(convert._Base64Decoder.new = function() {
>+  this[_state$0] = 0;
>+}).prototype = convert._Base64Decoder.prototype;
>+dart.addTypeTests(convert._Base64Decoder);
>+dart.setMethodSignature(convert._Base64Decoder, () => ({
>+  __proto__: dart.getMethods(convert._Base64Decoder.__proto__),
>+  decode: dart.fnType(typed_data.Uint8List, [core.String, core.int, core.int]),
>+  close: dart.fnType(dart.void, [core.String, core.int])
>+}));
>+dart.setLibraryUri(convert._Base64Decoder, "dart:convert");
>+dart.setFieldSignature(convert._Base64Decoder, () => ({
>+  __proto__: dart.getFields(convert._Base64Decoder.__proto__),
>+  [_state$0]: dart.fieldType(core.int)
>+}));
>+dart.defineLazy(convert._Base64Decoder, {
>+  /*convert._Base64Decoder._valueShift*/get _valueShift() {
>+    return 2;
>+  },
>+  /*convert._Base64Decoder._countMask*/get _countMask() {
>+    return 3;
>+  },
>+  /*convert._Base64Decoder._invalid*/get _invalid() {
>+    return -2;
>+  },
>+  /*convert._Base64Decoder._padding*/get _padding() {
>+    return -1;
>+  },
>+  /*convert._Base64Decoder.___*/get ___() {
>+    return -2;
>+  },
>+  /*convert._Base64Decoder._p*/get _p() {
>+    return -1;
>+  },
>+  /*convert._Base64Decoder._inverseAlphabet*/get _inverseAlphabet() {
>+    return typed_data.Int8List.fromList(JSArrayOfint().of([-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -2, -2, -2, -2, -2, 62, -2, 62, -2, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -2, -2, -2, -1, -2, -2, -2, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -2, -2, -2, -2, 63, -2, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -2, -2, -2, -2, -2]));
>+  },
>+  /*convert._Base64Decoder._char_percent*/get _char_percent() {
>+    return 37;
>+  },
>+  /*convert._Base64Decoder._char_3*/get _char_3() {
>+    return 51;
>+  },
>+  /*convert._Base64Decoder._char_d*/get _char_d() {
>+    return 100;
>+  }
>+});
>+const _decoder = dart.privateName(convert, "_decoder");
>+convert._Base64DecoderSink = class _Base64DecoderSink extends convert.StringConversionSinkBase {
>+  add(string) {
>+    core.String._check(string);
>+    if (string[$isEmpty]) return;
>+    let buffer = this[_decoder].decode(string, 0, string.length);
>+    if (buffer != null) this[_sink$].add(buffer);
>+  }
>+  close() {
>+    this[_decoder].close(null, null);
>+    this[_sink$].close();
>+  }
>+  addSlice(string, start, end, isLast) {
>+    end = core.RangeError.checkValidRange(start, end, string.length);
>+    if (start == end) return;
>+    let buffer = this[_decoder].decode(string, start, end);
>+    if (buffer != null) this[_sink$].add(buffer);
>+    if (dart.test(isLast)) {
>+      this[_decoder].close(string, end);
>+      this[_sink$].close();
>+    }
>+  }
>+};
>+(convert._Base64DecoderSink.new = function(sink) {
>+  this[_decoder] = new convert._Base64Decoder.new();
>+  this[_sink$] = sink;
>+}).prototype = convert._Base64DecoderSink.prototype;
>+dart.addTypeTests(convert._Base64DecoderSink);
>+dart.setMethodSignature(convert._Base64DecoderSink, () => ({
>+  __proto__: dart.getMethods(convert._Base64DecoderSink.__proto__),
>+  add: dart.fnType(dart.void, [core.Object]),
>+  close: dart.fnType(dart.void, []),
>+  addSlice: dart.fnType(dart.void, [core.String, core.int, core.int, core.bool])
>+}));
>+dart.setLibraryUri(convert._Base64DecoderSink, "dart:convert");
>+dart.setFieldSignature(convert._Base64DecoderSink, () => ({
>+  __proto__: dart.getFields(convert._Base64DecoderSink.__proto__),
>+  [_sink$]: dart.finalFieldType(SinkOfListOfint()),
>+  [_decoder]: dart.finalFieldType(convert._Base64Decoder)
>+}));
>+convert._ByteAdapterSink = class _ByteAdapterSink extends convert.ByteConversionSinkBase {
>+  add(chunk) {
>+    ListOfint()._check(chunk);
>+    this[_sink$].add(chunk);
>+  }
>+  close() {
>+    this[_sink$].close();
>+  }
>+};
>+(convert._ByteAdapterSink.new = function(sink) {
>+  this[_sink$] = sink;
>+  convert._ByteAdapterSink.__proto__.new.call(this);
>+}).prototype = convert._ByteAdapterSink.prototype;
>+dart.addTypeTests(convert._ByteAdapterSink);
>+dart.setMethodSignature(convert._ByteAdapterSink, () => ({
>+  __proto__: dart.getMethods(convert._ByteAdapterSink.__proto__),
>+  add: dart.fnType(dart.void, [core.Object]),
>+  close: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(convert._ByteAdapterSink, "dart:convert");
>+dart.setFieldSignature(convert._ByteAdapterSink, () => ({
>+  __proto__: dart.getFields(convert._ByteAdapterSink.__proto__),
>+  [_sink$]: dart.finalFieldType(SinkOfListOfint())
>+}));
>+const _callback = dart.privateName(convert, "_callback");
>+const _buffer = dart.privateName(convert, "_buffer");
>+const _bufferIndex = dart.privateName(convert, "_bufferIndex");
>+convert._ByteCallbackSink = class _ByteCallbackSink extends convert.ByteConversionSinkBase {
>+  add(chunk) {
>+    IterableOfint()._check(chunk);
>+    let freeCount = dart.notNull(this[_buffer][$length]) - dart.notNull(this[_bufferIndex]);
>+    if (dart.notNull(chunk[$length]) > freeCount) {
>+      let oldLength = this[_buffer][$length];
>+      let newLength = dart.notNull(convert._ByteCallbackSink._roundToPowerOf2(dart.notNull(chunk[$length]) + dart.notNull(oldLength))) * 2;
>+      let grown = typed_data.Uint8List.new(newLength);
>+      grown[$setRange](0, this[_buffer][$length], this[_buffer]);
>+      this[_buffer] = grown;
>+    }
>+    this[_buffer][$setRange](this[_bufferIndex], dart.notNull(this[_bufferIndex]) + dart.notNull(chunk[$length]), chunk);
>+    this[_bufferIndex] = dart.notNull(this[_bufferIndex]) + dart.notNull(chunk[$length]);
>+  }
>+  static _roundToPowerOf2(v) {
>+    if (!(dart.notNull(v) > 0)) dart.assertFailed(null, "dart:convert/byte_conversion.dart", 95, 12, "v > 0");
>+    v = dart.notNull(v) - 1;
>+    v = (dart.notNull(v) | v[$rightShift](1)) >>> 0;
>+    v = (dart.notNull(v) | v[$rightShift](2)) >>> 0;
>+    v = (dart.notNull(v) | v[$rightShift](4)) >>> 0;
>+    v = (dart.notNull(v) | v[$rightShift](8)) >>> 0;
>+    v = (dart.notNull(v) | v[$rightShift](16)) >>> 0;
>+    v = dart.notNull(v) + 1;
>+    return v;
>+  }
>+  close() {
>+    this[_callback](this[_buffer][$sublist](0, this[_bufferIndex]));
>+  }
>+};
>+(convert._ByteCallbackSink.new = function(callback) {
>+  this[_buffer] = typed_data.Uint8List.new(1024);
>+  this[_bufferIndex] = 0;
>+  this[_callback] = callback;
>+  convert._ByteCallbackSink.__proto__.new.call(this);
>+}).prototype = convert._ByteCallbackSink.prototype;
>+dart.addTypeTests(convert._ByteCallbackSink);
>+dart.setMethodSignature(convert._ByteCallbackSink, () => ({
>+  __proto__: dart.getMethods(convert._ByteCallbackSink.__proto__),
>+  add: dart.fnType(dart.void, [core.Object]),
>+  close: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(convert._ByteCallbackSink, "dart:convert");
>+dart.setFieldSignature(convert._ByteCallbackSink, () => ({
>+  __proto__: dart.getFields(convert._ByteCallbackSink.__proto__),
>+  [_callback]: dart.finalFieldType(ListOfintTovoid()),
>+  [_buffer]: dart.fieldType(ListOfint()),
>+  [_bufferIndex]: dart.fieldType(core.int)
>+}));
>+dart.defineLazy(convert._ByteCallbackSink, {
>+  /*convert._ByteCallbackSink._INITIAL_BUFFER_SIZE*/get _INITIAL_BUFFER_SIZE() {
>+    return 1024;
>+  }
>+});
>+const _accumulated = dart.privateName(convert, "_accumulated");
>+const _is__SimpleCallbackSink_default = Symbol('_is__SimpleCallbackSink_default');
>+convert._SimpleCallbackSink$ = dart.generic(T => {
>+  let JSArrayOfT = () => (JSArrayOfT = dart.constFn(_interceptors.JSArray$(T)))();
>+  let ListOfT = () => (ListOfT = dart.constFn(core.List$(T)))();
>+  let ListOfTTovoid = () => (ListOfTTovoid = dart.constFn(dart.fnType(dart.void, [ListOfT()])))();
>+  class _SimpleCallbackSink extends convert.ChunkedConversionSink$(T) {
>+    add(chunk) {
>+      T._check(chunk);
>+      this[_accumulated][$add](chunk);
>+    }
>+    close() {
>+      this[_callback](this[_accumulated]);
>+    }
>+  }
>+  (_SimpleCallbackSink.new = function(callback) {
>+    this[_accumulated] = JSArrayOfT().of([]);
>+    this[_callback] = callback;
>+    _SimpleCallbackSink.__proto__.new.call(this);
>+  }).prototype = _SimpleCallbackSink.prototype;
>+  dart.addTypeTests(_SimpleCallbackSink);
>+  _SimpleCallbackSink.prototype[_is__SimpleCallbackSink_default] = true;
>+  dart.setMethodSignature(_SimpleCallbackSink, () => ({
>+    __proto__: dart.getMethods(_SimpleCallbackSink.__proto__),
>+    add: dart.fnType(dart.void, [core.Object]),
>+    close: dart.fnType(dart.void, [])
>+  }));
>+  dart.setLibraryUri(_SimpleCallbackSink, "dart:convert");
>+  dart.setFieldSignature(_SimpleCallbackSink, () => ({
>+    __proto__: dart.getFields(_SimpleCallbackSink.__proto__),
>+    [_callback]: dart.finalFieldType(ListOfTTovoid()),
>+    [_accumulated]: dart.finalFieldType(ListOfT())
>+  }));
>+  return _SimpleCallbackSink;
>+});
>+convert._SimpleCallbackSink = convert._SimpleCallbackSink$();
>+dart.addTypeTests(convert._SimpleCallbackSink, _is__SimpleCallbackSink_default);
>+const _eventSink = dart.privateName(convert, "_eventSink");
>+const _chunkedSink = dart.privateName(convert, "_chunkedSink");
>+const _is__ConverterStreamEventSink_default = Symbol('_is__ConverterStreamEventSink_default');
>+convert._ConverterStreamEventSink$ = dart.generic((S, T) => {
>+  let EventSinkOfS = () => (EventSinkOfS = dart.constFn(async.EventSink$(S)))();
>+  let SinkOfS = () => (SinkOfS = dart.constFn(core.Sink$(S)))();
>+  let EventSinkOfT = () => (EventSinkOfT = dart.constFn(async.EventSink$(T)))();
>+  class _ConverterStreamEventSink extends core.Object {
>+    add(o) {
>+      S._check(o);
>+      this[_chunkedSink].add(o);
>+    }
>+    addError(error, stackTrace) {
>+      if (stackTrace === void 0) stackTrace = null;
>+      this[_eventSink].addError(error, stackTrace);
>+    }
>+    close() {
>+      this[_chunkedSink].close();
>+    }
>+  }
>+  (_ConverterStreamEventSink.new = function(converter, sink) {
>+    this[_eventSink] = sink;
>+    this[_chunkedSink] = converter.startChunkedConversion(sink);
>+  }).prototype = _ConverterStreamEventSink.prototype;
>+  dart.addTypeTests(_ConverterStreamEventSink);
>+  _ConverterStreamEventSink.prototype[_is__ConverterStreamEventSink_default] = true;
>+  _ConverterStreamEventSink[dart.implements] = () => [EventSinkOfS()];
>+  dart.setMethodSignature(_ConverterStreamEventSink, () => ({
>+    __proto__: dart.getMethods(_ConverterStreamEventSink.__proto__),
>+    add: dart.fnType(dart.void, [core.Object]),
>+    addError: dart.fnType(dart.void, [core.Object], [core.StackTrace]),
>+    close: dart.fnType(dart.void, [])
>+  }));
>+  dart.setLibraryUri(_ConverterStreamEventSink, "dart:convert");
>+  dart.setFieldSignature(_ConverterStreamEventSink, () => ({
>+    __proto__: dart.getFields(_ConverterStreamEventSink.__proto__),
>+    [_eventSink]: dart.finalFieldType(EventSinkOfT()),
>+    [_chunkedSink]: dart.finalFieldType(SinkOfS())
>+  }));
>+  return _ConverterStreamEventSink;
>+});
>+convert._ConverterStreamEventSink = convert._ConverterStreamEventSink$();
>+dart.addTypeTests(convert._ConverterStreamEventSink, _is__ConverterStreamEventSink_default);
>+const _first$0 = dart.privateName(convert, "_first");
>+const _second$ = dart.privateName(convert, "_second");
>+const _is__FusedCodec_default = Symbol('_is__FusedCodec_default');
>+convert._FusedCodec$ = dart.generic((S, M, T) => {
>+  let ConverterOfS$T = () => (ConverterOfS$T = dart.constFn(convert.Converter$(S, T)))();
>+  let ConverterOfT$S = () => (ConverterOfT$S = dart.constFn(convert.Converter$(T, S)))();
>+  let CodecOfS$M = () => (CodecOfS$M = dart.constFn(convert.Codec$(S, M)))();
>+  let CodecOfM$T = () => (CodecOfM$T = dart.constFn(convert.Codec$(M, T)))();
>+  class _FusedCodec extends convert.Codec$(S, T) {
>+    get encoder() {
>+      return ConverterOfS$T()._check(this[_first$0].encoder.fuse(T, this[_second$].encoder));
>+    }
>+    get decoder() {
>+      return ConverterOfT$S()._check(this[_second$].decoder.fuse(S, this[_first$0].decoder));
>+    }
>+  }
>+  (_FusedCodec.new = function(first, second) {
>+    this[_first$0] = first;
>+    this[_second$] = second;
>+    _FusedCodec.__proto__.new.call(this);
>+  }).prototype = _FusedCodec.prototype;
>+  dart.addTypeTests(_FusedCodec);
>+  _FusedCodec.prototype[_is__FusedCodec_default] = true;
>+  dart.setGetterSignature(_FusedCodec, () => ({
>+    __proto__: dart.getGetters(_FusedCodec.__proto__),
>+    encoder: convert.Converter$(S, T),
>+    decoder: convert.Converter$(T, S)
>+  }));
>+  dart.setLibraryUri(_FusedCodec, "dart:convert");
>+  dart.setFieldSignature(_FusedCodec, () => ({
>+    __proto__: dart.getFields(_FusedCodec.__proto__),
>+    [_first$0]: dart.finalFieldType(CodecOfS$M()),
>+    [_second$]: dart.finalFieldType(CodecOfM$T())
>+  }));
>+  return _FusedCodec;
>+});
>+convert._FusedCodec = convert._FusedCodec$();
>+dart.addTypeTests(convert._FusedCodec, _is__FusedCodec_default);
>+const _codec = dart.privateName(convert, "_codec");
>+const _is__InvertedCodec_default = Symbol('_is__InvertedCodec_default');
>+convert._InvertedCodec$ = dart.generic((T, S) => {
>+  let CodecOfS$T = () => (CodecOfS$T = dart.constFn(convert.Codec$(S, T)))();
>+  class _InvertedCodec extends convert.Codec$(T, S) {
>+    get encoder() {
>+      return this[_codec].decoder;
>+    }
>+    get decoder() {
>+      return this[_codec].encoder;
>+    }
>+    get inverted() {
>+      return this[_codec];
>+    }
>+  }
>+  (_InvertedCodec.new = function(codec) {
>+    this[_codec] = codec;
>+    _InvertedCodec.__proto__.new.call(this);
>+  }).prototype = _InvertedCodec.prototype;
>+  dart.addTypeTests(_InvertedCodec);
>+  _InvertedCodec.prototype[_is__InvertedCodec_default] = true;
>+  dart.setGetterSignature(_InvertedCodec, () => ({
>+    __proto__: dart.getGetters(_InvertedCodec.__proto__),
>+    encoder: convert.Converter$(T, S),
>+    decoder: convert.Converter$(S, T)
>+  }));
>+  dart.setLibraryUri(_InvertedCodec, "dart:convert");
>+  dart.setFieldSignature(_InvertedCodec, () => ({
>+    __proto__: dart.getFields(_InvertedCodec.__proto__),
>+    [_codec]: dart.finalFieldType(CodecOfS$T())
>+  }));
>+  return _InvertedCodec;
>+});
>+convert._InvertedCodec = convert._InvertedCodec$();
>+dart.addTypeTests(convert._InvertedCodec, _is__InvertedCodec_default);
>+const _is__FusedConverter_default = Symbol('_is__FusedConverter_default');
>+convert._FusedConverter$ = dart.generic((S, M, T) => {
>+  let ConverterOfS$M = () => (ConverterOfS$M = dart.constFn(convert.Converter$(S, M)))();
>+  let ConverterOfM$T = () => (ConverterOfM$T = dart.constFn(convert.Converter$(M, T)))();
>+  let SinkOfT = () => (SinkOfT = dart.constFn(core.Sink$(T)))();
>+  class _FusedConverter extends convert.Converter$(S, T) {
>+    convert(input) {
>+      S._check(input);
>+      return this[_second$].convert(this[_first$0].convert(input));
>+    }
>+    startChunkedConversion(sink) {
>+      SinkOfT()._check(sink);
>+      return this[_first$0].startChunkedConversion(this[_second$].startChunkedConversion(sink));
>+    }
>+  }
>+  (_FusedConverter.new = function(first, second) {
>+    this[_first$0] = first;
>+    this[_second$] = second;
>+    _FusedConverter.__proto__.new.call(this);
>+  }).prototype = _FusedConverter.prototype;
>+  dart.addTypeTests(_FusedConverter);
>+  _FusedConverter.prototype[_is__FusedConverter_default] = true;
>+  dart.setMethodSignature(_FusedConverter, () => ({
>+    __proto__: dart.getMethods(_FusedConverter.__proto__),
>+    convert: dart.fnType(T, [core.Object]),
>+    startChunkedConversion: dart.fnType(core.Sink$(S), [core.Object])
>+  }));
>+  dart.setLibraryUri(_FusedConverter, "dart:convert");
>+  dart.setFieldSignature(_FusedConverter, () => ({
>+    __proto__: dart.getFields(_FusedConverter.__proto__),
>+    [_first$0]: dart.finalFieldType(ConverterOfS$M()),
>+    [_second$]: dart.finalFieldType(ConverterOfM$T())
>+  }));
>+  return _FusedConverter;
>+});
>+convert._FusedConverter = convert._FusedConverter$();
>+dart.addTypeTests(convert._FusedConverter, _is__FusedConverter_default);
>+dart.defineLazy(convert, {
>+  /*convert.htmlEscape*/get htmlEscape() {
>+    return dart.const(new convert.HtmlEscape.new());
>+  }
>+});
>+const _name$1 = dart.privateName(convert, "_name");
>+convert.HtmlEscapeMode = class HtmlEscapeMode extends core.Object {
>+  get escapeLtGt() {
>+    return this[escapeLtGt$];
>+  }
>+  set escapeLtGt(value) {
>+    super.escapeLtGt = value;
>+  }
>+  get escapeQuot() {
>+    return this[escapeQuot$];
>+  }
>+  set escapeQuot(value) {
>+    super.escapeQuot = value;
>+  }
>+  get escapeApos() {
>+    return this[escapeApos$];
>+  }
>+  set escapeApos(value) {
>+    super.escapeApos = value;
>+  }
>+  get escapeSlash() {
>+    return this[escapeSlash$];
>+  }
>+  set escapeSlash(value) {
>+    super.escapeSlash = value;
>+  }
>+  toString() {
>+    return this[_name$1];
>+  }
>+};
>+(convert.HtmlEscapeMode.__ = function(name, escapeLtGt, escapeQuot, escapeApos, escapeSlash) {
>+  this[_name$1] = name;
>+  this[escapeLtGt$] = escapeLtGt;
>+  this[escapeQuot$] = escapeQuot;
>+  this[escapeApos$] = escapeApos;
>+  this[escapeSlash$] = escapeSlash;
>+}).prototype = convert.HtmlEscapeMode.prototype;
>+(convert.HtmlEscapeMode.new = function(opts) {
>+  let name = opts && 'name' in opts ? opts.name : "custom";
>+  let escapeLtGt = opts && 'escapeLtGt' in opts ? opts.escapeLtGt : false;
>+  let escapeQuot = opts && 'escapeQuot' in opts ? opts.escapeQuot : false;
>+  let escapeApos = opts && 'escapeApos' in opts ? opts.escapeApos : false;
>+  let escapeSlash = opts && 'escapeSlash' in opts ? opts.escapeSlash : false;
>+  this[escapeLtGt$] = escapeLtGt;
>+  this[escapeQuot$] = escapeQuot;
>+  this[escapeApos$] = escapeApos;
>+  this[escapeSlash$] = escapeSlash;
>+  this[_name$1] = name;
>+}).prototype = convert.HtmlEscapeMode.prototype;
>+dart.addTypeTests(convert.HtmlEscapeMode);
>+const escapeLtGt$ = Symbol("HtmlEscapeMode.escapeLtGt");
>+const escapeQuot$ = Symbol("HtmlEscapeMode.escapeQuot");
>+const escapeApos$ = Symbol("HtmlEscapeMode.escapeApos");
>+const escapeSlash$ = Symbol("HtmlEscapeMode.escapeSlash");
>+dart.setLibraryUri(convert.HtmlEscapeMode, "dart:convert");
>+dart.setFieldSignature(convert.HtmlEscapeMode, () => ({
>+  __proto__: dart.getFields(convert.HtmlEscapeMode.__proto__),
>+  [_name$1]: dart.finalFieldType(core.String),
>+  escapeLtGt: dart.finalFieldType(core.bool),
>+  escapeQuot: dart.finalFieldType(core.bool),
>+  escapeApos: dart.finalFieldType(core.bool),
>+  escapeSlash: dart.finalFieldType(core.bool)
>+}));
>+dart.defineExtensionMethods(convert.HtmlEscapeMode, ['toString']);
>+dart.defineLazy(convert.HtmlEscapeMode, {
>+  /*convert.HtmlEscapeMode.unknown*/get unknown() {
>+    return dart.const(new convert.HtmlEscapeMode.__("unknown", true, true, true, true));
>+  },
>+  /*convert.HtmlEscapeMode.attribute*/get attribute() {
>+    return dart.const(new convert.HtmlEscapeMode.__("attribute", true, true, false, false));
>+  },
>+  /*convert.HtmlEscapeMode.sqAttribute*/get sqAttribute() {
>+    return dart.const(new convert.HtmlEscapeMode.__("attribute", true, false, true, false));
>+  },
>+  /*convert.HtmlEscapeMode.element*/get element() {
>+    return dart.const(new convert.HtmlEscapeMode.__("element", true, false, false, false));
>+  }
>+});
>+const _convert = dart.privateName(convert, "_convert");
>+convert.HtmlEscape = class HtmlEscape extends convert.Converter$(core.String, core.String) {
>+  get mode() {
>+    return this[mode$];
>+  }
>+  set mode(value) {
>+    super.mode = value;
>+  }
>+  convert(text) {
>+    core.String._check(text);
>+    let val = this[_convert](text, 0, text.length);
>+    return val == null ? text : val;
>+  }
>+  [_convert](text, start, end) {
>+    let result = null;
>+    for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
>+      let ch = text[$_get](i);
>+      let replacement = null;
>+      switch (ch) {
>+        case "&":
>+        {
>+          replacement = "&amp;";
>+          break;
>+        }
>+        case "\"":
>+        {
>+          if (dart.test(this.mode.escapeQuot)) replacement = "&quot;";
>+          break;
>+        }
>+        case "'":
>+        {
>+          if (dart.test(this.mode.escapeApos)) replacement = "&#39;";
>+          break;
>+        }
>+        case "<":
>+        {
>+          if (dart.test(this.mode.escapeLtGt)) replacement = "&lt;";
>+          break;
>+        }
>+        case ">":
>+        {
>+          if (dart.test(this.mode.escapeLtGt)) replacement = "&gt;";
>+          break;
>+        }
>+        case "/":
>+        {
>+          if (dart.test(this.mode.escapeSlash)) replacement = "&#47;";
>+          break;
>+        }
>+      }
>+      if (replacement != null) {
>+        let t = result;
>+        t == null ? result = new core.StringBuffer.new() : t;
>+        if (dart.notNull(i) > dart.notNull(start)) result.write(text[$substring](start, i));
>+        result.write(replacement);
>+        start = dart.notNull(i) + 1;
>+      }
>+    }
>+    if (result == null) return null;
>+    if (dart.notNull(end) > dart.notNull(start)) result.write(text[$substring](start, end));
>+    return dart.toString(result);
>+  }
>+  startChunkedConversion(sink) {
>+    SinkOfString()._check(sink);
>+    return new convert._HtmlEscapeSink.new(this, convert.StringConversionSink.is(sink) ? sink : convert.StringConversionSink.from(sink));
>+  }
>+};
>+(convert.HtmlEscape.new = function(mode) {
>+  if (mode === void 0) mode = convert.HtmlEscapeMode.unknown;
>+  this[mode$] = mode;
>+  convert.HtmlEscape.__proto__.new.call(this);
>+}).prototype = convert.HtmlEscape.prototype;
>+dart.addTypeTests(convert.HtmlEscape);
>+const mode$ = Symbol("HtmlEscape.mode");
>+dart.setMethodSignature(convert.HtmlEscape, () => ({
>+  __proto__: dart.getMethods(convert.HtmlEscape.__proto__),
>+  convert: dart.fnType(core.String, [core.Object]),
>+  [_convert]: dart.fnType(core.String, [core.String, core.int, core.int]),
>+  startChunkedConversion: dart.fnType(convert.StringConversionSink, [core.Object])
>+}));
>+dart.setLibraryUri(convert.HtmlEscape, "dart:convert");
>+dart.setFieldSignature(convert.HtmlEscape, () => ({
>+  __proto__: dart.getFields(convert.HtmlEscape.__proto__),
>+  mode: dart.finalFieldType(convert.HtmlEscapeMode)
>+}));
>+const _escape = dart.privateName(convert, "_escape");
>+convert._HtmlEscapeSink = class _HtmlEscapeSink extends convert.StringConversionSinkBase {
>+  addSlice(chunk, start, end, isLast) {
>+    let val = this[_escape][_convert](chunk, start, end);
>+    if (val == null) {
>+      this[_sink$].addSlice(chunk, start, end, isLast);
>+    } else {
>+      this[_sink$].add(val);
>+      if (dart.test(isLast)) this[_sink$].close();
>+    }
>+  }
>+  close() {
>+    this[_sink$].close();
>+  }
>+};
>+(convert._HtmlEscapeSink.new = function(escape, sink) {
>+  this[_escape] = escape;
>+  this[_sink$] = sink;
>+}).prototype = convert._HtmlEscapeSink.prototype;
>+dart.addTypeTests(convert._HtmlEscapeSink);
>+dart.setMethodSignature(convert._HtmlEscapeSink, () => ({
>+  __proto__: dart.getMethods(convert._HtmlEscapeSink.__proto__),
>+  addSlice: dart.fnType(dart.void, [core.String, core.int, core.int, core.bool]),
>+  close: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(convert._HtmlEscapeSink, "dart:convert");
>+dart.setFieldSignature(convert._HtmlEscapeSink, () => ({
>+  __proto__: dart.getFields(convert._HtmlEscapeSink.__proto__),
>+  [_escape]: dart.finalFieldType(convert.HtmlEscape),
>+  [_sink$]: dart.finalFieldType(convert.StringConversionSink)
>+}));
>+convert.JsonUnsupportedObjectError = class JsonUnsupportedObjectError extends core.Error {
>+  get unsupportedObject() {
>+    return this[unsupportedObject$];
>+  }
>+  set unsupportedObject(value) {
>+    super.unsupportedObject = value;
>+  }
>+  get cause() {
>+    return this[cause$];
>+  }
>+  set cause(value) {
>+    super.cause = value;
>+  }
>+  get partialResult() {
>+    return this[partialResult$];
>+  }
>+  set partialResult(value) {
>+    super.partialResult = value;
>+  }
>+  toString() {
>+    let safeString = core.Error.safeToString(this.unsupportedObject);
>+    let prefix = null;
>+    if (this.cause != null) {
>+      prefix = "Converting object to an encodable object failed:";
>+    } else {
>+      prefix = "Converting object did not return an encodable object:";
>+    }
>+    return dart.str(prefix) + " " + dart.str(safeString);
>+  }
>+};
>+(convert.JsonUnsupportedObjectError.new = function(unsupportedObject, opts) {
>+  let cause = opts && 'cause' in opts ? opts.cause : null;
>+  let partialResult = opts && 'partialResult' in opts ? opts.partialResult : null;
>+  this[unsupportedObject$] = unsupportedObject;
>+  this[cause$] = cause;
>+  this[partialResult$] = partialResult;
>+  convert.JsonUnsupportedObjectError.__proto__.new.call(this);
>+}).prototype = convert.JsonUnsupportedObjectError.prototype;
>+dart.addTypeTests(convert.JsonUnsupportedObjectError);
>+const unsupportedObject$ = Symbol("JsonUnsupportedObjectError.unsupportedObject");
>+const cause$ = Symbol("JsonUnsupportedObjectError.cause");
>+const partialResult$ = Symbol("JsonUnsupportedObjectError.partialResult");
>+dart.setLibraryUri(convert.JsonUnsupportedObjectError, "dart:convert");
>+dart.setFieldSignature(convert.JsonUnsupportedObjectError, () => ({
>+  __proto__: dart.getFields(convert.JsonUnsupportedObjectError.__proto__),
>+  unsupportedObject: dart.finalFieldType(core.Object),
>+  cause: dart.finalFieldType(core.Object),
>+  partialResult: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionMethods(convert.JsonUnsupportedObjectError, ['toString']);
>+convert.JsonCyclicError = class JsonCyclicError extends convert.JsonUnsupportedObjectError {
>+  toString() {
>+    return "Cyclic error in JSON stringify";
>+  }
>+};
>+(convert.JsonCyclicError.new = function(object) {
>+  convert.JsonCyclicError.__proto__.new.call(this, object);
>+}).prototype = convert.JsonCyclicError.prototype;
>+dart.addTypeTests(convert.JsonCyclicError);
>+dart.setLibraryUri(convert.JsonCyclicError, "dart:convert");
>+dart.defineExtensionMethods(convert.JsonCyclicError, ['toString']);
>+dart.defineLazy(convert, {
>+  /*convert.json*/get json() {
>+    return dart.const(new convert.JsonCodec.new());
>+  }
>+});
>+convert.jsonEncode = function(object, opts) {
>+  let toEncodable = opts && 'toEncodable' in opts ? opts.toEncodable : null;
>+  return convert.json.encode(object, {toEncodable: toEncodable});
>+};
>+convert.jsonDecode = function(source, opts) {
>+  let reviver = opts && 'reviver' in opts ? opts.reviver : null;
>+  return convert.json.decode(source, {reviver: reviver});
>+};
>+const _toEncodable = dart.privateName(convert, "_toEncodable");
>+let const$41;
>+let const$42;
>+convert.JsonCodec = class JsonCodec extends convert.Codec$(core.Object, core.String) {
>+  decode(source, opts) {
>+    core.String._check(source);
>+    let reviver = opts && 'reviver' in opts ? opts.reviver : null;
>+    let t = reviver;
>+    t == null ? reviver = this[_reviver] : t;
>+    if (reviver == null) return this.decoder.convert(source);
>+    return new convert.JsonDecoder.new(reviver).convert(source);
>+  }
>+  encode(value, opts) {
>+    let toEncodable = opts && 'toEncodable' in opts ? opts.toEncodable : null;
>+    let t = toEncodable;
>+    t == null ? toEncodable = this[_toEncodable] : t;
>+    if (toEncodable == null) return this.encoder.convert(value);
>+    return new convert.JsonEncoder.new(toEncodable).convert(value);
>+  }
>+  get encoder() {
>+    if (this[_toEncodable] == null) return const$41 || (const$41 = dart.const(new convert.JsonEncoder.new()));
>+    return new convert.JsonEncoder.new(this[_toEncodable]);
>+  }
>+  get decoder() {
>+    if (this[_reviver] == null) return const$42 || (const$42 = dart.const(new convert.JsonDecoder.new()));
>+    return new convert.JsonDecoder.new(this[_reviver]);
>+  }
>+};
>+(convert.JsonCodec.new = function(opts) {
>+  let reviver = opts && 'reviver' in opts ? opts.reviver : null;
>+  let toEncodable = opts && 'toEncodable' in opts ? opts.toEncodable : null;
>+  this[_reviver] = reviver;
>+  this[_toEncodable] = toEncodable;
>+  convert.JsonCodec.__proto__.new.call(this);
>+}).prototype = convert.JsonCodec.prototype;
>+(convert.JsonCodec.withReviver = function(reviver) {
>+  convert.JsonCodec.new.call(this, {reviver: reviver});
>+}).prototype = convert.JsonCodec.prototype;
>+dart.addTypeTests(convert.JsonCodec);
>+dart.setMethodSignature(convert.JsonCodec, () => ({
>+  __proto__: dart.getMethods(convert.JsonCodec.__proto__),
>+  decode: dart.fnType(dart.dynamic, [core.Object], {reviver: dart.fnType(dart.dynamic, [core.Object, core.Object])}),
>+  encode: dart.fnType(core.String, [core.Object], {toEncodable: dart.fnType(dart.dynamic, [dart.dynamic])})
>+}));
>+dart.setGetterSignature(convert.JsonCodec, () => ({
>+  __proto__: dart.getGetters(convert.JsonCodec.__proto__),
>+  encoder: convert.JsonEncoder,
>+  decoder: convert.JsonDecoder
>+}));
>+dart.setLibraryUri(convert.JsonCodec, "dart:convert");
>+dart.setFieldSignature(convert.JsonCodec, () => ({
>+  __proto__: dart.getFields(convert.JsonCodec.__proto__),
>+  [_reviver]: dart.finalFieldType(ObjectAndObjectTodynamic()),
>+  [_toEncodable]: dart.finalFieldType(dynamicTodynamic())
>+}));
>+convert.JsonEncoder = class JsonEncoder extends convert.Converter$(core.Object, core.String) {
>+  get indent() {
>+    return this[indent$];
>+  }
>+  set indent(value) {
>+    super.indent = value;
>+  }
>+  convert(object) {
>+    return convert._JsonStringStringifier.stringify(object, this[_toEncodable], this.indent);
>+  }
>+  startChunkedConversion(sink) {
>+    SinkOfString()._check(sink);
>+    if (convert._Utf8EncoderSink.is(sink)) {
>+      return new convert._JsonUtf8EncoderSink.new(sink[_sink$], this[_toEncodable], convert.JsonUtf8Encoder._utf8Encode(this.indent), convert.JsonUtf8Encoder._defaultBufferSize);
>+    }
>+    return new convert._JsonEncoderSink.new(convert.StringConversionSink.is(sink) ? sink : convert.StringConversionSink.from(sink), this[_toEncodable], this.indent);
>+  }
>+  bind(stream) {
>+    return super.bind(stream);
>+  }
>+  fuse(T, other) {
>+    convert.Converter$(core.String, T)._check(other);
>+    if (convert.Utf8Encoder.is(other) && ListOfint().is(dart.wrapType(T))) {
>+      return convert.Converter$(core.Object, T)._check(new convert.JsonUtf8Encoder.new(this.indent, this[_toEncodable]));
>+    }
>+    return super.fuse(T, other);
>+  }
>+};
>+(convert.JsonEncoder.new = function(toEncodable) {
>+  if (toEncodable === void 0) toEncodable = null;
>+  this[indent$] = null;
>+  this[_toEncodable] = toEncodable;
>+  convert.JsonEncoder.__proto__.new.call(this);
>+}).prototype = convert.JsonEncoder.prototype;
>+(convert.JsonEncoder.withIndent = function(indent, toEncodable) {
>+  if (toEncodable === void 0) toEncodable = null;
>+  this[indent$] = indent;
>+  this[_toEncodable] = toEncodable;
>+  convert.JsonEncoder.__proto__.new.call(this);
>+}).prototype = convert.JsonEncoder.prototype;
>+dart.addTypeTests(convert.JsonEncoder);
>+const indent$ = Symbol("JsonEncoder.indent");
>+dart.setMethodSignature(convert.JsonEncoder, () => ({
>+  __proto__: dart.getMethods(convert.JsonEncoder.__proto__),
>+  convert: dart.fnType(core.String, [core.Object]),
>+  startChunkedConversion: dart.fnType(convert.ChunkedConversionSink$(core.Object), [core.Object]),
>+  bind: dart.fnType(async.Stream$(core.String), [async.Stream$(core.Object)]),
>+  fuse: dart.gFnType(T => [convert.Converter$(core.Object, T), [core.Object]])
>+}));
>+dart.setLibraryUri(convert.JsonEncoder, "dart:convert");
>+dart.setFieldSignature(convert.JsonEncoder, () => ({
>+  __proto__: dart.getFields(convert.JsonEncoder.__proto__),
>+  indent: dart.finalFieldType(core.String),
>+  [_toEncodable]: dart.finalFieldType(dynamicTodynamic())
>+}));
>+const _indent = dart.privateName(convert, "_indent");
>+const _bufferSize = dart.privateName(convert, "_bufferSize");
>+convert.JsonUtf8Encoder = class JsonUtf8Encoder extends convert.Converter$(core.Object, core.List$(core.int)) {
>+  static _utf8Encode(string) {
>+    if (string == null) return null;
>+    if (string[$isEmpty]) return typed_data.Uint8List.new(0);
>+    checkAscii: {
>+      for (let i = 0; i < string.length; i++) {
>+        if (string[$codeUnitAt](i) >= 128) break checkAscii;
>+      }
>+      return string[$codeUnits];
>+    }
>+    return convert.utf8.encode(string);
>+  }
>+  convert(object) {
>+    let bytes = JSArrayOfListOfint().of([]);
>+    function addChunk(chunk, start, end) {
>+      if (dart.notNull(start) > 0 || dart.notNull(end) < dart.notNull(chunk[$length])) {
>+        let length = dart.notNull(end) - dart.notNull(start);
>+        chunk = typed_data.Uint8List.view(chunk[$buffer], dart.notNull(chunk[$offsetInBytes]) + dart.notNull(start), length);
>+      }
>+      bytes[$add](chunk);
>+    }
>+    dart.fn(addChunk, Uint8ListAndintAndintTovoid());
>+    convert._JsonUtf8Stringifier.stringify(object, this[_indent], this[_toEncodable], this[_bufferSize], addChunk);
>+    if (bytes[$length] === 1) return bytes[$_get](0);
>+    let length = 0;
>+    for (let i = 0; i < dart.notNull(bytes[$length]); i++) {
>+      length = length + dart.notNull(bytes[$_get](i)[$length]);
>+    }
>+    let result = typed_data.Uint8List.new(length);
>+    for (let i = 0, offset = 0; i < dart.notNull(bytes[$length]); i++) {
>+      let byteList = bytes[$_get](i);
>+      let end = offset + dart.notNull(byteList[$length]);
>+      result[$setRange](offset, end, byteList);
>+      offset = end;
>+    }
>+    return result;
>+  }
>+  startChunkedConversion(sink) {
>+    SinkOfListOfint()._check(sink);
>+    let byteSink = null;
>+    if (convert.ByteConversionSink.is(sink)) {
>+      byteSink = sink;
>+    } else {
>+      byteSink = convert.ByteConversionSink.from(sink);
>+    }
>+    return new convert._JsonUtf8EncoderSink.new(byteSink, this[_toEncodable], this[_indent], this[_bufferSize]);
>+  }
>+  bind(stream) {
>+    return super.bind(stream);
>+  }
>+};
>+(convert.JsonUtf8Encoder.new = function(indent, toEncodable, bufferSize) {
>+  if (indent === void 0) indent = null;
>+  if (toEncodable === void 0) toEncodable = null;
>+  if (bufferSize === void 0) bufferSize = 256;
>+  this[_indent] = convert.JsonUtf8Encoder._utf8Encode(indent);
>+  this[_toEncodable] = toEncodable;
>+  this[_bufferSize] = bufferSize;
>+  convert.JsonUtf8Encoder.__proto__.new.call(this);
>+}).prototype = convert.JsonUtf8Encoder.prototype;
>+dart.addTypeTests(convert.JsonUtf8Encoder);
>+dart.setMethodSignature(convert.JsonUtf8Encoder, () => ({
>+  __proto__: dart.getMethods(convert.JsonUtf8Encoder.__proto__),
>+  convert: dart.fnType(core.List$(core.int), [core.Object]),
>+  startChunkedConversion: dart.fnType(convert.ChunkedConversionSink$(core.Object), [core.Object]),
>+  bind: dart.fnType(async.Stream$(core.List$(core.int)), [async.Stream$(core.Object)])
>+}));
>+dart.setLibraryUri(convert.JsonUtf8Encoder, "dart:convert");
>+dart.setFieldSignature(convert.JsonUtf8Encoder, () => ({
>+  __proto__: dart.getFields(convert.JsonUtf8Encoder.__proto__),
>+  [_indent]: dart.finalFieldType(ListOfint()),
>+  [_toEncodable]: dart.finalFieldType(dynamicTodynamic()),
>+  [_bufferSize]: dart.finalFieldType(core.int)
>+}));
>+dart.defineLazy(convert.JsonUtf8Encoder, {
>+  /*convert.JsonUtf8Encoder._defaultBufferSize*/get _defaultBufferSize() {
>+    return 256;
>+  },
>+  /*convert.JsonUtf8Encoder.DEFAULT_BUFFER_SIZE*/get DEFAULT_BUFFER_SIZE() {
>+    return 256;
>+  }
>+});
>+const _isDone = dart.privateName(convert, "_isDone");
>+convert._JsonEncoderSink = class _JsonEncoderSink extends convert.ChunkedConversionSink$(core.Object) {
>+  add(o) {
>+    if (dart.test(this[_isDone])) {
>+      dart.throw(new core.StateError.new("Only one call to add allowed"));
>+    }
>+    this[_isDone] = true;
>+    let stringSink = this[_sink$].asStringSink();
>+    convert._JsonStringStringifier.printOn(o, stringSink, this[_toEncodable], this[_indent]);
>+    stringSink.close();
>+  }
>+  close() {}
>+};
>+(convert._JsonEncoderSink.new = function(sink, toEncodable, indent) {
>+  this[_isDone] = false;
>+  this[_sink$] = sink;
>+  this[_toEncodable] = toEncodable;
>+  this[_indent] = indent;
>+  convert._JsonEncoderSink.__proto__.new.call(this);
>+}).prototype = convert._JsonEncoderSink.prototype;
>+dart.addTypeTests(convert._JsonEncoderSink);
>+dart.setMethodSignature(convert._JsonEncoderSink, () => ({
>+  __proto__: dart.getMethods(convert._JsonEncoderSink.__proto__),
>+  add: dart.fnType(dart.void, [core.Object]),
>+  close: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(convert._JsonEncoderSink, "dart:convert");
>+dart.setFieldSignature(convert._JsonEncoderSink, () => ({
>+  __proto__: dart.getFields(convert._JsonEncoderSink.__proto__),
>+  [_indent]: dart.finalFieldType(core.String),
>+  [_toEncodable]: dart.finalFieldType(dynamicTodynamic()),
>+  [_sink$]: dart.finalFieldType(convert.StringConversionSink),
>+  [_isDone]: dart.fieldType(core.bool)
>+}));
>+const _addChunk = dart.privateName(convert, "_addChunk");
>+convert._JsonUtf8EncoderSink = class _JsonUtf8EncoderSink extends convert.ChunkedConversionSink$(core.Object) {
>+  [_addChunk](chunk, start, end) {
>+    this[_sink$].addSlice(chunk, start, end, false);
>+  }
>+  add(object) {
>+    if (dart.test(this[_isDone])) {
>+      dart.throw(new core.StateError.new("Only one call to add allowed"));
>+    }
>+    this[_isDone] = true;
>+    convert._JsonUtf8Stringifier.stringify(object, this[_indent], this[_toEncodable], this[_bufferSize], dart.bind(this, _addChunk));
>+    this[_sink$].close();
>+  }
>+  close() {
>+    if (!dart.test(this[_isDone])) {
>+      this[_isDone] = true;
>+      this[_sink$].close();
>+    }
>+  }
>+};
>+(convert._JsonUtf8EncoderSink.new = function(sink, toEncodable, indent, bufferSize) {
>+  this[_isDone] = false;
>+  this[_sink$] = sink;
>+  this[_toEncodable] = toEncodable;
>+  this[_indent] = indent;
>+  this[_bufferSize] = bufferSize;
>+  convert._JsonUtf8EncoderSink.__proto__.new.call(this);
>+}).prototype = convert._JsonUtf8EncoderSink.prototype;
>+dart.addTypeTests(convert._JsonUtf8EncoderSink);
>+dart.setMethodSignature(convert._JsonUtf8EncoderSink, () => ({
>+  __proto__: dart.getMethods(convert._JsonUtf8EncoderSink.__proto__),
>+  [_addChunk]: dart.fnType(dart.void, [typed_data.Uint8List, core.int, core.int]),
>+  add: dart.fnType(dart.void, [core.Object]),
>+  close: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(convert._JsonUtf8EncoderSink, "dart:convert");
>+dart.setFieldSignature(convert._JsonUtf8EncoderSink, () => ({
>+  __proto__: dart.getFields(convert._JsonUtf8EncoderSink.__proto__),
>+  [_sink$]: dart.finalFieldType(convert.ByteConversionSink),
>+  [_indent]: dart.finalFieldType(ListOfint()),
>+  [_toEncodable]: dart.finalFieldType(dynamicTodynamic()),
>+  [_bufferSize]: dart.finalFieldType(core.int),
>+  [_isDone]: dart.fieldType(core.bool)
>+}));
>+convert.JsonDecoder = class JsonDecoder extends convert.Converter$(core.String, core.Object) {
>+  convert(input) {
>+    core.String._check(input);
>+    return convert._parseJson(input, this[_reviver]);
>+  }
>+  startChunkedConversion(sink) {
>+    return new convert._JsonDecoderSink.new(this[_reviver], sink);
>+  }
>+  bind(stream) {
>+    StreamOfString()._check(stream);
>+    return super.bind(stream);
>+  }
>+};
>+(convert.JsonDecoder.new = function(reviver) {
>+  if (reviver === void 0) reviver = null;
>+  this[_reviver] = reviver;
>+  convert.JsonDecoder.__proto__.new.call(this);
>+}).prototype = convert.JsonDecoder.prototype;
>+dart.addTypeTests(convert.JsonDecoder);
>+dart.setMethodSignature(convert.JsonDecoder, () => ({
>+  __proto__: dart.getMethods(convert.JsonDecoder.__proto__),
>+  convert: dart.fnType(dart.dynamic, [core.Object]),
>+  startChunkedConversion: dart.fnType(convert.StringConversionSink, [core.Sink$(core.Object)]),
>+  bind: dart.fnType(async.Stream$(core.Object), [core.Object])
>+}));
>+dart.setLibraryUri(convert.JsonDecoder, "dart:convert");
>+dart.setFieldSignature(convert.JsonDecoder, () => ({
>+  __proto__: dart.getFields(convert.JsonDecoder.__proto__),
>+  [_reviver]: dart.finalFieldType(ObjectAndObjectTodynamic())
>+}));
>+convert._parseJson = function(source, reviver) {
>+  if (!(typeof source == 'string')) dart.throw(_js_helper.argumentErrorValue(source));
>+  let parsed = null;
>+  try {
>+    parsed = JSON.parse(source);
>+  } catch (e$) {
>+    let e = dart.getThrown(e$);
>+    dart.throw(new core.FormatException.new(String(e)));
>+  }
>+  if (reviver == null) {
>+    return convert._convertJsonToDartLazy(parsed);
>+  } else {
>+    return convert._convertJsonToDart(parsed, reviver);
>+  }
>+};
>+convert._defaultToEncodable = function(object) {
>+  return dart.dsend(object, 'toJson', []);
>+};
>+const _seen = dart.privateName(convert, "_seen");
>+const _checkCycle = dart.privateName(convert, "_checkCycle");
>+const _removeSeen = dart.privateName(convert, "_removeSeen");
>+const _partialResult = dart.privateName(convert, "_partialResult");
>+convert._JsonStringifier = class _JsonStringifier extends core.Object {
>+  static hexDigit(x) {
>+    return dart.notNull(x) < 10 ? 48 + dart.notNull(x) : 87 + dart.notNull(x);
>+  }
>+  writeStringContent(s) {
>+    let offset = 0;
>+    let length = s.length;
>+    for (let i = 0; i < length; i++) {
>+      let charCode = s[$codeUnitAt](i);
>+      if (charCode > 92) continue;
>+      if (charCode < 32) {
>+        if (i > offset) this.writeStringSlice(s, offset, i);
>+        offset = i + 1;
>+        this.writeCharCode(92);
>+        switch (charCode) {
>+          case 8:
>+          {
>+            this.writeCharCode(98);
>+            break;
>+          }
>+          case 9:
>+          {
>+            this.writeCharCode(116);
>+            break;
>+          }
>+          case 10:
>+          {
>+            this.writeCharCode(110);
>+            break;
>+          }
>+          case 12:
>+          {
>+            this.writeCharCode(102);
>+            break;
>+          }
>+          case 13:
>+          {
>+            this.writeCharCode(114);
>+            break;
>+          }
>+          default:
>+          {
>+            this.writeCharCode(117);
>+            this.writeCharCode(48);
>+            this.writeCharCode(48);
>+            this.writeCharCode(convert._JsonStringifier.hexDigit(charCode >> 4 & 15));
>+            this.writeCharCode(convert._JsonStringifier.hexDigit(charCode & 15));
>+            break;
>+          }
>+        }
>+      } else if (charCode === 34 || charCode === 92) {
>+        if (i > offset) this.writeStringSlice(s, offset, i);
>+        offset = i + 1;
>+        this.writeCharCode(92);
>+        this.writeCharCode(charCode);
>+      }
>+    }
>+    if (offset === 0) {
>+      this.writeString(s);
>+    } else if (offset < length) {
>+      this.writeStringSlice(s, offset, length);
>+    }
>+  }
>+  [_checkCycle](object) {
>+    for (let i = 0; i < dart.notNull(this[_seen][$length]); i++) {
>+      if (core.identical(object, this[_seen][$_get](i))) {
>+        dart.throw(new convert.JsonCyclicError.new(object));
>+      }
>+    }
>+    this[_seen][$add](object);
>+  }
>+  [_removeSeen](object) {
>+    if (!dart.test(this[_seen][$isNotEmpty])) dart.assertFailed(null, "dart:convert/json.dart", 643, 12, "_seen.isNotEmpty");
>+    if (!core.identical(this[_seen][$last], object)) dart.assertFailed(null, "dart:convert/json.dart", 644, 12, "identical(_seen.last, object)");
>+    this[_seen][$removeLast]();
>+  }
>+  writeObject(object) {
>+    if (dart.test(this.writeJsonValue(object))) return;
>+    this[_checkCycle](object);
>+    try {
>+      let customJson = this[_toEncodable](object);
>+      if (!dart.test(this.writeJsonValue(customJson))) {
>+        dart.throw(new convert.JsonUnsupportedObjectError.new(object, {partialResult: this[_partialResult]}));
>+      }
>+      this[_removeSeen](object);
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      dart.throw(new convert.JsonUnsupportedObjectError.new(object, {cause: e, partialResult: this[_partialResult]}));
>+    }
>+  }
>+  writeJsonValue(object) {
>+    if (typeof object == 'number') {
>+      if (!object[$isFinite]) return false;
>+      this.writeNumber(object);
>+      return true;
>+    } else if (object === true) {
>+      this.writeString("true");
>+      return true;
>+    } else if (object === false) {
>+      this.writeString("false");
>+      return true;
>+    } else if (object == null) {
>+      this.writeString("null");
>+      return true;
>+    } else if (typeof object == 'string') {
>+      this.writeString("\"");
>+      this.writeStringContent(object);
>+      this.writeString("\"");
>+      return true;
>+    } else if (core.List.is(object)) {
>+      this[_checkCycle](object);
>+      this.writeList(object);
>+      this[_removeSeen](object);
>+      return true;
>+    } else if (core.Map.is(object)) {
>+      this[_checkCycle](object);
>+      let success = this.writeMap(object);
>+      this[_removeSeen](object);
>+      return success;
>+    } else {
>+      return false;
>+    }
>+  }
>+  writeList(list) {
>+    this.writeString("[");
>+    if (dart.test(list[$isNotEmpty])) {
>+      this.writeObject(list[$_get](0));
>+      for (let i = 1; i < dart.notNull(list[$length]); i++) {
>+        this.writeString(",");
>+        this.writeObject(list[$_get](i));
>+      }
>+    }
>+    this.writeString("]");
>+  }
>+  writeMap(map) {
>+    if (dart.test(map[$isEmpty])) {
>+      this.writeString("{}");
>+      return true;
>+    }
>+    let keyValueList = core.List.new(dart.notNull(map[$length]) * 2);
>+    let i = 0;
>+    let allStringKeys = true;
>+    map[$forEach](dart.fn((key, value) => {
>+      if (!(typeof key == 'string')) {
>+        allStringKeys = false;
>+      }
>+      keyValueList[$_set](i++, key);
>+      keyValueList[$_set](i++, value);
>+    }, dynamicAnddynamicToNull()));
>+    if (!allStringKeys) return false;
>+    this.writeString("{");
>+    let separator = "\"";
>+    for (let i = 0; i < dart.notNull(keyValueList[$length]); i = i + 2) {
>+      this.writeString(separator);
>+      separator = ",\"";
>+      this.writeStringContent(core.String._check(keyValueList[$_get](i)));
>+      this.writeString("\":");
>+      this.writeObject(keyValueList[$_get](i + 1));
>+    }
>+    this.writeString("}");
>+    return true;
>+  }
>+};
>+(convert._JsonStringifier.new = function(toEncodable) {
>+  this[_seen] = [];
>+  let l = toEncodable;
>+  this[_toEncodable] = l != null ? l : dart.fn(convert._defaultToEncodable, dynamicTodynamic());
>+}).prototype = convert._JsonStringifier.prototype;
>+dart.addTypeTests(convert._JsonStringifier);
>+dart.setMethodSignature(convert._JsonStringifier, () => ({
>+  __proto__: dart.getMethods(convert._JsonStringifier.__proto__),
>+  writeStringContent: dart.fnType(dart.void, [core.String]),
>+  [_checkCycle]: dart.fnType(dart.void, [dart.dynamic]),
>+  [_removeSeen]: dart.fnType(dart.void, [dart.dynamic]),
>+  writeObject: dart.fnType(dart.void, [dart.dynamic]),
>+  writeJsonValue: dart.fnType(core.bool, [dart.dynamic]),
>+  writeList: dart.fnType(dart.void, [core.List]),
>+  writeMap: dart.fnType(core.bool, [core.Map])
>+}));
>+dart.setLibraryUri(convert._JsonStringifier, "dart:convert");
>+dart.setFieldSignature(convert._JsonStringifier, () => ({
>+  __proto__: dart.getFields(convert._JsonStringifier.__proto__),
>+  [_seen]: dart.finalFieldType(core.List),
>+  [_toEncodable]: dart.finalFieldType(dynamicTodynamic())
>+}));
>+dart.defineLazy(convert._JsonStringifier, {
>+  /*convert._JsonStringifier.backspace*/get backspace() {
>+    return 8;
>+  },
>+  /*convert._JsonStringifier.tab*/get tab() {
>+    return 9;
>+  },
>+  /*convert._JsonStringifier.newline*/get newline() {
>+    return 10;
>+  },
>+  /*convert._JsonStringifier.carriageReturn*/get carriageReturn() {
>+    return 13;
>+  },
>+  /*convert._JsonStringifier.formFeed*/get formFeed() {
>+    return 12;
>+  },
>+  /*convert._JsonStringifier.quote*/get quote() {
>+    return 34;
>+  },
>+  /*convert._JsonStringifier.char_0*/get char_0() {
>+    return 48;
>+  },
>+  /*convert._JsonStringifier.backslash*/get backslash() {
>+    return 92;
>+  },
>+  /*convert._JsonStringifier.char_b*/get char_b() {
>+    return 98;
>+  },
>+  /*convert._JsonStringifier.char_f*/get char_f() {
>+    return 102;
>+  },
>+  /*convert._JsonStringifier.char_n*/get char_n() {
>+    return 110;
>+  },
>+  /*convert._JsonStringifier.char_r*/get char_r() {
>+    return 114;
>+  },
>+  /*convert._JsonStringifier.char_t*/get char_t() {
>+    return 116;
>+  },
>+  /*convert._JsonStringifier.char_u*/get char_u() {
>+    return 117;
>+  }
>+});
>+const _indentLevel = dart.privateName(convert, "_indentLevel");
>+convert._JsonPrettyPrintMixin = class _JsonPrettyPrintMixin extends core.Object {
>+  writeList(list) {
>+    if (dart.test(list[$isEmpty])) {
>+      this.writeString("[]");
>+    } else {
>+      this.writeString("[\n");
>+      this[_indentLevel] = dart.notNull(this[_indentLevel]) + 1;
>+      this.writeIndentation(this[_indentLevel]);
>+      this.writeObject(list[$_get](0));
>+      for (let i = 1; i < dart.notNull(list[$length]); i++) {
>+        this.writeString(",\n");
>+        this.writeIndentation(this[_indentLevel]);
>+        this.writeObject(list[$_get](i));
>+      }
>+      this.writeString("\n");
>+      this[_indentLevel] = dart.notNull(this[_indentLevel]) - 1;
>+      this.writeIndentation(this[_indentLevel]);
>+      this.writeString("]");
>+    }
>+  }
>+  writeMap(map) {
>+    if (dart.test(map[$isEmpty])) {
>+      this.writeString("{}");
>+      return true;
>+    }
>+    let keyValueList = core.List.new(dart.notNull(map[$length]) * 2);
>+    let i = 0;
>+    let allStringKeys = true;
>+    map[$forEach](dart.fn((key, value) => {
>+      if (!(typeof key == 'string')) {
>+        allStringKeys = false;
>+      }
>+      keyValueList[$_set](i++, key);
>+      keyValueList[$_set](i++, value);
>+    }, dynamicAnddynamicToNull()));
>+    if (!allStringKeys) return false;
>+    this.writeString("{\n");
>+    this[_indentLevel] = dart.notNull(this[_indentLevel]) + 1;
>+    let separator = "";
>+    for (let i = 0; i < dart.notNull(keyValueList[$length]); i = i + 2) {
>+      this.writeString(separator);
>+      separator = ",\n";
>+      this.writeIndentation(this[_indentLevel]);
>+      this.writeString("\"");
>+      this.writeStringContent(core.String._check(keyValueList[$_get](i)));
>+      this.writeString("\": ");
>+      this.writeObject(keyValueList[$_get](i + 1));
>+    }
>+    this.writeString("\n");
>+    this[_indentLevel] = dart.notNull(this[_indentLevel]) - 1;
>+    this.writeIndentation(this[_indentLevel]);
>+    this.writeString("}");
>+    return true;
>+  }
>+};
>+(convert._JsonPrettyPrintMixin.new = function() {
>+  this[_indentLevel] = 0;
>+}).prototype = convert._JsonPrettyPrintMixin.prototype;
>+dart.addTypeTests(convert._JsonPrettyPrintMixin);
>+convert._JsonPrettyPrintMixin[dart.implements] = () => [convert._JsonStringifier];
>+dart.setMethodSignature(convert._JsonPrettyPrintMixin, () => ({
>+  __proto__: dart.getMethods(convert._JsonPrettyPrintMixin.__proto__),
>+  writeList: dart.fnType(dart.void, [core.List]),
>+  writeMap: dart.fnType(core.bool, [core.Map])
>+}));
>+dart.setLibraryUri(convert._JsonPrettyPrintMixin, "dart:convert");
>+dart.setFieldSignature(convert._JsonPrettyPrintMixin, () => ({
>+  __proto__: dart.getFields(convert._JsonPrettyPrintMixin.__proto__),
>+  [_indentLevel]: dart.fieldType(core.int)
>+}));
>+convert._JsonStringStringifier = class _JsonStringStringifier extends convert._JsonStringifier {
>+  static stringify(object, toEncodable, indent) {
>+    let output = new core.StringBuffer.new();
>+    convert._JsonStringStringifier.printOn(object, output, toEncodable, indent);
>+    return output.toString();
>+  }
>+  static printOn(object, output, toEncodable, indent) {
>+    let stringifier = null;
>+    if (indent == null) {
>+      stringifier = new convert._JsonStringStringifier.new(output, toEncodable);
>+    } else {
>+      stringifier = new convert._JsonStringStringifierPretty.new(output, toEncodable, indent);
>+    }
>+    stringifier.writeObject(object);
>+  }
>+  get [_partialResult]() {
>+    return core.StringBuffer.is(this[_sink$]) ? dart.toString(this[_sink$]) : null;
>+  }
>+  writeNumber(number) {
>+    this[_sink$].write(dart.toString(number));
>+  }
>+  writeString(string) {
>+    this[_sink$].write(string);
>+  }
>+  writeStringSlice(string, start, end) {
>+    this[_sink$].write(string[$substring](start, end));
>+  }
>+  writeCharCode(charCode) {
>+    this[_sink$].writeCharCode(charCode);
>+  }
>+};
>+(convert._JsonStringStringifier.new = function(sink, _toEncodable) {
>+  this[_sink$] = sink;
>+  convert._JsonStringStringifier.__proto__.new.call(this, _toEncodable);
>+}).prototype = convert._JsonStringStringifier.prototype;
>+dart.addTypeTests(convert._JsonStringStringifier);
>+dart.setMethodSignature(convert._JsonStringStringifier, () => ({
>+  __proto__: dart.getMethods(convert._JsonStringStringifier.__proto__),
>+  writeNumber: dart.fnType(dart.void, [core.num]),
>+  writeString: dart.fnType(dart.void, [core.String]),
>+  writeStringSlice: dart.fnType(dart.void, [core.String, core.int, core.int]),
>+  writeCharCode: dart.fnType(dart.void, [core.int])
>+}));
>+dart.setGetterSignature(convert._JsonStringStringifier, () => ({
>+  __proto__: dart.getGetters(convert._JsonStringStringifier.__proto__),
>+  [_partialResult]: core.String
>+}));
>+dart.setLibraryUri(convert._JsonStringStringifier, "dart:convert");
>+dart.setFieldSignature(convert._JsonStringStringifier, () => ({
>+  __proto__: dart.getFields(convert._JsonStringStringifier.__proto__),
>+  [_sink$]: dart.finalFieldType(core.StringSink)
>+}));
>+const _JsonStringStringifier__JsonPrettyPrintMixin$ = class _JsonStringStringifier__JsonPrettyPrintMixin extends convert._JsonStringStringifier {};
>+(_JsonStringStringifier__JsonPrettyPrintMixin$.new = function(_sink, _toEncodable) {
>+  convert._JsonPrettyPrintMixin.new.call(this);
>+  _JsonStringStringifier__JsonPrettyPrintMixin$.__proto__.new.call(this, _sink, _toEncodable);
>+}).prototype = _JsonStringStringifier__JsonPrettyPrintMixin$.prototype;
>+dart.applyMixin(_JsonStringStringifier__JsonPrettyPrintMixin$, convert._JsonPrettyPrintMixin);
>+convert._JsonStringStringifierPretty = class _JsonStringStringifierPretty extends _JsonStringStringifier__JsonPrettyPrintMixin$ {
>+  writeIndentation(count) {
>+    for (let i = 0; i < dart.notNull(count); i++)
>+      this.writeString(this[_indent]);
>+  }
>+};
>+(convert._JsonStringStringifierPretty.new = function(sink, toEncodable, indent) {
>+  this[_indent] = indent;
>+  convert._JsonStringStringifierPretty.__proto__.new.call(this, sink, toEncodable);
>+}).prototype = convert._JsonStringStringifierPretty.prototype;
>+dart.addTypeTests(convert._JsonStringStringifierPretty);
>+dart.setMethodSignature(convert._JsonStringStringifierPretty, () => ({
>+  __proto__: dart.getMethods(convert._JsonStringStringifierPretty.__proto__),
>+  writeIndentation: dart.fnType(dart.void, [core.int])
>+}));
>+dart.setLibraryUri(convert._JsonStringStringifierPretty, "dart:convert");
>+dart.setFieldSignature(convert._JsonStringStringifierPretty, () => ({
>+  __proto__: dart.getFields(convert._JsonStringStringifierPretty.__proto__),
>+  [_indent]: dart.finalFieldType(core.String)
>+}));
>+convert._JsonUtf8Stringifier = class _JsonUtf8Stringifier extends convert._JsonStringifier {
>+  static stringify(object, indent, toEncodable, bufferSize, addChunk) {
>+    let stringifier = null;
>+    if (indent != null) {
>+      stringifier = new convert._JsonUtf8StringifierPretty.new(toEncodable, indent, bufferSize, addChunk);
>+    } else {
>+      stringifier = new convert._JsonUtf8Stringifier.new(toEncodable, bufferSize, addChunk);
>+    }
>+    stringifier.writeObject(object);
>+    stringifier.flush();
>+  }
>+  flush() {
>+    if (dart.notNull(this.index) > 0) {
>+      this.addChunk(this.buffer, 0, this.index);
>+    }
>+    this.buffer = null;
>+    this.index = 0;
>+  }
>+  get [_partialResult]() {
>+    return null;
>+  }
>+  writeNumber(number) {
>+    this.writeAsciiString(dart.toString(number));
>+  }
>+  writeAsciiString(string) {
>+    for (let i = 0; i < string.length; i++) {
>+      let char = string[$codeUnitAt](i);
>+      if (!(char <= 127)) dart.assertFailed(null, "dart:convert/json.dart", 944, 14, "char <= 0x7f");
>+      this.writeByte(char);
>+    }
>+  }
>+  writeString(string) {
>+    this.writeStringSlice(string, 0, string.length);
>+  }
>+  writeStringSlice(string, start, end) {
>+    for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
>+      let char = string[$codeUnitAt](i);
>+      if (char <= 127) {
>+        this.writeByte(char);
>+      } else {
>+        if ((char & 64512) === 55296 && dart.notNull(i) + 1 < dart.notNull(end)) {
>+          let nextChar = string[$codeUnitAt](dart.notNull(i) + 1);
>+          if ((nextChar & 64512) === 56320) {
>+            char = 65536 + ((char & 1023) << 10) + (nextChar & 1023);
>+            this.writeFourByteCharCode(char);
>+            i = dart.notNull(i) + 1;
>+            continue;
>+          }
>+        }
>+        this.writeMultiByteCharCode(char);
>+      }
>+    }
>+  }
>+  writeCharCode(charCode) {
>+    if (dart.notNull(charCode) <= 127) {
>+      this.writeByte(charCode);
>+      return;
>+    }
>+    this.writeMultiByteCharCode(charCode);
>+  }
>+  writeMultiByteCharCode(charCode) {
>+    if (dart.notNull(charCode) <= 2047) {
>+      this.writeByte((192 | charCode[$rightShift](6)) >>> 0);
>+      this.writeByte(128 | dart.notNull(charCode) & 63);
>+      return;
>+    }
>+    if (dart.notNull(charCode) <= 65535) {
>+      this.writeByte((224 | charCode[$rightShift](12)) >>> 0);
>+      this.writeByte(128 | dart.notNull(charCode) >> 6 & 63);
>+      this.writeByte(128 | dart.notNull(charCode) & 63);
>+      return;
>+    }
>+    this.writeFourByteCharCode(charCode);
>+  }
>+  writeFourByteCharCode(charCode) {
>+    if (!(dart.notNull(charCode) <= 1114111)) dart.assertFailed(null, "dart:convert/json.dart", 1002, 12, "charCode <= 0x10ffff");
>+    this.writeByte((240 | charCode[$rightShift](18)) >>> 0);
>+    this.writeByte(128 | dart.notNull(charCode) >> 12 & 63);
>+    this.writeByte(128 | dart.notNull(charCode) >> 6 & 63);
>+    this.writeByte(128 | dart.notNull(charCode) & 63);
>+  }
>+  writeByte(byte) {
>+    if (!(dart.notNull(byte) <= 255)) dart.assertFailed(null, "dart:convert/json.dart", 1010, 12, "byte <= 0xff");
>+    if (this.index == this.buffer[$length]) {
>+      this.addChunk(this.buffer, 0, this.index);
>+      this.buffer = typed_data.Uint8List.new(this.bufferSize);
>+      this.index = 0;
>+    }
>+    this.buffer[$_set]((() => {
>+      let x = this.index;
>+      this.index = dart.notNull(x) + 1;
>+      return x;
>+    })(), byte);
>+  }
>+};
>+(convert._JsonUtf8Stringifier.new = function(toEncodable, bufferSize, addChunk) {
>+  this.index = 0;
>+  this.bufferSize = bufferSize;
>+  this.addChunk = addChunk;
>+  this.buffer = typed_data.Uint8List.new(bufferSize);
>+  convert._JsonUtf8Stringifier.__proto__.new.call(this, toEncodable);
>+}).prototype = convert._JsonUtf8Stringifier.prototype;
>+dart.addTypeTests(convert._JsonUtf8Stringifier);
>+dart.setMethodSignature(convert._JsonUtf8Stringifier, () => ({
>+  __proto__: dart.getMethods(convert._JsonUtf8Stringifier.__proto__),
>+  flush: dart.fnType(dart.void, []),
>+  writeNumber: dart.fnType(dart.void, [core.num]),
>+  writeAsciiString: dart.fnType(dart.void, [core.String]),
>+  writeString: dart.fnType(dart.void, [core.String]),
>+  writeStringSlice: dart.fnType(dart.void, [core.String, core.int, core.int]),
>+  writeCharCode: dart.fnType(dart.void, [core.int]),
>+  writeMultiByteCharCode: dart.fnType(dart.void, [core.int]),
>+  writeFourByteCharCode: dart.fnType(dart.void, [core.int]),
>+  writeByte: dart.fnType(dart.void, [core.int])
>+}));
>+dart.setGetterSignature(convert._JsonUtf8Stringifier, () => ({
>+  __proto__: dart.getGetters(convert._JsonUtf8Stringifier.__proto__),
>+  [_partialResult]: core.String
>+}));
>+dart.setLibraryUri(convert._JsonUtf8Stringifier, "dart:convert");
>+dart.setFieldSignature(convert._JsonUtf8Stringifier, () => ({
>+  __proto__: dart.getFields(convert._JsonUtf8Stringifier.__proto__),
>+  bufferSize: dart.finalFieldType(core.int),
>+  addChunk: dart.finalFieldType(Uint8ListAndintAndintTovoid()),
>+  buffer: dart.fieldType(typed_data.Uint8List),
>+  index: dart.fieldType(core.int)
>+}));
>+const _JsonUtf8Stringifier__JsonPrettyPrintMixin$ = class _JsonUtf8Stringifier__JsonPrettyPrintMixin extends convert._JsonUtf8Stringifier {};
>+(_JsonUtf8Stringifier__JsonPrettyPrintMixin$.new = function(toEncodable, bufferSize, addChunk) {
>+  convert._JsonPrettyPrintMixin.new.call(this);
>+  _JsonUtf8Stringifier__JsonPrettyPrintMixin$.__proto__.new.call(this, toEncodable, bufferSize, addChunk);
>+}).prototype = _JsonUtf8Stringifier__JsonPrettyPrintMixin$.prototype;
>+dart.applyMixin(_JsonUtf8Stringifier__JsonPrettyPrintMixin$, convert._JsonPrettyPrintMixin);
>+convert._JsonUtf8StringifierPretty = class _JsonUtf8StringifierPretty extends _JsonUtf8Stringifier__JsonPrettyPrintMixin$ {
>+  writeIndentation(count) {
>+    let indent = this.indent;
>+    let indentLength = indent[$length];
>+    if (indentLength === 1) {
>+      let char = indent[$_get](0);
>+      while (dart.notNull(count) > 0) {
>+        this.writeByte(char);
>+        count = dart.notNull(count) - 1;
>+      }
>+      return;
>+    }
>+    while (dart.notNull(count) > 0) {
>+      count = dart.notNull(count) - 1;
>+      let end = dart.notNull(this.index) + dart.notNull(indentLength);
>+      if (end <= dart.notNull(this.buffer[$length])) {
>+        this.buffer[$setRange](this.index, end, indent);
>+        this.index = end;
>+      } else {
>+        for (let i = 0; i < dart.notNull(indentLength); i++) {
>+          this.writeByte(indent[$_get](i));
>+        }
>+      }
>+    }
>+  }
>+};
>+(convert._JsonUtf8StringifierPretty.new = function(toEncodable, indent, bufferSize, addChunk) {
>+  this.indent = indent;
>+  convert._JsonUtf8StringifierPretty.__proto__.new.call(this, toEncodable, bufferSize, addChunk);
>+}).prototype = convert._JsonUtf8StringifierPretty.prototype;
>+dart.addTypeTests(convert._JsonUtf8StringifierPretty);
>+dart.setMethodSignature(convert._JsonUtf8StringifierPretty, () => ({
>+  __proto__: dart.getMethods(convert._JsonUtf8StringifierPretty.__proto__),
>+  writeIndentation: dart.fnType(dart.void, [core.int])
>+}));
>+dart.setLibraryUri(convert._JsonUtf8StringifierPretty, "dart:convert");
>+dart.setFieldSignature(convert._JsonUtf8StringifierPretty, () => ({
>+  __proto__: dart.getFields(convert._JsonUtf8StringifierPretty.__proto__),
>+  indent: dart.finalFieldType(ListOfint())
>+}));
>+dart.defineLazy(convert, {
>+  /*convert.latin1*/get latin1() {
>+    return dart.const(new convert.Latin1Codec.new());
>+  },
>+  /*convert._latin1Mask*/get _latin1Mask() {
>+    return 255;
>+  }
>+});
>+let const$43;
>+let const$44;
>+let const$45;
>+let const$46;
>+let const$47;
>+convert.Latin1Codec = class Latin1Codec extends convert.Encoding {
>+  get name() {
>+    return "iso-8859-1";
>+  }
>+  encode(source) {
>+    core.String._check(source);
>+    return this.encoder.convert(source);
>+  }
>+  decode(bytes, opts) {
>+    ListOfint()._check(bytes);
>+    let allowInvalid = opts && 'allowInvalid' in opts ? opts.allowInvalid : null;
>+    let t = allowInvalid;
>+    t == null ? allowInvalid = this[_allowInvalid] : t;
>+    if (dart.test(allowInvalid)) {
>+      return (const$43 || (const$43 = dart.const(new convert.Latin1Decoder.new({allowInvalid: true})))).convert(bytes);
>+    } else {
>+      return (const$44 || (const$44 = dart.const(new convert.Latin1Decoder.new({allowInvalid: false})))).convert(bytes);
>+    }
>+  }
>+  get encoder() {
>+    return const$45 || (const$45 = dart.const(new convert.Latin1Encoder.new()));
>+  }
>+  get decoder() {
>+    return dart.test(this[_allowInvalid]) ? const$46 || (const$46 = dart.const(new convert.Latin1Decoder.new({allowInvalid: true}))) : const$47 || (const$47 = dart.const(new convert.Latin1Decoder.new({allowInvalid: false})));
>+  }
>+};
>+(convert.Latin1Codec.new = function(opts) {
>+  let allowInvalid = opts && 'allowInvalid' in opts ? opts.allowInvalid : false;
>+  this[_allowInvalid] = allowInvalid;
>+  convert.Latin1Codec.__proto__.new.call(this);
>+}).prototype = convert.Latin1Codec.prototype;
>+dart.addTypeTests(convert.Latin1Codec);
>+dart.setMethodSignature(convert.Latin1Codec, () => ({
>+  __proto__: dart.getMethods(convert.Latin1Codec.__proto__),
>+  encode: dart.fnType(typed_data.Uint8List, [core.Object]),
>+  decode: dart.fnType(core.String, [core.Object], {allowInvalid: core.bool})
>+}));
>+dart.setGetterSignature(convert.Latin1Codec, () => ({
>+  __proto__: dart.getGetters(convert.Latin1Codec.__proto__),
>+  name: core.String,
>+  encoder: convert.Latin1Encoder,
>+  decoder: convert.Latin1Decoder
>+}));
>+dart.setLibraryUri(convert.Latin1Codec, "dart:convert");
>+dart.setFieldSignature(convert.Latin1Codec, () => ({
>+  __proto__: dart.getFields(convert.Latin1Codec.__proto__),
>+  [_allowInvalid]: dart.finalFieldType(core.bool)
>+}));
>+convert.Latin1Encoder = class Latin1Encoder extends convert._UnicodeSubsetEncoder {};
>+(convert.Latin1Encoder.new = function() {
>+  convert.Latin1Encoder.__proto__.new.call(this, 255);
>+}).prototype = convert.Latin1Encoder.prototype;
>+dart.addTypeTests(convert.Latin1Encoder);
>+dart.setLibraryUri(convert.Latin1Encoder, "dart:convert");
>+convert.Latin1Decoder = class Latin1Decoder extends convert._UnicodeSubsetDecoder {
>+  startChunkedConversion(sink) {
>+    SinkOfString()._check(sink);
>+    let stringSink = null;
>+    if (convert.StringConversionSink.is(sink)) {
>+      stringSink = sink;
>+    } else {
>+      stringSink = convert.StringConversionSink.from(sink);
>+    }
>+    if (!dart.test(this[_allowInvalid])) return new convert._Latin1DecoderSink.new(stringSink);
>+    return new convert._Latin1AllowInvalidDecoderSink.new(stringSink);
>+  }
>+};
>+(convert.Latin1Decoder.new = function(opts) {
>+  let allowInvalid = opts && 'allowInvalid' in opts ? opts.allowInvalid : false;
>+  convert.Latin1Decoder.__proto__.new.call(this, allowInvalid, 255);
>+}).prototype = convert.Latin1Decoder.prototype;
>+dart.addTypeTests(convert.Latin1Decoder);
>+dart.setMethodSignature(convert.Latin1Decoder, () => ({
>+  __proto__: dart.getMethods(convert.Latin1Decoder.__proto__),
>+  startChunkedConversion: dart.fnType(convert.ByteConversionSink, [core.Object])
>+}));
>+dart.setLibraryUri(convert.Latin1Decoder, "dart:convert");
>+const _addSliceToSink = dart.privateName(convert, "_addSliceToSink");
>+convert._Latin1DecoderSink = class _Latin1DecoderSink extends convert.ByteConversionSinkBase {
>+  close() {
>+    this[_sink$].close();
>+    this[_sink$] = null;
>+  }
>+  add(source) {
>+    ListOfint()._check(source);
>+    this.addSlice(source, 0, source[$length], false);
>+  }
>+  [_addSliceToSink](source, start, end, isLast) {
>+    this[_sink$].add(core.String.fromCharCodes(source, start, end));
>+    if (dart.test(isLast)) this.close();
>+  }
>+  addSlice(source, start, end, isLast) {
>+    end = core.RangeError.checkValidRange(start, end, source[$length]);
>+    if (start == end) return;
>+    if (!typed_data.Uint8List.is(source)) {
>+      convert._Latin1DecoderSink._checkValidLatin1(source, start, end);
>+    }
>+    this[_addSliceToSink](source, start, end, isLast);
>+  }
>+  static _checkValidLatin1(source, start, end) {
>+    let mask = 0;
>+    for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
>+      mask = (mask | dart.notNull(source[$_get](i))) >>> 0;
>+    }
>+    if (mask >= 0 && mask <= 255) {
>+      return;
>+    }
>+    convert._Latin1DecoderSink._reportInvalidLatin1(source, start, end);
>+  }
>+  static _reportInvalidLatin1(source, start, end) {
>+    for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
>+      let char = source[$_get](i);
>+      if (dart.notNull(char) < 0 || dart.notNull(char) > 255) {
>+        dart.throw(new core.FormatException.new("Source contains non-Latin-1 characters.", source, i));
>+      }
>+    }
>+    if (!false) dart.assertFailed(null, "dart:convert/latin1.dart", 157, 12, "false");
>+  }
>+};
>+(convert._Latin1DecoderSink.new = function(sink) {
>+  this[_sink$] = sink;
>+  convert._Latin1DecoderSink.__proto__.new.call(this);
>+}).prototype = convert._Latin1DecoderSink.prototype;
>+dart.addTypeTests(convert._Latin1DecoderSink);
>+dart.setMethodSignature(convert._Latin1DecoderSink, () => ({
>+  __proto__: dart.getMethods(convert._Latin1DecoderSink.__proto__),
>+  close: dart.fnType(dart.void, []),
>+  add: dart.fnType(dart.void, [core.Object]),
>+  [_addSliceToSink]: dart.fnType(dart.void, [core.List$(core.int), core.int, core.int, core.bool])
>+}));
>+dart.setLibraryUri(convert._Latin1DecoderSink, "dart:convert");
>+dart.setFieldSignature(convert._Latin1DecoderSink, () => ({
>+  __proto__: dart.getFields(convert._Latin1DecoderSink.__proto__),
>+  [_sink$]: dart.fieldType(convert.StringConversionSink)
>+}));
>+let const$48;
>+convert._Latin1AllowInvalidDecoderSink = class _Latin1AllowInvalidDecoderSink extends convert._Latin1DecoderSink {
>+  addSlice(source, start, end, isLast) {
>+    core.RangeError.checkValidRange(start, end, source[$length]);
>+    for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
>+      let char = source[$_get](i);
>+      if (dart.notNull(char) > 255 || dart.notNull(char) < 0) {
>+        if (dart.notNull(i) > dart.notNull(start)) this[_addSliceToSink](source, start, i, false);
>+        this[_addSliceToSink](const$48 || (const$48 = dart.constList([65533], core.int)), 0, 1, false);
>+        start = dart.notNull(i) + 1;
>+      }
>+    }
>+    if (dart.notNull(start) < dart.notNull(end)) {
>+      this[_addSliceToSink](source, start, end, isLast);
>+    }
>+    if (dart.test(isLast)) {
>+      this.close();
>+    }
>+  }
>+};
>+(convert._Latin1AllowInvalidDecoderSink.new = function(sink) {
>+  convert._Latin1AllowInvalidDecoderSink.__proto__.new.call(this, sink);
>+}).prototype = convert._Latin1AllowInvalidDecoderSink.prototype;
>+dart.addTypeTests(convert._Latin1AllowInvalidDecoderSink);
>+dart.setLibraryUri(convert._Latin1AllowInvalidDecoderSink, "dart:convert");
>+dart.defineLazy(convert, {
>+  /*convert._LF*/get _LF() {
>+    return 10;
>+  },
>+  /*convert._CR*/get _CR() {
>+    return 13;
>+  }
>+});
>+convert.LineSplitter = class LineSplitter extends async.StreamTransformerBase$(core.String, core.String) {
>+  static split(lines, start, end) {
>+    if (start === void 0) start = 0;
>+    if (end === void 0) end = null;
>+    return new (SyncIterableOfString()).new(() => (function* split(end) {
>+      end = core.RangeError.checkValidRange(start, end, lines.length);
>+      let sliceStart = start;
>+      let char = 0;
>+      for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
>+        let previousChar = char;
>+        char = lines[$codeUnitAt](i);
>+        if (char !== 13) {
>+          if (char !== 10) continue;
>+          if (previousChar === 13) {
>+            sliceStart = dart.notNull(i) + 1;
>+            continue;
>+          }
>+        }
>+        yield lines[$substring](sliceStart, i);
>+        sliceStart = dart.notNull(i) + 1;
>+      }
>+      if (dart.notNull(sliceStart) < dart.notNull(end)) {
>+        yield lines[$substring](sliceStart, end);
>+      }
>+    })(end));
>+  }
>+  convert(data) {
>+    let lines = JSArrayOfString().of([]);
>+    let end = data.length;
>+    let sliceStart = 0;
>+    let char = 0;
>+    for (let i = 0; i < end; i++) {
>+      let previousChar = char;
>+      char = data[$codeUnitAt](i);
>+      if (char !== 13) {
>+        if (char !== 10) continue;
>+        if (previousChar === 13) {
>+          sliceStart = i + 1;
>+          continue;
>+        }
>+      }
>+      lines[$add](data[$substring](sliceStart, i));
>+      sliceStart = i + 1;
>+    }
>+    if (sliceStart < end) {
>+      lines[$add](data[$substring](sliceStart, end));
>+    }
>+    return lines;
>+  }
>+  startChunkedConversion(sink) {
>+    return new convert._LineSplitterSink.new(convert.StringConversionSink.is(sink) ? sink : convert.StringConversionSink.from(sink));
>+  }
>+  bind(stream) {
>+    StreamOfString()._check(stream);
>+    return StreamOfString().eventTransformed(stream, dart.fn(sink => new convert._LineSplitterEventSink.new(sink), EventSinkOfStringTo_LineSplitterEventSink()));
>+  }
>+};
>+(convert.LineSplitter.new = function() {
>+  convert.LineSplitter.__proto__.new.call(this);
>+}).prototype = convert.LineSplitter.prototype;
>+dart.addTypeTests(convert.LineSplitter);
>+dart.setMethodSignature(convert.LineSplitter, () => ({
>+  __proto__: dart.getMethods(convert.LineSplitter.__proto__),
>+  convert: dart.fnType(core.List$(core.String), [core.String]),
>+  startChunkedConversion: dart.fnType(convert.StringConversionSink, [core.Sink$(core.String)]),
>+  bind: dart.fnType(async.Stream$(core.String), [core.Object])
>+}));
>+dart.setLibraryUri(convert.LineSplitter, "dart:convert");
>+const _carry = dart.privateName(convert, "_carry");
>+const _skipLeadingLF = dart.privateName(convert, "_skipLeadingLF");
>+const _addLines = dart.privateName(convert, "_addLines");
>+convert._LineSplitterSink = class _LineSplitterSink extends convert.StringConversionSinkBase {
>+  addSlice(chunk, start, end, isLast) {
>+    end = core.RangeError.checkValidRange(start, end, chunk.length);
>+    if (dart.notNull(start) >= dart.notNull(end)) {
>+      if (dart.test(isLast)) this.close();
>+      return;
>+    }
>+    if (this[_carry] != null) {
>+      if (!!dart.test(this[_skipLeadingLF])) dart.assertFailed(null, "dart:convert/line_splitter.dart", 114, 14, "!_skipLeadingLF");
>+      chunk = dart.notNull(this[_carry]) + chunk[$substring](start, end);
>+      start = 0;
>+      end = chunk.length;
>+      this[_carry] = null;
>+    } else if (dart.test(this[_skipLeadingLF])) {
>+      if (chunk[$codeUnitAt](start) === 10) {
>+        start = dart.notNull(start) + 1;
>+      }
>+      this[_skipLeadingLF] = false;
>+    }
>+    this[_addLines](chunk, start, end);
>+    if (dart.test(isLast)) this.close();
>+  }
>+  close() {
>+    if (this[_carry] != null) {
>+      this[_sink$].add(this[_carry]);
>+      this[_carry] = null;
>+    }
>+    this[_sink$].close();
>+  }
>+  [_addLines](lines, start, end) {
>+    let sliceStart = start;
>+    let char = 0;
>+    for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
>+      let previousChar = char;
>+      char = lines[$codeUnitAt](i);
>+      if (char !== 13) {
>+        if (char !== 10) continue;
>+        if (previousChar === 13) {
>+          sliceStart = dart.notNull(i) + 1;
>+          continue;
>+        }
>+      }
>+      this[_sink$].add(lines[$substring](sliceStart, i));
>+      sliceStart = dart.notNull(i) + 1;
>+    }
>+    if (dart.notNull(sliceStart) < dart.notNull(end)) {
>+      this[_carry] = lines[$substring](sliceStart, end);
>+    } else {
>+      this[_skipLeadingLF] = char === 13;
>+    }
>+  }
>+};
>+(convert._LineSplitterSink.new = function(sink) {
>+  this[_carry] = null;
>+  this[_skipLeadingLF] = false;
>+  this[_sink$] = sink;
>+}).prototype = convert._LineSplitterSink.prototype;
>+dart.addTypeTests(convert._LineSplitterSink);
>+dart.setMethodSignature(convert._LineSplitterSink, () => ({
>+  __proto__: dart.getMethods(convert._LineSplitterSink.__proto__),
>+  addSlice: dart.fnType(dart.void, [core.String, core.int, core.int, core.bool]),
>+  close: dart.fnType(dart.void, []),
>+  [_addLines]: dart.fnType(dart.void, [core.String, core.int, core.int])
>+}));
>+dart.setLibraryUri(convert._LineSplitterSink, "dart:convert");
>+dart.setFieldSignature(convert._LineSplitterSink, () => ({
>+  __proto__: dart.getFields(convert._LineSplitterSink.__proto__),
>+  [_sink$]: dart.finalFieldType(convert.StringConversionSink),
>+  [_carry]: dart.fieldType(core.String),
>+  [_skipLeadingLF]: dart.fieldType(core.bool)
>+}));
>+convert._LineSplitterEventSink = class _LineSplitterEventSink extends convert._LineSplitterSink {
>+  addError(o, stackTrace) {
>+    if (stackTrace === void 0) stackTrace = null;
>+    this[_eventSink].addError(o, stackTrace);
>+  }
>+};
>+(convert._LineSplitterEventSink.new = function(eventSink) {
>+  this[_eventSink] = eventSink;
>+  convert._LineSplitterEventSink.__proto__.new.call(this, convert.StringConversionSink.from(eventSink));
>+}).prototype = convert._LineSplitterEventSink.prototype;
>+dart.addTypeTests(convert._LineSplitterEventSink);
>+convert._LineSplitterEventSink[dart.implements] = () => [EventSinkOfString()];
>+dart.setMethodSignature(convert._LineSplitterEventSink, () => ({
>+  __proto__: dart.getMethods(convert._LineSplitterEventSink.__proto__),
>+  addError: dart.fnType(dart.void, [core.Object], [core.StackTrace])
>+}));
>+dart.setLibraryUri(convert._LineSplitterEventSink, "dart:convert");
>+dart.setFieldSignature(convert._LineSplitterEventSink, () => ({
>+  __proto__: dart.getFields(convert._LineSplitterEventSink.__proto__),
>+  [_eventSink]: dart.finalFieldType(EventSinkOfString())
>+}));
>+convert.StringConversionSink = class StringConversionSink extends convert.ChunkedConversionSink$(core.String) {
>+  static withCallback(callback) {
>+    return new convert._StringCallbackSink.new(callback);
>+  }
>+  static from(sink) {
>+    return new convert._StringAdapterSink.new(sink);
>+  }
>+  static fromStringSink(sink) {
>+    return new (_StringSinkConversionSinkOfStringSink()).new(sink);
>+  }
>+};
>+(convert.StringConversionSink.new = function() {
>+  convert.StringConversionSink.__proto__.new.call(this);
>+}).prototype = convert.StringConversionSink.prototype;
>+dart.addTypeTests(convert.StringConversionSink);
>+dart.setLibraryUri(convert.StringConversionSink, "dart:convert");
>+convert.ClosableStringSink = class ClosableStringSink extends core.StringSink {
>+  static fromStringSink(sink, onClose) {
>+    return new convert._ClosableStringSink.new(sink, onClose);
>+  }
>+};
>+dart.addTypeTests(convert.ClosableStringSink);
>+dart.setLibraryUri(convert.ClosableStringSink, "dart:convert");
>+convert._ClosableStringSink = class _ClosableStringSink extends core.Object {
>+  close() {
>+    this[_callback]();
>+  }
>+  writeCharCode(charCode) {
>+    this[_sink$].writeCharCode(charCode);
>+  }
>+  write(o) {
>+    this[_sink$].write(o);
>+  }
>+  writeln(o) {
>+    if (o === void 0) o = "";
>+    this[_sink$].writeln(o);
>+  }
>+  writeAll(objects, separator) {
>+    if (separator === void 0) separator = "";
>+    this[_sink$].writeAll(objects, separator);
>+  }
>+};
>+(convert._ClosableStringSink.new = function(sink, callback) {
>+  this[_sink$] = sink;
>+  this[_callback] = callback;
>+}).prototype = convert._ClosableStringSink.prototype;
>+dart.addTypeTests(convert._ClosableStringSink);
>+convert._ClosableStringSink[dart.implements] = () => [convert.ClosableStringSink];
>+dart.setMethodSignature(convert._ClosableStringSink, () => ({
>+  __proto__: dart.getMethods(convert._ClosableStringSink.__proto__),
>+  close: dart.fnType(dart.void, []),
>+  writeCharCode: dart.fnType(dart.void, [core.int]),
>+  write: dart.fnType(dart.void, [core.Object]),
>+  writeln: dart.fnType(dart.void, [], [core.Object]),
>+  writeAll: dart.fnType(dart.void, [core.Iterable], [core.String])
>+}));
>+dart.setLibraryUri(convert._ClosableStringSink, "dart:convert");
>+dart.setFieldSignature(convert._ClosableStringSink, () => ({
>+  __proto__: dart.getFields(convert._ClosableStringSink.__proto__),
>+  [_callback]: dart.finalFieldType(VoidTovoid()),
>+  [_sink$]: dart.finalFieldType(core.StringSink)
>+}));
>+const _flush = dart.privateName(convert, "_flush");
>+convert._StringConversionSinkAsStringSinkAdapter = class _StringConversionSinkAsStringSinkAdapter extends core.Object {
>+  close() {
>+    if (dart.test(this[_buffer].isNotEmpty)) this[_flush]();
>+    this[_chunkedSink].close();
>+  }
>+  writeCharCode(charCode) {
>+    this[_buffer].writeCharCode(charCode);
>+    if (dart.notNull(this[_buffer].length) > 16) this[_flush]();
>+  }
>+  write(o) {
>+    if (dart.test(this[_buffer].isNotEmpty)) this[_flush]();
>+    this[_chunkedSink].add(dart.toString(o));
>+  }
>+  writeln(o) {
>+    if (o === void 0) o = "";
>+    this[_buffer].writeln(o);
>+    if (dart.notNull(this[_buffer].length) > 16) this[_flush]();
>+  }
>+  writeAll(objects, separator) {
>+    if (separator === void 0) separator = "";
>+    if (dart.test(this[_buffer].isNotEmpty)) this[_flush]();
>+    let iterator = objects[$iterator];
>+    if (!dart.test(iterator.moveNext())) return;
>+    if (separator[$isEmpty]) {
>+      do {
>+        this[_chunkedSink].add(dart.toString(iterator.current));
>+      } while (dart.test(iterator.moveNext()));
>+    } else {
>+      this[_chunkedSink].add(dart.toString(iterator.current));
>+      while (dart.test(iterator.moveNext())) {
>+        this.write(separator);
>+        this[_chunkedSink].add(dart.toString(iterator.current));
>+      }
>+    }
>+  }
>+  [_flush]() {
>+    let accumulated = dart.toString(this[_buffer]);
>+    this[_buffer].clear();
>+    this[_chunkedSink].add(accumulated);
>+  }
>+};
>+(convert._StringConversionSinkAsStringSinkAdapter.new = function(chunkedSink) {
>+  this[_chunkedSink] = chunkedSink;
>+  this[_buffer] = new core.StringBuffer.new();
>+}).prototype = convert._StringConversionSinkAsStringSinkAdapter.prototype;
>+dart.addTypeTests(convert._StringConversionSinkAsStringSinkAdapter);
>+convert._StringConversionSinkAsStringSinkAdapter[dart.implements] = () => [convert.ClosableStringSink];
>+dart.setMethodSignature(convert._StringConversionSinkAsStringSinkAdapter, () => ({
>+  __proto__: dart.getMethods(convert._StringConversionSinkAsStringSinkAdapter.__proto__),
>+  close: dart.fnType(dart.void, []),
>+  writeCharCode: dart.fnType(dart.void, [core.int]),
>+  write: dart.fnType(dart.void, [core.Object]),
>+  writeln: dart.fnType(dart.void, [], [core.Object]),
>+  writeAll: dart.fnType(dart.void, [core.Iterable], [core.String]),
>+  [_flush]: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(convert._StringConversionSinkAsStringSinkAdapter, "dart:convert");
>+dart.setFieldSignature(convert._StringConversionSinkAsStringSinkAdapter, () => ({
>+  __proto__: dart.getFields(convert._StringConversionSinkAsStringSinkAdapter.__proto__),
>+  [_buffer]: dart.fieldType(core.StringBuffer),
>+  [_chunkedSink]: dart.fieldType(convert.StringConversionSink)
>+}));
>+dart.defineLazy(convert._StringConversionSinkAsStringSinkAdapter, {
>+  /*convert._StringConversionSinkAsStringSinkAdapter._MIN_STRING_SIZE*/get _MIN_STRING_SIZE() {
>+    return 16;
>+  }
>+});
>+const _contents = dart.privateName(core, "_contents");
>+const _writeString = dart.privateName(core, "_writeString");
>+core.StringBuffer = class StringBuffer extends core.Object {
>+  get length() {
>+    return this[_contents].length;
>+  }
>+  get isEmpty() {
>+    return this.length === 0;
>+  }
>+  get isNotEmpty() {
>+    return !dart.test(this.isEmpty);
>+  }
>+  write(obj) {
>+    this[_writeString](dart.str(obj));
>+  }
>+  writeCharCode(charCode) {
>+    this[_writeString](core.String.fromCharCode(charCode));
>+  }
>+  writeAll(objects, separator) {
>+    if (separator === void 0) separator = "";
>+    this[_contents] = core.StringBuffer._writeAll(this[_contents], objects, separator);
>+  }
>+  writeln(obj) {
>+    if (obj === void 0) obj = "";
>+    this[_writeString](dart.str(obj) + "\n");
>+  }
>+  clear() {
>+    this[_contents] = "";
>+  }
>+  toString() {
>+    return _js_helper.Primitives.flattenString(this[_contents]);
>+  }
>+  [_writeString](str) {
>+    this[_contents] = _js_helper.Primitives.stringConcatUnchecked(this[_contents], core.String._check(str));
>+  }
>+  static _writeAll(string, objects, separator) {
>+    let iterator = objects[$iterator];
>+    if (!dart.test(iterator.moveNext())) return string;
>+    if (separator[$isEmpty]) {
>+      do {
>+        string = core.StringBuffer._writeOne(string, iterator.current);
>+      } while (dart.test(iterator.moveNext()));
>+    } else {
>+      string = core.StringBuffer._writeOne(string, iterator.current);
>+      while (dart.test(iterator.moveNext())) {
>+        string = core.StringBuffer._writeOne(string, separator);
>+        string = core.StringBuffer._writeOne(string, iterator.current);
>+      }
>+    }
>+    return string;
>+  }
>+  static _writeOne(string, obj) {
>+    return _js_helper.Primitives.stringConcatUnchecked(string, dart.str(obj));
>+  }
>+};
>+(core.StringBuffer.new = function(content) {
>+  if (content === void 0) content = "";
>+  this[_contents] = dart.str(content);
>+}).prototype = core.StringBuffer.prototype;
>+dart.addTypeTests(core.StringBuffer);
>+core.StringBuffer[dart.implements] = () => [core.StringSink];
>+dart.setMethodSignature(core.StringBuffer, () => ({
>+  __proto__: dart.getMethods(core.StringBuffer.__proto__),
>+  write: dart.fnType(dart.void, [core.Object]),
>+  writeCharCode: dart.fnType(dart.void, [core.int]),
>+  writeAll: dart.fnType(dart.void, [core.Iterable], [core.String]),
>+  writeln: dart.fnType(dart.void, [], [core.Object]),
>+  clear: dart.fnType(dart.void, []),
>+  [_writeString]: dart.fnType(dart.void, [dart.dynamic])
>+}));
>+dart.setGetterSignature(core.StringBuffer, () => ({
>+  __proto__: dart.getGetters(core.StringBuffer.__proto__),
>+  length: core.int,
>+  isEmpty: core.bool,
>+  isNotEmpty: core.bool
>+}));
>+dart.setLibraryUri(core.StringBuffer, "dart:core");
>+dart.setFieldSignature(core.StringBuffer, () => ({
>+  __proto__: dart.getFields(core.StringBuffer.__proto__),
>+  [_contents]: dart.fieldType(core.String)
>+}));
>+dart.defineExtensionMethods(core.StringBuffer, ['toString']);
>+convert._StringCallbackSink = class _StringCallbackSink extends convert._StringSinkConversionSink$(core.StringBuffer) {
>+  close() {
>+    let accumulated = dart.toString(this[_stringSink]);
>+    this[_stringSink].clear();
>+    this[_callback](accumulated);
>+  }
>+  asUtf8Sink(allowMalformed) {
>+    return new convert._Utf8StringSinkAdapter.new(this, this[_stringSink], allowMalformed);
>+  }
>+};
>+(convert._StringCallbackSink.new = function(callback) {
>+  this[_callback] = callback;
>+  convert._StringCallbackSink.__proto__.new.call(this, new core.StringBuffer.new());
>+}).prototype = convert._StringCallbackSink.prototype;
>+dart.addTypeTests(convert._StringCallbackSink);
>+dart.setMethodSignature(convert._StringCallbackSink, () => ({
>+  __proto__: dart.getMethods(convert._StringCallbackSink.__proto__),
>+  close: dart.fnType(dart.void, []),
>+  asUtf8Sink: dart.fnType(convert.ByteConversionSink, [core.bool])
>+}));
>+dart.setLibraryUri(convert._StringCallbackSink, "dart:convert");
>+dart.setFieldSignature(convert._StringCallbackSink, () => ({
>+  __proto__: dart.getFields(convert._StringCallbackSink.__proto__),
>+  [_callback]: dart.finalFieldType(StringTovoid())
>+}));
>+convert._StringAdapterSink = class _StringAdapterSink extends convert.StringConversionSinkBase {
>+  add(str) {
>+    core.String._check(str);
>+    this[_sink$].add(str);
>+  }
>+  addSlice(str, start, end, isLast) {
>+    if (start === 0 && end === str.length) {
>+      this.add(str);
>+    } else {
>+      this.add(str[$substring](start, end));
>+    }
>+    if (dart.test(isLast)) this.close();
>+  }
>+  close() {
>+    this[_sink$].close();
>+  }
>+};
>+(convert._StringAdapterSink.new = function(sink) {
>+  this[_sink$] = sink;
>+}).prototype = convert._StringAdapterSink.prototype;
>+dart.addTypeTests(convert._StringAdapterSink);
>+dart.setMethodSignature(convert._StringAdapterSink, () => ({
>+  __proto__: dart.getMethods(convert._StringAdapterSink.__proto__),
>+  add: dart.fnType(dart.void, [core.Object]),
>+  addSlice: dart.fnType(dart.void, [core.String, core.int, core.int, core.bool]),
>+  close: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(convert._StringAdapterSink, "dart:convert");
>+dart.setFieldSignature(convert._StringAdapterSink, () => ({
>+  __proto__: dart.getFields(convert._StringAdapterSink.__proto__),
>+  [_sink$]: dart.finalFieldType(SinkOfString())
>+}));
>+convert._Utf8StringSinkAdapter = class _Utf8StringSinkAdapter extends convert.ByteConversionSink {
>+  close() {
>+    this[_decoder].close();
>+    if (this[_sink$] != null) this[_sink$].close();
>+  }
>+  add(chunk) {
>+    ListOfint()._check(chunk);
>+    this.addSlice(chunk, 0, chunk[$length], false);
>+  }
>+  addSlice(codeUnits, startIndex, endIndex, isLast) {
>+    this[_decoder].convert(codeUnits, startIndex, endIndex);
>+    if (dart.test(isLast)) this.close();
>+  }
>+};
>+(convert._Utf8StringSinkAdapter.new = function(sink, stringSink, allowMalformed) {
>+  this[_sink$] = sink;
>+  this[_decoder] = new convert._Utf8Decoder.new(stringSink, allowMalformed);
>+  convert._Utf8StringSinkAdapter.__proto__.new.call(this);
>+}).prototype = convert._Utf8StringSinkAdapter.prototype;
>+dart.addTypeTests(convert._Utf8StringSinkAdapter);
>+dart.setMethodSignature(convert._Utf8StringSinkAdapter, () => ({
>+  __proto__: dart.getMethods(convert._Utf8StringSinkAdapter.__proto__),
>+  close: dart.fnType(dart.void, []),
>+  add: dart.fnType(dart.void, [core.Object]),
>+  addSlice: dart.fnType(dart.void, [core.List$(core.int), core.int, core.int, core.bool])
>+}));
>+dart.setLibraryUri(convert._Utf8StringSinkAdapter, "dart:convert");
>+dart.setFieldSignature(convert._Utf8StringSinkAdapter, () => ({
>+  __proto__: dart.getFields(convert._Utf8StringSinkAdapter.__proto__),
>+  [_decoder]: dart.finalFieldType(convert._Utf8Decoder),
>+  [_sink$]: dart.finalFieldType(core.Sink)
>+}));
>+convert._Utf8ConversionSink = class _Utf8ConversionSink extends convert.ByteConversionSink {
>+  close() {
>+    this[_decoder].close();
>+    if (dart.test(this[_buffer].isNotEmpty)) {
>+      let accumulated = dart.toString(this[_buffer]);
>+      this[_buffer].clear();
>+      this[_chunkedSink].addSlice(accumulated, 0, accumulated.length, true);
>+    } else {
>+      this[_chunkedSink].close();
>+    }
>+  }
>+  add(chunk) {
>+    ListOfint()._check(chunk);
>+    this.addSlice(chunk, 0, chunk[$length], false);
>+  }
>+  addSlice(chunk, startIndex, endIndex, isLast) {
>+    this[_decoder].convert(chunk, startIndex, endIndex);
>+    if (dart.test(this[_buffer].isNotEmpty)) {
>+      let accumulated = dart.toString(this[_buffer]);
>+      this[_chunkedSink].addSlice(accumulated, 0, accumulated.length, isLast);
>+      this[_buffer].clear();
>+      return;
>+    }
>+    if (dart.test(isLast)) this.close();
>+  }
>+};
>+(convert._Utf8ConversionSink.new = function(sink, allowMalformed) {
>+  convert._Utf8ConversionSink.__.call(this, sink, new core.StringBuffer.new(), allowMalformed);
>+}).prototype = convert._Utf8ConversionSink.prototype;
>+(convert._Utf8ConversionSink.__ = function(chunkedSink, stringBuffer, allowMalformed) {
>+  this[_chunkedSink] = chunkedSink;
>+  this[_decoder] = new convert._Utf8Decoder.new(stringBuffer, allowMalformed);
>+  this[_buffer] = stringBuffer;
>+  convert._Utf8ConversionSink.__proto__.new.call(this);
>+}).prototype = convert._Utf8ConversionSink.prototype;
>+dart.addTypeTests(convert._Utf8ConversionSink);
>+dart.setMethodSignature(convert._Utf8ConversionSink, () => ({
>+  __proto__: dart.getMethods(convert._Utf8ConversionSink.__proto__),
>+  close: dart.fnType(dart.void, []),
>+  add: dart.fnType(dart.void, [core.Object]),
>+  addSlice: dart.fnType(dart.void, [core.List$(core.int), core.int, core.int, core.bool])
>+}));
>+dart.setLibraryUri(convert._Utf8ConversionSink, "dart:convert");
>+dart.setFieldSignature(convert._Utf8ConversionSink, () => ({
>+  __proto__: dart.getFields(convert._Utf8ConversionSink.__proto__),
>+  [_decoder]: dart.finalFieldType(convert._Utf8Decoder),
>+  [_chunkedSink]: dart.finalFieldType(convert.StringConversionSink),
>+  [_buffer]: dart.finalFieldType(core.StringBuffer)
>+}));
>+dart.defineLazy(convert, {
>+  /*convert.unicodeReplacementCharacterRune*/get unicodeReplacementCharacterRune() {
>+    return 65533;
>+  },
>+  /*convert.unicodeBomCharacterRune*/get unicodeBomCharacterRune() {
>+    return 65279;
>+  },
>+  /*convert.utf8*/get utf8() {
>+    return dart.const(new convert.Utf8Codec.new());
>+  }
>+});
>+const _allowMalformed = dart.privateName(convert, "_allowMalformed");
>+let const$49;
>+convert.Utf8Codec = class Utf8Codec extends convert.Encoding {
>+  get name() {
>+    return "utf-8";
>+  }
>+  decode(codeUnits, opts) {
>+    ListOfint()._check(codeUnits);
>+    let allowMalformed = opts && 'allowMalformed' in opts ? opts.allowMalformed : null;
>+    let t = allowMalformed;
>+    t == null ? allowMalformed = this[_allowMalformed] : t;
>+    return new convert.Utf8Decoder.new({allowMalformed: allowMalformed}).convert(codeUnits);
>+  }
>+  get encoder() {
>+    return const$49 || (const$49 = dart.const(new convert.Utf8Encoder.new()));
>+  }
>+  get decoder() {
>+    return new convert.Utf8Decoder.new({allowMalformed: this[_allowMalformed]});
>+  }
>+};
>+(convert.Utf8Codec.new = function(opts) {
>+  let allowMalformed = opts && 'allowMalformed' in opts ? opts.allowMalformed : false;
>+  this[_allowMalformed] = allowMalformed;
>+  convert.Utf8Codec.__proto__.new.call(this);
>+}).prototype = convert.Utf8Codec.prototype;
>+dart.addTypeTests(convert.Utf8Codec);
>+dart.setMethodSignature(convert.Utf8Codec, () => ({
>+  __proto__: dart.getMethods(convert.Utf8Codec.__proto__),
>+  decode: dart.fnType(core.String, [core.Object], {allowMalformed: core.bool})
>+}));
>+dart.setGetterSignature(convert.Utf8Codec, () => ({
>+  __proto__: dart.getGetters(convert.Utf8Codec.__proto__),
>+  name: core.String,
>+  encoder: convert.Utf8Encoder,
>+  decoder: convert.Utf8Decoder
>+}));
>+dart.setLibraryUri(convert.Utf8Codec, "dart:convert");
>+dart.setFieldSignature(convert.Utf8Codec, () => ({
>+  __proto__: dart.getFields(convert.Utf8Codec.__proto__),
>+  [_allowMalformed]: dart.finalFieldType(core.bool)
>+}));
>+const _fillBuffer = dart.privateName(convert, "_fillBuffer");
>+const _writeSurrogate = dart.privateName(convert, "_writeSurrogate");
>+convert.Utf8Encoder = class Utf8Encoder extends convert.Converter$(core.String, core.List$(core.int)) {
>+  convert(string, start, end) {
>+    core.String._check(string);
>+    if (start === void 0) start = 0;
>+    if (end === void 0) end = null;
>+    let stringLength = string.length;
>+    end = core.RangeError.checkValidRange(start, end, stringLength);
>+    let length = dart.notNull(end) - dart.notNull(start);
>+    if (length === 0) return typed_data.Uint8List.new(0);
>+    let encoder = new convert._Utf8Encoder.withBufferSize(length * 3);
>+    let endPosition = encoder[_fillBuffer](string, start, end);
>+    if (!(dart.notNull(endPosition) >= dart.notNull(end) - 1)) dart.assertFailed(null, "dart:convert/utf.dart", 87, 12, "endPosition >= end - 1");
>+    if (endPosition != end) {
>+      let lastCodeUnit = string[$codeUnitAt](dart.notNull(end) - 1);
>+      if (!dart.test(convert._isLeadSurrogate(lastCodeUnit))) dart.assertFailed(null, "dart:convert/utf.dart", 93, 14, "_isLeadSurrogate(lastCodeUnit)");
>+      let wasCombined = encoder[_writeSurrogate](lastCodeUnit, 0);
>+      if (!!dart.test(wasCombined)) dart.assertFailed(null, "dart:convert/utf.dart", 97, 14, "!wasCombined");
>+    }
>+    return encoder[_buffer][$sublist](0, encoder[_bufferIndex]);
>+  }
>+  startChunkedConversion(sink) {
>+    SinkOfListOfint()._check(sink);
>+    return new convert._Utf8EncoderSink.new(convert.ByteConversionSink.is(sink) ? sink : convert.ByteConversionSink.from(sink));
>+  }
>+  bind(stream) {
>+    StreamOfString()._check(stream);
>+    return super.bind(stream);
>+  }
>+};
>+(convert.Utf8Encoder.new = function() {
>+  convert.Utf8Encoder.__proto__.new.call(this);
>+}).prototype = convert.Utf8Encoder.prototype;
>+dart.addTypeTests(convert.Utf8Encoder);
>+dart.setMethodSignature(convert.Utf8Encoder, () => ({
>+  __proto__: dart.getMethods(convert.Utf8Encoder.__proto__),
>+  convert: dart.fnType(core.List$(core.int), [core.Object], [core.int, core.int]),
>+  startChunkedConversion: dart.fnType(convert.StringConversionSink, [core.Object]),
>+  bind: dart.fnType(async.Stream$(core.List$(core.int)), [core.Object])
>+}));
>+dart.setLibraryUri(convert.Utf8Encoder, "dart:convert");
>+convert._Utf8Encoder = class _Utf8Encoder extends core.Object {
>+  static _createBuffer(size) {
>+    return typed_data.Uint8List.new(size);
>+  }
>+  [_writeSurrogate](leadingSurrogate, nextCodeUnit) {
>+    if (dart.test(convert._isTailSurrogate(nextCodeUnit))) {
>+      let rune = convert._combineSurrogatePair(leadingSurrogate, nextCodeUnit);
>+      if (!(dart.notNull(rune) > 65535)) dart.assertFailed(null, "dart:convert/utf.dart", 146, 14, "rune > _THREE_BYTE_LIMIT");
>+      if (!(dart.notNull(rune) <= 1114111)) dart.assertFailed(null, "dart:convert/utf.dart", 147, 14, "rune <= _FOUR_BYTE_LIMIT");
>+      this[_buffer][$_set]((() => {
>+        let x = this[_bufferIndex];
>+        this[_bufferIndex] = dart.notNull(x) + 1;
>+        return x;
>+      })(), (240 | rune[$rightShift](18)) >>> 0);
>+      this[_buffer][$_set]((() => {
>+        let x = this[_bufferIndex];
>+        this[_bufferIndex] = dart.notNull(x) + 1;
>+        return x;
>+      })(), 128 | dart.notNull(rune) >> 12 & 63);
>+      this[_buffer][$_set]((() => {
>+        let x = this[_bufferIndex];
>+        this[_bufferIndex] = dart.notNull(x) + 1;
>+        return x;
>+      })(), 128 | dart.notNull(rune) >> 6 & 63);
>+      this[_buffer][$_set]((() => {
>+        let x = this[_bufferIndex];
>+        this[_bufferIndex] = dart.notNull(x) + 1;
>+        return x;
>+      })(), 128 | dart.notNull(rune) & 63);
>+      return true;
>+    } else {
>+      this[_buffer][$_set]((() => {
>+        let x = this[_bufferIndex];
>+        this[_bufferIndex] = dart.notNull(x) + 1;
>+        return x;
>+      })(), (224 | leadingSurrogate[$rightShift](12)) >>> 0);
>+      this[_buffer][$_set]((() => {
>+        let x = this[_bufferIndex];
>+        this[_bufferIndex] = dart.notNull(x) + 1;
>+        return x;
>+      })(), 128 | dart.notNull(leadingSurrogate) >> 6 & 63);
>+      this[_buffer][$_set]((() => {
>+        let x = this[_bufferIndex];
>+        this[_bufferIndex] = dart.notNull(x) + 1;
>+        return x;
>+      })(), 128 | dart.notNull(leadingSurrogate) & 63);
>+      return false;
>+    }
>+  }
>+  [_fillBuffer](str, start, end) {
>+    if (start != end && dart.test(convert._isLeadSurrogate(str[$codeUnitAt](dart.notNull(end) - 1)))) {
>+      end = dart.notNull(end) - 1;
>+    }
>+    let stringIndex = null;
>+    for (stringIndex = start; dart.notNull(stringIndex) < dart.notNull(end); stringIndex = dart.notNull(stringIndex) + 1) {
>+      let codeUnit = str[$codeUnitAt](stringIndex);
>+      if (codeUnit <= 127) {
>+        if (dart.notNull(this[_bufferIndex]) >= dart.notNull(this[_buffer][$length])) break;
>+        this[_buffer][$_set]((() => {
>+          let x = this[_bufferIndex];
>+          this[_bufferIndex] = dart.notNull(x) + 1;
>+          return x;
>+        })(), codeUnit);
>+      } else if (dart.test(convert._isLeadSurrogate(codeUnit))) {
>+        if (dart.notNull(this[_bufferIndex]) + 3 >= dart.notNull(this[_buffer][$length])) break;
>+        let nextCodeUnit = str[$codeUnitAt](dart.notNull(stringIndex) + 1);
>+        let wasCombined = this[_writeSurrogate](codeUnit, nextCodeUnit);
>+        if (dart.test(wasCombined)) {
>+          stringIndex = dart.notNull(stringIndex) + 1;
>+        }
>+      } else {
>+        let rune = codeUnit;
>+        if (rune <= 2047) {
>+          if (dart.notNull(this[_bufferIndex]) + 1 >= dart.notNull(this[_buffer][$length])) break;
>+          this[_buffer][$_set]((() => {
>+            let x = this[_bufferIndex];
>+            this[_bufferIndex] = dart.notNull(x) + 1;
>+            return x;
>+          })(), (192 | rune[$rightShift](6)) >>> 0);
>+          this[_buffer][$_set]((() => {
>+            let x = this[_bufferIndex];
>+            this[_bufferIndex] = dart.notNull(x) + 1;
>+            return x;
>+          })(), 128 | rune & 63);
>+        } else {
>+          if (!(rune <= 65535)) dart.assertFailed(null, "dart:convert/utf.dart", 200, 18, "rune <= _THREE_BYTE_LIMIT");
>+          if (dart.notNull(this[_bufferIndex]) + 2 >= dart.notNull(this[_buffer][$length])) break;
>+          this[_buffer][$_set]((() => {
>+            let x = this[_bufferIndex];
>+            this[_bufferIndex] = dart.notNull(x) + 1;
>+            return x;
>+          })(), (224 | rune[$rightShift](12)) >>> 0);
>+          this[_buffer][$_set]((() => {
>+            let x = this[_bufferIndex];
>+            this[_bufferIndex] = dart.notNull(x) + 1;
>+            return x;
>+          })(), 128 | rune >> 6 & 63);
>+          this[_buffer][$_set]((() => {
>+            let x = this[_bufferIndex];
>+            this[_bufferIndex] = dart.notNull(x) + 1;
>+            return x;
>+          })(), 128 | rune & 63);
>+        }
>+      }
>+    }
>+    return stringIndex;
>+  }
>+};
>+(convert._Utf8Encoder.new = function() {
>+  convert._Utf8Encoder.withBufferSize.call(this, 1024);
>+}).prototype = convert._Utf8Encoder.prototype;
>+(convert._Utf8Encoder.withBufferSize = function(bufferSize) {
>+  this[_carry] = 0;
>+  this[_bufferIndex] = 0;
>+  this[_buffer] = convert._Utf8Encoder._createBuffer(bufferSize);
>+}).prototype = convert._Utf8Encoder.prototype;
>+dart.addTypeTests(convert._Utf8Encoder);
>+dart.setMethodSignature(convert._Utf8Encoder, () => ({
>+  __proto__: dart.getMethods(convert._Utf8Encoder.__proto__),
>+  [_writeSurrogate]: dart.fnType(core.bool, [core.int, core.int]),
>+  [_fillBuffer]: dart.fnType(core.int, [core.String, core.int, core.int])
>+}));
>+dart.setLibraryUri(convert._Utf8Encoder, "dart:convert");
>+dart.setFieldSignature(convert._Utf8Encoder, () => ({
>+  __proto__: dart.getFields(convert._Utf8Encoder.__proto__),
>+  [_carry]: dart.fieldType(core.int),
>+  [_bufferIndex]: dart.fieldType(core.int),
>+  [_buffer]: dart.finalFieldType(ListOfint())
>+}));
>+dart.defineLazy(convert._Utf8Encoder, {
>+  /*convert._Utf8Encoder._DEFAULT_BYTE_BUFFER_SIZE*/get _DEFAULT_BYTE_BUFFER_SIZE() {
>+    return 1024;
>+  }
>+});
>+const _Utf8Encoder_StringConversionSinkMixin$ = class _Utf8Encoder_StringConversionSinkMixin extends convert._Utf8Encoder {};
>+(_Utf8Encoder_StringConversionSinkMixin$.new = function() {
>+  _Utf8Encoder_StringConversionSinkMixin$.__proto__.new.call(this);
>+}).prototype = _Utf8Encoder_StringConversionSinkMixin$.prototype;
>+(_Utf8Encoder_StringConversionSinkMixin$.withBufferSize = function(bufferSize) {
>+  _Utf8Encoder_StringConversionSinkMixin$.__proto__.withBufferSize.call(this, bufferSize);
>+}).prototype = _Utf8Encoder_StringConversionSinkMixin$.prototype;
>+dart.applyMixin(_Utf8Encoder_StringConversionSinkMixin$, convert.StringConversionSinkMixin);
>+convert._Utf8EncoderSink = class _Utf8EncoderSink extends _Utf8Encoder_StringConversionSinkMixin$ {
>+  close() {
>+    if (this[_carry] !== 0) {
>+      this.addSlice("", 0, 0, true);
>+      return;
>+    }
>+    this[_sink$].close();
>+  }
>+  addSlice(str, start, end, isLast) {
>+    this[_bufferIndex] = 0;
>+    if (start == end && !dart.test(isLast)) {
>+      return;
>+    }
>+    if (this[_carry] !== 0) {
>+      let nextCodeUnit = 0;
>+      if (start != end) {
>+        nextCodeUnit = str[$codeUnitAt](start);
>+      } else {
>+        if (!dart.test(isLast)) dart.assertFailed(null, "dart:convert/utf.dart", 240, 16, "isLast");
>+      }
>+      let wasCombined = this[_writeSurrogate](this[_carry], nextCodeUnit);
>+      if (!(!dart.test(wasCombined) || start != end)) dart.assertFailed(null, "dart:convert/utf.dart", 244, 14, "!wasCombined || start != end");
>+      if (dart.test(wasCombined)) {
>+        start = dart.notNull(start) + 1;
>+      }
>+      this[_carry] = 0;
>+    }
>+    do {
>+      start = this[_fillBuffer](str, start, end);
>+      let isLastSlice = dart.test(isLast) && start == end;
>+      if (start === dart.notNull(end) - 1 && dart.test(convert._isLeadSurrogate(str[$codeUnitAt](start)))) {
>+        if (dart.test(isLast) && dart.notNull(this[_bufferIndex]) < dart.notNull(this[_buffer][$length]) - 3) {
>+          let hasBeenCombined = this[_writeSurrogate](str[$codeUnitAt](start), 0);
>+          if (!!dart.test(hasBeenCombined)) dart.assertFailed(null, "dart:convert/utf.dart", 257, 18, "!hasBeenCombined");
>+        } else {
>+          this[_carry] = str[$codeUnitAt](start);
>+        }
>+        start = dart.notNull(start) + 1;
>+      }
>+      this[_sink$].addSlice(this[_buffer], 0, this[_bufferIndex], isLastSlice);
>+      this[_bufferIndex] = 0;
>+    } while (dart.notNull(start) < dart.notNull(end));
>+    if (dart.test(isLast)) this.close();
>+  }
>+};
>+(convert._Utf8EncoderSink.new = function(sink) {
>+  this[_sink$] = sink;
>+  convert._Utf8EncoderSink.__proto__.new.call(this);
>+}).prototype = convert._Utf8EncoderSink.prototype;
>+dart.addTypeTests(convert._Utf8EncoderSink);
>+dart.setMethodSignature(convert._Utf8EncoderSink, () => ({
>+  __proto__: dart.getMethods(convert._Utf8EncoderSink.__proto__),
>+  close: dart.fnType(dart.void, []),
>+  addSlice: dart.fnType(dart.void, [core.String, core.int, core.int, core.bool])
>+}));
>+dart.setLibraryUri(convert._Utf8EncoderSink, "dart:convert");
>+dart.setFieldSignature(convert._Utf8EncoderSink, () => ({
>+  __proto__: dart.getFields(convert._Utf8EncoderSink.__proto__),
>+  [_sink$]: dart.finalFieldType(convert.ByteConversionSink)
>+}));
>+const _isFirstCharacter = dart.privateName(convert, "_isFirstCharacter");
>+convert.Utf8Decoder = class Utf8Decoder extends convert.Converter$(core.List$(core.int), core.String) {
>+  convert(codeUnits, start, end) {
>+    ListOfint()._check(codeUnits);
>+    if (start === void 0) start = 0;
>+    if (end === void 0) end = null;
>+    let result = convert.Utf8Decoder._convertIntercepted(this[_allowMalformed], codeUnits, start, end);
>+    if (result != null) {
>+      return result;
>+    }
>+    let length = codeUnits[$length];
>+    end = core.RangeError.checkValidRange(start, end, length);
>+    let oneBytes = convert._scanOneByteCharacters(codeUnits, start, end);
>+    let buffer = null;
>+    let isFirstCharacter = true;
>+    if (dart.notNull(oneBytes) > 0) {
>+      let firstPart = core.String.fromCharCodes(codeUnits, start, dart.notNull(start) + dart.notNull(oneBytes));
>+      start = dart.notNull(start) + dart.notNull(oneBytes);
>+      if (start == end) {
>+        return firstPart;
>+      }
>+      buffer = new core.StringBuffer.new(firstPart);
>+      isFirstCharacter = false;
>+    }
>+    let t = buffer;
>+    t == null ? buffer = new core.StringBuffer.new() : t;
>+    let decoder = new convert._Utf8Decoder.new(buffer, this[_allowMalformed]);
>+    decoder[_isFirstCharacter] = isFirstCharacter;
>+    decoder.convert(codeUnits, start, end);
>+    decoder.flush(codeUnits, end);
>+    return dart.toString(buffer);
>+  }
>+  startChunkedConversion(sink) {
>+    SinkOfString()._check(sink);
>+    let stringSink = null;
>+    if (convert.StringConversionSink.is(sink)) {
>+      stringSink = sink;
>+    } else {
>+      stringSink = convert.StringConversionSink.from(sink);
>+    }
>+    return stringSink.asUtf8Sink(this[_allowMalformed]);
>+  }
>+  bind(stream) {
>+    StreamOfListOfint()._check(stream);
>+    return super.bind(stream);
>+  }
>+  fuse(T, next) {
>+    convert.Converter$(core.String, T)._check(next);
>+    return super.fuse(T, next);
>+  }
>+  static _convertIntercepted(allowMalformed, codeUnits, start, end) {
>+    if (codeUnits instanceof Uint8Array) {
>+      let casted = codeUnits;
>+      return convert.Utf8Decoder._convertInterceptedUint8List(allowMalformed, casted, start, end);
>+    }
>+  }
>+  static _convertInterceptedUint8List(allowMalformed, codeUnits, start, end) {
>+    if (dart.test(allowMalformed)) {
>+      return null;
>+    }
>+    let decoder = convert.Utf8Decoder._decoder;
>+    if (decoder == null) return null;
>+    if (0 === start && end == null) {
>+      return convert.Utf8Decoder._useTextDecoderChecked(decoder, codeUnits);
>+    }
>+    let length = codeUnits[$length];
>+    end = core.RangeError.checkValidRange(start, end, length);
>+    if (0 === start && end == codeUnits[$length]) {
>+      return convert.Utf8Decoder._useTextDecoderChecked(decoder, codeUnits);
>+    }
>+    return convert.Utf8Decoder._useTextDecoderChecked(decoder, codeUnits.subarray(start, end));
>+  }
>+  static _useTextDecoderChecked(decoder, codeUnits) {
>+    if (dart.test(convert.Utf8Decoder._unsafe(codeUnits))) return null;
>+    return convert.Utf8Decoder._useTextDecoderUnchecked(decoder, codeUnits);
>+  }
>+  static _useTextDecoderUnchecked(decoder, codeUnits) {
>+    try {
>+      return decoder.decode(codeUnits);
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+    }
>+    return null;
>+  }
>+  static _unsafe(codeUnits) {
>+    let limit = dart.notNull(codeUnits[$length]) - 2;
>+    for (let i = 0; i < limit; i++) {
>+      let unit1 = codeUnits[$_get](i);
>+      if (unit1 === 237) {
>+        let unit2 = codeUnits[$_get](i + 1);
>+        if ((unit2 & 224) === 160) return true;
>+      }
>+    }
>+    return false;
>+  }
>+};
>+(convert.Utf8Decoder.new = function(opts) {
>+  let allowMalformed = opts && 'allowMalformed' in opts ? opts.allowMalformed : false;
>+  this[_allowMalformed] = allowMalformed;
>+  convert.Utf8Decoder.__proto__.new.call(this);
>+}).prototype = convert.Utf8Decoder.prototype;
>+dart.addTypeTests(convert.Utf8Decoder);
>+dart.setMethodSignature(convert.Utf8Decoder, () => ({
>+  __proto__: dart.getMethods(convert.Utf8Decoder.__proto__),
>+  convert: dart.fnType(core.String, [core.Object], [core.int, core.int]),
>+  startChunkedConversion: dart.fnType(convert.ByteConversionSink, [core.Object]),
>+  bind: dart.fnType(async.Stream$(core.String), [core.Object]),
>+  fuse: dart.gFnType(T => [convert.Converter$(core.List$(core.int), T), [core.Object]])
>+}));
>+dart.setLibraryUri(convert.Utf8Decoder, "dart:convert");
>+dart.setFieldSignature(convert.Utf8Decoder, () => ({
>+  __proto__: dart.getFields(convert.Utf8Decoder.__proto__),
>+  [_allowMalformed]: dart.finalFieldType(core.bool)
>+}));
>+dart.defineLazy(convert.Utf8Decoder, {
>+  /*convert.Utf8Decoder._decoder*/get _decoder() {
>+    return dart.fn(() => {
>+      try {
>+        return new TextDecoder("utf-8", {fatal: true});
>+      } catch (e$) {
>+        let e = dart.getThrown(e$);
>+      }
>+      return null;
>+    }, VoidTodynamic())();
>+  }
>+});
>+dart.defineLazy(convert, {
>+  /*convert._ONE_BYTE_LIMIT*/get _ONE_BYTE_LIMIT() {
>+    return 127;
>+  },
>+  /*convert._TWO_BYTE_LIMIT*/get _TWO_BYTE_LIMIT() {
>+    return 2047;
>+  },
>+  /*convert._THREE_BYTE_LIMIT*/get _THREE_BYTE_LIMIT() {
>+    return 65535;
>+  },
>+  /*convert._FOUR_BYTE_LIMIT*/get _FOUR_BYTE_LIMIT() {
>+    return 1114111;
>+  },
>+  /*convert._SURROGATE_TAG_MASK*/get _SURROGATE_TAG_MASK() {
>+    return 64512;
>+  },
>+  /*convert._SURROGATE_VALUE_MASK*/get _SURROGATE_VALUE_MASK() {
>+    return 1023;
>+  },
>+  /*convert._LEAD_SURROGATE_MIN*/get _LEAD_SURROGATE_MIN() {
>+    return 55296;
>+  },
>+  /*convert._TAIL_SURROGATE_MIN*/get _TAIL_SURROGATE_MIN() {
>+    return 56320;
>+  }
>+});
>+convert._isLeadSurrogate = function(codeUnit) {
>+  return (dart.notNull(codeUnit) & 64512) === 55296;
>+};
>+convert._isTailSurrogate = function(codeUnit) {
>+  return (dart.notNull(codeUnit) & 64512) === 56320;
>+};
>+convert._combineSurrogatePair = function(lead, tail) {
>+  return (65536 + ((dart.notNull(lead) & 1023) << 10) | dart.notNull(tail) & 1023) >>> 0;
>+};
>+const _value$ = dart.privateName(convert, "_value");
>+const _expectedUnits = dart.privateName(convert, "_expectedUnits");
>+const _extraUnits = dart.privateName(convert, "_extraUnits");
>+convert._Utf8Decoder = class _Utf8Decoder extends core.Object {
>+  get hasPartialInput() {
>+    return dart.notNull(this[_expectedUnits]) > 0;
>+  }
>+  close() {
>+    this.flush();
>+  }
>+  flush(source, offset) {
>+    if (source === void 0) source = null;
>+    if (offset === void 0) offset = null;
>+    if (dart.test(this.hasPartialInput)) {
>+      if (!dart.test(this[_allowMalformed])) {
>+        dart.throw(new core.FormatException.new("Unfinished UTF-8 octet sequence", source, offset));
>+      }
>+      this[_stringSink].writeCharCode(65533);
>+      this[_value$] = 0;
>+      this[_expectedUnits] = 0;
>+      this[_extraUnits] = 0;
>+    }
>+  }
>+  convert(codeUnits, startIndex, endIndex) {
>+    let value = this[_value$];
>+    let expectedUnits = this[_expectedUnits];
>+    let extraUnits = this[_extraUnits];
>+    this[_value$] = 0;
>+    this[_expectedUnits] = 0;
>+    this[_extraUnits] = 0;
>+    let i = startIndex;
>+    loop:
>+      while (true) {
>+        multibyte:
>+          if (dart.notNull(expectedUnits) > 0) {
>+            do {
>+              if (i == endIndex) {
>+                break loop;
>+              }
>+              let unit = codeUnits[$_get](i);
>+              if ((dart.notNull(unit) & 192) !== 128) {
>+                expectedUnits = 0;
>+                if (!dart.test(this[_allowMalformed])) {
>+                  dart.throw(new core.FormatException.new("Bad UTF-8 encoding 0x" + unit[$toRadixString](16), codeUnits, i));
>+                }
>+                this[_isFirstCharacter] = false;
>+                this[_stringSink].writeCharCode(65533);
>+                break multibyte;
>+              } else {
>+                value = (dart.notNull(value) << 6 | dart.notNull(unit) & 63) >>> 0;
>+                expectedUnits = dart.notNull(expectedUnits) - 1;
>+                i = dart.notNull(i) + 1;
>+              }
>+            } while (dart.notNull(expectedUnits) > 0);
>+            if (dart.notNull(value) <= dart.notNull(convert._Utf8Decoder._LIMITS[$_get](dart.notNull(extraUnits) - 1))) {
>+              if (!dart.test(this[_allowMalformed])) {
>+                dart.throw(new core.FormatException.new("Overlong encoding of 0x" + value[$toRadixString](16), codeUnits, dart.notNull(i) - dart.notNull(extraUnits) - 1));
>+              }
>+              expectedUnits = extraUnits = 0;
>+              value = 65533;
>+            }
>+            if (dart.notNull(value) > 1114111) {
>+              if (!dart.test(this[_allowMalformed])) {
>+                dart.throw(new core.FormatException.new("Character outside valid Unicode range: " + ("0x" + value[$toRadixString](16)), codeUnits, dart.notNull(i) - dart.notNull(extraUnits) - 1));
>+              }
>+              value = 65533;
>+            }
>+            if (!dart.test(this[_isFirstCharacter]) || value !== 65279) {
>+              this[_stringSink].writeCharCode(value);
>+            }
>+            this[_isFirstCharacter] = false;
>+          }
>+        while (dart.notNull(i) < dart.notNull(endIndex)) {
>+          let oneBytes = convert._scanOneByteCharacters(codeUnits, i, endIndex);
>+          if (dart.notNull(oneBytes) > 0) {
>+            this[_isFirstCharacter] = false;
>+            if (!(dart.notNull(i) + dart.notNull(oneBytes) <= dart.notNull(endIndex))) dart.assertFailed(null, "dart:convert/utf.dart", 586, 18, "i + oneBytes <= endIndex");
>+            this[_stringSink].write(core.String.fromCharCodes(codeUnits, i, dart.notNull(i) + dart.notNull(oneBytes)));
>+            i = dart.notNull(i) + dart.notNull(oneBytes);
>+            if (i == endIndex) break;
>+          }
>+          let unit = codeUnits[$_get]((() => {
>+            let x = i;
>+            i = dart.notNull(x) + 1;
>+            return x;
>+          })());
>+          if (dart.notNull(unit) < 0) {
>+            if (!dart.test(this[_allowMalformed])) {
>+              dart.throw(new core.FormatException.new("Negative UTF-8 code unit: -0x" + (-dart.notNull(unit))[$toRadixString](16), codeUnits, dart.notNull(i) - 1));
>+            }
>+            this[_stringSink].writeCharCode(65533);
>+          } else {
>+            if (!(dart.notNull(unit) > 127)) dart.assertFailed(null, "dart:convert/utf.dart", 608, 18, "unit > _ONE_BYTE_LIMIT");
>+            if ((dart.notNull(unit) & 224) === 192) {
>+              value = dart.notNull(unit) & 31;
>+              expectedUnits = extraUnits = 1;
>+              continue loop;
>+            }
>+            if ((dart.notNull(unit) & 240) === 224) {
>+              value = dart.notNull(unit) & 15;
>+              expectedUnits = extraUnits = 2;
>+              continue loop;
>+            }
>+            if ((dart.notNull(unit) & 248) === 240 && dart.notNull(unit) < 245) {
>+              value = dart.notNull(unit) & 7;
>+              expectedUnits = extraUnits = 3;
>+              continue loop;
>+            }
>+            if (!dart.test(this[_allowMalformed])) {
>+              dart.throw(new core.FormatException.new("Bad UTF-8 encoding 0x" + unit[$toRadixString](16), codeUnits, dart.notNull(i) - 1));
>+            }
>+            value = 65533;
>+            expectedUnits = extraUnits = 0;
>+            this[_isFirstCharacter] = false;
>+            this[_stringSink].writeCharCode(value);
>+          }
>+        }
>+        break loop;
>+      }
>+    if (dart.notNull(expectedUnits) > 0) {
>+      this[_value$] = value;
>+      this[_expectedUnits] = expectedUnits;
>+      this[_extraUnits] = extraUnits;
>+    }
>+  }
>+};
>+(convert._Utf8Decoder.new = function(stringSink, allowMalformed) {
>+  this[_isFirstCharacter] = true;
>+  this[_value$] = 0;
>+  this[_expectedUnits] = 0;
>+  this[_extraUnits] = 0;
>+  this[_stringSink] = stringSink;
>+  this[_allowMalformed] = allowMalformed;
>+}).prototype = convert._Utf8Decoder.prototype;
>+dart.addTypeTests(convert._Utf8Decoder);
>+dart.setMethodSignature(convert._Utf8Decoder, () => ({
>+  __proto__: dart.getMethods(convert._Utf8Decoder.__proto__),
>+  close: dart.fnType(dart.void, []),
>+  flush: dart.fnType(dart.void, [], [core.List$(core.int), core.int]),
>+  convert: dart.fnType(dart.void, [core.List$(core.int), core.int, core.int])
>+}));
>+dart.setGetterSignature(convert._Utf8Decoder, () => ({
>+  __proto__: dart.getGetters(convert._Utf8Decoder.__proto__),
>+  hasPartialInput: core.bool
>+}));
>+dart.setLibraryUri(convert._Utf8Decoder, "dart:convert");
>+dart.setFieldSignature(convert._Utf8Decoder, () => ({
>+  __proto__: dart.getFields(convert._Utf8Decoder.__proto__),
>+  [_allowMalformed]: dart.finalFieldType(core.bool),
>+  [_stringSink]: dart.finalFieldType(core.StringSink),
>+  [_isFirstCharacter]: dart.fieldType(core.bool),
>+  [_value$]: dart.fieldType(core.int),
>+  [_expectedUnits]: dart.fieldType(core.int),
>+  [_extraUnits]: dart.fieldType(core.int)
>+}));
>+dart.defineLazy(convert._Utf8Decoder, {
>+  /*convert._Utf8Decoder._LIMITS*/get _LIMITS() {
>+    return dart.constList([127, 2047, 65535, 1114111], core.int);
>+  }
>+});
>+convert._scanOneByteCharacters = function(units, from, endIndex) {
>+  let to = endIndex;
>+  for (let i = from; dart.notNull(i) < dart.notNull(to); i = dart.notNull(i) + 1) {
>+    let unit = units[$_get](i);
>+    if ((dart.notNull(unit) & 127) !== unit) return dart.notNull(i) - dart.notNull(from);
>+  }
>+  return dart.notNull(to) - dart.notNull(from);
>+};
>+core._symbolToString = function(symbol) {
>+  return _js_helper.PrivateSymbol.is(symbol) ? _js_helper.PrivateSymbol.getName(symbol) : _internal.Symbol.getName(_internal.Symbol._check(symbol));
>+};
>+core._kNull = function(_) {
>+  return null;
>+};
>+const _errorMsg = dart.privateName(core, "_errorMsg");
>+core._CompileTimeError = class _CompileTimeError extends core.Error {
>+  toString() {
>+    return this[_errorMsg];
>+  }
>+};
>+(core._CompileTimeError.new = function(errorMsg) {
>+  this[_errorMsg] = errorMsg;
>+  core._CompileTimeError.__proto__.new.call(this);
>+}).prototype = core._CompileTimeError.prototype;
>+dart.addTypeTests(core._CompileTimeError);
>+dart.setLibraryUri(core._CompileTimeError, "dart:core");
>+dart.setFieldSignature(core._CompileTimeError, () => ({
>+  __proto__: dart.getFields(core._CompileTimeError.__proto__),
>+  [_errorMsg]: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionMethods(core._CompileTimeError, ['toString']);
>+const _name$2 = dart.privateName(core, "_name");
>+core._DuplicatedFieldInitializerError = class _DuplicatedFieldInitializerError extends core.Object {
>+  toString() {
>+    return "Error: field '" + dart.str(this[_name$2]) + "' is already initialized.";
>+  }
>+};
>+(core._DuplicatedFieldInitializerError.new = function(name) {
>+  this[_name$2] = name;
>+}).prototype = core._DuplicatedFieldInitializerError.prototype;
>+dart.addTypeTests(core._DuplicatedFieldInitializerError);
>+dart.setLibraryUri(core._DuplicatedFieldInitializerError, "dart:core");
>+dart.setFieldSignature(core._DuplicatedFieldInitializerError, () => ({
>+  __proto__: dart.getFields(core._DuplicatedFieldInitializerError.__proto__),
>+  [_name$2]: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionMethods(core._DuplicatedFieldInitializerError, ['toString']);
>+core._max = function(a, b) {
>+  return dart.notNull(a) > dart.notNull(b) ? a : b;
>+};
>+core._min = function(a, b) {
>+  return dart.notNull(a) < dart.notNull(b) ? a : b;
>+};
>+const _used = dart.privateName(core, "_used");
>+const _digits = dart.privateName(core, "_digits");
>+const _isNegative = dart.privateName(core, "_isNegative");
>+const _isZero = dart.privateName(core, "_isZero");
>+const _dlShift = dart.privateName(core, "_dlShift");
>+const _drShift = dart.privateName(core, "_drShift");
>+const _absCompare = dart.privateName(core, "_absCompare");
>+const _absAddSetSign = dart.privateName(core, "_absAddSetSign");
>+const _absSubSetSign = dart.privateName(core, "_absSubSetSign");
>+const _absAndSetSign = dart.privateName(core, "_absAndSetSign");
>+const _absAndNotSetSign = dart.privateName(core, "_absAndNotSetSign");
>+const _absOrSetSign = dart.privateName(core, "_absOrSetSign");
>+const _absXorSetSign = dart.privateName(core, "_absXorSetSign");
>+const _divRem = dart.privateName(core, "_divRem");
>+const _div = dart.privateName(core, "_div");
>+const _rem = dart.privateName(core, "_rem");
>+let const$50;
>+let const$51;
>+let const$52;
>+const _toRadixCodeUnit = dart.privateName(core, "_toRadixCodeUnit");
>+const _toHexString = dart.privateName(core, "_toHexString");
>+core._BigIntImpl = class _BigIntImpl extends core.Object {
>+  static parse(source, opts) {
>+    let radix = opts && 'radix' in opts ? opts.radix : null;
>+    let result = core._BigIntImpl._tryParse(source, {radix: radix});
>+    if (result == null) {
>+      dart.throw(new core.FormatException.new("Could not parse BigInt", source));
>+    }
>+    return result;
>+  }
>+  static _parseDecimal(source, isNegative) {
>+    let _0 = 48;
>+    let part = 0;
>+    let result = core._BigIntImpl.zero;
>+    let digitInPartCount = dart.asInt(4 - source.length[$remainder](4));
>+    if (digitInPartCount === 4) digitInPartCount = 0;
>+    for (let i = 0; i < source.length; i++) {
>+      part = part * 10 + source[$codeUnitAt](i) - _0;
>+      if ((digitInPartCount = dart.notNull(digitInPartCount) + 1) === 4) {
>+        result = result['*'](core._BigIntImpl._bigInt10000)['+'](core._BigIntImpl._fromInt(part));
>+        part = 0;
>+        digitInPartCount = 0;
>+      }
>+    }
>+    if (dart.test(isNegative)) return result._negate();
>+    return result;
>+  }
>+  static _codeUnitToRadixValue(codeUnit) {
>+    let _0 = 48;
>+    let _9 = 57;
>+    let _a = 97;
>+    if (_0 <= dart.notNull(codeUnit) && dart.notNull(codeUnit) <= _9) return dart.notNull(codeUnit) - _0;
>+    codeUnit = (dart.notNull(codeUnit) | 32) >>> 0;
>+    let result = dart.notNull(codeUnit) - _a + 10;
>+    return result;
>+  }
>+  static _parseHex(source, startPos, isNegative) {
>+    let hexDigitsPerChunk = (16 / 4)[$truncate]();
>+    let sourceLength = source.length - dart.notNull(startPos);
>+    let chunkCount = (sourceLength / hexDigitsPerChunk)[$ceil]();
>+    let digits = typed_data.Uint16List.new(chunkCount);
>+    let lastDigitLength = sourceLength - (chunkCount - 1) * hexDigitsPerChunk;
>+    let digitIndex = dart.notNull(digits[$length]) - 1;
>+    let i = startPos;
>+    let chunk = 0;
>+    for (let j = 0; j < lastDigitLength; j++) {
>+      let digitValue = core._BigIntImpl._codeUnitToRadixValue(source[$codeUnitAt]((() => {
>+        let x = i;
>+        i = dart.notNull(x) + 1;
>+        return x;
>+      })()));
>+      if (dart.notNull(digitValue) >= 16) return null;
>+      chunk = chunk * 16 + dart.notNull(digitValue);
>+    }
>+    digits[$_set](digitIndex--, chunk);
>+    while (dart.notNull(i) < source.length) {
>+      chunk = 0;
>+      for (let j = 0; j < hexDigitsPerChunk; j++) {
>+        let digitValue = core._BigIntImpl._codeUnitToRadixValue(source[$codeUnitAt]((() => {
>+          let x = i;
>+          i = dart.notNull(x) + 1;
>+          return x;
>+        })()));
>+        if (dart.notNull(digitValue) >= 16) return null;
>+        chunk = chunk * 16 + dart.notNull(digitValue);
>+      }
>+      digits[$_set](digitIndex--, chunk);
>+    }
>+    if (digits[$length] === 1 && digits[$_get](0) === 0) return core._BigIntImpl.zero;
>+    return new core._BigIntImpl.__(isNegative, digits[$length], digits);
>+  }
>+  static _parseRadix(source, radix, isNegative) {
>+    let result = core._BigIntImpl.zero;
>+    let base = core._BigIntImpl._fromInt(radix);
>+    for (let i = 0; i < source.length; i++) {
>+      let digitValue = core._BigIntImpl._codeUnitToRadixValue(source[$codeUnitAt](i));
>+      if (dart.notNull(digitValue) >= dart.notNull(radix)) return null;
>+      result = result['*'](base)['+'](core._BigIntImpl._fromInt(digitValue));
>+    }
>+    if (dart.test(isNegative)) return result._negate();
>+    return result;
>+  }
>+  static _tryParse(source, opts) {
>+    let radix = opts && 'radix' in opts ? opts.radix : null;
>+    if (source === "") return null;
>+    let re = core.RegExp.new("^\\s*([+-]?)((0x[a-f0-9]+)|(\\d+)|([a-z0-9]+))\\s*$", {caseSensitive: false});
>+    let match = re.firstMatch(source);
>+    let signIndex = 1;
>+    let hexIndex = 3;
>+    let decimalIndex = 4;
>+    let nonDecimalHexIndex = 5;
>+    if (match == null) return null;
>+    let isNegative = match._get(signIndex) === "-";
>+    let decimalMatch = match._get(decimalIndex);
>+    let hexMatch = match._get(hexIndex);
>+    let nonDecimalMatch = match._get(nonDecimalHexIndex);
>+    if (radix == null) {
>+      if (decimalMatch != null) {
>+        return core._BigIntImpl._parseDecimal(decimalMatch, isNegative);
>+      }
>+      if (hexMatch != null) {
>+        return core._BigIntImpl._parseHex(hexMatch, 2, isNegative);
>+      }
>+      return null;
>+    }
>+    if (!core.int.is(radix)) {
>+      dart.throw(new core.ArgumentError.value(radix, "radix", "is not an integer"));
>+    }
>+    if (dart.notNull(radix) < 2 || dart.notNull(radix) > 36) {
>+      dart.throw(new core.RangeError.range(radix, 2, 36, "radix"));
>+    }
>+    if (radix === 10 && decimalMatch != null) {
>+      return core._BigIntImpl._parseDecimal(decimalMatch, isNegative);
>+    }
>+    if (radix === 16 && (decimalMatch != null || nonDecimalMatch != null)) {
>+      return core._BigIntImpl._parseHex(decimalMatch != null ? decimalMatch : nonDecimalMatch, 0, isNegative);
>+    }
>+    return core._BigIntImpl._parseRadix((() => {
>+      let l = decimalMatch != null ? decimalMatch : nonDecimalMatch;
>+      return l != null ? l : hexMatch;
>+    })(), radix, isNegative);
>+  }
>+  static _normalize(used, digits) {
>+    while (dart.notNull(used) > 0 && digits[$_get](dart.notNull(used) - 1) === 0) {
>+      used = dart.notNull(used) - 1;
>+    }
>+    return used;
>+  }
>+  get [_isZero]() {
>+    return this[_used] === 0;
>+  }
>+  static _cloneDigits(digits, from, to, length) {
>+    let resultDigits = typed_data.Uint16List.new(length);
>+    let n = dart.notNull(to) - dart.notNull(from);
>+    for (let i = 0; i < n; i++) {
>+      resultDigits[$_set](i, digits[$_get](dart.notNull(from) + i));
>+    }
>+    return resultDigits;
>+  }
>+  static from(value) {
>+    if (value === 0) return core._BigIntImpl.zero;
>+    if (value === 1) return core._BigIntImpl.one;
>+    if (value === 2) return core._BigIntImpl.two;
>+    if (value[$abs]() < 4294967296) return core._BigIntImpl._fromInt(value[$toInt]());
>+    if (typeof value == 'number') return core._BigIntImpl._fromDouble(value);
>+    return core._BigIntImpl._fromInt(dart.asInt(value));
>+  }
>+  static _fromInt(value) {
>+    let isNegative = dart.notNull(value) < 0;
>+    if (!(16 === 16)) dart.assertFailed(null, "dart:core", 524, 12, "_digitBits == 16");
>+    if (isNegative) {
>+      let minInt64 = -2147483648 * 4294967296;
>+      if (value === minInt64) {
>+        let digits = typed_data.Uint16List.new(4);
>+        digits[$_set](3, 32768);
>+        return new core._BigIntImpl.__(true, 4, digits);
>+      }
>+      value = -dart.notNull(value);
>+    }
>+    if (dart.notNull(value) < 65536) {
>+      let digits = typed_data.Uint16List.new(1);
>+      digits[$_set](0, value);
>+      return new core._BigIntImpl.__(isNegative, 1, digits);
>+    }
>+    if (dart.notNull(value) <= 4294967295) {
>+      let digits = typed_data.Uint16List.new(2);
>+      digits[$_set](0, dart.notNull(value) & 65535);
>+      digits[$_set](1, value[$rightShift](16));
>+      return new core._BigIntImpl.__(isNegative, 2, digits);
>+    }
>+    let bits = value[$bitLength];
>+    let digits = typed_data.Uint16List.new(((bits - 1) / 16)[$truncate]() + 1);
>+    let i = 0;
>+    while (value !== 0) {
>+      digits[$_set](i++, dart.notNull(value) & 65535);
>+      value = (dart.notNull(value) / 65536)[$truncate]();
>+    }
>+    return new core._BigIntImpl.__(isNegative, digits[$length], digits);
>+  }
>+  static _fromDouble(value) {
>+    let exponentBias = 1075;
>+    if (value[$isNaN] || value[$isInfinite]) {
>+      dart.throw(new core.ArgumentError.new("Value must be finite: " + dart.str(value)));
>+    }
>+    let isNegative = dart.notNull(value) < 0;
>+    if (isNegative) value = -dart.notNull(value);
>+    value = value[$floorToDouble]();
>+    if (value === 0) return core._BigIntImpl.zero;
>+    let bits = core._BigIntImpl._bitsForFromDouble;
>+    for (let i = 0; i < 8; i++) {
>+      bits[$_set](i, 0);
>+    }
>+    bits[$buffer][$asByteData]()[$setFloat64](0, value, typed_data.Endian.little);
>+    let biasedExponent = (dart.notNull(bits[$_get](7)) << 4 >>> 0) + bits[$_get](6)[$rightShift](4);
>+    let exponent = biasedExponent - exponentBias;
>+    if (!(16 === 16)) dart.assertFailed(null, "dart:core", 583, 12, "_digitBits == 16");
>+    let unshiftedDigits = typed_data.Uint16List.new(4);
>+    unshiftedDigits[$_set](0, (dart.notNull(bits[$_get](1)) << 8 >>> 0) + dart.notNull(bits[$_get](0)));
>+    unshiftedDigits[$_set](1, (dart.notNull(bits[$_get](3)) << 8 >>> 0) + dart.notNull(bits[$_get](2)));
>+    unshiftedDigits[$_set](2, (dart.notNull(bits[$_get](5)) << 8 >>> 0) + dart.notNull(bits[$_get](4)));
>+    unshiftedDigits[$_set](3, 16 | dart.notNull(bits[$_get](6)) & 15);
>+    let unshiftedBig = new core._BigIntImpl._normalized(false, 4, unshiftedDigits);
>+    let absResult = unshiftedBig;
>+    if (exponent < 0) {
>+      absResult = unshiftedBig['>>'](-exponent);
>+    } else if (exponent > 0) {
>+      absResult = unshiftedBig['<<'](exponent);
>+    }
>+    if (isNegative) return absResult._negate();
>+    return absResult;
>+  }
>+  _negate() {
>+    if (this[_used] === 0) return this;
>+    return new core._BigIntImpl.__(!dart.test(this[_isNegative]), this[_used], this[_digits]);
>+  }
>+  abs() {
>+    return dart.test(this[_isNegative]) ? this._negate() : this;
>+  }
>+  [_dlShift](n) {
>+    let used = this[_used];
>+    if (used === 0) {
>+      return core._BigIntImpl.zero;
>+    }
>+    let resultUsed = dart.notNull(used) + dart.notNull(n);
>+    let digits = this[_digits];
>+    let resultDigits = typed_data.Uint16List.new(resultUsed);
>+    for (let i = dart.notNull(used) - 1; i >= 0; i--) {
>+      resultDigits[$_set](i + dart.notNull(n), digits[$_get](i));
>+    }
>+    return new core._BigIntImpl.__(this[_isNegative], resultUsed, resultDigits);
>+  }
>+  static _dlShiftDigits(xDigits, xUsed, n, resultDigits) {
>+    if (xUsed === 0) {
>+      return 0;
>+    }
>+    if (n === 0 && resultDigits == xDigits) {
>+      return xUsed;
>+    }
>+    let resultUsed = dart.notNull(xUsed) + dart.notNull(n);
>+    for (let i = dart.notNull(xUsed) - 1; i >= 0; i--) {
>+      resultDigits[$_set](i + dart.notNull(n), xDigits[$_get](i));
>+    }
>+    for (let i = dart.notNull(n) - 1; i >= 0; i--) {
>+      resultDigits[$_set](i, 0);
>+    }
>+    return resultUsed;
>+  }
>+  [_drShift](n) {
>+    let used = this[_used];
>+    if (used === 0) {
>+      return core._BigIntImpl.zero;
>+    }
>+    let resultUsed = dart.notNull(used) - dart.notNull(n);
>+    if (resultUsed <= 0) {
>+      return dart.test(this[_isNegative]) ? core._BigIntImpl._minusOne : core._BigIntImpl.zero;
>+    }
>+    let digits = this[_digits];
>+    let resultDigits = typed_data.Uint16List.new(resultUsed);
>+    for (let i = n; dart.notNull(i) < dart.notNull(used); i = dart.notNull(i) + 1) {
>+      resultDigits[$_set](dart.notNull(i) - dart.notNull(n), digits[$_get](i));
>+    }
>+    let result = new core._BigIntImpl.__(this[_isNegative], resultUsed, resultDigits);
>+    if (dart.test(this[_isNegative])) {
>+      for (let i = 0; i < dart.notNull(n); i++) {
>+        if (digits[$_get](i) !== 0) {
>+          return result['-'](core._BigIntImpl.one);
>+        }
>+      }
>+    }
>+    return result;
>+  }
>+  static _lsh(xDigits, xUsed, n, resultDigits) {
>+    if (!(dart.notNull(xUsed) > 0)) dart.assertFailed(null, "dart:core", 694, 12, "xUsed > 0");
>+    let digitShift = (dart.notNull(n) / 16)[$truncate]();
>+    let bitShift = n[$modulo](16);
>+    let carryBitShift = 16 - bitShift;
>+    let bitMask = (1)[$leftShift](carryBitShift) - 1;
>+    let carry = 0;
>+    for (let i = dart.notNull(xUsed) - 1; i >= 0; i--) {
>+      let digit = xDigits[$_get](i);
>+      resultDigits[$_set](i + digitShift + 1, (digit[$rightShift](carryBitShift) | carry) >>> 0);
>+      carry = ((dart.notNull(digit) & bitMask) >>> 0)[$leftShift](bitShift);
>+    }
>+    resultDigits[$_set](digitShift, carry);
>+  }
>+  ['<<'](shiftAmount) {
>+    if (dart.notNull(shiftAmount) < 0) {
>+      dart.throw(new core.ArgumentError.new("shift-amount must be posititve " + dart.str(shiftAmount)));
>+    }
>+    if (dart.test(this[_isZero])) return this;
>+    let digitShift = (dart.notNull(shiftAmount) / 16)[$truncate]();
>+    let bitShift = shiftAmount[$modulo](16);
>+    if (bitShift === 0) {
>+      return this[_dlShift](digitShift);
>+    }
>+    let resultUsed = dart.notNull(this[_used]) + digitShift + 1;
>+    let resultDigits = typed_data.Uint16List.new(resultUsed);
>+    core._BigIntImpl._lsh(this[_digits], this[_used], shiftAmount, resultDigits);
>+    return new core._BigIntImpl.__(this[_isNegative], resultUsed, resultDigits);
>+  }
>+  static _lShiftDigits(xDigits, xUsed, n, resultDigits) {
>+    let digitsShift = (dart.notNull(n) / 16)[$truncate]();
>+    let bitShift = n[$modulo](16);
>+    if (bitShift === 0) {
>+      return core._BigIntImpl._dlShiftDigits(xDigits, xUsed, digitsShift, resultDigits);
>+    }
>+    let resultUsed = dart.notNull(xUsed) + digitsShift + 1;
>+    core._BigIntImpl._lsh(xDigits, xUsed, n, resultDigits);
>+    let i = digitsShift;
>+    while (--i >= 0) {
>+      resultDigits[$_set](i, 0);
>+    }
>+    if (resultDigits[$_get](resultUsed - 1) === 0) {
>+      resultUsed--;
>+    }
>+    return resultUsed;
>+  }
>+  static _rsh(xDigits, xUsed, n, resultDigits) {
>+    if (!(dart.notNull(xUsed) > 0)) dart.assertFailed(null, "dart:core", 760, 12, "xUsed > 0");
>+    let digitsShift = (dart.notNull(n) / 16)[$truncate]();
>+    let bitShift = n[$modulo](16);
>+    let carryBitShift = 16 - bitShift;
>+    let bitMask = (1)[$leftShift](bitShift) - 1;
>+    let carry = xDigits[$_get](digitsShift)[$rightShift](bitShift);
>+    let last = dart.notNull(xUsed) - digitsShift - 1;
>+    for (let i = 0; i < last; i++) {
>+      let digit = xDigits[$_get](i + digitsShift + 1);
>+      resultDigits[$_set](i, (((dart.notNull(digit) & bitMask) >>> 0)[$leftShift](carryBitShift) | carry) >>> 0);
>+      carry = digit[$rightShift](bitShift);
>+    }
>+    resultDigits[$_set](last, carry);
>+  }
>+  ['>>'](shiftAmount) {
>+    if (dart.notNull(shiftAmount) < 0) {
>+      dart.throw(new core.ArgumentError.new("shift-amount must be posititve " + dart.str(shiftAmount)));
>+    }
>+    if (dart.test(this[_isZero])) return this;
>+    let digitShift = (dart.notNull(shiftAmount) / 16)[$truncate]();
>+    let bitShift = shiftAmount[$modulo](16);
>+    if (bitShift === 0) {
>+      return this[_drShift](digitShift);
>+    }
>+    let used = this[_used];
>+    let resultUsed = dart.notNull(used) - digitShift;
>+    if (resultUsed <= 0) {
>+      return dart.test(this[_isNegative]) ? core._BigIntImpl._minusOne : core._BigIntImpl.zero;
>+    }
>+    let digits = this[_digits];
>+    let resultDigits = typed_data.Uint16List.new(resultUsed);
>+    core._BigIntImpl._rsh(digits, used, shiftAmount, resultDigits);
>+    let result = new core._BigIntImpl.__(this[_isNegative], resultUsed, resultDigits);
>+    if (dart.test(this[_isNegative])) {
>+      if ((dart.notNull(digits[$_get](digitShift)) & (1)[$leftShift](bitShift) - 1) !== 0) {
>+        return result['-'](core._BigIntImpl.one);
>+      }
>+      for (let i = 0; i < digitShift; i++) {
>+        if (digits[$_get](i) !== 0) {
>+          return result['-'](core._BigIntImpl.one);
>+        }
>+      }
>+    }
>+    return result;
>+  }
>+  [_absCompare](bigInt) {
>+    let other = core._BigIntImpl._check(bigInt);
>+    return core._BigIntImpl._compareDigits(this[_digits], this[_used], other[_digits], other[_used]);
>+  }
>+  compareTo(bigInt) {
>+    core.BigInt._check(bigInt);
>+    let other = core._BigIntImpl._check(bigInt);
>+    if (this[_isNegative] == other[_isNegative]) {
>+      let result = this[_absCompare](other);
>+      return dart.test(this[_isNegative]) ? 0 - dart.notNull(result) : result;
>+    }
>+    return dart.test(this[_isNegative]) ? -1 : 1;
>+  }
>+  static _compareDigits(digits, used, otherDigits, otherUsed) {
>+    let result = dart.notNull(used) - dart.notNull(otherUsed);
>+    if (result === 0) {
>+      for (let i = dart.notNull(used) - 1; i >= 0; i--) {
>+        result = dart.notNull(digits[$_get](i)) - dart.notNull(otherDigits[$_get](i));
>+        if (result !== 0) return result;
>+      }
>+    }
>+    return result;
>+  }
>+  static _absAdd(digits, used, otherDigits, otherUsed, resultDigits) {
>+    if (!(dart.notNull(used) >= dart.notNull(otherUsed) && dart.notNull(otherUsed) > 0)) dart.assertFailed(null, "dart:core", 862, 12, "used >= otherUsed && otherUsed > 0");
>+    let carry = 0;
>+    for (let i = 0; i < dart.notNull(otherUsed); i++) {
>+      carry = carry + (dart.notNull(digits[$_get](i)) + dart.notNull(otherDigits[$_get](i)));
>+      resultDigits[$_set](i, carry & 65535);
>+      carry = carry[$rightShift](16);
>+    }
>+    for (let i = otherUsed; dart.notNull(i) < dart.notNull(used); i = dart.notNull(i) + 1) {
>+      carry = carry + dart.notNull(digits[$_get](i));
>+      resultDigits[$_set](i, carry & 65535);
>+      carry = carry[$rightShift](16);
>+    }
>+    resultDigits[$_set](used, carry);
>+  }
>+  static _absSub(digits, used, otherDigits, otherUsed, resultDigits) {
>+    if (!(dart.notNull(used) >= dart.notNull(otherUsed) && dart.notNull(otherUsed) > 0)) dart.assertFailed(null, "dart:core", 881, 12, "used >= otherUsed && otherUsed > 0");
>+    let carry = 0;
>+    for (let i = 0; i < dart.notNull(otherUsed); i++) {
>+      carry = carry + (dart.notNull(digits[$_get](i)) - dart.notNull(otherDigits[$_get](i)));
>+      resultDigits[$_set](i, carry & 65535);
>+      carry = 0 - (carry >> 16 & 1);
>+    }
>+    for (let i = otherUsed; dart.notNull(i) < dart.notNull(used); i = dart.notNull(i) + 1) {
>+      carry = carry + dart.notNull(digits[$_get](i));
>+      resultDigits[$_set](i, carry & 65535);
>+      carry = 0 - (carry >> 16 & 1);
>+    }
>+  }
>+  [_absAddSetSign](other, isNegative) {
>+    let used = this[_used];
>+    let otherUsed = other[_used];
>+    if (dart.notNull(used) < dart.notNull(otherUsed)) {
>+      return other[_absAddSetSign](this, isNegative);
>+    }
>+    if (used === 0) {
>+      if (!!dart.test(isNegative)) dart.assertFailed(null, "dart:core", 908, 14, "!isNegative");
>+      return core._BigIntImpl.zero;
>+    }
>+    if (otherUsed === 0) {
>+      return this[_isNegative] == isNegative ? this : this._negate();
>+    }
>+    let resultUsed = dart.notNull(used) + 1;
>+    let resultDigits = typed_data.Uint16List.new(resultUsed);
>+    core._BigIntImpl._absAdd(this[_digits], used, other[_digits], otherUsed, resultDigits);
>+    return new core._BigIntImpl.__(isNegative, resultUsed, resultDigits);
>+  }
>+  [_absSubSetSign](other, isNegative) {
>+    if (!(dart.notNull(this[_absCompare](other)) >= 0)) dart.assertFailed(null, "dart:core", 924, 12, "_absCompare(other) >= 0");
>+    let used = this[_used];
>+    if (used === 0) {
>+      if (!!dart.test(isNegative)) dart.assertFailed(null, "dart:core", 927, 14, "!isNegative");
>+      return core._BigIntImpl.zero;
>+    }
>+    let otherUsed = other[_used];
>+    if (otherUsed === 0) {
>+      return this[_isNegative] == isNegative ? this : this._negate();
>+    }
>+    let resultDigits = typed_data.Uint16List.new(used);
>+    core._BigIntImpl._absSub(this[_digits], used, other[_digits], otherUsed, resultDigits);
>+    return new core._BigIntImpl.__(isNegative, used, resultDigits);
>+  }
>+  [_absAndSetSign](other, isNegative) {
>+    let resultUsed = core._min(this[_used], other[_used]);
>+    let digits = this[_digits];
>+    let otherDigits = other[_digits];
>+    let resultDigits = typed_data.Uint16List.new(resultUsed);
>+    for (let i = 0; i < dart.notNull(resultUsed); i++) {
>+      resultDigits[$_set](i, (dart.notNull(digits[$_get](i)) & dart.notNull(otherDigits[$_get](i))) >>> 0);
>+    }
>+    return new core._BigIntImpl.__(isNegative, resultUsed, resultDigits);
>+  }
>+  [_absAndNotSetSign](other, isNegative) {
>+    let resultUsed = this[_used];
>+    let digits = this[_digits];
>+    let otherDigits = other[_digits];
>+    let resultDigits = typed_data.Uint16List.new(resultUsed);
>+    let m = core._min(resultUsed, other[_used]);
>+    for (let i = 0; i < dart.notNull(m); i++) {
>+      resultDigits[$_set](i, (dart.notNull(digits[$_get](i)) & dart.notNull(core.int._check(~dart.notNull(otherDigits[$_get](i)) >>> 0))) >>> 0);
>+    }
>+    for (let i = m; dart.notNull(i) < dart.notNull(resultUsed); i = dart.notNull(i) + 1) {
>+      resultDigits[$_set](i, digits[$_get](i));
>+    }
>+    return new core._BigIntImpl.__(isNegative, resultUsed, resultDigits);
>+  }
>+  [_absOrSetSign](other, isNegative) {
>+    let used = this[_used];
>+    let otherUsed = other[_used];
>+    let resultUsed = core._max(used, otherUsed);
>+    let digits = this[_digits];
>+    let otherDigits = other[_digits];
>+    let resultDigits = typed_data.Uint16List.new(resultUsed);
>+    let l = null, m = null;
>+    if (dart.notNull(used) < dart.notNull(otherUsed)) {
>+      l = other;
>+      m = used;
>+    } else {
>+      l = this;
>+      m = otherUsed;
>+    }
>+    for (let i = 0; i < dart.notNull(core.num._check(m)); i++) {
>+      resultDigits[$_set](i, (dart.notNull(digits[$_get](i)) | dart.notNull(otherDigits[$_get](i))) >>> 0);
>+    }
>+    let lDigits = dart.dload(l, _digits);
>+    for (let i = m; dart.dtest(dart.dsend(i, '<', [resultUsed])); i = dart.dsend(i, '+', [1])) {
>+      resultDigits[$_set](core.int._check(i), core.int._check(dart.dindex(lDigits, i)));
>+    }
>+    return new core._BigIntImpl.__(isNegative, resultUsed, resultDigits);
>+  }
>+  [_absXorSetSign](other, isNegative) {
>+    let used = this[_used];
>+    let otherUsed = other[_used];
>+    let resultUsed = core._max(used, otherUsed);
>+    let digits = this[_digits];
>+    let otherDigits = other[_digits];
>+    let resultDigits = typed_data.Uint16List.new(resultUsed);
>+    let l = null, m = null;
>+    if (dart.notNull(used) < dart.notNull(otherUsed)) {
>+      l = other;
>+      m = used;
>+    } else {
>+      l = this;
>+      m = otherUsed;
>+    }
>+    for (let i = 0; i < dart.notNull(core.num._check(m)); i++) {
>+      resultDigits[$_set](i, (dart.notNull(digits[$_get](i)) ^ dart.notNull(otherDigits[$_get](i))) >>> 0);
>+    }
>+    let lDigits = dart.dload(l, _digits);
>+    for (let i = m; dart.dtest(dart.dsend(i, '<', [resultUsed])); i = dart.dsend(i, '+', [1])) {
>+      resultDigits[$_set](core.int._check(i), core.int._check(dart.dindex(lDigits, i)));
>+    }
>+    return new core._BigIntImpl.__(isNegative, resultUsed, resultDigits);
>+  }
>+  ['&'](bigInt) {
>+    let other = core._BigIntImpl._check(bigInt);
>+    if (dart.test(this[_isZero]) || dart.test(other[_isZero])) return core._BigIntImpl.zero;
>+    if (this[_isNegative] == other[_isNegative]) {
>+      if (dart.test(this[_isNegative])) {
>+        let this1 = this[_absSubSetSign](core._BigIntImpl.one, true);
>+        let other1 = other[_absSubSetSign](core._BigIntImpl.one, true);
>+        return this1[_absOrSetSign](other1, true)[_absAddSetSign](core._BigIntImpl.one, true);
>+      }
>+      return this[_absAndSetSign](other, false);
>+    }
>+    let p = null, n = null;
>+    if (dart.test(this[_isNegative])) {
>+      p = other;
>+      n = this;
>+    } else {
>+      p = this;
>+      n = other;
>+    }
>+    let n1 = dart.dsend(n, _absSubSetSign, [core._BigIntImpl.one, false]);
>+    return core._BigIntImpl._check(dart.dsend(p, _absAndNotSetSign, [n1, false]));
>+  }
>+  ['|'](bigInt) {
>+    let other = core._BigIntImpl._check(bigInt);
>+    if (dart.test(this[_isZero])) return other;
>+    if (dart.test(other[_isZero])) return this;
>+    if (this[_isNegative] == other[_isNegative]) {
>+      if (dart.test(this[_isNegative])) {
>+        let this1 = this[_absSubSetSign](core._BigIntImpl.one, true);
>+        let other1 = other[_absSubSetSign](core._BigIntImpl.one, true);
>+        return this1[_absAndSetSign](other1, true)[_absAddSetSign](core._BigIntImpl.one, true);
>+      }
>+      return this[_absOrSetSign](other, false);
>+    }
>+    let p = null, n = null;
>+    if (dart.test(this[_isNegative])) {
>+      p = other;
>+      n = this;
>+    } else {
>+      p = this;
>+      n = other;
>+    }
>+    let n1 = dart.dsend(n, _absSubSetSign, [core._BigIntImpl.one, true]);
>+    return core._BigIntImpl._check(dart.dsend(dart.dsend(n1, _absAndNotSetSign, [p, true]), _absAddSetSign, [core._BigIntImpl.one, true]));
>+  }
>+  ['^'](bigInt) {
>+    let other = core._BigIntImpl._check(bigInt);
>+    if (dart.test(this[_isZero])) return other;
>+    if (dart.test(other[_isZero])) return this;
>+    if (this[_isNegative] == other[_isNegative]) {
>+      if (dart.test(this[_isNegative])) {
>+        let this1 = this[_absSubSetSign](core._BigIntImpl.one, true);
>+        let other1 = other[_absSubSetSign](core._BigIntImpl.one, true);
>+        return this1[_absXorSetSign](other1, false);
>+      }
>+      return this[_absXorSetSign](other, false);
>+    }
>+    let p = null, n = null;
>+    if (dart.test(this[_isNegative])) {
>+      p = other;
>+      n = this;
>+    } else {
>+      p = this;
>+      n = other;
>+    }
>+    let n1 = dart.dsend(n, _absSubSetSign, [core._BigIntImpl.one, true]);
>+    return core._BigIntImpl._check(dart.dsend(dart.dsend(p, _absXorSetSign, [n1, true]), _absAddSetSign, [core._BigIntImpl.one, true]));
>+  }
>+  ['~']() {
>+    if (dart.test(this[_isZero])) return core._BigIntImpl._minusOne;
>+    if (dart.test(this[_isNegative])) {
>+      return this[_absSubSetSign](core._BigIntImpl.one, false);
>+    }
>+    return this[_absAddSetSign](core._BigIntImpl.one, true);
>+  }
>+  ['+'](bigInt) {
>+    let other = core._BigIntImpl._check(bigInt);
>+    if (dart.test(this[_isZero])) return other;
>+    if (dart.test(other[_isZero])) return this;
>+    let isNegative = this[_isNegative];
>+    if (isNegative == other[_isNegative]) {
>+      return this[_absAddSetSign](other, isNegative);
>+    }
>+    if (dart.notNull(this[_absCompare](other)) >= 0) {
>+      return this[_absSubSetSign](other, isNegative);
>+    }
>+    return other[_absSubSetSign](this, !dart.test(isNegative));
>+  }
>+  ['-'](bigInt) {
>+    let other = core._BigIntImpl._check(bigInt);
>+    if (dart.test(this[_isZero])) return other._negate();
>+    if (dart.test(other[_isZero])) return this;
>+    let isNegative = this[_isNegative];
>+    if (isNegative != other[_isNegative]) {
>+      return this[_absAddSetSign](other, isNegative);
>+    }
>+    if (dart.notNull(this[_absCompare](other)) >= 0) {
>+      return this[_absSubSetSign](other, isNegative);
>+    }
>+    return other[_absSubSetSign](this, !dart.test(isNegative));
>+  }
>+  static _mulAdd(x, multiplicandDigits, i, accumulatorDigits, j, n) {
>+    if (x === 0) {
>+      return;
>+    }
>+    let c = 0;
>+    while ((n = dart.notNull(n) - 1) >= 0) {
>+      let product = dart.notNull(x) * dart.notNull(multiplicandDigits[$_get]((() => {
>+        let x = i;
>+        i = dart.notNull(x) + 1;
>+        return x;
>+      })()));
>+      let combined = product + dart.notNull(accumulatorDigits[$_get](j)) + c;
>+      accumulatorDigits[$_set]((() => {
>+        let x = j;
>+        j = dart.notNull(x) + 1;
>+        return x;
>+      })(), combined & 65535);
>+      c = (combined / 65536)[$truncate]();
>+    }
>+    while (c !== 0) {
>+      let l = dart.notNull(accumulatorDigits[$_get](j)) + c;
>+      accumulatorDigits[$_set]((() => {
>+        let x = j;
>+        j = dart.notNull(x) + 1;
>+        return x;
>+      })(), l & 65535);
>+      c = (l / 65536)[$truncate]();
>+    }
>+  }
>+  ['*'](bigInt) {
>+    let other = core._BigIntImpl._check(bigInt);
>+    let used = this[_used];
>+    let otherUsed = other[_used];
>+    if (used === 0 || otherUsed === 0) {
>+      return core._BigIntImpl.zero;
>+    }
>+    let resultUsed = dart.notNull(used) + dart.notNull(otherUsed);
>+    let digits = this[_digits];
>+    let otherDigits = other[_digits];
>+    let resultDigits = typed_data.Uint16List.new(resultUsed);
>+    let i = 0;
>+    while (i < dart.notNull(otherUsed)) {
>+      core._BigIntImpl._mulAdd(otherDigits[$_get](i), digits, 0, resultDigits, i, used);
>+      i++;
>+    }
>+    return new core._BigIntImpl.__(this[_isNegative] != other[_isNegative], resultUsed, resultDigits);
>+  }
>+  static _mulDigits(xDigits, xUsed, otherDigits, otherUsed, resultDigits) {
>+    let resultUsed = dart.notNull(xUsed) + dart.notNull(otherUsed);
>+    let i = resultUsed;
>+    if (!(dart.notNull(resultDigits[$length]) >= i)) dart.assertFailed(null, "dart:core", 1258, 12, "resultDigits.length >= i");
>+    while (--i >= 0) {
>+      resultDigits[$_set](i, 0);
>+    }
>+    i = 0;
>+    while (i < dart.notNull(otherUsed)) {
>+      core._BigIntImpl._mulAdd(otherDigits[$_get](i), xDigits, 0, resultDigits, i, xUsed);
>+      i++;
>+    }
>+    return resultUsed;
>+  }
>+  static _estimateQuotientDigit(topDigitDivisor, digits, i) {
>+    if (digits[$_get](i) == topDigitDivisor) return 65535;
>+    let quotientDigit = (((dart.notNull(digits[$_get](i)) << 16 | dart.notNull(digits[$_get](dart.notNull(i) - 1))) >>> 0) / dart.notNull(topDigitDivisor))[$truncate]();
>+    if (quotientDigit > 65535) return 65535;
>+    return quotientDigit;
>+  }
>+  [_div](bigInt) {
>+    let other = core._BigIntImpl._check(bigInt);
>+    if (!(dart.notNull(other[_used]) > 0)) dart.assertFailed(null, "dart:core", 1283, 12, "other._used > 0");
>+    if (dart.notNull(this[_used]) < dart.notNull(other[_used])) {
>+      return core._BigIntImpl.zero;
>+    }
>+    this[_divRem](other);
>+    let lastQuo_used = dart.notNull(core._BigIntImpl._lastQuoRemUsed) - dart.notNull(core._BigIntImpl._lastRemUsed);
>+    let quo_digits = core._BigIntImpl._cloneDigits(core._BigIntImpl._lastQuoRemDigits, core._BigIntImpl._lastRemUsed, core._BigIntImpl._lastQuoRemUsed, lastQuo_used);
>+    let quo = new core._BigIntImpl.__(false, lastQuo_used, quo_digits);
>+    if (this[_isNegative] != other[_isNegative] && dart.notNull(quo[_used]) > 0) {
>+      quo = quo._negate();
>+    }
>+    return quo;
>+  }
>+  [_rem](bigInt) {
>+    let other = core._BigIntImpl._check(bigInt);
>+    if (!(dart.notNull(other[_used]) > 0)) dart.assertFailed(null, "dart:core", 1303, 12, "other._used > 0");
>+    if (dart.notNull(this[_used]) < dart.notNull(other[_used])) {
>+      return this;
>+    }
>+    this[_divRem](other);
>+    let remDigits = core._BigIntImpl._cloneDigits(core._BigIntImpl._lastQuoRemDigits, 0, core._BigIntImpl._lastRemUsed, core._BigIntImpl._lastRemUsed);
>+    let rem = new core._BigIntImpl.__(false, core._BigIntImpl._lastRemUsed, remDigits);
>+    if (dart.notNull(core._BigIntImpl._lastRem_nsh) > 0) {
>+      rem = rem['>>'](core._BigIntImpl._lastRem_nsh);
>+    }
>+    if (dart.test(this[_isNegative]) && dart.notNull(rem[_used]) > 0) {
>+      rem = rem._negate();
>+    }
>+    return rem;
>+  }
>+  [_divRem](other) {
>+    if (this[_used] == core._BigIntImpl._lastDividendUsed && other[_used] == core._BigIntImpl._lastDivisorUsed && this[_digits] == core._BigIntImpl._lastDividendDigits && other[_digits] == core._BigIntImpl._lastDivisorDigits) {
>+      return;
>+    }
>+    if (!(dart.notNull(this[_used]) >= dart.notNull(other[_used]))) dart.assertFailed(null, "dart:core", 1338, 12, "_used >= other._used");
>+    let nsh = 16 - other[_digits][$_get](dart.notNull(other[_used]) - 1)[$bitLength];
>+    let resultDigits = null;
>+    let resultUsed = null;
>+    let yDigits = null;
>+    let yUsed = null;
>+    if (nsh > 0) {
>+      yDigits = typed_data.Uint16List.new(dart.notNull(other[_used]) + 5);
>+      yUsed = core._BigIntImpl._lShiftDigits(other[_digits], other[_used], nsh, yDigits);
>+      resultDigits = typed_data.Uint16List.new(dart.notNull(this[_used]) + 5);
>+      resultUsed = core._BigIntImpl._lShiftDigits(this[_digits], this[_used], nsh, resultDigits);
>+    } else {
>+      yDigits = other[_digits];
>+      yUsed = other[_used];
>+      resultDigits = core._BigIntImpl._cloneDigits(this[_digits], 0, this[_used], dart.notNull(this[_used]) + 2);
>+      resultUsed = this[_used];
>+    }
>+    let topDigitDivisor = yDigits[$_get](dart.notNull(yUsed) - 1);
>+    let i = resultUsed;
>+    let j = dart.notNull(i) - dart.notNull(yUsed);
>+    let tmpDigits = typed_data.Uint16List.new(i);
>+    let tmpUsed = core._BigIntImpl._dlShiftDigits(yDigits, yUsed, j, tmpDigits);
>+    if (dart.notNull(core._BigIntImpl._compareDigits(resultDigits, resultUsed, tmpDigits, tmpUsed)) >= 0) {
>+      if (!(i == resultUsed)) dart.assertFailed(null, "dart:core", 1371, 14, "i == resultUsed");
>+      resultDigits[$_set]((() => {
>+        let x = resultUsed;
>+        resultUsed = dart.notNull(x) + 1;
>+        return x;
>+      })(), 1);
>+      core._BigIntImpl._absSub(resultDigits, resultUsed, tmpDigits, tmpUsed, resultDigits);
>+    } else {
>+      resultDigits[$_set]((() => {
>+        let x = resultUsed;
>+        resultUsed = dart.notNull(x) + 1;
>+        return x;
>+      })(), 0);
>+    }
>+    let nyDigits = typed_data.Uint16List.new(dart.notNull(yUsed) + 2);
>+    nyDigits[$_set](yUsed, 1);
>+    core._BigIntImpl._absSub(nyDigits, dart.notNull(yUsed) + 1, yDigits, yUsed, nyDigits);
>+    i = dart.notNull(i) - 1;
>+    while (j > 0) {
>+      let estimatedQuotientDigit = core._BigIntImpl._estimateQuotientDigit(topDigitDivisor, resultDigits, i);
>+      j--;
>+      core._BigIntImpl._mulAdd(estimatedQuotientDigit, nyDigits, 0, resultDigits, j, yUsed);
>+      if (dart.notNull(resultDigits[$_get](i)) < dart.notNull(estimatedQuotientDigit)) {
>+        let tmpUsed = core._BigIntImpl._dlShiftDigits(nyDigits, yUsed, j, tmpDigits);
>+        core._BigIntImpl._absSub(resultDigits, resultUsed, tmpDigits, tmpUsed, resultDigits);
>+        while (dart.notNull(resultDigits[$_get](i)) < (estimatedQuotientDigit = dart.notNull(estimatedQuotientDigit) - 1)) {
>+          core._BigIntImpl._absSub(resultDigits, resultUsed, tmpDigits, tmpUsed, resultDigits);
>+        }
>+      }
>+      i = dart.notNull(i) - 1;
>+    }
>+    core._BigIntImpl._lastDividendDigits = this[_digits];
>+    core._BigIntImpl._lastDividendUsed = this[_used];
>+    core._BigIntImpl._lastDivisorDigits = other[_digits];
>+    core._BigIntImpl._lastDivisorUsed = other[_used];
>+    core._BigIntImpl._lastQuoRemDigits = resultDigits;
>+    core._BigIntImpl._lastQuoRemUsed = resultUsed;
>+    core._BigIntImpl._lastRemUsed = yUsed;
>+    core._BigIntImpl._lastRem_nsh = nsh;
>+  }
>+  get hashCode() {
>+    function combine(hash, value) {
>+      hash = 536870911 & dart.notNull(hash) + dart.notNull(value);
>+      hash = 536870911 & dart.notNull(hash) + ((524287 & dart.notNull(hash)) << 10);
>+      return (dart.notNull(hash) ^ hash[$rightShift](6)) >>> 0;
>+    }
>+    dart.fn(combine, intAndintToint());
>+    function finish(hash) {
>+      hash = 536870911 & dart.notNull(hash) + ((67108863 & dart.notNull(hash)) << 3);
>+      hash = (dart.notNull(hash) ^ hash[$rightShift](11)) >>> 0;
>+      return 536870911 & dart.notNull(hash) + ((16383 & dart.notNull(hash)) << 15);
>+    }
>+    dart.fn(finish, intToint());
>+    if (dart.test(this[_isZero])) return 6707;
>+    let hash = dart.test(this[_isNegative]) ? 83585 : 429689;
>+    for (let i = 0; i < dart.notNull(this[_used]); i++) {
>+      hash = combine(hash, this[_digits][$_get](i));
>+    }
>+    return finish(hash);
>+  }
>+  _equals(other) {
>+    return core._BigIntImpl.is(other) && this.compareTo(other) === 0;
>+  }
>+  get bitLength() {
>+    if (this[_used] === 0) return 0;
>+    if (dart.test(this[_isNegative])) return this['~']().bitLength;
>+    return 16 * (dart.notNull(this[_used]) - 1) + this[_digits][$_get](dart.notNull(this[_used]) - 1)[$bitLength];
>+  }
>+  ['~/'](bigInt) {
>+    let other = core._BigIntImpl._check(bigInt);
>+    if (other[_used] === 0) {
>+      dart.throw(const$50 || (const$50 = dart.const(new core.IntegerDivisionByZeroException.new())));
>+    }
>+    return this[_div](other);
>+  }
>+  remainder(bigInt) {
>+    let other = core._BigIntImpl._check(bigInt);
>+    if (other[_used] === 0) {
>+      dart.throw(const$51 || (const$51 = dart.const(new core.IntegerDivisionByZeroException.new())));
>+    }
>+    return this[_rem](other);
>+  }
>+  ['/'](other) {
>+    return dart.notNull(this.toDouble()) / dart.notNull(other.toDouble());
>+  }
>+  ['<'](other) {
>+    return dart.notNull(this.compareTo(other)) < 0;
>+  }
>+  ['<='](other) {
>+    return dart.notNull(this.compareTo(other)) <= 0;
>+  }
>+  ['>'](other) {
>+    return dart.notNull(this.compareTo(other)) > 0;
>+  }
>+  ['>='](other) {
>+    return dart.notNull(this.compareTo(other)) >= 0;
>+  }
>+  ['%'](bigInt) {
>+    let other = core._BigIntImpl._check(bigInt);
>+    if (other[_used] === 0) {
>+      dart.throw(const$52 || (const$52 = dart.const(new core.IntegerDivisionByZeroException.new())));
>+    }
>+    let result = this[_rem](other);
>+    if (dart.test(result[_isNegative])) {
>+      if (dart.test(other[_isNegative])) {
>+        result = result['-'](other);
>+      } else {
>+        result = result['+'](other);
>+      }
>+    }
>+    return result;
>+  }
>+  get sign() {
>+    if (this[_used] === 0) return 0;
>+    return dart.test(this[_isNegative]) ? -1 : 1;
>+  }
>+  get isEven() {
>+    return this[_used] === 0 || (dart.notNull(this[_digits][$_get](0)) & 1) === 0;
>+  }
>+  get isOdd() {
>+    return !dart.test(this.isEven);
>+  }
>+  get isNegative() {
>+    return this[_isNegative];
>+  }
>+  pow(exponent) {
>+    if (dart.notNull(exponent) < 0) {
>+      dart.throw(new core.ArgumentError.new("Exponent must not be negative: " + dart.str(exponent)));
>+    }
>+    if (exponent === 0) return core._BigIntImpl.one;
>+    let result = core._BigIntImpl.one;
>+    let base = this;
>+    while (exponent !== 0) {
>+      if ((dart.notNull(exponent) & 1) === 1) {
>+        result = result['*'](base);
>+      }
>+      exponent = exponent[$rightShift](1);
>+      if (exponent !== 0) {
>+        base = base['*'](base);
>+      }
>+    }
>+    return result;
>+  }
>+  modPow(bigExponent, bigModulus) {
>+    let exponent = core._BigIntImpl._check(bigExponent);
>+    let modulus = core._BigIntImpl._check(bigModulus);
>+    if (dart.test(exponent[_isNegative])) {
>+      dart.throw(new core.ArgumentError.new("exponent must be positive: " + dart.str(exponent)));
>+    }
>+    if (dart.test(modulus['<='](core._BigIntImpl.zero))) {
>+      dart.throw(new core.ArgumentError.new("modulus must be strictly positive: " + dart.str(modulus)));
>+    }
>+    if (dart.test(exponent[_isZero])) return core._BigIntImpl.one;
>+    let modulusUsed = modulus[_used];
>+    let modulusUsed2p4 = 2 * dart.notNull(modulusUsed) + 4;
>+    let exponentBitlen = exponent.bitLength;
>+    if (dart.notNull(exponentBitlen) <= 0) return core._BigIntImpl.one;
>+    let z = new core._BigIntClassic.new(modulus);
>+    let resultDigits = typed_data.Uint16List.new(modulusUsed2p4);
>+    let result2Digits = typed_data.Uint16List.new(modulusUsed2p4);
>+    let gDigits = typed_data.Uint16List.new(modulusUsed);
>+    let gUsed = z.convert(this, gDigits);
>+    for (let j = dart.notNull(gUsed) - 1; j >= 0; j--) {
>+      resultDigits[$_set](j, gDigits[$_get](j));
>+    }
>+    let resultUsed = gUsed;
>+    let result2Used = null;
>+    for (let i = dart.notNull(exponentBitlen) - 2; i >= 0; i--) {
>+      result2Used = z.sqr(resultDigits, resultUsed, result2Digits);
>+      if (!dart.test(exponent['&'](core._BigIntImpl.one['<<'](i))[_isZero])) {
>+        resultUsed = z.mul(result2Digits, core.int._check(result2Used), gDigits, gUsed, resultDigits);
>+      } else {
>+        let tmpDigits = resultDigits;
>+        let tmpUsed = resultUsed;
>+        resultDigits = result2Digits;
>+        resultUsed = core.int._check(result2Used);
>+        result2Digits = tmpDigits;
>+        result2Used = tmpUsed;
>+      }
>+    }
>+    return z.revert(resultDigits, resultUsed);
>+  }
>+  static _binaryGcd(x, y, inv) {
>+    let xDigits = x[_digits];
>+    let yDigits = y[_digits];
>+    let xUsed = x[_used];
>+    let yUsed = y[_used];
>+    let maxUsed = dart.notNull(xUsed) > dart.notNull(yUsed) ? xUsed : yUsed;
>+    let unshiftedMaxUsed = maxUsed;
>+    xDigits = core._BigIntImpl._cloneDigits(xDigits, 0, xUsed, maxUsed);
>+    yDigits = core._BigIntImpl._cloneDigits(yDigits, 0, yUsed, maxUsed);
>+    let shiftAmount = 0;
>+    if (dart.test(inv)) {
>+      if (yUsed === 1 && yDigits[$_get](0) === 1) return core._BigIntImpl.one;
>+      if (yUsed === 0 || yDigits[$_get](0)[$isEven] && xDigits[$_get](0)[$isEven]) {
>+        dart.throw(core.Exception.new("Not coprime"));
>+      }
>+    } else {
>+      if (dart.test(x[_isZero])) {
>+        dart.throw(new core.ArgumentError.value(0, "this", "must not be zero"));
>+      }
>+      if (dart.test(y[_isZero])) {
>+        dart.throw(new core.ArgumentError.value(0, "other", "must not be zero"));
>+      }
>+      if (xUsed === 1 && xDigits[$_get](0) === 1 || yUsed === 1 && yDigits[$_get](0) === 1) return core._BigIntImpl.one;
>+      while ((dart.notNull(xDigits[$_get](0)) & 1) === 0 && (dart.notNull(yDigits[$_get](0)) & 1) === 0) {
>+        core._BigIntImpl._rsh(xDigits, xUsed, 1, xDigits);
>+        core._BigIntImpl._rsh(yDigits, yUsed, 1, yDigits);
>+        shiftAmount++;
>+      }
>+      if (shiftAmount >= 16) {
>+        let digitShiftAmount = (shiftAmount / 16)[$truncate]();
>+        xUsed = dart.notNull(xUsed) - digitShiftAmount;
>+        yUsed = dart.notNull(yUsed) - digitShiftAmount;
>+        maxUsed = dart.notNull(maxUsed) - digitShiftAmount;
>+      }
>+      if ((dart.notNull(yDigits[$_get](0)) & 1) === 1) {
>+        let tmpDigits = xDigits;
>+        let tmpUsed = xUsed;
>+        xDigits = yDigits;
>+        xUsed = yUsed;
>+        yDigits = tmpDigits;
>+        yUsed = tmpUsed;
>+      }
>+    }
>+    let uDigits = core._BigIntImpl._cloneDigits(xDigits, 0, xUsed, unshiftedMaxUsed);
>+    let vDigits = core._BigIntImpl._cloneDigits(yDigits, 0, yUsed, dart.notNull(unshiftedMaxUsed) + 2);
>+    let ac = (dart.notNull(xDigits[$_get](0)) & 1) === 0;
>+    let abcdUsed = dart.notNull(maxUsed) + 1;
>+    let abcdLen = abcdUsed + 2;
>+    let aDigits = null, bDigits = null, cDigits = null, dDigits = null;
>+    let aIsNegative = null, bIsNegative = null, cIsNegative = null, dIsNegative = null;
>+    if (ac) {
>+      aDigits = typed_data.Uint16List.new(abcdLen);
>+      aIsNegative = false;
>+      dart.dsetindex(aDigits, 0, 1);
>+      cDigits = typed_data.Uint16List.new(abcdLen);
>+      cIsNegative = false;
>+    }
>+    bDigits = typed_data.Uint16List.new(abcdLen);
>+    bIsNegative = false;
>+    dDigits = typed_data.Uint16List.new(abcdLen);
>+    dIsNegative = false;
>+    dart.dsetindex(dDigits, 0, 1);
>+    while (true) {
>+      while ((dart.notNull(uDigits[$_get](0)) & 1) === 0) {
>+        core._BigIntImpl._rsh(uDigits, maxUsed, 1, uDigits);
>+        if (ac) {
>+          if (dart.equals(dart.dsend(dart.dindex(aDigits, 0), '&', [1]), 1) || dart.equals(dart.dsend(dart.dindex(bDigits, 0), '&', [1]), 1)) {
>+            if (dart.test(aIsNegative)) {
>+              if (!dart.equals(dart.dindex(aDigits, maxUsed), 0) || dart.notNull(core._BigIntImpl._compareDigits(typed_data.Uint16List._check(aDigits), maxUsed, yDigits, maxUsed)) > 0) {
>+                core._BigIntImpl._absSub(typed_data.Uint16List._check(aDigits), abcdUsed, yDigits, maxUsed, typed_data.Uint16List._check(aDigits));
>+              } else {
>+                core._BigIntImpl._absSub(yDigits, maxUsed, typed_data.Uint16List._check(aDigits), maxUsed, typed_data.Uint16List._check(aDigits));
>+                aIsNegative = false;
>+              }
>+            } else {
>+              core._BigIntImpl._absAdd(typed_data.Uint16List._check(aDigits), abcdUsed, yDigits, maxUsed, typed_data.Uint16List._check(aDigits));
>+            }
>+            if (dart.test(bIsNegative)) {
>+              core._BigIntImpl._absAdd(typed_data.Uint16List._check(bDigits), abcdUsed, xDigits, maxUsed, typed_data.Uint16List._check(bDigits));
>+            } else if (!dart.equals(dart.dindex(bDigits, maxUsed), 0) || dart.notNull(core._BigIntImpl._compareDigits(typed_data.Uint16List._check(bDigits), maxUsed, xDigits, maxUsed)) > 0) {
>+              core._BigIntImpl._absSub(typed_data.Uint16List._check(bDigits), abcdUsed, xDigits, maxUsed, typed_data.Uint16List._check(bDigits));
>+            } else {
>+              core._BigIntImpl._absSub(xDigits, maxUsed, typed_data.Uint16List._check(bDigits), maxUsed, typed_data.Uint16List._check(bDigits));
>+              bIsNegative = true;
>+            }
>+          }
>+          core._BigIntImpl._rsh(typed_data.Uint16List._check(aDigits), abcdUsed, 1, typed_data.Uint16List._check(aDigits));
>+        } else if (dart.equals(dart.dsend(dart.dindex(bDigits, 0), '&', [1]), 1)) {
>+          if (dart.test(bIsNegative)) {
>+            core._BigIntImpl._absAdd(typed_data.Uint16List._check(bDigits), abcdUsed, xDigits, maxUsed, typed_data.Uint16List._check(bDigits));
>+          } else if (!dart.equals(dart.dindex(bDigits, maxUsed), 0) || dart.notNull(core._BigIntImpl._compareDigits(typed_data.Uint16List._check(bDigits), maxUsed, xDigits, maxUsed)) > 0) {
>+            core._BigIntImpl._absSub(typed_data.Uint16List._check(bDigits), abcdUsed, xDigits, maxUsed, typed_data.Uint16List._check(bDigits));
>+          } else {
>+            core._BigIntImpl._absSub(xDigits, maxUsed, typed_data.Uint16List._check(bDigits), maxUsed, typed_data.Uint16List._check(bDigits));
>+            bIsNegative = true;
>+          }
>+        }
>+        core._BigIntImpl._rsh(typed_data.Uint16List._check(bDigits), abcdUsed, 1, typed_data.Uint16List._check(bDigits));
>+      }
>+      while ((dart.notNull(vDigits[$_get](0)) & 1) === 0) {
>+        core._BigIntImpl._rsh(vDigits, maxUsed, 1, vDigits);
>+        if (ac) {
>+          if (dart.equals(dart.dsend(dart.dindex(cDigits, 0), '&', [1]), 1) || dart.equals(dart.dsend(dart.dindex(dDigits, 0), '&', [1]), 1)) {
>+            if (dart.test(cIsNegative)) {
>+              if (!dart.equals(dart.dindex(cDigits, maxUsed), 0) || dart.notNull(core._BigIntImpl._compareDigits(typed_data.Uint16List._check(cDigits), maxUsed, yDigits, maxUsed)) > 0) {
>+                core._BigIntImpl._absSub(typed_data.Uint16List._check(cDigits), abcdUsed, yDigits, maxUsed, typed_data.Uint16List._check(cDigits));
>+              } else {
>+                core._BigIntImpl._absSub(yDigits, maxUsed, typed_data.Uint16List._check(cDigits), maxUsed, typed_data.Uint16List._check(cDigits));
>+                cIsNegative = false;
>+              }
>+            } else {
>+              core._BigIntImpl._absAdd(typed_data.Uint16List._check(cDigits), abcdUsed, yDigits, maxUsed, typed_data.Uint16List._check(cDigits));
>+            }
>+            if (dart.test(dIsNegative)) {
>+              core._BigIntImpl._absAdd(typed_data.Uint16List._check(dDigits), abcdUsed, xDigits, maxUsed, typed_data.Uint16List._check(dDigits));
>+            } else if (!dart.equals(dart.dindex(dDigits, maxUsed), 0) || dart.notNull(core._BigIntImpl._compareDigits(typed_data.Uint16List._check(dDigits), maxUsed, xDigits, maxUsed)) > 0) {
>+              core._BigIntImpl._absSub(typed_data.Uint16List._check(dDigits), abcdUsed, xDigits, maxUsed, typed_data.Uint16List._check(dDigits));
>+            } else {
>+              core._BigIntImpl._absSub(xDigits, maxUsed, typed_data.Uint16List._check(dDigits), maxUsed, typed_data.Uint16List._check(dDigits));
>+              dIsNegative = true;
>+            }
>+          }
>+          core._BigIntImpl._rsh(typed_data.Uint16List._check(cDigits), abcdUsed, 1, typed_data.Uint16List._check(cDigits));
>+        } else if (dart.equals(dart.dsend(dart.dindex(dDigits, 0), '&', [1]), 1)) {
>+          if (dart.test(dIsNegative)) {
>+            core._BigIntImpl._absAdd(typed_data.Uint16List._check(dDigits), abcdUsed, xDigits, maxUsed, typed_data.Uint16List._check(dDigits));
>+          } else if (!dart.equals(dart.dindex(dDigits, maxUsed), 0) || dart.notNull(core._BigIntImpl._compareDigits(typed_data.Uint16List._check(dDigits), maxUsed, xDigits, maxUsed)) > 0) {
>+            core._BigIntImpl._absSub(typed_data.Uint16List._check(dDigits), abcdUsed, xDigits, maxUsed, typed_data.Uint16List._check(dDigits));
>+          } else {
>+            core._BigIntImpl._absSub(xDigits, maxUsed, typed_data.Uint16List._check(dDigits), maxUsed, typed_data.Uint16List._check(dDigits));
>+            dIsNegative = true;
>+          }
>+        }
>+        core._BigIntImpl._rsh(typed_data.Uint16List._check(dDigits), abcdUsed, 1, typed_data.Uint16List._check(dDigits));
>+      }
>+      if (dart.notNull(core._BigIntImpl._compareDigits(uDigits, maxUsed, vDigits, maxUsed)) >= 0) {
>+        core._BigIntImpl._absSub(uDigits, maxUsed, vDigits, maxUsed, uDigits);
>+        if (ac) {
>+          if (aIsNegative == cIsNegative) {
>+            let a_cmp_c = core._BigIntImpl._compareDigits(typed_data.Uint16List._check(aDigits), abcdUsed, typed_data.Uint16List._check(cDigits), abcdUsed);
>+            if (dart.notNull(a_cmp_c) > 0) {
>+              core._BigIntImpl._absSub(typed_data.Uint16List._check(aDigits), abcdUsed, typed_data.Uint16List._check(cDigits), abcdUsed, typed_data.Uint16List._check(aDigits));
>+            } else {
>+              core._BigIntImpl._absSub(typed_data.Uint16List._check(cDigits), abcdUsed, typed_data.Uint16List._check(aDigits), abcdUsed, typed_data.Uint16List._check(aDigits));
>+              aIsNegative = !dart.test(aIsNegative) && a_cmp_c !== 0;
>+            }
>+          } else {
>+            core._BigIntImpl._absAdd(typed_data.Uint16List._check(aDigits), abcdUsed, typed_data.Uint16List._check(cDigits), abcdUsed, typed_data.Uint16List._check(aDigits));
>+          }
>+        }
>+        if (bIsNegative == dIsNegative) {
>+          let b_cmp_d = core._BigIntImpl._compareDigits(typed_data.Uint16List._check(bDigits), abcdUsed, typed_data.Uint16List._check(dDigits), abcdUsed);
>+          if (dart.notNull(b_cmp_d) > 0) {
>+            core._BigIntImpl._absSub(typed_data.Uint16List._check(bDigits), abcdUsed, typed_data.Uint16List._check(dDigits), abcdUsed, typed_data.Uint16List._check(bDigits));
>+          } else {
>+            core._BigIntImpl._absSub(typed_data.Uint16List._check(dDigits), abcdUsed, typed_data.Uint16List._check(bDigits), abcdUsed, typed_data.Uint16List._check(bDigits));
>+            bIsNegative = !dart.test(bIsNegative) && b_cmp_d !== 0;
>+          }
>+        } else {
>+          core._BigIntImpl._absAdd(typed_data.Uint16List._check(bDigits), abcdUsed, typed_data.Uint16List._check(dDigits), abcdUsed, typed_data.Uint16List._check(bDigits));
>+        }
>+      } else {
>+        core._BigIntImpl._absSub(vDigits, maxUsed, uDigits, maxUsed, vDigits);
>+        if (ac) {
>+          if (cIsNegative == aIsNegative) {
>+            let c_cmp_a = core._BigIntImpl._compareDigits(typed_data.Uint16List._check(cDigits), abcdUsed, typed_data.Uint16List._check(aDigits), abcdUsed);
>+            if (dart.notNull(c_cmp_a) > 0) {
>+              core._BigIntImpl._absSub(typed_data.Uint16List._check(cDigits), abcdUsed, typed_data.Uint16List._check(aDigits), abcdUsed, typed_data.Uint16List._check(cDigits));
>+            } else {
>+              core._BigIntImpl._absSub(typed_data.Uint16List._check(aDigits), abcdUsed, typed_data.Uint16List._check(cDigits), abcdUsed, typed_data.Uint16List._check(cDigits));
>+              cIsNegative = !dart.test(cIsNegative) && c_cmp_a !== 0;
>+            }
>+          } else {
>+            core._BigIntImpl._absAdd(typed_data.Uint16List._check(cDigits), abcdUsed, typed_data.Uint16List._check(aDigits), abcdUsed, typed_data.Uint16List._check(cDigits));
>+          }
>+        }
>+        if (dIsNegative == bIsNegative) {
>+          let d_cmp_b = core._BigIntImpl._compareDigits(typed_data.Uint16List._check(dDigits), abcdUsed, typed_data.Uint16List._check(bDigits), abcdUsed);
>+          if (dart.notNull(d_cmp_b) > 0) {
>+            core._BigIntImpl._absSub(typed_data.Uint16List._check(dDigits), abcdUsed, typed_data.Uint16List._check(bDigits), abcdUsed, typed_data.Uint16List._check(dDigits));
>+          } else {
>+            core._BigIntImpl._absSub(typed_data.Uint16List._check(bDigits), abcdUsed, typed_data.Uint16List._check(dDigits), abcdUsed, typed_data.Uint16List._check(dDigits));
>+            dIsNegative = !dart.test(dIsNegative) && d_cmp_b !== 0;
>+          }
>+        } else {
>+          core._BigIntImpl._absAdd(typed_data.Uint16List._check(dDigits), abcdUsed, typed_data.Uint16List._check(bDigits), abcdUsed, typed_data.Uint16List._check(dDigits));
>+        }
>+      }
>+      let i = maxUsed;
>+      while (dart.notNull(i) > 0 && uDigits[$_get](dart.notNull(i) - 1) === 0) {
>+        i = dart.notNull(i) - 1;
>+      }
>+      if (i === 0) break;
>+    }
>+    if (!dart.test(inv)) {
>+      if (shiftAmount > 0) {
>+        maxUsed = core._BigIntImpl._lShiftDigits(vDigits, maxUsed, shiftAmount, vDigits);
>+      }
>+      return new core._BigIntImpl.__(false, maxUsed, vDigits);
>+    }
>+    let i = dart.notNull(maxUsed) - 1;
>+    while (i > 0 && vDigits[$_get](i) === 0)
>+      --i;
>+    if (i !== 0 || vDigits[$_get](0) !== 1) {
>+      dart.throw(core.Exception.new("Not coprime"));
>+    }
>+    if (dart.test(dIsNegative)) {
>+      while (!dart.equals(dart.dindex(dDigits, maxUsed), 0) || dart.notNull(core._BigIntImpl._compareDigits(typed_data.Uint16List._check(dDigits), maxUsed, xDigits, maxUsed)) > 0) {
>+        core._BigIntImpl._absSub(typed_data.Uint16List._check(dDigits), abcdUsed, xDigits, maxUsed, typed_data.Uint16List._check(dDigits));
>+      }
>+      core._BigIntImpl._absSub(xDigits, maxUsed, typed_data.Uint16List._check(dDigits), maxUsed, typed_data.Uint16List._check(dDigits));
>+      dIsNegative = false;
>+    } else {
>+      while (!dart.equals(dart.dindex(dDigits, maxUsed), 0) || dart.notNull(core._BigIntImpl._compareDigits(typed_data.Uint16List._check(dDigits), maxUsed, xDigits, maxUsed)) >= 0) {
>+        core._BigIntImpl._absSub(typed_data.Uint16List._check(dDigits), abcdUsed, xDigits, maxUsed, typed_data.Uint16List._check(dDigits));
>+      }
>+    }
>+    return new core._BigIntImpl.__(false, maxUsed, typed_data.Uint16List._check(dDigits));
>+  }
>+  modInverse(bigInt) {
>+    let modulus = core._BigIntImpl._check(bigInt);
>+    if (dart.test(modulus['<='](core._BigIntImpl.zero))) {
>+      dart.throw(new core.ArgumentError.new("Modulus must be strictly positive: " + dart.str(modulus)));
>+    }
>+    if (dart.equals(modulus, core._BigIntImpl.one)) return core._BigIntImpl.zero;
>+    let tmp = this;
>+    if (dart.test(tmp[_isNegative]) || dart.notNull(tmp[_absCompare](modulus)) >= 0) {
>+      tmp = tmp['%'](modulus);
>+    }
>+    return core._BigIntImpl._binaryGcd(modulus, tmp, true);
>+  }
>+  gcd(bigInt) {
>+    let other = core._BigIntImpl._check(bigInt);
>+    if (dart.test(this[_isZero])) return other.abs();
>+    if (dart.test(other[_isZero])) return this.abs();
>+    return core._BigIntImpl._binaryGcd(this, other, false);
>+  }
>+  toUnsigned(width) {
>+    return this['&'](core._BigIntImpl.one['<<'](width)['-'](core._BigIntImpl.one));
>+  }
>+  toSigned(width) {
>+    let signMask = core._BigIntImpl.one['<<'](dart.notNull(width) - 1);
>+    return this['&'](signMask['-'](core._BigIntImpl.one))['-'](this['&'](signMask));
>+  }
>+  get isValidInt() {
>+    if (dart.notNull(this[_used]) <= 3) return true;
>+    let asInt = this.toInt();
>+    if (!asInt[$toDouble]()[$isFinite]) return false;
>+    return this._equals(core._BigIntImpl._fromInt(asInt));
>+  }
>+  toInt() {
>+    let result = 0;
>+    for (let i = dart.notNull(this[_used]) - 1; i >= 0; i--) {
>+      result = result * 65536 + dart.notNull(this[_digits][$_get](i));
>+    }
>+    return dart.test(this[_isNegative]) ? -result : result;
>+  }
>+  toDouble() {
>+    let exponentBias = 1075;
>+    let maxDoubleExponent = 2046 - exponentBias;
>+    if (dart.test(this[_isZero])) return 0.0;
>+    let resultBits = typed_data.Uint8List.new(8);
>+    let length = 16 * (dart.notNull(this[_used]) - 1) + this[_digits][$_get](dart.notNull(this[_used]) - 1)[$bitLength];
>+    if (length > maxDoubleExponent + 53) {
>+      return dart.test(this[_isNegative]) ? core.double.negativeInfinity : core.double.infinity;
>+    }
>+    if (dart.test(this[_isNegative])) resultBits[$_set](7, 128);
>+    let biasedExponent = length - 53 + exponentBias;
>+    resultBits[$_set](6, (biasedExponent & 15) << 4);
>+    let i$ = 7;
>+    resultBits[$_set](i$, (dart.notNull(resultBits[$_get](i$)) | biasedExponent[$rightShift](4)) >>> 0);
>+    let cachedBits = 0;
>+    let cachedBitsLength = 0;
>+    let digitIndex = dart.notNull(this[_used]) - 1;
>+    const readBits = n => {
>+      while (cachedBitsLength < dart.notNull(n)) {
>+        let nextDigit = null;
>+        let nextDigitLength = 16;
>+        if (digitIndex < 0) {
>+          nextDigit = 0;
>+          digitIndex--;
>+        } else {
>+          nextDigit = this[_digits][$_get](digitIndex);
>+          if (digitIndex === dart.notNull(this[_used]) - 1) nextDigitLength = nextDigit[$bitLength];
>+          digitIndex--;
>+        }
>+        cachedBits = cachedBits[$leftShift](nextDigitLength) + dart.notNull(nextDigit);
>+        cachedBitsLength = cachedBitsLength + nextDigitLength;
>+      }
>+      let result = cachedBits[$rightShift](cachedBitsLength - dart.notNull(n));
>+      cachedBits = cachedBits - result[$leftShift](cachedBitsLength - dart.notNull(n));
>+      cachedBitsLength = cachedBitsLength - dart.notNull(n);
>+      return result;
>+    };
>+    dart.fn(readBits, intToint());
>+    let leadingBits = dart.notNull(readBits(5)) & 15;
>+    let i$0 = 6;
>+    resultBits[$_set](i$0, (dart.notNull(resultBits[$_get](i$0)) | leadingBits) >>> 0);
>+    for (let i = 5; i >= 0; i--) {
>+      resultBits[$_set](i, readBits(8));
>+    }
>+    function roundUp() {
>+      let carry = 1;
>+      for (let i = 0; i < 8; i++) {
>+        if (carry === 0) break;
>+        let sum = dart.notNull(resultBits[$_get](i)) + carry;
>+        resultBits[$_set](i, sum & 255);
>+        carry = sum[$rightShift](8);
>+      }
>+    }
>+    dart.fn(roundUp, VoidTovoid());
>+    if (readBits(1) === 1) {
>+      if (resultBits[$_get](0)[$isOdd]) {
>+        roundUp();
>+      } else {
>+        if (cachedBits !== 0) {
>+          roundUp();
>+        } else {
>+          for (let i = digitIndex; digitIndex >= 0; i--) {
>+            if (this[_digits][$_get](i) !== 0) {
>+              roundUp();
>+              break;
>+            }
>+          }
>+        }
>+      }
>+    }
>+    return resultBits[$buffer][$asByteData]()[$getFloat64](0, typed_data.Endian.little);
>+  }
>+  toString() {
>+    if (this[_used] === 0) return "0";
>+    if (this[_used] === 1) {
>+      if (dart.test(this[_isNegative])) return (-dart.notNull(this[_digits][$_get](0)))[$toString]();
>+      return dart.toString(this[_digits][$_get](0));
>+    }
>+    let decimalDigitChunks = JSArrayOfString().of([]);
>+    let rest = dart.test(this.isNegative) ? this._negate() : this;
>+    while (dart.notNull(rest[_used]) > 1) {
>+      let digits4 = dart.toString(rest.remainder(core._BigIntImpl._bigInt10000));
>+      decimalDigitChunks[$add](digits4);
>+      if (digits4.length === 1) decimalDigitChunks[$add]("000");
>+      if (digits4.length === 2) decimalDigitChunks[$add]("00");
>+      if (digits4.length === 3) decimalDigitChunks[$add]("0");
>+      rest = rest['~/'](core._BigIntImpl._bigInt10000);
>+    }
>+    decimalDigitChunks[$add](dart.toString(rest[_digits][$_get](0)));
>+    if (dart.test(this[_isNegative])) decimalDigitChunks[$add]("-");
>+    return decimalDigitChunks[$reversed][$join]();
>+  }
>+  [_toRadixCodeUnit](digit) {
>+    let _0 = 48;
>+    let _a = 97;
>+    if (dart.notNull(digit) < 10) return _0 + dart.notNull(digit);
>+    return _a + dart.notNull(digit) - 10;
>+  }
>+  toRadixString(radix) {
>+    if (dart.notNull(radix) > 36) dart.throw(new core.RangeError.range(radix, 2, 36));
>+    if (this[_used] === 0) return "0";
>+    if (this[_used] === 1) {
>+      let digitString = this[_digits][$_get](0)[$toRadixString](radix);
>+      if (dart.test(this[_isNegative])) return "-" + digitString;
>+      return digitString;
>+    }
>+    if (radix === 16) return this[_toHexString]();
>+    let base = core._BigIntImpl._fromInt(radix);
>+    let reversedDigitCodeUnits = JSArrayOfint().of([]);
>+    let rest = this.abs();
>+    while (!dart.test(rest[_isZero])) {
>+      let digit = rest.remainder(base).toInt();
>+      rest = rest['~/'](base);
>+      reversedDigitCodeUnits[$add](this[_toRadixCodeUnit](digit));
>+    }
>+    let digitString = core.String.fromCharCodes(reversedDigitCodeUnits[$reversed]);
>+    if (dart.test(this[_isNegative])) return "-" + digitString;
>+    return digitString;
>+  }
>+  [_toHexString]() {
>+    let chars = JSArrayOfint().of([]);
>+    for (let i = 0; i < dart.notNull(this[_used]) - 1; i++) {
>+      let chunk = this[_digits][$_get](i);
>+      for (let j = 0; j < (16 / 4)[$truncate](); j++) {
>+        chars[$add](this[_toRadixCodeUnit](dart.notNull(chunk) & 15));
>+        chunk = chunk[$rightShift](4);
>+      }
>+    }
>+    let msbChunk = this[_digits][$_get](dart.notNull(this[_used]) - 1);
>+    while (msbChunk !== 0) {
>+      chars[$add](this[_toRadixCodeUnit](dart.notNull(msbChunk) & 15));
>+      msbChunk = msbChunk[$rightShift](4);
>+    }
>+    if (dart.test(this[_isNegative])) {
>+      let _dash = 45;
>+      chars[$add](_dash);
>+    }
>+    return core.String.fromCharCodes(chars[$reversed]);
>+  }
>+};
>+(core._BigIntImpl.__ = function(isNegative, used, digits) {
>+  core._BigIntImpl._normalized.call(this, isNegative, core._BigIntImpl._normalize(used, digits), digits);
>+}).prototype = core._BigIntImpl.prototype;
>+(core._BigIntImpl._normalized = function(isNegative, used, digits) {
>+  this[_used] = used;
>+  this[_digits] = digits;
>+  this[_isNegative] = used === 0 ? false : isNegative;
>+}).prototype = core._BigIntImpl.prototype;
>+dart.addTypeTests(core._BigIntImpl);
>+core._BigIntImpl[dart.implements] = () => [core.BigInt];
>+dart.setMethodSignature(core._BigIntImpl, () => ({
>+  __proto__: dart.getMethods(core._BigIntImpl.__proto__),
>+  _negate: dart.fnType(core._BigIntImpl, []),
>+  abs: dart.fnType(core._BigIntImpl, []),
>+  [_dlShift]: dart.fnType(core._BigIntImpl, [core.int]),
>+  [_drShift]: dart.fnType(core._BigIntImpl, [core.int]),
>+  '<<': dart.fnType(core._BigIntImpl, [core.int]),
>+  '>>': dart.fnType(core._BigIntImpl, [core.int]),
>+  [_absCompare]: dart.fnType(core.int, [core.BigInt]),
>+  compareTo: dart.fnType(core.int, [core.Object]),
>+  [$compareTo]: dart.fnType(core.int, [core.Object]),
>+  [_absAddSetSign]: dart.fnType(core._BigIntImpl, [core._BigIntImpl, core.bool]),
>+  [_absSubSetSign]: dart.fnType(core._BigIntImpl, [core._BigIntImpl, core.bool]),
>+  [_absAndSetSign]: dart.fnType(core._BigIntImpl, [core._BigIntImpl, core.bool]),
>+  [_absAndNotSetSign]: dart.fnType(core._BigIntImpl, [core._BigIntImpl, core.bool]),
>+  [_absOrSetSign]: dart.fnType(core._BigIntImpl, [core._BigIntImpl, core.bool]),
>+  [_absXorSetSign]: dart.fnType(core._BigIntImpl, [core._BigIntImpl, core.bool]),
>+  '&': dart.fnType(core._BigIntImpl, [core.BigInt]),
>+  '|': dart.fnType(core._BigIntImpl, [core.BigInt]),
>+  '^': dart.fnType(core._BigIntImpl, [core.BigInt]),
>+  '~': dart.fnType(core._BigIntImpl, []),
>+  '+': dart.fnType(core._BigIntImpl, [core.BigInt]),
>+  '-': dart.fnType(core._BigIntImpl, [core.BigInt]),
>+  '*': dart.fnType(core._BigIntImpl, [core.BigInt]),
>+  [_div]: dart.fnType(core._BigIntImpl, [core.BigInt]),
>+  [_rem]: dart.fnType(core._BigIntImpl, [core.BigInt]),
>+  [_divRem]: dart.fnType(dart.void, [core._BigIntImpl]),
>+  _equals: dart.fnType(core.bool, [core.Object]),
>+  [$_equals]: dart.fnType(core.bool, [core.Object]),
>+  '~/': dart.fnType(core._BigIntImpl, [core.BigInt]),
>+  remainder: dart.fnType(core._BigIntImpl, [core.BigInt]),
>+  '/': dart.fnType(core.double, [core.BigInt]),
>+  '<': dart.fnType(core.bool, [core.BigInt]),
>+  '<=': dart.fnType(core.bool, [core.BigInt]),
>+  '>': dart.fnType(core.bool, [core.BigInt]),
>+  '>=': dart.fnType(core.bool, [core.BigInt]),
>+  '%': dart.fnType(core._BigIntImpl, [core.BigInt]),
>+  pow: dart.fnType(core._BigIntImpl, [core.int]),
>+  modPow: dart.fnType(core._BigIntImpl, [core.BigInt, core.BigInt]),
>+  modInverse: dart.fnType(core._BigIntImpl, [core.BigInt]),
>+  gcd: dart.fnType(core._BigIntImpl, [core.BigInt]),
>+  toUnsigned: dart.fnType(core._BigIntImpl, [core.int]),
>+  toSigned: dart.fnType(core._BigIntImpl, [core.int]),
>+  toInt: dart.fnType(core.int, []),
>+  toDouble: dart.fnType(core.double, []),
>+  [_toRadixCodeUnit]: dart.fnType(core.int, [core.int]),
>+  toRadixString: dart.fnType(core.String, [core.int]),
>+  [_toHexString]: dart.fnType(core.String, [])
>+}));
>+dart.setGetterSignature(core._BigIntImpl, () => ({
>+  __proto__: dart.getGetters(core._BigIntImpl.__proto__),
>+  [_isZero]: core.bool,
>+  bitLength: core.int,
>+  sign: core.int,
>+  isEven: core.bool,
>+  isOdd: core.bool,
>+  isNegative: core.bool,
>+  isValidInt: core.bool
>+}));
>+dart.setLibraryUri(core._BigIntImpl, "dart:core");
>+dart.setFieldSignature(core._BigIntImpl, () => ({
>+  __proto__: dart.getFields(core._BigIntImpl.__proto__),
>+  [_isNegative]: dart.finalFieldType(core.bool),
>+  [_digits]: dart.finalFieldType(typed_data.Uint16List),
>+  [_used]: dart.finalFieldType(core.int)
>+}));
>+dart.defineExtensionMethods(core._BigIntImpl, ['compareTo', '_equals', 'toString']);
>+dart.defineExtensionAccessors(core._BigIntImpl, ['hashCode']);
>+dart.defineLazy(core._BigIntImpl, {
>+  /*core._BigIntImpl._digitBits*/get _digitBits() {
>+    return 16;
>+  },
>+  /*core._BigIntImpl._digitBase*/get _digitBase() {
>+    return 1 << 16;
>+  },
>+  /*core._BigIntImpl._digitMask*/get _digitMask() {
>+    return (1 << 16) - 1;
>+  },
>+  /*core._BigIntImpl.zero*/get zero() {
>+    return core._BigIntImpl._fromInt(0);
>+  },
>+  /*core._BigIntImpl.one*/get one() {
>+    return core._BigIntImpl._fromInt(1);
>+  },
>+  /*core._BigIntImpl.two*/get two() {
>+    return core._BigIntImpl._fromInt(2);
>+  },
>+  /*core._BigIntImpl._minusOne*/get _minusOne() {
>+    return core._BigIntImpl.one._negate();
>+  },
>+  /*core._BigIntImpl._bigInt10000*/get _bigInt10000() {
>+    return core._BigIntImpl._fromInt(10000);
>+  },
>+  /*core._BigIntImpl._lastDividendDigits*/get _lastDividendDigits() {
>+    return null;
>+  },
>+  set _lastDividendDigits(_) {},
>+  /*core._BigIntImpl._lastDividendUsed*/get _lastDividendUsed() {
>+    return null;
>+  },
>+  set _lastDividendUsed(_) {},
>+  /*core._BigIntImpl._lastDivisorDigits*/get _lastDivisorDigits() {
>+    return null;
>+  },
>+  set _lastDivisorDigits(_) {},
>+  /*core._BigIntImpl._lastDivisorUsed*/get _lastDivisorUsed() {
>+    return null;
>+  },
>+  set _lastDivisorUsed(_) {},
>+  /*core._BigIntImpl._lastQuoRemDigits*/get _lastQuoRemDigits() {
>+    return null;
>+  },
>+  set _lastQuoRemDigits(_) {},
>+  /*core._BigIntImpl._lastQuoRemUsed*/get _lastQuoRemUsed() {
>+    return null;
>+  },
>+  set _lastQuoRemUsed(_) {},
>+  /*core._BigIntImpl._lastRemUsed*/get _lastRemUsed() {
>+    return null;
>+  },
>+  set _lastRemUsed(_) {},
>+  /*core._BigIntImpl._lastRem_nsh*/get _lastRem_nsh() {
>+    return null;
>+  },
>+  set _lastRem_nsh(_) {},
>+  /*core._BigIntImpl._bitsForFromDouble*/get _bitsForFromDouble() {
>+    return typed_data.Uint8List.new(8);
>+  },
>+  /*core._BigIntImpl._simpleValidIntDigits*/get _simpleValidIntDigits() {
>+    return (53 / 16)[$truncate]();
>+  }
>+});
>+core._BigIntReduction = class _BigIntReduction extends core.Object {};
>+(core._BigIntReduction.new = function() {
>+}).prototype = core._BigIntReduction.prototype;
>+dart.addTypeTests(core._BigIntReduction);
>+dart.setLibraryUri(core._BigIntReduction, "dart:core");
>+const _modulus = dart.privateName(core, "_modulus");
>+const _normalizedModulus = dart.privateName(core, "_normalizedModulus");
>+const _reduce = dart.privateName(core, "_reduce");
>+core._BigIntClassic = class _BigIntClassic extends core.Object {
>+  convert(x, resultDigits) {
>+    let digits = null;
>+    let used = null;
>+    if (dart.test(x[_isNegative]) || dart.notNull(x[_absCompare](this[_modulus])) >= 0) {
>+      let remainder = x[_rem](this[_modulus]);
>+      if (dart.test(x[_isNegative]) && dart.notNull(remainder[_used]) > 0) {
>+        if (!dart.test(remainder[_isNegative])) dart.assertFailed(null, "dart:core", 2268, 16, "remainder._isNegative");
>+        remainder = remainder['+'](this[_modulus]);
>+      }
>+      if (!!dart.test(remainder[_isNegative])) dart.assertFailed(null, "dart:core", 2271, 14, "!remainder._isNegative");
>+      used = remainder[_used];
>+      digits = remainder[_digits];
>+    } else {
>+      used = x[_used];
>+      digits = x[_digits];
>+    }
>+    let i = used;
>+    while (dart.dtest(dart.dsend(i = dart.dsend(i, '-', [1]), '>=', [0]))) {
>+      resultDigits[$_set](core.int._check(i), core.int._check(dart.dindex(digits, i)));
>+    }
>+    return core.int._check(used);
>+  }
>+  revert(xDigits, xUsed) {
>+    return new core._BigIntImpl.__(false, xUsed, xDigits);
>+  }
>+  [_reduce](xDigits, xUsed) {
>+    if (dart.notNull(xUsed) < dart.notNull(this[_modulus][_used])) {
>+      return xUsed;
>+    }
>+    let reverted = this.revert(xDigits, xUsed);
>+    let rem = reverted[_rem](this[_normalizedModulus]);
>+    return this.convert(rem, xDigits);
>+  }
>+  sqr(xDigits, xUsed, resultDigits) {
>+    let b = new core._BigIntImpl.__(false, xUsed, xDigits);
>+    let b2 = b['*'](b);
>+    for (let i = 0; i < dart.notNull(b2[_used]); i++) {
>+      resultDigits[$_set](i, b2[_digits][$_get](i));
>+    }
>+    for (let i = b2[_used]; dart.notNull(i) < 2 * dart.notNull(xUsed); i = dart.notNull(i) + 1) {
>+      resultDigits[$_set](i, 0);
>+    }
>+    return this[_reduce](resultDigits, 2 * dart.notNull(xUsed));
>+  }
>+  mul(xDigits, xUsed, yDigits, yUsed, resultDigits) {
>+    let resultUsed = core._BigIntImpl._mulDigits(xDigits, xUsed, yDigits, yUsed, resultDigits);
>+    return this[_reduce](resultDigits, resultUsed);
>+  }
>+};
>+(core._BigIntClassic.new = function(modulus) {
>+  this[_modulus] = modulus;
>+  this[_normalizedModulus] = modulus['<<'](core._BigIntImpl._digitBits - modulus[_digits][$_get](dart.notNull(modulus[_used]) - 1)[$bitLength]);
>+}).prototype = core._BigIntClassic.prototype;
>+dart.addTypeTests(core._BigIntClassic);
>+core._BigIntClassic[dart.implements] = () => [core._BigIntReduction];
>+dart.setMethodSignature(core._BigIntClassic, () => ({
>+  __proto__: dart.getMethods(core._BigIntClassic.__proto__),
>+  convert: dart.fnType(core.int, [core._BigIntImpl, typed_data.Uint16List]),
>+  revert: dart.fnType(core._BigIntImpl, [typed_data.Uint16List, core.int]),
>+  [_reduce]: dart.fnType(core.int, [typed_data.Uint16List, core.int]),
>+  sqr: dart.fnType(core.int, [typed_data.Uint16List, core.int, typed_data.Uint16List]),
>+  mul: dart.fnType(core.int, [typed_data.Uint16List, core.int, typed_data.Uint16List, core.int, typed_data.Uint16List])
>+}));
>+dart.setLibraryUri(core._BigIntClassic, "dart:core");
>+dart.setFieldSignature(core._BigIntClassic, () => ({
>+  __proto__: dart.getFields(core._BigIntClassic.__proto__),
>+  [_modulus]: dart.finalFieldType(core._BigIntImpl),
>+  [_normalizedModulus]: dart.finalFieldType(core._BigIntImpl)
>+}));
>+core.Deprecated = class Deprecated extends core.Object {
>+  get message() {
>+    return this[message$1];
>+  }
>+  set message(value) {
>+    super.message = value;
>+  }
>+  get expires() {
>+    return this.message;
>+  }
>+  toString() {
>+    return "Deprecated feature: " + dart.str(this.message);
>+  }
>+};
>+(core.Deprecated.new = function(message) {
>+  this[message$1] = message;
>+}).prototype = core.Deprecated.prototype;
>+dart.addTypeTests(core.Deprecated);
>+const message$1 = Symbol("Deprecated.message");
>+dart.setGetterSignature(core.Deprecated, () => ({
>+  __proto__: dart.getGetters(core.Deprecated.__proto__),
>+  expires: core.String
>+}));
>+dart.setLibraryUri(core.Deprecated, "dart:core");
>+dart.setFieldSignature(core.Deprecated, () => ({
>+  __proto__: dart.getFields(core.Deprecated.__proto__),
>+  message: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionMethods(core.Deprecated, ['toString']);
>+dart.defineLazy(core, {
>+  /*core.deprecated*/get deprecated() {
>+    return dart.const(new core.Deprecated.new("next release"));
>+  }
>+});
>+core._Override = class _Override extends core.Object {};
>+(core._Override.new = function() {
>+}).prototype = core._Override.prototype;
>+dart.addTypeTests(core._Override);
>+dart.setLibraryUri(core._Override, "dart:core");
>+dart.defineLazy(core, {
>+  /*core.override*/get override() {
>+    return dart.const(new core._Override.new());
>+  }
>+});
>+core.Provisional = class Provisional extends core.Object {
>+  get message() {
>+    return null;
>+  }
>+};
>+(core.Provisional.new = function(opts) {
>+  let message = opts && 'message' in opts ? opts.message : null;
>+}).prototype = core.Provisional.prototype;
>+dart.addTypeTests(core.Provisional);
>+dart.setGetterSignature(core.Provisional, () => ({
>+  __proto__: dart.getGetters(core.Provisional.__proto__),
>+  message: core.String
>+}));
>+dart.setLibraryUri(core.Provisional, "dart:core");
>+dart.defineLazy(core, {
>+  /*core.provisional*/get provisional() {
>+    return null;
>+  }
>+});
>+core._Proxy = class _Proxy extends core.Object {};
>+(core._Proxy.new = function() {
>+}).prototype = core._Proxy.prototype;
>+dart.addTypeTests(core._Proxy);
>+dart.setLibraryUri(core._Proxy, "dart:core");
>+dart.defineLazy(core, {
>+  /*core.proxy*/get proxy() {
>+    return dart.const(new core._Proxy.new());
>+  }
>+});
>+core.pragma = class pragma extends core.Object {
>+  get name() {
>+    return this[name$0];
>+  }
>+  set name(value) {
>+    super.name = value;
>+  }
>+  get options() {
>+    return this[options$];
>+  }
>+  set options(value) {
>+    super.options = value;
>+  }
>+  static new(name, options) {
>+    return new core.pragma.__(name, options);
>+  }
>+};
>+(core.pragma.__ = function(name, options) {
>+  if (options === void 0) options = null;
>+  this[name$0] = name;
>+  this[options$] = options;
>+}).prototype = core.pragma.prototype;
>+dart.addTypeTests(core.pragma);
>+const name$0 = Symbol("pragma.name");
>+const options$ = Symbol("pragma.options");
>+dart.setLibraryUri(core.pragma, "dart:core");
>+dart.setFieldSignature(core.pragma, () => ({
>+  __proto__: dart.getFields(core.pragma.__proto__),
>+  name: dart.finalFieldType(core.String),
>+  options: dart.finalFieldType(core.Object)
>+}));
>+core.BigInt = class BigInt extends core.Object {
>+  static get zero() {
>+    return core._BigIntImpl.zero;
>+  }
>+  static get one() {
>+    return core._BigIntImpl.one;
>+  }
>+  static get two() {
>+    return core._BigIntImpl.two;
>+  }
>+  static parse(source, opts) {
>+    let radix = opts && 'radix' in opts ? opts.radix : null;
>+    return core._BigIntImpl.parse(source, {radix: radix});
>+  }
>+  static tryParse(source, opts) {
>+    let radix = opts && 'radix' in opts ? opts.radix : null;
>+    return core._BigIntImpl._tryParse(source, {radix: radix});
>+  }
>+  static from(value) {
>+    return core._BigIntImpl.from(value);
>+  }
>+};
>+(core.BigInt[dart.mixinNew] = function() {
>+}).prototype = core.BigInt.prototype;
>+dart.addTypeTests(core.BigInt);
>+core.BigInt[dart.implements] = () => [ComparableOfBigInt()];
>+dart.setLibraryUri(core.BigInt, "dart:core");
>+core.bool = class bool extends core.Object {
>+  static fromEnvironment(name, opts) {
>+    let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : false;
>+    dart.throw(new core.UnsupportedError.new("bool.fromEnvironment can only be used as a const constructor"));
>+  }
>+  get [$hashCode]() {
>+    return super[$hashCode];
>+  }
>+  [$bitAnd](other) {
>+    return dart.test(other) && this;
>+  }
>+  [$bitOr](other) {
>+    return dart.test(other) || this;
>+  }
>+  [$bitXor](other) {
>+    return !dart.test(other) === this;
>+  }
>+  [$toString]() {
>+    return this ? "true" : "false";
>+  }
>+};
>+(core.bool[dart.mixinNew] = function() {
>+}).prototype = core.bool.prototype;
>+core.bool.is = function is_bool(o) {
>+  return o === true || o === false;
>+};
>+core.bool.as = function as_bool(o) {
>+  if (o === true || o === false || o == null) return o;
>+  return dart.as(o, core.bool, false);
>+};
>+core.bool._check = function check_bool(o) {
>+  if (o === true || o === false || o == null) return o;
>+  return dart.as(o, core.bool, true);
>+};
>+dart.setMethodSignature(core.bool, () => ({
>+  __proto__: dart.getMethods(core.bool.__proto__),
>+  [$bitAnd]: dart.fnType(core.bool, [core.bool]),
>+  [$bitOr]: dart.fnType(core.bool, [core.bool]),
>+  [$bitXor]: dart.fnType(core.bool, [core.bool])
>+}));
>+dart.setLibraryUri(core.bool, "dart:core");
>+const _is_Comparable_default = Symbol('_is_Comparable_default');
>+core.Comparable$ = dart.generic(T => {
>+  class Comparable extends core.Object {
>+    static compare(a, b) {
>+      return a[$compareTo](b);
>+    }
>+  }
>+  (Comparable.new = function() {
>+  }).prototype = Comparable.prototype;
>+  dart.addTypeTests(Comparable);
>+  Comparable.prototype[_is_Comparable_default] = true;
>+  dart.setLibraryUri(Comparable, "dart:core");
>+  return Comparable;
>+});
>+core.Comparable = core.Comparable$();
>+dart.addTypeTests(core.Comparable, _is_Comparable_default);
>+const _value$0 = dart.privateName(core, "_value");
>+core.DateTime = class DateTime extends core.Object {
>+  get isUtc() {
>+    return this[isUtc$];
>+  }
>+  set isUtc(value) {
>+    super.isUtc = value;
>+  }
>+  static parse(formattedString) {
>+    let re = core.DateTime._parseFormat;
>+    let match = re.firstMatch(formattedString);
>+    if (match != null) {
>+      function parseIntOrZero(matched) {
>+        if (matched == null) return 0;
>+        return core.int.parse(matched);
>+      }
>+      dart.fn(parseIntOrZero, StringToint());
>+      function parseMilliAndMicroseconds(matched) {
>+        if (matched == null) return 0;
>+        let length = matched.length;
>+        if (!(length >= 1)) dart.assertFailed(null, "dart:core/date_time.dart", 291, 16, "length >= 1");
>+        if (!(length <= 6)) dart.assertFailed(null, "dart:core/date_time.dart", 292, 16, "length <= 6");
>+        let result = 0;
>+        for (let i = 0; i < 6; i++) {
>+          result = result * 10;
>+          if (i < matched.length) {
>+            result = result + ((matched[$codeUnitAt](i) ^ 48) >>> 0);
>+          }
>+        }
>+        return result;
>+      }
>+      dart.fn(parseMilliAndMicroseconds, StringToint());
>+      let years = core.int.parse(match._get(1));
>+      let month = core.int.parse(match._get(2));
>+      let day = core.int.parse(match._get(3));
>+      let hour = parseIntOrZero(match._get(4));
>+      let minute = parseIntOrZero(match._get(5));
>+      let second = parseIntOrZero(match._get(6));
>+      let addOneMillisecond = false;
>+      let milliAndMicroseconds = parseMilliAndMicroseconds(match._get(7));
>+      let millisecond = (dart.notNull(milliAndMicroseconds) / core.Duration.microsecondsPerMillisecond)[$truncate]();
>+      let microsecond = dart.asInt(milliAndMicroseconds[$remainder](core.Duration.microsecondsPerMillisecond));
>+      let isUtc = false;
>+      if (match._get(8) != null) {
>+        isUtc = true;
>+        if (match._get(9) != null) {
>+          let sign = match._get(9) === "-" ? -1 : 1;
>+          let hourDifference = core.int.parse(match._get(10));
>+          let minuteDifference = parseIntOrZero(match._get(11));
>+          minuteDifference = dart.notNull(minuteDifference) + 60 * dart.notNull(hourDifference);
>+          minute = dart.notNull(minute) - sign * dart.notNull(minuteDifference);
>+        }
>+      }
>+      let value = core.DateTime._brokenDownDateToValue(years, month, day, hour, minute, second, millisecond, microsecond, isUtc);
>+      if (value == null) {
>+        dart.throw(new core.FormatException.new("Time out of range", formattedString));
>+      }
>+      return new core.DateTime._withValue(value, {isUtc: isUtc});
>+    } else {
>+      dart.throw(new core.FormatException.new("Invalid date format", formattedString));
>+    }
>+  }
>+  static tryParse(formattedString) {
>+    try {
>+      return core.DateTime.parse(formattedString);
>+    } catch (e) {
>+      let ex = dart.getThrown(e);
>+      if (core.FormatException.is(ex)) {
>+        return null;
>+      } else
>+        throw e;
>+    }
>+  }
>+  _equals(other) {
>+    return core.DateTime.is(other) && this[_value$0] == other.millisecondsSinceEpoch && this.isUtc == other.isUtc;
>+  }
>+  isBefore(other) {
>+    return dart.notNull(this[_value$0]) < dart.notNull(other.millisecondsSinceEpoch);
>+  }
>+  isAfter(other) {
>+    return dart.notNull(this[_value$0]) > dart.notNull(other.millisecondsSinceEpoch);
>+  }
>+  isAtSameMomentAs(other) {
>+    return this[_value$0] == other.millisecondsSinceEpoch;
>+  }
>+  compareTo(other) {
>+    core.DateTime._check(other);
>+    return this[_value$0][$compareTo](other.millisecondsSinceEpoch);
>+  }
>+  get hashCode() {
>+    return (dart.notNull(this[_value$0]) ^ this[_value$0][$rightShift](30)) & 1073741823;
>+  }
>+  toLocal() {
>+    if (dart.test(this.isUtc)) {
>+      return new core.DateTime._withValue(this[_value$0], {isUtc: false});
>+    }
>+    return this;
>+  }
>+  toUtc() {
>+    if (dart.test(this.isUtc)) return this;
>+    return new core.DateTime._withValue(this[_value$0], {isUtc: true});
>+  }
>+  static _fourDigits(n) {
>+    let absN = n[$abs]();
>+    let sign = dart.notNull(n) < 0 ? "-" : "";
>+    if (absN >= 1000) return dart.str(n);
>+    if (absN >= 100) return sign + "0" + dart.str(absN);
>+    if (absN >= 10) return sign + "00" + dart.str(absN);
>+    return sign + "000" + dart.str(absN);
>+  }
>+  static _sixDigits(n) {
>+    if (!(dart.notNull(n) < -9999 || dart.notNull(n) > 9999)) dart.assertFailed(null, "dart:core/date_time.dart", 548, 12, "n < -9999 || n > 9999");
>+    let absN = n[$abs]();
>+    let sign = dart.notNull(n) < 0 ? "-" : "+";
>+    if (absN >= 100000) return sign + dart.str(absN);
>+    return sign + "0" + dart.str(absN);
>+  }
>+  static _threeDigits(n) {
>+    if (dart.notNull(n) >= 100) return dart.str(n);
>+    if (dart.notNull(n) >= 10) return "0" + dart.str(n);
>+    return "00" + dart.str(n);
>+  }
>+  static _twoDigits(n) {
>+    if (dart.notNull(n) >= 10) return dart.str(n);
>+    return "0" + dart.str(n);
>+  }
>+  toString() {
>+    let y = core.DateTime._fourDigits(this.year);
>+    let m = core.DateTime._twoDigits(this.month);
>+    let d = core.DateTime._twoDigits(this.day);
>+    let h = core.DateTime._twoDigits(this.hour);
>+    let min = core.DateTime._twoDigits(this.minute);
>+    let sec = core.DateTime._twoDigits(this.second);
>+    let ms = core.DateTime._threeDigits(this.millisecond);
>+    let us = this.microsecond === 0 ? "" : core.DateTime._threeDigits(this.microsecond);
>+    if (dart.test(this.isUtc)) {
>+      return dart.str(y) + "-" + dart.str(m) + "-" + dart.str(d) + " " + dart.str(h) + ":" + dart.str(min) + ":" + dart.str(sec) + "." + dart.str(ms) + dart.str(us) + "Z";
>+    } else {
>+      return dart.str(y) + "-" + dart.str(m) + "-" + dart.str(d) + " " + dart.str(h) + ":" + dart.str(min) + ":" + dart.str(sec) + "." + dart.str(ms) + dart.str(us);
>+    }
>+  }
>+  toIso8601String() {
>+    let y = dart.notNull(this.year) >= -9999 && dart.notNull(this.year) <= 9999 ? core.DateTime._fourDigits(this.year) : core.DateTime._sixDigits(this.year);
>+    let m = core.DateTime._twoDigits(this.month);
>+    let d = core.DateTime._twoDigits(this.day);
>+    let h = core.DateTime._twoDigits(this.hour);
>+    let min = core.DateTime._twoDigits(this.minute);
>+    let sec = core.DateTime._twoDigits(this.second);
>+    let ms = core.DateTime._threeDigits(this.millisecond);
>+    let us = this.microsecond === 0 ? "" : core.DateTime._threeDigits(this.microsecond);
>+    if (dart.test(this.isUtc)) {
>+      return dart.str(y) + "-" + dart.str(m) + "-" + dart.str(d) + "T" + dart.str(h) + ":" + dart.str(min) + ":" + dart.str(sec) + "." + dart.str(ms) + dart.str(us) + "Z";
>+    } else {
>+      return dart.str(y) + "-" + dart.str(m) + "-" + dart.str(d) + "T" + dart.str(h) + ":" + dart.str(min) + ":" + dart.str(sec) + "." + dart.str(ms) + dart.str(us);
>+    }
>+  }
>+  add(duration) {
>+    return new core.DateTime._withValue(dart.notNull(this[_value$0]) + dart.notNull(duration.inMilliseconds), {isUtc: this.isUtc});
>+  }
>+  subtract(duration) {
>+    return new core.DateTime._withValue(dart.notNull(this[_value$0]) - dart.notNull(duration.inMilliseconds), {isUtc: this.isUtc});
>+  }
>+  difference(other) {
>+    return new core.Duration.new({milliseconds: dart.notNull(this[_value$0]) - dart.notNull(other[_value$0])});
>+  }
>+  static _brokenDownDateToValue(year, month, day, hour, minute, second, millisecond, microsecond, isUtc) {
>+    return dart.asInt(_js_helper.Primitives.valueFromDecomposedDate(year, month, day, hour, minute, second, dart.notNull(millisecond) + dart.notNull(core.DateTime._microsecondInRoundedMilliseconds(microsecond)), isUtc));
>+  }
>+  get millisecondsSinceEpoch() {
>+    return this[_value$0];
>+  }
>+  get microsecondsSinceEpoch() {
>+    return dart.notNull(this[_value$0]) * 1000;
>+  }
>+  get timeZoneName() {
>+    if (dart.test(this.isUtc)) return "UTC";
>+    return _js_helper.Primitives.getTimeZoneName(this);
>+  }
>+  get timeZoneOffset() {
>+    if (dart.test(this.isUtc)) return new core.Duration.new();
>+    return new core.Duration.new({minutes: _js_helper.Primitives.getTimeZoneOffsetInMinutes(this)});
>+  }
>+  get year() {
>+    return _js_helper.Primitives.getYear(this);
>+  }
>+  get month() {
>+    return _js_helper.Primitives.getMonth(this);
>+  }
>+  get day() {
>+    return _js_helper.Primitives.getDay(this);
>+  }
>+  get hour() {
>+    return _js_helper.Primitives.getHours(this);
>+  }
>+  get minute() {
>+    return _js_helper.Primitives.getMinutes(this);
>+  }
>+  get second() {
>+    return _js_helper.Primitives.getSeconds(this);
>+  }
>+  get millisecond() {
>+    return _js_helper.Primitives.getMilliseconds(this);
>+  }
>+  get microsecond() {
>+    return 0;
>+  }
>+  get weekday() {
>+    return _js_helper.Primitives.getWeekday(this);
>+  }
>+  static _microsecondInRoundedMilliseconds(microsecond) {
>+    return (dart.notNull(microsecond) / 1000)[$round]();
>+  }
>+};
>+(core.DateTime.new = function(year, month, day, hour, minute, second, millisecond, microsecond) {
>+  if (month === void 0) month = 1;
>+  if (day === void 0) day = 1;
>+  if (hour === void 0) hour = 0;
>+  if (minute === void 0) minute = 0;
>+  if (second === void 0) second = 0;
>+  if (millisecond === void 0) millisecond = 0;
>+  if (microsecond === void 0) microsecond = 0;
>+  core.DateTime._internal.call(this, year, month, day, hour, minute, second, millisecond, microsecond, false);
>+}).prototype = core.DateTime.prototype;
>+(core.DateTime.utc = function(year, month, day, hour, minute, second, millisecond, microsecond) {
>+  if (month === void 0) month = 1;
>+  if (day === void 0) day = 1;
>+  if (hour === void 0) hour = 0;
>+  if (minute === void 0) minute = 0;
>+  if (second === void 0) second = 0;
>+  if (millisecond === void 0) millisecond = 0;
>+  if (microsecond === void 0) microsecond = 0;
>+  core.DateTime._internal.call(this, year, month, day, hour, minute, second, millisecond, microsecond, true);
>+}).prototype = core.DateTime.prototype;
>+(core.DateTime.now = function() {
>+  core.DateTime._now.call(this);
>+}).prototype = core.DateTime.prototype;
>+(core.DateTime.fromMillisecondsSinceEpoch = function(millisecondsSinceEpoch, opts) {
>+  let isUtc = opts && 'isUtc' in opts ? opts.isUtc : false;
>+  core.DateTime._withValue.call(this, millisecondsSinceEpoch, {isUtc: isUtc});
>+}).prototype = core.DateTime.prototype;
>+(core.DateTime.fromMicrosecondsSinceEpoch = function(microsecondsSinceEpoch, opts) {
>+  let isUtc = opts && 'isUtc' in opts ? opts.isUtc : false;
>+  core.DateTime._withValue.call(this, core.DateTime._microsecondInRoundedMilliseconds(microsecondsSinceEpoch), {isUtc: isUtc});
>+}).prototype = core.DateTime.prototype;
>+(core.DateTime._withValue = function(value, opts) {
>+  let isUtc = opts && 'isUtc' in opts ? opts.isUtc : null;
>+  this[_value$0] = value;
>+  this[isUtc$] = isUtc;
>+  if (this.millisecondsSinceEpoch[$abs]() > 8640000000000000 || this.millisecondsSinceEpoch[$abs]() === 8640000000000000 && this.microsecond !== 0) {
>+    dart.throw(new core.ArgumentError.new("DateTime is outside valid range: " + dart.str(this.millisecondsSinceEpoch)));
>+  }
>+  if (this.isUtc == null) {
>+    dart.throw(new core.ArgumentError.new("'isUtc' flag may not be 'null'"));
>+  }
>+}).prototype = core.DateTime.prototype;
>+(core.DateTime._internal = function(year, month, day, hour, minute, second, millisecond, microsecond, isUtc) {
>+  this[isUtc$] = typeof isUtc == 'boolean' ? isUtc : dart.throw(new core.ArgumentError.value(isUtc, "isUtc"));
>+  this[_value$0] = core.int._check(_js_helper.checkInt(_js_helper.Primitives.valueFromDecomposedDate(year, month, day, hour, minute, second, dart.notNull(millisecond) + dart.notNull(core.DateTime._microsecondInRoundedMilliseconds(microsecond)), isUtc)));
>+}).prototype = core.DateTime.prototype;
>+(core.DateTime._now = function() {
>+  this[isUtc$] = false;
>+  this[_value$0] = _js_helper.Primitives.dateNow();
>+}).prototype = core.DateTime.prototype;
>+dart.addTypeTests(core.DateTime);
>+const isUtc$ = Symbol("DateTime.isUtc");
>+core.DateTime[dart.implements] = () => [ComparableOfDateTime()];
>+dart.setMethodSignature(core.DateTime, () => ({
>+  __proto__: dart.getMethods(core.DateTime.__proto__),
>+  isBefore: dart.fnType(core.bool, [core.DateTime]),
>+  isAfter: dart.fnType(core.bool, [core.DateTime]),
>+  isAtSameMomentAs: dart.fnType(core.bool, [core.DateTime]),
>+  compareTo: dart.fnType(core.int, [core.Object]),
>+  [$compareTo]: dart.fnType(core.int, [core.Object]),
>+  toLocal: dart.fnType(core.DateTime, []),
>+  toUtc: dart.fnType(core.DateTime, []),
>+  toIso8601String: dart.fnType(core.String, []),
>+  add: dart.fnType(core.DateTime, [core.Duration]),
>+  subtract: dart.fnType(core.DateTime, [core.Duration]),
>+  difference: dart.fnType(core.Duration, [core.DateTime])
>+}));
>+dart.setGetterSignature(core.DateTime, () => ({
>+  __proto__: dart.getGetters(core.DateTime.__proto__),
>+  millisecondsSinceEpoch: core.int,
>+  microsecondsSinceEpoch: core.int,
>+  timeZoneName: core.String,
>+  timeZoneOffset: core.Duration,
>+  year: core.int,
>+  month: core.int,
>+  day: core.int,
>+  hour: core.int,
>+  minute: core.int,
>+  second: core.int,
>+  millisecond: core.int,
>+  microsecond: core.int,
>+  weekday: core.int
>+}));
>+dart.setLibraryUri(core.DateTime, "dart:core");
>+dart.setFieldSignature(core.DateTime, () => ({
>+  __proto__: dart.getFields(core.DateTime.__proto__),
>+  [_value$0]: dart.finalFieldType(core.int),
>+  isUtc: dart.finalFieldType(core.bool)
>+}));
>+dart.defineExtensionMethods(core.DateTime, ['_equals', 'compareTo', 'toString']);
>+dart.defineExtensionAccessors(core.DateTime, ['hashCode']);
>+dart.defineLazy(core.DateTime, {
>+  /*core.DateTime.monday*/get monday() {
>+    return 1;
>+  },
>+  /*core.DateTime.tuesday*/get tuesday() {
>+    return 2;
>+  },
>+  /*core.DateTime.wednesday*/get wednesday() {
>+    return 3;
>+  },
>+  /*core.DateTime.thursday*/get thursday() {
>+    return 4;
>+  },
>+  /*core.DateTime.friday*/get friday() {
>+    return 5;
>+  },
>+  /*core.DateTime.saturday*/get saturday() {
>+    return 6;
>+  },
>+  /*core.DateTime.sunday*/get sunday() {
>+    return 7;
>+  },
>+  /*core.DateTime.daysPerWeek*/get daysPerWeek() {
>+    return 7;
>+  },
>+  /*core.DateTime.january*/get january() {
>+    return 1;
>+  },
>+  /*core.DateTime.february*/get february() {
>+    return 2;
>+  },
>+  /*core.DateTime.march*/get march() {
>+    return 3;
>+  },
>+  /*core.DateTime.april*/get april() {
>+    return 4;
>+  },
>+  /*core.DateTime.may*/get may() {
>+    return 5;
>+  },
>+  /*core.DateTime.june*/get june() {
>+    return 6;
>+  },
>+  /*core.DateTime.july*/get july() {
>+    return 7;
>+  },
>+  /*core.DateTime.august*/get august() {
>+    return 8;
>+  },
>+  /*core.DateTime.september*/get september() {
>+    return 9;
>+  },
>+  /*core.DateTime.october*/get october() {
>+    return 10;
>+  },
>+  /*core.DateTime.november*/get november() {
>+    return 11;
>+  },
>+  /*core.DateTime.december*/get december() {
>+    return 12;
>+  },
>+  /*core.DateTime.monthsPerYear*/get monthsPerYear() {
>+    return 12;
>+  },
>+  /*core.DateTime._maxMillisecondsSinceEpoch*/get _maxMillisecondsSinceEpoch() {
>+    return 8640000000000000;
>+  },
>+  /*core.DateTime._parseFormat*/get _parseFormat() {
>+    return core.RegExp.new("^([+-]?\\d{4,6})-?(\\d\\d)-?(\\d\\d)" + "(?:[ T](\\d\\d)(?::?(\\d\\d)(?::?(\\d\\d)(?:[.,](\\d{1,6}))?)?)?" + "( ?[zZ]| ?([-+])(\\d\\d)(?::?(\\d\\d))?)?)?$");
>+  }
>+});
>+const _duration = dart.privateName(core, "_duration");
>+core.Duration = class Duration extends core.Object {
>+  ['+'](other) {
>+    return new core.Duration._microseconds(dart.notNull(this[_duration]) + dart.notNull(other[_duration]));
>+  }
>+  ['-'](other) {
>+    return new core.Duration._microseconds(dart.notNull(this[_duration]) - dart.notNull(other[_duration]));
>+  }
>+  ['*'](factor) {
>+    return new core.Duration._microseconds((dart.notNull(this[_duration]) * dart.notNull(factor))[$round]());
>+  }
>+  ['~/'](quotient) {
>+    if (quotient === 0) dart.throw(new core.IntegerDivisionByZeroException.new());
>+    return new core.Duration._microseconds((dart.notNull(this[_duration]) / dart.notNull(quotient))[$truncate]());
>+  }
>+  ['<'](other) {
>+    return dart.notNull(this[_duration]) < dart.notNull(other[_duration]);
>+  }
>+  ['>'](other) {
>+    return dart.notNull(this[_duration]) > dart.notNull(other[_duration]);
>+  }
>+  ['<='](other) {
>+    return dart.notNull(this[_duration]) <= dart.notNull(other[_duration]);
>+  }
>+  ['>='](other) {
>+    return dart.notNull(this[_duration]) >= dart.notNull(other[_duration]);
>+  }
>+  get inDays() {
>+    return (dart.notNull(this[_duration]) / core.Duration.microsecondsPerDay)[$truncate]();
>+  }
>+  get inHours() {
>+    return (dart.notNull(this[_duration]) / core.Duration.microsecondsPerHour)[$truncate]();
>+  }
>+  get inMinutes() {
>+    return (dart.notNull(this[_duration]) / core.Duration.microsecondsPerMinute)[$truncate]();
>+  }
>+  get inSeconds() {
>+    return (dart.notNull(this[_duration]) / core.Duration.microsecondsPerSecond)[$truncate]();
>+  }
>+  get inMilliseconds() {
>+    return (dart.notNull(this[_duration]) / core.Duration.microsecondsPerMillisecond)[$truncate]();
>+  }
>+  get inMicroseconds() {
>+    return this[_duration];
>+  }
>+  _equals(other) {
>+    return core.Duration.is(other) && this[_duration] == other.inMicroseconds;
>+  }
>+  get hashCode() {
>+    return dart.hashCode(this[_duration]);
>+  }
>+  compareTo(other) {
>+    core.Duration._check(other);
>+    return this[_duration][$compareTo](other[_duration]);
>+  }
>+  toString() {
>+    function sixDigits(n) {
>+      if (dart.notNull(n) >= 100000) return dart.str(n);
>+      if (dart.notNull(n) >= 10000) return "0" + dart.str(n);
>+      if (dart.notNull(n) >= 1000) return "00" + dart.str(n);
>+      if (dart.notNull(n) >= 100) return "000" + dart.str(n);
>+      if (dart.notNull(n) >= 10) return "0000" + dart.str(n);
>+      return "00000" + dart.str(n);
>+    }
>+    dart.fn(sixDigits, intToString());
>+    function twoDigits(n) {
>+      if (dart.notNull(n) >= 10) return dart.str(n);
>+      return "0" + dart.str(n);
>+    }
>+    dart.fn(twoDigits, intToString());
>+    if (dart.notNull(this.inMicroseconds) < 0) {
>+      return "-" + dart.str(this._negate());
>+    }
>+    let twoDigitMinutes = twoDigits(dart.asInt(this.inMinutes[$remainder](60)));
>+    let twoDigitSeconds = twoDigits(dart.asInt(this.inSeconds[$remainder](60)));
>+    let sixDigitUs = sixDigits(dart.asInt(this.inMicroseconds[$remainder](1000000)));
>+    return dart.str(this.inHours) + ":" + dart.str(twoDigitMinutes) + ":" + dart.str(twoDigitSeconds) + "." + dart.str(sixDigitUs);
>+  }
>+  get isNegative() {
>+    return dart.notNull(this[_duration]) < 0;
>+  }
>+  abs() {
>+    return new core.Duration._microseconds(this[_duration][$abs]());
>+  }
>+  _negate() {
>+    return new core.Duration._microseconds(0 - dart.notNull(this[_duration]));
>+  }
>+};
>+(core.Duration.new = function(opts) {
>+  let days = opts && 'days' in opts ? opts.days : 0;
>+  let hours = opts && 'hours' in opts ? opts.hours : 0;
>+  let minutes = opts && 'minutes' in opts ? opts.minutes : 0;
>+  let seconds = opts && 'seconds' in opts ? opts.seconds : 0;
>+  let milliseconds = opts && 'milliseconds' in opts ? opts.milliseconds : 0;
>+  let microseconds = opts && 'microseconds' in opts ? opts.microseconds : 0;
>+  core.Duration._microseconds.call(this, 86400000000 * dart.notNull(days) + 3600000000 * dart.notNull(hours) + 60000000 * dart.notNull(minutes) + 1000000 * dart.notNull(seconds) + 1000 * dart.notNull(milliseconds) + dart.notNull(microseconds));
>+}).prototype = core.Duration.prototype;
>+(core.Duration._microseconds = function(duration) {
>+  this[_duration] = duration;
>+}).prototype = core.Duration.prototype;
>+dart.addTypeTests(core.Duration);
>+core.Duration[dart.implements] = () => [ComparableOfDuration()];
>+dart.setMethodSignature(core.Duration, () => ({
>+  __proto__: dart.getMethods(core.Duration.__proto__),
>+  '+': dart.fnType(core.Duration, [core.Duration]),
>+  '-': dart.fnType(core.Duration, [core.Duration]),
>+  '*': dart.fnType(core.Duration, [core.num]),
>+  '~/': dart.fnType(core.Duration, [core.int]),
>+  '<': dart.fnType(core.bool, [core.Duration]),
>+  '>': dart.fnType(core.bool, [core.Duration]),
>+  '<=': dart.fnType(core.bool, [core.Duration]),
>+  '>=': dart.fnType(core.bool, [core.Duration]),
>+  compareTo: dart.fnType(core.int, [core.Object]),
>+  [$compareTo]: dart.fnType(core.int, [core.Object]),
>+  abs: dart.fnType(core.Duration, []),
>+  _negate: dart.fnType(core.Duration, [])
>+}));
>+dart.setGetterSignature(core.Duration, () => ({
>+  __proto__: dart.getGetters(core.Duration.__proto__),
>+  inDays: core.int,
>+  inHours: core.int,
>+  inMinutes: core.int,
>+  inSeconds: core.int,
>+  inMilliseconds: core.int,
>+  inMicroseconds: core.int,
>+  isNegative: core.bool
>+}));
>+dart.setLibraryUri(core.Duration, "dart:core");
>+dart.setFieldSignature(core.Duration, () => ({
>+  __proto__: dart.getFields(core.Duration.__proto__),
>+  [_duration]: dart.finalFieldType(core.int)
>+}));
>+dart.defineExtensionMethods(core.Duration, ['_equals', 'compareTo', 'toString']);
>+dart.defineExtensionAccessors(core.Duration, ['hashCode']);
>+dart.defineLazy(core.Duration, {
>+  /*core.Duration.microsecondsPerMillisecond*/get microsecondsPerMillisecond() {
>+    return 1000;
>+  },
>+  /*core.Duration.millisecondsPerSecond*/get millisecondsPerSecond() {
>+    return 1000;
>+  },
>+  /*core.Duration.secondsPerMinute*/get secondsPerMinute() {
>+    return 60;
>+  },
>+  /*core.Duration.minutesPerHour*/get minutesPerHour() {
>+    return 60;
>+  },
>+  /*core.Duration.hoursPerDay*/get hoursPerDay() {
>+    return 24;
>+  },
>+  /*core.Duration.microsecondsPerSecond*/get microsecondsPerSecond() {
>+    return 1000 * 1000;
>+  },
>+  /*core.Duration.microsecondsPerMinute*/get microsecondsPerMinute() {
>+    return 1000000 * 60;
>+  },
>+  /*core.Duration.microsecondsPerHour*/get microsecondsPerHour() {
>+    return 60000000 * 60;
>+  },
>+  /*core.Duration.microsecondsPerDay*/get microsecondsPerDay() {
>+    return 3600000000 * 24;
>+  },
>+  /*core.Duration.millisecondsPerMinute*/get millisecondsPerMinute() {
>+    return 1000 * 60;
>+  },
>+  /*core.Duration.millisecondsPerHour*/get millisecondsPerHour() {
>+    return 60000 * 60;
>+  },
>+  /*core.Duration.millisecondsPerDay*/get millisecondsPerDay() {
>+    return 3600000 * 24;
>+  },
>+  /*core.Duration.secondsPerHour*/get secondsPerHour() {
>+    return 60 * 60;
>+  },
>+  /*core.Duration.secondsPerDay*/get secondsPerDay() {
>+    return 3600 * 24;
>+  },
>+  /*core.Duration.minutesPerDay*/get minutesPerDay() {
>+    return 60 * 24;
>+  },
>+  /*core.Duration.zero*/get zero() {
>+    return dart.const(new core.Duration.new({seconds: 0}));
>+  }
>+});
>+core.TypeError = class TypeError extends core.AssertionError {};
>+(core.TypeError.new = function() {
>+  core.TypeError.__proto__.new.call(this);
>+}).prototype = core.TypeError.prototype;
>+dart.addTypeTests(core.TypeError);
>+dart.setLibraryUri(core.TypeError, "dart:core");
>+core.CastError = class CastError extends core.Error {};
>+(core.CastError.new = function() {
>+  core.CastError.__proto__.new.call(this);
>+}).prototype = core.CastError.prototype;
>+dart.addTypeTests(core.CastError);
>+dart.setLibraryUri(core.CastError, "dart:core");
>+core.NullThrownError = class NullThrownError extends core.Error {
>+  toString() {
>+    return "Throw of null.";
>+  }
>+};
>+(core.NullThrownError.new = function() {
>+  core.NullThrownError.__proto__.new.call(this);
>+}).prototype = core.NullThrownError.prototype;
>+dart.addTypeTests(core.NullThrownError);
>+dart.setLibraryUri(core.NullThrownError, "dart:core");
>+dart.defineExtensionMethods(core.NullThrownError, ['toString']);
>+const _hasValue = dart.privateName(core, "_hasValue");
>+const _errorName = dart.privateName(core, "_errorName");
>+const _errorExplanation = dart.privateName(core, "_errorExplanation");
>+core.ArgumentError = class ArgumentError extends core.Error {
>+  get invalidValue() {
>+    return this[invalidValue];
>+  }
>+  set invalidValue(value) {
>+    super.invalidValue = value;
>+  }
>+  get name() {
>+    return this[name$1];
>+  }
>+  set name(value) {
>+    super.name = value;
>+  }
>+  get message() {
>+    return this[message$2];
>+  }
>+  set message(value) {
>+    super.message = value;
>+  }
>+  static checkNotNull(argument, name) {
>+    if (name === void 0) name = null;
>+    if (argument == null) dart.throw(new core.ArgumentError.notNull(name));
>+  }
>+  get [_errorName]() {
>+    return "Invalid argument" + (!dart.test(this[_hasValue]) ? "(s)" : "");
>+  }
>+  get [_errorExplanation]() {
>+    return "";
>+  }
>+  toString() {
>+    let nameString = "";
>+    if (this[$name] != null) {
>+      nameString = " (" + dart.str(this[$name]) + ")";
>+    }
>+    let message = this[$message] == null ? "" : ": " + dart.str(this[$message]);
>+    let prefix = dart.str(this[_errorName]) + nameString + message;
>+    if (!dart.test(this[_hasValue])) return prefix;
>+    let explanation = this[_errorExplanation];
>+    let errorValue = core.Error.safeToString(this[$invalidValue]);
>+    return prefix + dart.str(explanation) + ": " + dart.str(errorValue);
>+  }
>+};
>+(core.ArgumentError.new = function(message) {
>+  if (message === void 0) message = null;
>+  this[message$2] = message;
>+  this[invalidValue] = null;
>+  this[_hasValue] = false;
>+  this[name$1] = null;
>+  core.ArgumentError.__proto__.new.call(this);
>+}).prototype = core.ArgumentError.prototype;
>+(core.ArgumentError.value = function(value, name, message) {
>+  if (name === void 0) name = null;
>+  if (message === void 0) message = null;
>+  this[name$1] = name;
>+  this[message$2] = message;
>+  this[invalidValue] = value;
>+  this[_hasValue] = true;
>+  core.ArgumentError.__proto__.new.call(this);
>+}).prototype = core.ArgumentError.prototype;
>+(core.ArgumentError.notNull = function(name) {
>+  if (name === void 0) name = null;
>+  this[name$1] = name;
>+  this[_hasValue] = false;
>+  this[message$2] = "Must not be null";
>+  this[invalidValue] = null;
>+  core.ArgumentError.__proto__.new.call(this);
>+}).prototype = core.ArgumentError.prototype;
>+dart.addTypeTests(core.ArgumentError);
>+const invalidValue = Symbol("ArgumentError.invalidValue");
>+const name$1 = Symbol("ArgumentError.name");
>+const message$2 = Symbol("ArgumentError.message");
>+dart.setGetterSignature(core.ArgumentError, () => ({
>+  __proto__: dart.getGetters(core.ArgumentError.__proto__),
>+  [_errorName]: core.String,
>+  [_errorExplanation]: core.String
>+}));
>+dart.setLibraryUri(core.ArgumentError, "dart:core");
>+dart.setFieldSignature(core.ArgumentError, () => ({
>+  __proto__: dart.getFields(core.ArgumentError.__proto__),
>+  [_hasValue]: dart.finalFieldType(core.bool),
>+  invalidValue: dart.finalFieldType(dart.dynamic),
>+  name: dart.finalFieldType(core.String),
>+  message: dart.finalFieldType(dart.dynamic)
>+}));
>+dart.defineExtensionMethods(core.ArgumentError, ['toString']);
>+dart.defineExtensionAccessors(core.ArgumentError, ['invalidValue', 'name', 'message']);
>+core.RangeError = class RangeError extends core.ArgumentError {
>+  get start() {
>+    return this[start];
>+  }
>+  set start(value) {
>+    super.start = value;
>+  }
>+  get end() {
>+    return this[end];
>+  }
>+  set end(value) {
>+    super.end = value;
>+  }
>+  static index(index, indexable, name, message, length) {
>+    return new core.IndexError.new(index, indexable, name, message, length);
>+  }
>+  static checkValueInInterval(value, minValue, maxValue, name, message) {
>+    if (name === void 0) name = null;
>+    if (message === void 0) message = null;
>+    if (dart.notNull(value) < dart.notNull(minValue) || dart.notNull(value) > dart.notNull(maxValue)) {
>+      dart.throw(new core.RangeError.range(value, minValue, maxValue, name, message));
>+    }
>+  }
>+  static checkValidIndex(index, indexable, name, length, message) {
>+    if (name === void 0) name = null;
>+    if (length === void 0) length = null;
>+    if (message === void 0) message = null;
>+    let t = length;
>+    t == null ? length = core.int._check(dart.dload(indexable, 'length')) : t;
>+    if (0 > dart.notNull(index) || dart.notNull(index) >= dart.notNull(length)) {
>+      let t$ = name;
>+      t$ == null ? name = "index" : t$;
>+      dart.throw(core.RangeError.index(index, indexable, name, message, length));
>+    }
>+  }
>+  static checkValidRange(start, end, length, startName, endName, message) {
>+    if (startName === void 0) startName = null;
>+    if (endName === void 0) endName = null;
>+    if (message === void 0) message = null;
>+    if (0 > dart.notNull(start) || dart.notNull(start) > dart.notNull(length)) {
>+      let t = startName;
>+      t == null ? startName = "start" : t;
>+      dart.throw(new core.RangeError.range(start, 0, length, startName, message));
>+    }
>+    if (end != null) {
>+      if (dart.notNull(start) > dart.notNull(end) || dart.notNull(end) > dart.notNull(length)) {
>+        let t$ = endName;
>+        t$ == null ? endName = "end" : t$;
>+        dart.throw(new core.RangeError.range(end, start, length, endName, message));
>+      }
>+      return end;
>+    }
>+    return length;
>+  }
>+  static checkNotNegative(value, name, message) {
>+    if (name === void 0) name = null;
>+    if (message === void 0) message = null;
>+    if (dart.notNull(value) < 0) dart.throw(new core.RangeError.range(value, 0, null, name, message));
>+  }
>+  get [_errorName]() {
>+    return "RangeError";
>+  }
>+  get [_errorExplanation]() {
>+    if (!dart.test(this[_hasValue])) dart.assertFailed(null, "dart:core/errors.dart", 355, 12, "_hasValue");
>+    let explanation = "";
>+    if (this.start == null) {
>+      if (this.end != null) {
>+        explanation = ": Not less than or equal to " + dart.str(this.end);
>+      }
>+    } else if (this.end == null) {
>+      explanation = ": Not greater than or equal to " + dart.str(this.start);
>+    } else if (dart.notNull(this.end) > dart.notNull(this.start)) {
>+      explanation = ": Not in range " + dart.str(this.start) + ".." + dart.str(this.end) + ", inclusive";
>+    } else if (dart.notNull(this.end) < dart.notNull(this.start)) {
>+      explanation = ": Valid value range is empty";
>+    } else {
>+      explanation = ": Only valid value is " + dart.str(this.start);
>+    }
>+    return explanation;
>+  }
>+};
>+(core.RangeError.new = function(message) {
>+  this[start] = null;
>+  this[end] = null;
>+  core.RangeError.__proto__.new.call(this, message);
>+}).prototype = core.RangeError.prototype;
>+(core.RangeError.value = function(value, name, message) {
>+  if (name === void 0) name = null;
>+  if (message === void 0) message = null;
>+  this[start] = null;
>+  this[end] = null;
>+  core.RangeError.__proto__.value.call(this, value, name, message != null ? message : "Value not in range");
>+}).prototype = core.RangeError.prototype;
>+(core.RangeError.range = function(invalidValue, minValue, maxValue, name, message) {
>+  if (name === void 0) name = null;
>+  if (message === void 0) message = null;
>+  this[start] = minValue;
>+  this[end] = maxValue;
>+  core.RangeError.__proto__.value.call(this, invalidValue, name, message != null ? message : "Invalid value");
>+}).prototype = core.RangeError.prototype;
>+dart.addTypeTests(core.RangeError);
>+const start = Symbol("RangeError.start");
>+const end = Symbol("RangeError.end");
>+dart.setLibraryUri(core.RangeError, "dart:core");
>+dart.setFieldSignature(core.RangeError, () => ({
>+  __proto__: dart.getFields(core.RangeError.__proto__),
>+  start: dart.finalFieldType(core.num),
>+  end: dart.finalFieldType(core.num)
>+}));
>+core.IndexError = class IndexError extends core.ArgumentError {
>+  get indexable() {
>+    return this[indexable$];
>+  }
>+  set indexable(value) {
>+    super.indexable = value;
>+  }
>+  get length() {
>+    return this[length$];
>+  }
>+  set length(value) {
>+    super.length = value;
>+  }
>+  get start() {
>+    return 0;
>+  }
>+  get end() {
>+    return dart.notNull(this.length) - 1;
>+  }
>+  get [_errorName]() {
>+    return "RangeError";
>+  }
>+  get [_errorExplanation]() {
>+    if (!dart.test(this[_hasValue])) dart.assertFailed(null, "dart:core/errors.dart", 411, 12, "_hasValue");
>+    let invalidValue = core.int._check(this.invalidValue);
>+    if (dart.notNull(invalidValue) < 0) {
>+      return ": index must not be negative";
>+    }
>+    if (this.length === 0) {
>+      return ": no indices are valid";
>+    }
>+    return ": index should be less than " + dart.str(this.length);
>+  }
>+};
>+(core.IndexError.new = function(invalidValue, indexable, name, message, length) {
>+  if (name === void 0) name = null;
>+  if (message === void 0) message = null;
>+  if (length === void 0) length = null;
>+  this[indexable$] = indexable;
>+  this[length$] = core.int._check((() => {
>+    let l = length;
>+    return l != null ? l : dart.dload(indexable, 'length');
>+  })());
>+  core.IndexError.__proto__.value.call(this, invalidValue, name, message != null ? message : "Index out of range");
>+}).prototype = core.IndexError.prototype;
>+dart.addTypeTests(core.IndexError);
>+const indexable$ = Symbol("IndexError.indexable");
>+const length$ = Symbol("IndexError.length");
>+core.IndexError[dart.implements] = () => [core.RangeError];
>+dart.setGetterSignature(core.IndexError, () => ({
>+  __proto__: dart.getGetters(core.IndexError.__proto__),
>+  start: core.int,
>+  end: core.int
>+}));
>+dart.setLibraryUri(core.IndexError, "dart:core");
>+dart.setFieldSignature(core.IndexError, () => ({
>+  __proto__: dart.getFields(core.IndexError.__proto__),
>+  indexable: dart.finalFieldType(dart.dynamic),
>+  length: dart.finalFieldType(core.int)
>+}));
>+const _className = dart.privateName(core, "_className");
>+core.AbstractClassInstantiationError = class AbstractClassInstantiationError extends core.Error {
>+  toString() {
>+    return "Cannot instantiate abstract class: '" + dart.str(this[_className]) + "'";
>+  }
>+};
>+(core.AbstractClassInstantiationError.new = function(className) {
>+  this[_className] = className;
>+  core.AbstractClassInstantiationError.__proto__.new.call(this);
>+}).prototype = core.AbstractClassInstantiationError.prototype;
>+dart.addTypeTests(core.AbstractClassInstantiationError);
>+dart.setLibraryUri(core.AbstractClassInstantiationError, "dart:core");
>+dart.setFieldSignature(core.AbstractClassInstantiationError, () => ({
>+  __proto__: dart.getFields(core.AbstractClassInstantiationError.__proto__),
>+  [_className]: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionMethods(core.AbstractClassInstantiationError, ['toString']);
>+const _receiver$ = dart.privateName(core, "_receiver");
>+const _memberName = dart.privateName(core, "_memberName");
>+const _arguments = dart.privateName(core, "_arguments");
>+const _namedArguments = dart.privateName(core, "_namedArguments");
>+const _existingArgumentNames = dart.privateName(core, "_existingArgumentNames");
>+const _invocation = dart.privateName(core, "_invocation");
>+core.NoSuchMethodError = class NoSuchMethodError extends core.Error {
>+  toString() {
>+    let sb = new core.StringBuffer.new("");
>+    let comma = "";
>+    if (this[_arguments] != null) {
>+      for (let argument of this[_arguments]) {
>+        sb.write(comma);
>+        sb.write(core.Error.safeToString(argument));
>+        comma = ", ";
>+      }
>+    }
>+    if (this[_namedArguments] != null) {
>+      this[_namedArguments][$forEach](dart.fn((key, value) => {
>+        sb.write(comma);
>+        sb.write(core._symbolToString(key));
>+        sb.write(": ");
>+        sb.write(core.Error.safeToString(value));
>+        comma = ", ";
>+      }, SymbolAnddynamicToNull()));
>+    }
>+    let memberName = core._symbolToString(this[_memberName]);
>+    let receiverText = core.Error.safeToString(this[_receiver$]);
>+    let actualParameters = dart.str(sb);
>+    let failureMessage = dart.InvocationImpl.is(this[_invocation]) ? dart.InvocationImpl.as(this[_invocation]).failureMessage : "method not found";
>+    if (this[_existingArgumentNames] == null) {
>+      return "NoSuchMethodError: '" + dart.str(memberName) + "'\n" + (dart.str(failureMessage) + "\n") + ("Receiver: " + dart.str(receiverText) + "\n") + ("Arguments: [" + actualParameters + "]");
>+    } else {
>+      let formalParameters = this[_existingArgumentNames][$join](", ");
>+      return "NoSuchMethodError: incorrect number of arguments passed to " + ("method named '" + dart.str(memberName) + "'\n") + ("Receiver: " + dart.str(receiverText) + "\n") + ("Tried calling: " + dart.str(memberName) + "(" + actualParameters + ")\n") + ("Found: " + dart.str(memberName) + "(" + dart.str(formalParameters) + ")");
>+    }
>+  }
>+};
>+(core.NoSuchMethodError.withInvocation = function(receiver, invocation) {
>+  this[_receiver$] = receiver;
>+  this[_memberName] = invocation.memberName;
>+  this[_arguments] = invocation.positionalArguments;
>+  this[_namedArguments] = invocation.namedArguments;
>+  this[_existingArgumentNames] = null;
>+  this[_invocation] = invocation;
>+  core.NoSuchMethodError.__proto__.new.call(this);
>+}).prototype = core.NoSuchMethodError.prototype;
>+(core.NoSuchMethodError.new = function(receiver, memberName, positionalArguments, namedArguments, existingArgumentNames) {
>+  if (existingArgumentNames === void 0) existingArgumentNames = null;
>+  this[_receiver$] = receiver;
>+  this[_memberName] = memberName;
>+  this[_arguments] = positionalArguments;
>+  this[_namedArguments] = namedArguments;
>+  this[_existingArgumentNames] = existingArgumentNames;
>+  this[_invocation] = null;
>+  core.NoSuchMethodError.__proto__.new.call(this);
>+}).prototype = core.NoSuchMethodError.prototype;
>+dart.addTypeTests(core.NoSuchMethodError);
>+dart.setLibraryUri(core.NoSuchMethodError, "dart:core");
>+dart.setFieldSignature(core.NoSuchMethodError, () => ({
>+  __proto__: dart.getFields(core.NoSuchMethodError.__proto__),
>+  [_receiver$]: dart.finalFieldType(core.Object),
>+  [_memberName]: dart.finalFieldType(core.Symbol),
>+  [_arguments]: dart.finalFieldType(core.List),
>+  [_namedArguments]: dart.finalFieldType(MapOfSymbol$dynamic()),
>+  [_existingArgumentNames]: dart.finalFieldType(core.List),
>+  [_invocation]: dart.finalFieldType(core.Invocation)
>+}));
>+dart.defineExtensionMethods(core.NoSuchMethodError, ['toString']);
>+core.UnsupportedError = class UnsupportedError extends core.Error {
>+  get message() {
>+    return this[message$3];
>+  }
>+  set message(value) {
>+    super.message = value;
>+  }
>+  toString() {
>+    return "Unsupported operation: " + dart.str(this.message);
>+  }
>+};
>+(core.UnsupportedError.new = function(message) {
>+  this[message$3] = message;
>+  core.UnsupportedError.__proto__.new.call(this);
>+}).prototype = core.UnsupportedError.prototype;
>+dart.addTypeTests(core.UnsupportedError);
>+const message$3 = Symbol("UnsupportedError.message");
>+dart.setLibraryUri(core.UnsupportedError, "dart:core");
>+dart.setFieldSignature(core.UnsupportedError, () => ({
>+  __proto__: dart.getFields(core.UnsupportedError.__proto__),
>+  message: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionMethods(core.UnsupportedError, ['toString']);
>+core.UnimplementedError = class UnimplementedError extends core.Error {
>+  get message() {
>+    return this[message$4];
>+  }
>+  set message(value) {
>+    super.message = value;
>+  }
>+  toString() {
>+    return this.message != null ? "UnimplementedError: " + dart.str(this.message) : "UnimplementedError";
>+  }
>+};
>+(core.UnimplementedError.new = function(message) {
>+  if (message === void 0) message = null;
>+  this[message$4] = message;
>+  core.UnimplementedError.__proto__.new.call(this);
>+}).prototype = core.UnimplementedError.prototype;
>+dart.addTypeTests(core.UnimplementedError);
>+const message$4 = Symbol("UnimplementedError.message");
>+core.UnimplementedError[dart.implements] = () => [core.UnsupportedError];
>+dart.setLibraryUri(core.UnimplementedError, "dart:core");
>+dart.setFieldSignature(core.UnimplementedError, () => ({
>+  __proto__: dart.getFields(core.UnimplementedError.__proto__),
>+  message: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionMethods(core.UnimplementedError, ['toString']);
>+core.StateError = class StateError extends core.Error {
>+  get message() {
>+    return this[message$5];
>+  }
>+  set message(value) {
>+    super.message = value;
>+  }
>+  toString() {
>+    return "Bad state: " + dart.str(this.message);
>+  }
>+};
>+(core.StateError.new = function(message) {
>+  this[message$5] = message;
>+  core.StateError.__proto__.new.call(this);
>+}).prototype = core.StateError.prototype;
>+dart.addTypeTests(core.StateError);
>+const message$5 = Symbol("StateError.message");
>+dart.setLibraryUri(core.StateError, "dart:core");
>+dart.setFieldSignature(core.StateError, () => ({
>+  __proto__: dart.getFields(core.StateError.__proto__),
>+  message: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionMethods(core.StateError, ['toString']);
>+core.ConcurrentModificationError = class ConcurrentModificationError extends core.Error {
>+  get modifiedObject() {
>+    return this[modifiedObject$];
>+  }
>+  set modifiedObject(value) {
>+    super.modifiedObject = value;
>+  }
>+  toString() {
>+    if (this.modifiedObject == null) {
>+      return "Concurrent modification during iteration.";
>+    }
>+    return "Concurrent modification during iteration: " + (dart.str(core.Error.safeToString(this.modifiedObject)) + ".");
>+  }
>+};
>+(core.ConcurrentModificationError.new = function(modifiedObject) {
>+  if (modifiedObject === void 0) modifiedObject = null;
>+  this[modifiedObject$] = modifiedObject;
>+  core.ConcurrentModificationError.__proto__.new.call(this);
>+}).prototype = core.ConcurrentModificationError.prototype;
>+dart.addTypeTests(core.ConcurrentModificationError);
>+const modifiedObject$ = Symbol("ConcurrentModificationError.modifiedObject");
>+dart.setLibraryUri(core.ConcurrentModificationError, "dart:core");
>+dart.setFieldSignature(core.ConcurrentModificationError, () => ({
>+  __proto__: dart.getFields(core.ConcurrentModificationError.__proto__),
>+  modifiedObject: dart.finalFieldType(core.Object)
>+}));
>+dart.defineExtensionMethods(core.ConcurrentModificationError, ['toString']);
>+core.OutOfMemoryError = class OutOfMemoryError extends core.Object {
>+  toString() {
>+    return "Out of Memory";
>+  }
>+  get stackTrace() {
>+    return null;
>+  }
>+};
>+(core.OutOfMemoryError.new = function() {
>+}).prototype = core.OutOfMemoryError.prototype;
>+dart.addTypeTests(core.OutOfMemoryError);
>+core.OutOfMemoryError[dart.implements] = () => [core.Error];
>+dart.setGetterSignature(core.OutOfMemoryError, () => ({
>+  __proto__: dart.getGetters(core.OutOfMemoryError.__proto__),
>+  stackTrace: core.StackTrace,
>+  [$stackTrace]: core.StackTrace
>+}));
>+dart.setLibraryUri(core.OutOfMemoryError, "dart:core");
>+dart.defineExtensionMethods(core.OutOfMemoryError, ['toString']);
>+dart.defineExtensionAccessors(core.OutOfMemoryError, ['stackTrace']);
>+core.StackOverflowError = class StackOverflowError extends core.Object {
>+  toString() {
>+    return "Stack Overflow";
>+  }
>+  get stackTrace() {
>+    return null;
>+  }
>+};
>+(core.StackOverflowError.new = function() {
>+}).prototype = core.StackOverflowError.prototype;
>+dart.addTypeTests(core.StackOverflowError);
>+core.StackOverflowError[dart.implements] = () => [core.Error];
>+dart.setGetterSignature(core.StackOverflowError, () => ({
>+  __proto__: dart.getGetters(core.StackOverflowError.__proto__),
>+  stackTrace: core.StackTrace,
>+  [$stackTrace]: core.StackTrace
>+}));
>+dart.setLibraryUri(core.StackOverflowError, "dart:core");
>+dart.defineExtensionMethods(core.StackOverflowError, ['toString']);
>+dart.defineExtensionAccessors(core.StackOverflowError, ['stackTrace']);
>+core.CyclicInitializationError = class CyclicInitializationError extends core.Error {
>+  get variableName() {
>+    return this[variableName$];
>+  }
>+  set variableName(value) {
>+    super.variableName = value;
>+  }
>+  toString() {
>+    return this.variableName == null ? "Reading static variable during its initialization" : "Reading static variable '" + dart.str(this.variableName) + "' during its initialization";
>+  }
>+};
>+(core.CyclicInitializationError.new = function(variableName) {
>+  if (variableName === void 0) variableName = null;
>+  this[variableName$] = variableName;
>+  core.CyclicInitializationError.__proto__.new.call(this);
>+}).prototype = core.CyclicInitializationError.prototype;
>+dart.addTypeTests(core.CyclicInitializationError);
>+const variableName$ = Symbol("CyclicInitializationError.variableName");
>+dart.setLibraryUri(core.CyclicInitializationError, "dart:core");
>+dart.setFieldSignature(core.CyclicInitializationError, () => ({
>+  __proto__: dart.getFields(core.CyclicInitializationError.__proto__),
>+  variableName: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionMethods(core.CyclicInitializationError, ['toString']);
>+core.Exception = class Exception extends core.Object {
>+  static new(message) {
>+    if (message === void 0) message = null;
>+    return new core._Exception.new(message);
>+  }
>+};
>+(core.Exception[dart.mixinNew] = function() {
>+}).prototype = core.Exception.prototype;
>+dart.addTypeTests(core.Exception);
>+dart.setLibraryUri(core.Exception, "dart:core");
>+core._Exception = class _Exception extends core.Object {
>+  toString() {
>+    if (this.message == null) return "Exception";
>+    return "Exception: " + dart.str(this.message);
>+  }
>+};
>+(core._Exception.new = function(message) {
>+  if (message === void 0) message = null;
>+  this.message = message;
>+}).prototype = core._Exception.prototype;
>+dart.addTypeTests(core._Exception);
>+core._Exception[dart.implements] = () => [core.Exception];
>+dart.setLibraryUri(core._Exception, "dart:core");
>+dart.setFieldSignature(core._Exception, () => ({
>+  __proto__: dart.getFields(core._Exception.__proto__),
>+  message: dart.finalFieldType(dart.dynamic)
>+}));
>+dart.defineExtensionMethods(core._Exception, ['toString']);
>+core.FormatException = class FormatException extends core.Object {
>+  get message() {
>+    return this[message$6];
>+  }
>+  set message(value) {
>+    super.message = value;
>+  }
>+  get source() {
>+    return this[source$];
>+  }
>+  set source(value) {
>+    super.source = value;
>+  }
>+  get offset() {
>+    return this[offset$];
>+  }
>+  set offset(value) {
>+    super.offset = value;
>+  }
>+  toString() {
>+    let report = "FormatException";
>+    if (this.message != null && "" !== this.message) {
>+      report = report + ": " + dart.str(this.message);
>+    }
>+    let offset = this.offset;
>+    let objectSource = this.source;
>+    if (typeof objectSource == 'string') {
>+      let source = objectSource;
>+      if (offset != null && (dart.notNull(offset) < 0 || dart.notNull(offset) > source.length)) {
>+        offset = null;
>+      }
>+      if (offset == null) {
>+        if (source.length > 78) {
>+          source = source[$substring](0, 75) + "...";
>+        }
>+        return report + "\n" + dart.str(source);
>+      }
>+      let lineNum = 1;
>+      let lineStart = 0;
>+      let previousCharWasCR = false;
>+      for (let i = 0; i < dart.notNull(offset); i++) {
>+        let char = source[$codeUnitAt](i);
>+        if (char === 10) {
>+          if (lineStart !== i || !previousCharWasCR) {
>+            lineNum++;
>+          }
>+          lineStart = i + 1;
>+          previousCharWasCR = false;
>+        } else if (char === 13) {
>+          lineNum++;
>+          lineStart = i + 1;
>+          previousCharWasCR = true;
>+        }
>+      }
>+      if (lineNum > 1) {
>+        report = report + (" (at line " + dart.str(lineNum) + ", character " + dart.str(dart.notNull(offset) - lineStart + 1) + ")\n");
>+      } else {
>+        report = report + (" (at character " + dart.str(dart.notNull(offset) + 1) + ")\n");
>+      }
>+      let lineEnd = source.length;
>+      for (let i = offset; dart.notNull(i) < source.length; i = dart.notNull(i) + 1) {
>+        let char = source[$codeUnitAt](i);
>+        if (char === 10 || char === 13) {
>+          lineEnd = i;
>+          break;
>+        }
>+      }
>+      let length = dart.notNull(lineEnd) - lineStart;
>+      let start = lineStart;
>+      let end = lineEnd;
>+      let prefix = "";
>+      let postfix = "";
>+      if (length > 78) {
>+        let index = dart.notNull(offset) - lineStart;
>+        if (index < 75) {
>+          end = start + 75;
>+          postfix = "...";
>+        } else if (dart.notNull(end) - dart.notNull(offset) < 75) {
>+          start = dart.notNull(end) - 75;
>+          prefix = "...";
>+        } else {
>+          start = dart.notNull(offset) - 36;
>+          end = dart.notNull(offset) + 36;
>+          prefix = postfix = "...";
>+        }
>+      }
>+      let slice = source[$substring](start, end);
>+      let markOffset = dart.notNull(offset) - start + prefix.length;
>+      return report + prefix + slice + postfix + "\n" + " "[$times](markOffset) + "^\n";
>+    } else {
>+      if (offset != null) {
>+        report = report + (" (at offset " + dart.str(offset) + ")");
>+      }
>+      return report;
>+    }
>+  }
>+};
>+(core.FormatException.new = function(message, source, offset) {
>+  if (message === void 0) message = "";
>+  if (source === void 0) source = null;
>+  if (offset === void 0) offset = null;
>+  this[message$6] = message;
>+  this[source$] = source;
>+  this[offset$] = offset;
>+}).prototype = core.FormatException.prototype;
>+dart.addTypeTests(core.FormatException);
>+const message$6 = Symbol("FormatException.message");
>+const source$ = Symbol("FormatException.source");
>+const offset$ = Symbol("FormatException.offset");
>+core.FormatException[dart.implements] = () => [core.Exception];
>+dart.setLibraryUri(core.FormatException, "dart:core");
>+dart.setFieldSignature(core.FormatException, () => ({
>+  __proto__: dart.getFields(core.FormatException.__proto__),
>+  message: dart.finalFieldType(core.String),
>+  source: dart.finalFieldType(dart.dynamic),
>+  offset: dart.finalFieldType(core.int)
>+}));
>+dart.defineExtensionMethods(core.FormatException, ['toString']);
>+core.IntegerDivisionByZeroException = class IntegerDivisionByZeroException extends core.Object {
>+  toString() {
>+    return "IntegerDivisionByZeroException";
>+  }
>+};
>+(core.IntegerDivisionByZeroException.new = function() {
>+}).prototype = core.IntegerDivisionByZeroException.prototype;
>+dart.addTypeTests(core.IntegerDivisionByZeroException);
>+core.IntegerDivisionByZeroException[dart.implements] = () => [core.Exception];
>+dart.setLibraryUri(core.IntegerDivisionByZeroException, "dart:core");
>+dart.defineExtensionMethods(core.IntegerDivisionByZeroException, ['toString']);
>+const _getKey = dart.privateName(core, "_getKey");
>+const _is_Expando_default = Symbol('_is_Expando_default');
>+core.Expando$ = dart.generic(T => {
>+  class Expando extends core.Object {
>+    get name() {
>+      return this[name$];
>+    }
>+    set name(value) {
>+      super.name = value;
>+    }
>+    toString() {
>+      return "Expando:" + dart.str(this.name);
>+    }
>+    _get(object) {
>+      let values = _js_helper.Primitives.getProperty(object, "expando$values");
>+      return T._check(values == null ? null : _js_helper.Primitives.getProperty(values, this[_getKey]()));
>+    }
>+    _set(object, value) {
>+      T._check(value);
>+      let values = _js_helper.Primitives.getProperty(object, "expando$values");
>+      if (values == null) {
>+        values = new core.Object.new();
>+        _js_helper.Primitives.setProperty(object, "expando$values", values);
>+      }
>+      _js_helper.Primitives.setProperty(values, this[_getKey](), value);
>+      return value;
>+    }
>+    [_getKey]() {
>+      let key = core.String._check(_js_helper.Primitives.getProperty(this, "expando$key"));
>+      if (key == null) {
>+        key = "expando$key$" + dart.str((() => {
>+          let x = core.Expando._keyCount;
>+          core.Expando._keyCount = dart.notNull(x) + 1;
>+          return x;
>+        })());
>+        _js_helper.Primitives.setProperty(this, "expando$key", key);
>+      }
>+      return key;
>+    }
>+  }
>+  (Expando.new = function(name) {
>+    if (name === void 0) name = null;
>+    this[name$] = name;
>+  }).prototype = Expando.prototype;
>+  dart.addTypeTests(Expando);
>+  Expando.prototype[_is_Expando_default] = true;
>+  const name$ = Symbol("Expando.name");
>+  dart.setMethodSignature(Expando, () => ({
>+    __proto__: dart.getMethods(Expando.__proto__),
>+    toString: dart.fnType(core.String, []),
>+    [$toString]: dart.fnType(core.String, []),
>+    _get: dart.fnType(T, [core.Object]),
>+    _set: dart.fnType(dart.void, [core.Object, core.Object]),
>+    [_getKey]: dart.fnType(core.String, [])
>+  }));
>+  dart.setLibraryUri(Expando, "dart:core");
>+  dart.setFieldSignature(Expando, () => ({
>+    __proto__: dart.getFields(Expando.__proto__),
>+    name: dart.finalFieldType(core.String)
>+  }));
>+  dart.defineExtensionMethods(Expando, ['toString']);
>+  return Expando;
>+});
>+core.Expando = core.Expando$();
>+dart.defineLazy(core.Expando, {
>+  /*core.Expando._KEY_PROPERTY_NAME*/get _KEY_PROPERTY_NAME() {
>+    return "expando$key";
>+  },
>+  /*core.Expando._EXPANDO_PROPERTY_NAME*/get _EXPANDO_PROPERTY_NAME() {
>+    return "expando$values";
>+  },
>+  /*core.Expando._keyCount*/get _keyCount() {
>+    return 0;
>+  },
>+  set _keyCount(_) {}
>+});
>+dart.addTypeTests(core.Expando, _is_Expando_default);
>+core.Function = class Function extends core.Object {
>+  static apply(f, positionalArguments, namedArguments) {
>+    if (namedArguments === void 0) namedArguments = null;
>+    let t = positionalArguments;
>+    t == null ? positionalArguments = [] : t;
>+    if (namedArguments != null && dart.test(namedArguments[$isNotEmpty])) {
>+      let map = {};
>+      namedArguments[$forEach](dart.fn((symbol, arg) => {
>+        map[core._symbolToString(symbol)] = arg;
>+      }, SymbolAnddynamicToNull()));
>+      return dart.dcall(f, positionalArguments, map);
>+    }
>+    return dart.dcall(f, positionalArguments);
>+  }
>+  static _toMangledNames(namedArguments) {
>+    let result = new (IdentityMapOfString$dynamic()).new();
>+    namedArguments[$forEach](dart.fn((symbol, value) => {
>+      result[$_set](core._symbolToString(symbol), value);
>+    }, SymbolAnddynamicToNull()));
>+    return result;
>+  }
>+};
>+(core.Function.new = function() {
>+}).prototype = core.Function.prototype;
>+core.Function.is = function is_Function(o) {
>+  return typeof o == "function";
>+};
>+core.Function.as = function as_Function(o) {
>+  if (typeof o == "function" || o == null) return o;
>+  return dart.as(o, core.Function, false);
>+};
>+core.Function._check = function check_Function(o) {
>+  if (typeof o == "function" || o == null) return o;
>+  return dart.as(o, core.Function, true);
>+};
>+dart.setLibraryUri(core.Function, "dart:core");
>+core.identical = function(a, b) {
>+  return a == null ? b == null : a === b;
>+};
>+core.identityHashCode = function(object) {
>+  if (object == null) return 0;
>+  let hash = object[dart.identityHashCode_];
>+  if (hash == null) {
>+    hash = Math.random() * 0x3fffffff | 0;
>+    object[dart.identityHashCode_] = hash;
>+  }
>+  return hash;
>+};
>+const _positional = dart.privateName(core, "_positional");
>+let const$53;
>+const _named = dart.privateName(core, "_named");
>+let const$54;
>+let const$55;
>+let const$56;
>+let const$57;
>+let const$58;
>+let const$59;
>+core._Invocation = class _Invocation extends core.Object {
>+  get positionalArguments() {
>+    return this[_positional] != null ? this[_positional] : const$57 || (const$57 = dart.constList([], core.Object));
>+  }
>+  get namedArguments() {
>+    return this[_named] != null ? this[_named] : const$58 || (const$58 = dart.constMap(core.Symbol, core.Object, []));
>+  }
>+  get isMethod() {
>+    return this[_named] != null;
>+  }
>+  get isGetter() {
>+    return this[_positional] == null;
>+  }
>+  get isSetter() {
>+    return this[_positional] != null && this[_named] == null;
>+  }
>+  get isAccessor() {
>+    return this[_named] == null;
>+  }
>+  static _ensureNonNullTypes(types) {
>+    if (types == null) return const$59 || (const$59 = dart.constList([], core.Type));
>+    for (let i = 0; i < dart.notNull(types[$length]); i++) {
>+      if (types[$_get](i) == null) {
>+        dart.throw(new core.ArgumentError.new("Type arguments must be non-null, was null at index " + dart.str(i) + "."));
>+      }
>+    }
>+    return types;
>+  }
>+  static _makeUnmodifiable(T, elements) {
>+    if (elements == null) return null;
>+    return core.List$(T).unmodifiable(elements);
>+  }
>+};
>+(core._Invocation.method = function(memberName, types, positional, named) {
>+  this.memberName = memberName;
>+  this.typeArguments = core._Invocation._ensureNonNullTypes(core._Invocation._makeUnmodifiable(core.Type, types));
>+  let l = core._Invocation._makeUnmodifiable(core.Object, positional);
>+  this[_positional] = l != null ? l : const$53 || (const$53 = dart.constList([], core.Object));
>+  this[_named] = named == null || dart.test(named[$isEmpty]) ? const$54 || (const$54 = dart.constMap(core.Symbol, core.Object, [])) : MapOfSymbol$Object().unmodifiable(named);
>+}).prototype = core._Invocation.prototype;
>+(core._Invocation.getter = function(memberName) {
>+  this.memberName = memberName;
>+  this.typeArguments = const$55 || (const$55 = dart.constList([], core.Type));
>+  this[_positional] = null;
>+  this[_named] = null;
>+}).prototype = core._Invocation.prototype;
>+(core._Invocation.setter = function(memberName, argument) {
>+  this.memberName = memberName;
>+  this.typeArguments = const$56 || (const$56 = dart.constList([], core.Type));
>+  this[_positional] = ListOfObject().unmodifiable([argument]);
>+  this[_named] = null;
>+}).prototype = core._Invocation.prototype;
>+dart.addTypeTests(core._Invocation);
>+core._Invocation[dart.implements] = () => [core.Invocation];
>+dart.setGetterSignature(core._Invocation, () => ({
>+  __proto__: dart.getGetters(core._Invocation.__proto__),
>+  positionalArguments: core.List,
>+  namedArguments: core.Map$(core.Symbol, dart.dynamic),
>+  isMethod: core.bool,
>+  isGetter: core.bool,
>+  isSetter: core.bool,
>+  isAccessor: core.bool
>+}));
>+dart.setLibraryUri(core._Invocation, "dart:core");
>+dart.setFieldSignature(core._Invocation, () => ({
>+  __proto__: dart.getFields(core._Invocation.__proto__),
>+  memberName: dart.finalFieldType(core.Symbol),
>+  typeArguments: dart.finalFieldType(ListOfType()),
>+  [_positional]: dart.finalFieldType(ListOfObject()),
>+  [_named]: dart.finalFieldType(MapOfSymbol$Object())
>+}));
>+const _generator = dart.privateName(core, "_generator");
>+const _is__GeneratorIterable_default = Symbol('_is__GeneratorIterable_default');
>+core._GeneratorIterable$ = dart.generic(E => {
>+  let intToE = () => (intToE = dart.constFn(dart.fnType(E, [core.int])))();
>+  class _GeneratorIterable extends _internal.ListIterable$(E) {
>+    get length() {
>+      return this[length$];
>+    }
>+    set length(value) {
>+      super.length = value;
>+    }
>+    elementAt(index) {
>+      core.RangeError.checkValidIndex(index, this);
>+      return this[_generator](index);
>+    }
>+    static _id(n) {
>+      return n;
>+    }
>+  }
>+  (_GeneratorIterable.new = function(length, generator) {
>+    this[length$] = length;
>+    this[_generator] = generator != null ? generator : intToE().as(dart.fn(core._GeneratorIterable._id, intToint()));
>+    _GeneratorIterable.__proto__.new.call(this);
>+  }).prototype = _GeneratorIterable.prototype;
>+  dart.addTypeTests(_GeneratorIterable);
>+  _GeneratorIterable.prototype[_is__GeneratorIterable_default] = true;
>+  const length$ = Symbol("_GeneratorIterable.length");
>+  dart.setMethodSignature(_GeneratorIterable, () => ({
>+    __proto__: dart.getMethods(_GeneratorIterable.__proto__),
>+    elementAt: dart.fnType(E, [core.int]),
>+    [$elementAt]: dart.fnType(E, [core.int])
>+  }));
>+  dart.setLibraryUri(_GeneratorIterable, "dart:core");
>+  dart.setFieldSignature(_GeneratorIterable, () => ({
>+    __proto__: dart.getFields(_GeneratorIterable.__proto__),
>+    length: dart.finalFieldType(core.int),
>+    [_generator]: dart.finalFieldType(intToE())
>+  }));
>+  dart.defineExtensionMethods(_GeneratorIterable, ['elementAt']);
>+  dart.defineExtensionAccessors(_GeneratorIterable, ['length']);
>+  return _GeneratorIterable;
>+});
>+core._GeneratorIterable = core._GeneratorIterable$();
>+dart.addTypeTests(core._GeneratorIterable, _is__GeneratorIterable_default);
>+const _is_BidirectionalIterator_default = Symbol('_is_BidirectionalIterator_default');
>+core.BidirectionalIterator$ = dart.generic(E => {
>+  let IteratorOfE = () => (IteratorOfE = dart.constFn(core.Iterator$(E)))();
>+  class BidirectionalIterator extends core.Object {}
>+  (BidirectionalIterator.new = function() {
>+  }).prototype = BidirectionalIterator.prototype;
>+  dart.addTypeTests(BidirectionalIterator);
>+  BidirectionalIterator.prototype[_is_BidirectionalIterator_default] = true;
>+  BidirectionalIterator[dart.implements] = () => [IteratorOfE()];
>+  dart.setLibraryUri(BidirectionalIterator, "dart:core");
>+  return BidirectionalIterator;
>+});
>+core.BidirectionalIterator = core.BidirectionalIterator$();
>+dart.addTypeTests(core.BidirectionalIterator, _is_BidirectionalIterator_default);
>+core.Map$ = dart.generic((K, V) => {
>+  let LinkedMapOfK$V = () => (LinkedMapOfK$V = dart.constFn(_js_helper.LinkedMap$(K, V)))();
>+  let LinkedHashMapOfK$V = () => (LinkedHashMapOfK$V = dart.constFn(collection.LinkedHashMap$(K, V)))();
>+  let MapOfK$V = () => (MapOfK$V = dart.constFn(core.Map$(K, V)))();
>+  let UnmodifiableMapViewOfK$V = () => (UnmodifiableMapViewOfK$V = dart.constFn(collection.UnmodifiableMapView$(K, V)))();
>+  class Map extends core.Object {
>+    static new() {
>+      return new (LinkedMapOfK$V()).new();
>+    }
>+    static from(other) {
>+      return LinkedHashMapOfK$V().from(other);
>+    }
>+    static of(other) {
>+      return LinkedHashMapOfK$V().of(other);
>+    }
>+    static unmodifiable(other) {
>+      return new (UnmodifiableMapViewOfK$V()).new(MapOfK$V().from(other));
>+    }
>+    static identity() {
>+      return LinkedHashMapOfK$V().identity();
>+    }
>+    static fromIterable(iterable, opts) {
>+      return LinkedHashMapOfK$V().fromIterable(iterable, opts);
>+    }
>+    static fromIterables(keys, values) {
>+      return LinkedHashMapOfK$V().fromIterables(keys, values);
>+    }
>+    static castFrom(K, V, K2, V2, source) {
>+      return new (_internal.CastMap$(K, V, K2, V2)).new(source);
>+    }
>+    static fromEntries(entries) {
>+      let _ = new (LinkedMapOfK$V()).new();
>+      _[$addEntries](entries);
>+      return _;
>+    }
>+  }
>+  (Map[dart.mixinNew] = function() {
>+  }).prototype = Map.prototype;
>+  dart.addTypeTests(Map);
>+  Map.prototype[dart.isMap] = true;
>+  dart.setLibraryUri(Map, "dart:core");
>+  return Map;
>+});
>+core.Map = core.Map$();
>+dart.addTypeTests(core.Map, dart.isMap);
>+const _is_MapEntry_default = Symbol('_is_MapEntry_default');
>+core.MapEntry$ = dart.generic((K, V) => {
>+  let MapEntryOfK$V = () => (MapEntryOfK$V = dart.constFn(core.MapEntry$(K, V)))();
>+  class MapEntry extends core.Object {
>+    get key() {
>+      return this[key$];
>+    }
>+    set key(value) {
>+      super.key = value;
>+    }
>+    get value() {
>+      return this[value$];
>+    }
>+    set value(value) {
>+      super.value = value;
>+    }
>+    static new(key, value) {
>+      return new (MapEntryOfK$V()).__(key, value);
>+    }
>+    toString() {
>+      return "MapEntry(" + dart.str(this.key) + ": " + dart.str(this.value) + ")";
>+    }
>+  }
>+  (MapEntry.__ = function(key, value) {
>+    this[key$] = key;
>+    this[value$] = value;
>+  }).prototype = MapEntry.prototype;
>+  dart.addTypeTests(MapEntry);
>+  MapEntry.prototype[_is_MapEntry_default] = true;
>+  const key$ = Symbol("MapEntry.key");
>+  const value$ = Symbol("MapEntry.value");
>+  dart.setMethodSignature(MapEntry, () => ({
>+    __proto__: dart.getMethods(MapEntry.__proto__),
>+    toString: dart.fnType(core.String, []),
>+    [$toString]: dart.fnType(core.String, [])
>+  }));
>+  dart.setLibraryUri(MapEntry, "dart:core");
>+  dart.setFieldSignature(MapEntry, () => ({
>+    __proto__: dart.getFields(MapEntry.__proto__),
>+    key: dart.finalFieldType(K),
>+    value: dart.finalFieldType(V)
>+  }));
>+  dart.defineExtensionMethods(MapEntry, ['toString']);
>+  return MapEntry;
>+});
>+core.MapEntry = core.MapEntry$();
>+dart.addTypeTests(core.MapEntry, _is_MapEntry_default);
>+core.Null = class Null extends core.Object {
>+  get hashCode() {
>+    return super.hashCode;
>+  }
>+  toString() {
>+    return "null";
>+  }
>+};
>+(core.Null[dart.mixinNew] = function() {
>+}).prototype = core.Null.prototype;
>+core.Null.is = function is_Null(o) {
>+  return o == null;
>+};
>+core.Null.as = function as_Null(o) {
>+  if (o == null) return o;
>+  return dart.as(o, core.Null, false);
>+};
>+core.Null._check = function check_Null(o) {
>+  if (o == null) return o;
>+  return dart.as(o, core.Null, true);
>+};
>+dart.setLibraryUri(core.Null, "dart:core");
>+dart.defineExtensionMethods(core.Null, ['toString']);
>+dart.defineExtensionAccessors(core.Null, ['hashCode']);
>+core.Pattern = class Pattern extends core.Object {};
>+(core.Pattern.new = function() {
>+}).prototype = core.Pattern.prototype;
>+dart.addTypeTests(core.Pattern);
>+dart.setLibraryUri(core.Pattern, "dart:core");
>+core.print = function(object) {
>+  let line = dart.str(object);
>+  if (_internal.printToZone == null) {
>+    _internal.printToConsole(line);
>+  } else {
>+    _internal.printToZone(line);
>+  }
>+};
>+core.RegExp = class RegExp extends core.Object {
>+  static new(source, opts) {
>+    let multiLine = opts && 'multiLine' in opts ? opts.multiLine : false;
>+    let caseSensitive = opts && 'caseSensitive' in opts ? opts.caseSensitive : true;
>+    let unicode = opts && 'unicode' in opts ? opts.unicode : false;
>+    let dotAll = opts && 'dotAll' in opts ? opts.dotAll : false;
>+    return new _js_helper.JSSyntaxRegExp.new(source, {multiLine: multiLine, caseSensitive: caseSensitive, unicode: unicode, dotAll: dotAll});
>+  }
>+  static escape(text) {
>+    return _js_helper.quoteStringForRegExp(text);
>+  }
>+};
>+(core.RegExp[dart.mixinNew] = function() {
>+}).prototype = core.RegExp.prototype;
>+dart.addTypeTests(core.RegExp);
>+core.RegExp[dart.implements] = () => [core.Pattern];
>+dart.setLibraryUri(core.RegExp, "dart:core");
>+const _is_Set_default = Symbol('_is_Set_default');
>+core.Set$ = dart.generic(E => {
>+  let LinkedHashSetOfE = () => (LinkedHashSetOfE = dart.constFn(collection.LinkedHashSet$(E)))();
>+  class Set extends _internal.EfficientLengthIterable$(E) {
>+    static new() {
>+      return LinkedHashSetOfE().new();
>+    }
>+    static identity() {
>+      return LinkedHashSetOfE().identity();
>+    }
>+    static from(elements) {
>+      return LinkedHashSetOfE().from(elements);
>+    }
>+    static of(elements) {
>+      return LinkedHashSetOfE().of(elements);
>+    }
>+    static castFrom(S, T, source, opts) {
>+      let newSet = opts && 'newSet' in opts ? opts.newSet : null;
>+      return new (_internal.CastSet$(S, T)).new(source, newSet);
>+    }
>+  }
>+  dart.addTypeTests(Set);
>+  Set.prototype[_is_Set_default] = true;
>+  dart.setLibraryUri(Set, "dart:core");
>+  return Set;
>+});
>+core.Set = core.Set$();
>+dart.addTypeTests(core.Set, _is_Set_default);
>+const _is_Sink_default = Symbol('_is_Sink_default');
>+core.Sink$ = dart.generic(T => {
>+  class Sink extends core.Object {}
>+  (Sink.new = function() {
>+  }).prototype = Sink.prototype;
>+  dart.addTypeTests(Sink);
>+  Sink.prototype[_is_Sink_default] = true;
>+  dart.setLibraryUri(Sink, "dart:core");
>+  return Sink;
>+});
>+core.Sink = core.Sink$();
>+dart.addTypeTests(core.Sink, _is_Sink_default);
>+core.StackTrace = class StackTrace extends core.Object {
>+  static fromString(stackTraceString) {
>+    return new core._StringStackTrace.new(stackTraceString);
>+  }
>+  static get current() {
>+    return dart.stackTrace(Error());
>+  }
>+};
>+(core.StackTrace.new = function() {
>+}).prototype = core.StackTrace.prototype;
>+dart.addTypeTests(core.StackTrace);
>+dart.setLibraryUri(core.StackTrace, "dart:core");
>+const _stackTrace = dart.privateName(core, "_stackTrace");
>+core._StringStackTrace = class _StringStackTrace extends core.Object {
>+  toString() {
>+    return this[_stackTrace];
>+  }
>+};
>+(core._StringStackTrace.new = function(stackTrace) {
>+  this[_stackTrace] = stackTrace;
>+}).prototype = core._StringStackTrace.prototype;
>+dart.addTypeTests(core._StringStackTrace);
>+core._StringStackTrace[dart.implements] = () => [core.StackTrace];
>+dart.setLibraryUri(core._StringStackTrace, "dart:core");
>+dart.setFieldSignature(core._StringStackTrace, () => ({
>+  __proto__: dart.getFields(core._StringStackTrace.__proto__),
>+  [_stackTrace]: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionMethods(core._StringStackTrace, ['toString']);
>+const _start$0 = dart.privateName(core, "_start");
>+const _stop = dart.privateName(core, "_stop");
>+core.Stopwatch = class Stopwatch extends core.Object {
>+  get frequency() {
>+    return core.Stopwatch._frequency;
>+  }
>+  start() {
>+    if (this[_stop] != null) {
>+      this[_start$0] = dart.notNull(this[_start$0]) + (dart.notNull(core.Stopwatch._now()) - dart.notNull(this[_stop]));
>+      this[_stop] = null;
>+    }
>+  }
>+  stop() {
>+    let t = this[_stop];
>+    t == null ? this[_stop] = core.Stopwatch._now() : t;
>+  }
>+  reset() {
>+    let l = this[_stop];
>+    this[_start$0] = l != null ? l : core.Stopwatch._now();
>+  }
>+  get elapsedTicks() {
>+    return dart.notNull((() => {
>+      let l = this[_stop];
>+      return l != null ? l : core.Stopwatch._now();
>+    })()) - dart.notNull(this[_start$0]);
>+  }
>+  get elapsed() {
>+    return new core.Duration.new({microseconds: this.elapsedMicroseconds});
>+  }
>+  get elapsedMicroseconds() {
>+    let ticks = this.elapsedTicks;
>+    if (core.Stopwatch._frequency === 1000000) return ticks;
>+    if (!(core.Stopwatch._frequency === 1000)) dart.assertFailed(null, "dart:core/stopwatch.dart", 108, 12, "_frequency == 1000");
>+    return dart.notNull(ticks) * 1000;
>+  }
>+  get elapsedMilliseconds() {
>+    let ticks = this.elapsedTicks;
>+    if (core.Stopwatch._frequency === 1000) return ticks;
>+    if (!(core.Stopwatch._frequency === 1000000)) dart.assertFailed(null, "dart:core/stopwatch.dart", 118, 12, "_frequency == 1000000");
>+    return (dart.notNull(ticks) / 1000)[$truncate]();
>+  }
>+  get isRunning() {
>+    return this[_stop] == null;
>+  }
>+  static _initTicker() {
>+    _js_helper.Primitives.initTicker();
>+    core.Stopwatch._frequency = _js_helper.Primitives.timerFrequency;
>+  }
>+  static _now() {
>+    return dart.asInt(_js_helper.Primitives.timerTicks());
>+  }
>+};
>+(core.Stopwatch.new = function() {
>+  this[_start$0] = 0;
>+  this[_stop] = 0;
>+  if (core.Stopwatch._frequency == null) core.Stopwatch._initTicker();
>+}).prototype = core.Stopwatch.prototype;
>+dart.addTypeTests(core.Stopwatch);
>+dart.setMethodSignature(core.Stopwatch, () => ({
>+  __proto__: dart.getMethods(core.Stopwatch.__proto__),
>+  start: dart.fnType(dart.void, []),
>+  stop: dart.fnType(dart.void, []),
>+  reset: dart.fnType(dart.void, [])
>+}));
>+dart.setGetterSignature(core.Stopwatch, () => ({
>+  __proto__: dart.getGetters(core.Stopwatch.__proto__),
>+  frequency: core.int,
>+  elapsedTicks: core.int,
>+  elapsed: core.Duration,
>+  elapsedMicroseconds: core.int,
>+  elapsedMilliseconds: core.int,
>+  isRunning: core.bool
>+}));
>+dart.setLibraryUri(core.Stopwatch, "dart:core");
>+dart.setFieldSignature(core.Stopwatch, () => ({
>+  __proto__: dart.getFields(core.Stopwatch.__proto__),
>+  [_start$0]: dart.fieldType(core.int),
>+  [_stop]: dart.fieldType(core.int)
>+}));
>+dart.defineLazy(core.Stopwatch, {
>+  /*core.Stopwatch._frequency*/get _frequency() {
>+    return null;
>+  },
>+  set _frequency(_) {}
>+});
>+core.Runes = class Runes extends core.Iterable$(core.int) {
>+  get string() {
>+    return this[string$];
>+  }
>+  set string(value) {
>+    super.string = value;
>+  }
>+  get iterator() {
>+    return new core.RuneIterator.new(this.string);
>+  }
>+  get last() {
>+    if (this.string.length === 0) {
>+      dart.throw(new core.StateError.new("No elements."));
>+    }
>+    let length = this.string.length;
>+    let code = this.string[$codeUnitAt](length - 1);
>+    if (dart.test(core._isTrailSurrogate(code)) && this.string.length > 1) {
>+      let previousCode = this.string[$codeUnitAt](length - 2);
>+      if (dart.test(core._isLeadSurrogate(previousCode))) {
>+        return core._combineSurrogatePair(previousCode, code);
>+      }
>+    }
>+    return code;
>+  }
>+};
>+(core.Runes.new = function(string) {
>+  this[string$] = string;
>+  core.Runes.__proto__.new.call(this);
>+}).prototype = core.Runes.prototype;
>+dart.addTypeTests(core.Runes);
>+const string$ = Symbol("Runes.string");
>+dart.setGetterSignature(core.Runes, () => ({
>+  __proto__: dart.getGetters(core.Runes.__proto__),
>+  iterator: core.RuneIterator,
>+  [$iterator]: core.RuneIterator,
>+  last: core.int,
>+  [$last]: core.int
>+}));
>+dart.setLibraryUri(core.Runes, "dart:core");
>+dart.setFieldSignature(core.Runes, () => ({
>+  __proto__: dart.getFields(core.Runes.__proto__),
>+  string: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionAccessors(core.Runes, ['iterator', 'last']);
>+core._isLeadSurrogate = function(code) {
>+  return (dart.notNull(code) & 64512) === 55296;
>+};
>+core._isTrailSurrogate = function(code) {
>+  return (dart.notNull(code) & 64512) === 56320;
>+};
>+core._combineSurrogatePair = function(start, end) {
>+  return 65536 + ((dart.notNull(start) & 1023) << 10) + (dart.notNull(end) & 1023);
>+};
>+const _position$ = dart.privateName(core, "_position");
>+const _nextPosition = dart.privateName(core, "_nextPosition");
>+const _currentCodePoint = dart.privateName(core, "_currentCodePoint");
>+const _checkSplitSurrogate = dart.privateName(core, "_checkSplitSurrogate");
>+core.RuneIterator = class RuneIterator extends core.Object {
>+  get string() {
>+    return this[string$0];
>+  }
>+  set string(value) {
>+    super.string = value;
>+  }
>+  [_checkSplitSurrogate](index) {
>+    if (dart.notNull(index) > 0 && dart.notNull(index) < this.string.length && dart.test(core._isLeadSurrogate(this.string[$codeUnitAt](dart.notNull(index) - 1))) && dart.test(core._isTrailSurrogate(this.string[$codeUnitAt](index)))) {
>+      dart.throw(new core.ArgumentError.new("Index inside surrogate pair: " + dart.str(index)));
>+    }
>+  }
>+  get rawIndex() {
>+    return this[_position$] != this[_nextPosition] ? this[_position$] : null;
>+  }
>+  set rawIndex(rawIndex) {
>+    core.RangeError.checkValidIndex(rawIndex, this.string, "rawIndex");
>+    this.reset(rawIndex);
>+    this.moveNext();
>+  }
>+  reset(rawIndex) {
>+    if (rawIndex === void 0) rawIndex = 0;
>+    core.RangeError.checkValueInInterval(rawIndex, 0, this.string.length, "rawIndex");
>+    this[_checkSplitSurrogate](rawIndex);
>+    this[_position$] = this[_nextPosition] = rawIndex;
>+    this[_currentCodePoint] = null;
>+  }
>+  get current() {
>+    return this[_currentCodePoint];
>+  }
>+  get currentSize() {
>+    return dart.notNull(this[_nextPosition]) - dart.notNull(this[_position$]);
>+  }
>+  get currentAsString() {
>+    if (this[_position$] == this[_nextPosition]) return null;
>+    if (dart.notNull(this[_position$]) + 1 === this[_nextPosition]) return this.string[$_get](this[_position$]);
>+    return this.string[$substring](this[_position$], this[_nextPosition]);
>+  }
>+  moveNext() {
>+    this[_position$] = this[_nextPosition];
>+    if (this[_position$] === this.string.length) {
>+      this[_currentCodePoint] = null;
>+      return false;
>+    }
>+    let codeUnit = this.string[$codeUnitAt](this[_position$]);
>+    let nextPosition = dart.notNull(this[_position$]) + 1;
>+    if (dart.test(core._isLeadSurrogate(codeUnit)) && nextPosition < this.string.length) {
>+      let nextCodeUnit = this.string[$codeUnitAt](nextPosition);
>+      if (dart.test(core._isTrailSurrogate(nextCodeUnit))) {
>+        this[_nextPosition] = nextPosition + 1;
>+        this[_currentCodePoint] = core._combineSurrogatePair(codeUnit, nextCodeUnit);
>+        return true;
>+      }
>+    }
>+    this[_nextPosition] = nextPosition;
>+    this[_currentCodePoint] = codeUnit;
>+    return true;
>+  }
>+  movePrevious() {
>+    this[_nextPosition] = this[_position$];
>+    if (this[_position$] === 0) {
>+      this[_currentCodePoint] = null;
>+      return false;
>+    }
>+    let position = dart.notNull(this[_position$]) - 1;
>+    let codeUnit = this.string[$codeUnitAt](position);
>+    if (dart.test(core._isTrailSurrogate(codeUnit)) && position > 0) {
>+      let prevCodeUnit = this.string[$codeUnitAt](position - 1);
>+      if (dart.test(core._isLeadSurrogate(prevCodeUnit))) {
>+        this[_position$] = position - 1;
>+        this[_currentCodePoint] = core._combineSurrogatePair(prevCodeUnit, codeUnit);
>+        return true;
>+      }
>+    }
>+    this[_position$] = position;
>+    this[_currentCodePoint] = codeUnit;
>+    return true;
>+  }
>+};
>+(core.RuneIterator.new = function(string) {
>+  this[_currentCodePoint] = null;
>+  this[string$0] = string;
>+  this[_position$] = 0;
>+  this[_nextPosition] = 0;
>+}).prototype = core.RuneIterator.prototype;
>+(core.RuneIterator.at = function(string, index) {
>+  this[_currentCodePoint] = null;
>+  this[string$0] = string;
>+  this[_position$] = index;
>+  this[_nextPosition] = index;
>+  core.RangeError.checkValueInInterval(index, 0, string.length);
>+  this[_checkSplitSurrogate](index);
>+}).prototype = core.RuneIterator.prototype;
>+dart.addTypeTests(core.RuneIterator);
>+const string$0 = Symbol("RuneIterator.string");
>+core.RuneIterator[dart.implements] = () => [BidirectionalIteratorOfint()];
>+dart.setMethodSignature(core.RuneIterator, () => ({
>+  __proto__: dart.getMethods(core.RuneIterator.__proto__),
>+  [_checkSplitSurrogate]: dart.fnType(dart.void, [core.int]),
>+  reset: dart.fnType(dart.void, [], [core.int]),
>+  moveNext: dart.fnType(core.bool, []),
>+  movePrevious: dart.fnType(core.bool, [])
>+}));
>+dart.setGetterSignature(core.RuneIterator, () => ({
>+  __proto__: dart.getGetters(core.RuneIterator.__proto__),
>+  rawIndex: core.int,
>+  current: core.int,
>+  currentSize: core.int,
>+  currentAsString: core.String
>+}));
>+dart.setSetterSignature(core.RuneIterator, () => ({
>+  __proto__: dart.getSetters(core.RuneIterator.__proto__),
>+  rawIndex: core.int
>+}));
>+dart.setLibraryUri(core.RuneIterator, "dart:core");
>+dart.setFieldSignature(core.RuneIterator, () => ({
>+  __proto__: dart.getFields(core.RuneIterator.__proto__),
>+  string: dart.finalFieldType(core.String),
>+  [_position$]: dart.fieldType(core.int),
>+  [_nextPosition]: dart.fieldType(core.int),
>+  [_currentCodePoint]: dart.fieldType(core.int)
>+}));
>+core.Symbol = class Symbol extends core.Object {
>+  static new(name) {
>+    return new _internal.Symbol.new(name);
>+  }
>+};
>+(core.Symbol[dart.mixinNew] = function() {
>+}).prototype = core.Symbol.prototype;
>+dart.addTypeTests(core.Symbol);
>+dart.setLibraryUri(core.Symbol, "dart:core");
>+dart.defineLazy(core.Symbol, {
>+  /*core.Symbol.unaryMinus*/get unaryMinus() {
>+    return dart.const(core.Symbol.new("unary-"));
>+  },
>+  /*core.Symbol.empty*/get empty() {
>+    return dart.const(core.Symbol.new(""));
>+  }
>+});
>+dart.defineLazy(core, {
>+  /*core._SPACE*/get _SPACE() {
>+    return 32;
>+  },
>+  /*core._PERCENT*/get _PERCENT() {
>+    return 37;
>+  },
>+  /*core._AMPERSAND*/get _AMPERSAND() {
>+    return 38;
>+  },
>+  /*core._PLUS*/get _PLUS() {
>+    return 43;
>+  },
>+  /*core._DOT*/get _DOT() {
>+    return 46;
>+  },
>+  /*core._SLASH*/get _SLASH() {
>+    return 47;
>+  },
>+  /*core._COLON*/get _COLON() {
>+    return 58;
>+  },
>+  /*core._EQUALS*/get _EQUALS() {
>+    return 61;
>+  },
>+  /*core._UPPER_CASE_A*/get _UPPER_CASE_A() {
>+    return 65;
>+  },
>+  /*core._UPPER_CASE_Z*/get _UPPER_CASE_Z() {
>+    return 90;
>+  },
>+  /*core._LEFT_BRACKET*/get _LEFT_BRACKET() {
>+    return 91;
>+  },
>+  /*core._BACKSLASH*/get _BACKSLASH() {
>+    return 92;
>+  },
>+  /*core._RIGHT_BRACKET*/get _RIGHT_BRACKET() {
>+    return 93;
>+  },
>+  /*core._LOWER_CASE_A*/get _LOWER_CASE_A() {
>+    return 97;
>+  },
>+  /*core._LOWER_CASE_F*/get _LOWER_CASE_F() {
>+    return 102;
>+  },
>+  /*core._LOWER_CASE_Z*/get _LOWER_CASE_Z() {
>+    return 122;
>+  },
>+  /*core._hexDigits*/get _hexDigits() {
>+    return "0123456789ABCDEF";
>+  }
>+});
>+core.Uri = class Uri extends core.Object {
>+  static get base() {
>+    let uri = _js_helper.Primitives.currentUri();
>+    if (uri != null) return core.Uri.parse(uri);
>+    dart.throw(new core.UnsupportedError.new("'Uri.base' is not supported"));
>+  }
>+  static new(opts) {
>+    return core._Uri.new(opts);
>+  }
>+  static http(authority, unencodedPath, queryParameters) {
>+    return core._Uri.http(authority, unencodedPath, queryParameters);
>+  }
>+  static https(authority, unencodedPath, queryParameters) {
>+    return core._Uri.https(authority, unencodedPath, queryParameters);
>+  }
>+  static file(path, opts) {
>+    return core._Uri.file(path, opts);
>+  }
>+  static directory(path, opts) {
>+    return core._Uri.directory(path, opts);
>+  }
>+  static dataFromString(content, opts) {
>+    let mimeType = opts && 'mimeType' in opts ? opts.mimeType : null;
>+    let encoding = opts && 'encoding' in opts ? opts.encoding : null;
>+    let parameters = opts && 'parameters' in opts ? opts.parameters : null;
>+    let base64 = opts && 'base64' in opts ? opts.base64 : false;
>+    let data = core.UriData.fromString(content, {mimeType: mimeType, encoding: encoding, parameters: parameters, base64: base64});
>+    return data.uri;
>+  }
>+  static dataFromBytes(bytes, opts) {
>+    let mimeType = opts && 'mimeType' in opts ? opts.mimeType : "application/octet-stream";
>+    let parameters = opts && 'parameters' in opts ? opts.parameters : null;
>+    let percentEncoded = opts && 'percentEncoded' in opts ? opts.percentEncoded : false;
>+    let data = core.UriData.fromBytes(bytes, {mimeType: mimeType, parameters: parameters, percentEncoded: percentEncoded});
>+    return data.uri;
>+  }
>+  get hasScheme() {
>+    return this.scheme[$isNotEmpty];
>+  }
>+  static parse(uri, start, end) {
>+    if (start === void 0) start = 0;
>+    if (end === void 0) end = null;
>+    let t = end;
>+    t == null ? end = uri.length : t;
>+    if (dart.notNull(end) >= dart.notNull(start) + 5) {
>+      let dataDelta = core._startsWithData(uri, start);
>+      if (dataDelta === 0) {
>+        if (dart.notNull(start) > 0 || dart.notNull(end) < uri.length) uri = uri[$substring](start, end);
>+        return core.UriData._parse(uri, 5, null).uri;
>+      } else if (dataDelta === 32) {
>+        return core.UriData._parse(uri[$substring](dart.notNull(start) + 5, end), 0, null).uri;
>+      }
>+    }
>+    let indices = ListOfint().new(8);
>+    indices[$_set](0, 0);
>+    indices[$_set](1, dart.notNull(start) - 1);
>+    indices[$_set](2, dart.notNull(start) - 1);
>+    indices[$_set](7, dart.notNull(start) - 1);
>+    indices[$_set](3, start);
>+    indices[$_set](4, start);
>+    indices[$_set](5, end);
>+    indices[$_set](6, end);
>+    let state = core._scan(uri, start, end, 0, indices);
>+    if (dart.notNull(state) >= 14) {
>+      indices[$_set](7, end);
>+    }
>+    let schemeEnd = indices[$_get](1);
>+    if (dart.notNull(schemeEnd) >= dart.notNull(start)) {
>+      state = core._scan(uri, start, schemeEnd, 20, indices);
>+      if (state === 20) {
>+        indices[$_set](7, schemeEnd);
>+      }
>+    }
>+    let hostStart = dart.notNull(indices[$_get](2)) + 1;
>+    let portStart = indices[$_get](3);
>+    let pathStart = indices[$_get](4);
>+    let queryStart = indices[$_get](5);
>+    let fragmentStart = indices[$_get](6);
>+    let scheme = null;
>+    if (dart.notNull(fragmentStart) < dart.notNull(queryStart)) queryStart = fragmentStart;
>+    if (dart.notNull(pathStart) < hostStart) {
>+      pathStart = queryStart;
>+    } else if (dart.notNull(pathStart) <= dart.notNull(schemeEnd)) {
>+      pathStart = dart.notNull(schemeEnd) + 1;
>+    }
>+    if (dart.notNull(portStart) < hostStart) portStart = pathStart;
>+    if (!(hostStart === start || dart.notNull(schemeEnd) <= hostStart)) dart.assertFailed(null, "dart:core/uri.dart", 875, 12, "hostStart == start || schemeEnd <= hostStart");
>+    if (!(hostStart <= dart.notNull(portStart))) dart.assertFailed(null, "dart:core/uri.dart", 876, 12, "hostStart <= portStart");
>+    if (!(dart.notNull(schemeEnd) <= dart.notNull(pathStart))) dart.assertFailed(null, "dart:core/uri.dart", 877, 12, "schemeEnd <= pathStart");
>+    if (!(dart.notNull(portStart) <= dart.notNull(pathStart))) dart.assertFailed(null, "dart:core/uri.dart", 878, 12, "portStart <= pathStart");
>+    if (!(dart.notNull(pathStart) <= dart.notNull(queryStart))) dart.assertFailed(null, "dart:core/uri.dart", 879, 12, "pathStart <= queryStart");
>+    if (!(dart.notNull(queryStart) <= dart.notNull(fragmentStart))) dart.assertFailed(null, "dart:core/uri.dart", 880, 12, "queryStart <= fragmentStart");
>+    let isSimple = dart.notNull(indices[$_get](7)) < dart.notNull(start);
>+    if (isSimple) {
>+      if (hostStart > dart.notNull(schemeEnd) + 3) {
>+        isSimple = false;
>+      } else if (dart.notNull(portStart) > dart.notNull(start) && dart.notNull(portStart) + 1 === pathStart) {
>+        isSimple = false;
>+      } else if (dart.notNull(queryStart) < dart.notNull(end) && queryStart === dart.notNull(pathStart) + 2 && uri[$startsWith]("..", pathStart) || dart.notNull(queryStart) > dart.notNull(pathStart) + 2 && uri[$startsWith]("/..", dart.notNull(queryStart) - 3)) {
>+        isSimple = false;
>+      } else {
>+        if (schemeEnd === dart.notNull(start) + 4) {
>+          if (uri[$startsWith]("file", start)) {
>+            scheme = "file";
>+            if (hostStart <= dart.notNull(start)) {
>+              let schemeAuth = "file://";
>+              let delta = 2;
>+              if (!uri[$startsWith]("/", pathStart)) {
>+                schemeAuth = "file:///";
>+                delta = 3;
>+              }
>+              uri = schemeAuth + uri[$substring](pathStart, end);
>+              schemeEnd = dart.notNull(schemeEnd) - dart.notNull(start);
>+              hostStart = 7;
>+              portStart = 7;
>+              pathStart = 7;
>+              queryStart = dart.notNull(queryStart) + (delta - dart.notNull(start));
>+              fragmentStart = dart.notNull(fragmentStart) + (delta - dart.notNull(start));
>+              start = 0;
>+              end = uri.length;
>+            } else if (pathStart == queryStart) {
>+              if (start === 0 && end === uri.length) {
>+                uri = uri[$replaceRange](pathStart, queryStart, "/");
>+                queryStart = dart.notNull(queryStart) + 1;
>+                fragmentStart = dart.notNull(fragmentStart) + 1;
>+                end = dart.notNull(end) + 1;
>+              } else {
>+                uri = uri[$substring](start, pathStart) + "/" + uri[$substring](queryStart, end);
>+                schemeEnd = dart.notNull(schemeEnd) - dart.notNull(start);
>+                hostStart = hostStart - dart.notNull(start);
>+                portStart = dart.notNull(portStart) - dart.notNull(start);
>+                pathStart = dart.notNull(pathStart) - dart.notNull(start);
>+                queryStart = dart.notNull(queryStart) + (1 - dart.notNull(start));
>+                fragmentStart = dart.notNull(fragmentStart) + (1 - dart.notNull(start));
>+                start = 0;
>+                end = uri.length;
>+              }
>+            }
>+          } else if (uri[$startsWith]("http", start)) {
>+            scheme = "http";
>+            if (dart.notNull(portStart) > dart.notNull(start) && dart.notNull(portStart) + 3 === pathStart && uri[$startsWith]("80", dart.notNull(portStart) + 1)) {
>+              if (start === 0 && end === uri.length) {
>+                uri = uri[$replaceRange](portStart, pathStart, "");
>+                pathStart = dart.notNull(pathStart) - 3;
>+                queryStart = dart.notNull(queryStart) - 3;
>+                fragmentStart = dart.notNull(fragmentStart) - 3;
>+                end = dart.notNull(end) - 3;
>+              } else {
>+                uri = uri[$substring](start, portStart) + uri[$substring](pathStart, end);
>+                schemeEnd = dart.notNull(schemeEnd) - dart.notNull(start);
>+                hostStart = hostStart - dart.notNull(start);
>+                portStart = dart.notNull(portStart) - dart.notNull(start);
>+                pathStart = dart.notNull(pathStart) - (3 + dart.notNull(start));
>+                queryStart = dart.notNull(queryStart) - (3 + dart.notNull(start));
>+                fragmentStart = dart.notNull(fragmentStart) - (3 + dart.notNull(start));
>+                start = 0;
>+                end = uri.length;
>+              }
>+            }
>+          }
>+        } else if (schemeEnd === dart.notNull(start) + 5 && uri[$startsWith]("https", start)) {
>+          scheme = "https";
>+          if (dart.notNull(portStart) > dart.notNull(start) && dart.notNull(portStart) + 4 === pathStart && uri[$startsWith]("443", dart.notNull(portStart) + 1)) {
>+            if (start === 0 && end === uri.length) {
>+              uri = uri[$replaceRange](portStart, pathStart, "");
>+              pathStart = dart.notNull(pathStart) - 4;
>+              queryStart = dart.notNull(queryStart) - 4;
>+              fragmentStart = dart.notNull(fragmentStart) - 4;
>+              end = dart.notNull(end) - 3;
>+            } else {
>+              uri = uri[$substring](start, portStart) + uri[$substring](pathStart, end);
>+              schemeEnd = dart.notNull(schemeEnd) - dart.notNull(start);
>+              hostStart = hostStart - dart.notNull(start);
>+              portStart = dart.notNull(portStart) - dart.notNull(start);
>+              pathStart = dart.notNull(pathStart) - (4 + dart.notNull(start));
>+              queryStart = dart.notNull(queryStart) - (4 + dart.notNull(start));
>+              fragmentStart = dart.notNull(fragmentStart) - (4 + dart.notNull(start));
>+              start = 0;
>+              end = uri.length;
>+            }
>+          }
>+        }
>+      }
>+    }
>+    if (isSimple) {
>+      if (dart.notNull(start) > 0 || dart.notNull(end) < uri.length) {
>+        uri = uri[$substring](start, end);
>+        schemeEnd = dart.notNull(schemeEnd) - dart.notNull(start);
>+        hostStart = hostStart - dart.notNull(start);
>+        portStart = dart.notNull(portStart) - dart.notNull(start);
>+        pathStart = dart.notNull(pathStart) - dart.notNull(start);
>+        queryStart = dart.notNull(queryStart) - dart.notNull(start);
>+        fragmentStart = dart.notNull(fragmentStart) - dart.notNull(start);
>+      }
>+      return new core._SimpleUri.new(uri, schemeEnd, hostStart, portStart, pathStart, queryStart, fragmentStart, scheme);
>+    }
>+    return core._Uri.notSimple(uri, start, end, schemeEnd, hostStart, portStart, pathStart, queryStart, fragmentStart, scheme);
>+  }
>+  static tryParse(uri, start, end) {
>+    if (start === void 0) start = 0;
>+    if (end === void 0) end = null;
>+    try {
>+      return core.Uri.parse(uri, start, end);
>+    } catch (e) {
>+      let ex = dart.getThrown(e);
>+      if (core.FormatException.is(ex)) {
>+        return null;
>+      } else
>+        throw e;
>+    }
>+  }
>+  static encodeComponent(component) {
>+    return core._Uri._uriEncode(core._Uri._unreserved2396Table, component, convert.utf8, false);
>+  }
>+  static encodeQueryComponent(component, opts) {
>+    let encoding = opts && 'encoding' in opts ? opts.encoding : convert.utf8;
>+    return core._Uri._uriEncode(core._Uri._unreservedTable, component, encoding, true);
>+  }
>+  static decodeComponent(encodedComponent) {
>+    return core._Uri._uriDecode(encodedComponent, 0, encodedComponent.length, convert.utf8, false);
>+  }
>+  static decodeQueryComponent(encodedComponent, opts) {
>+    let encoding = opts && 'encoding' in opts ? opts.encoding : convert.utf8;
>+    return core._Uri._uriDecode(encodedComponent, 0, encodedComponent.length, encoding, true);
>+  }
>+  static encodeFull(uri) {
>+    return core._Uri._uriEncode(core._Uri._encodeFullTable, uri, convert.utf8, false);
>+  }
>+  static decodeFull(uri) {
>+    return core._Uri._uriDecode(uri, 0, uri.length, convert.utf8, false);
>+  }
>+  static splitQueryString(query, opts) {
>+    let encoding = opts && 'encoding' in opts ? opts.encoding : convert.utf8;
>+    return MapOfString$String()._check(query[$split]("&")[$fold](MapOfString$String(), new (IdentityMapOfString$String()).new(), dart.fn((map, element) => {
>+      let index = element[$indexOf]("=");
>+      if (index === -1) {
>+        if (element !== "") {
>+          map[$_set](core.Uri.decodeQueryComponent(element, {encoding: encoding}), "");
>+        }
>+      } else if (index !== 0) {
>+        let key = element[$substring](0, index);
>+        let value = element[$substring](index + 1);
>+        map[$_set](core.Uri.decodeQueryComponent(key, {encoding: encoding}), core.Uri.decodeQueryComponent(value, {encoding: encoding}));
>+      }
>+      return map;
>+    }, MapOfString$StringAndStringToMapOfString$String())));
>+  }
>+  static parseIPv4Address(host) {
>+    return core.Uri._parseIPv4Address(host, 0, host.length);
>+  }
>+  static _parseIPv4Address(host, start, end) {
>+    function error(msg, position) {
>+      dart.throw(new core.FormatException.new("Illegal IPv4 address, " + dart.str(msg), host, position));
>+    }
>+    dart.fn(error, StringAndintTovoid());
>+    let result = typed_data.Uint8List.new(4);
>+    let partIndex = 0;
>+    let partStart = start;
>+    for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
>+      let char = host[$codeUnitAt](i);
>+      if (char !== 46) {
>+        if ((char ^ 48) >>> 0 > 9) {
>+          error("invalid character", i);
>+        }
>+      } else {
>+        if (partIndex === 3) {
>+          error("IPv4 address should contain exactly 4 parts", i);
>+        }
>+        let part = core.int.parse(host[$substring](partStart, i));
>+        if (dart.notNull(part) > 255) {
>+          error("each part must be in the range 0..255", partStart);
>+        }
>+        result[$_set](partIndex++, part);
>+        partStart = dart.notNull(i) + 1;
>+      }
>+    }
>+    if (partIndex !== 3) {
>+      error("IPv4 address should contain exactly 4 parts", end);
>+    }
>+    let part = core.int.parse(host[$substring](partStart, end));
>+    if (dart.notNull(part) > 255) {
>+      error("each part must be in the range 0..255", partStart);
>+    }
>+    result[$_set](partIndex, part);
>+    return result;
>+  }
>+  static parseIPv6Address(host, start, end) {
>+    if (start === void 0) start = 0;
>+    if (end === void 0) end = null;
>+    let t = end;
>+    t == null ? end = host.length : t;
>+    function error(msg, position) {
>+      if (position === void 0) position = null;
>+      dart.throw(new core.FormatException.new("Illegal IPv6 address, " + dart.str(msg), host, core.int._check(position)));
>+    }
>+    dart.fn(error, String__Tovoid());
>+    function parseHex(start, end) {
>+      if (dart.notNull(end) - dart.notNull(start) > 4) {
>+        error("an IPv6 part can only contain a maximum of 4 hex digits", start);
>+      }
>+      let value = core.int.parse(host[$substring](start, end), {radix: 16});
>+      if (dart.notNull(value) < 0 || dart.notNull(value) > 65535) {
>+        error("each part must be in the range of `0x0..0xFFFF`", start);
>+      }
>+      return value;
>+    }
>+    dart.fn(parseHex, intAndintToint());
>+    if (host.length < 2) error("address is too short");
>+    let parts = JSArrayOfint().of([]);
>+    let wildcardSeen = false;
>+    let seenDot = false;
>+    let partStart = start;
>+    for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
>+      let char = host[$codeUnitAt](i);
>+      if (char === 58) {
>+        if (i == start) {
>+          i = dart.notNull(i) + 1;
>+          if (host[$codeUnitAt](i) !== 58) {
>+            error("invalid start colon.", i);
>+          }
>+          partStart = i;
>+        }
>+        if (i == partStart) {
>+          if (wildcardSeen) {
>+            error("only one wildcard `::` is allowed", i);
>+          }
>+          wildcardSeen = true;
>+          parts[$add](-1);
>+        } else {
>+          parts[$add](parseHex(partStart, i));
>+        }
>+        partStart = dart.notNull(i) + 1;
>+      } else if (char === 46) {
>+        seenDot = true;
>+      }
>+    }
>+    if (parts[$length] === 0) error("too few parts");
>+    let atEnd = partStart == end;
>+    let isLastWildcard = parts[$last] === -1;
>+    if (atEnd && !isLastWildcard) {
>+      error("expected a part after last `:`", end);
>+    }
>+    if (!atEnd) {
>+      if (!seenDot) {
>+        parts[$add](parseHex(partStart, end));
>+      } else {
>+        let last = core.Uri._parseIPv4Address(host, partStart, end);
>+        parts[$add]((dart.notNull(last[$_get](0)) << 8 | dart.notNull(last[$_get](1))) >>> 0);
>+        parts[$add]((dart.notNull(last[$_get](2)) << 8 | dart.notNull(last[$_get](3))) >>> 0);
>+      }
>+    }
>+    if (wildcardSeen) {
>+      if (dart.notNull(parts[$length]) > 7) {
>+        error("an address with a wildcard must have less than 7 parts");
>+      }
>+    } else if (parts[$length] !== 8) {
>+      error("an address without a wildcard must contain exactly 8 parts");
>+    }
>+    let bytes = typed_data.Uint8List.new(16);
>+    for (let i = 0, index = 0; i < dart.notNull(parts[$length]); i++) {
>+      let value = parts[$_get](i);
>+      if (value === -1) {
>+        let wildCardLength = 9 - dart.notNull(parts[$length]);
>+        for (let j = 0; j < wildCardLength; j++) {
>+          bytes[$_set](index, 0);
>+          bytes[$_set](index + 1, 0);
>+          index = index + 2;
>+        }
>+      } else {
>+        bytes[$_set](index, value[$rightShift](8));
>+        bytes[$_set](index + 1, dart.notNull(value) & 255);
>+        index = index + 2;
>+      }
>+    }
>+    return bytes;
>+  }
>+};
>+(core.Uri[dart.mixinNew] = function() {
>+}).prototype = core.Uri.prototype;
>+dart.addTypeTests(core.Uri);
>+dart.setGetterSignature(core.Uri, () => ({
>+  __proto__: dart.getGetters(core.Uri.__proto__),
>+  hasScheme: core.bool
>+}));
>+dart.setLibraryUri(core.Uri, "dart:core");
>+const _userInfo = dart.privateName(core, "_userInfo");
>+const _host = dart.privateName(core, "_host");
>+const _port = dart.privateName(core, "_port");
>+const _query = dart.privateName(core, "_query");
>+const _fragment = dart.privateName(core, "_fragment");
>+const _pathSegments = dart.privateName(core, "_pathSegments");
>+const _text = dart.privateName(core, "_text");
>+const _hashCodeCache = dart.privateName(core, "_hashCodeCache");
>+const _queryParameters = dart.privateName(core, "_queryParameters");
>+const _queryParameterLists = dart.privateName(core, "_queryParameterLists");
>+const _writeAuthority = dart.privateName(core, "_writeAuthority");
>+let const$60;
>+const _mergePaths = dart.privateName(core, "_mergePaths");
>+const _toFilePath = dart.privateName(core, "_toFilePath");
>+const _isPathAbsolute = dart.privateName(core, "_isPathAbsolute");
>+const _initializeText = dart.privateName(core, "_initializeText");
>+core._Uri = class _Uri extends core.Object {
>+  static notSimple(uri, start, end, schemeEnd, hostStart, portStart, pathStart, queryStart, fragmentStart, scheme) {
>+    if (scheme == null) {
>+      scheme = "";
>+      if (dart.notNull(schemeEnd) > dart.notNull(start)) {
>+        scheme = core._Uri._makeScheme(uri, start, schemeEnd);
>+      } else if (schemeEnd == start) {
>+        core._Uri._fail(uri, start, "Invalid empty scheme");
>+      }
>+    }
>+    let userInfo = "";
>+    let host = null;
>+    let port = null;
>+    if (dart.notNull(hostStart) > dart.notNull(start)) {
>+      let userInfoStart = dart.notNull(schemeEnd) + 3;
>+      if (userInfoStart < dart.notNull(hostStart)) {
>+        userInfo = core._Uri._makeUserInfo(uri, userInfoStart, dart.notNull(hostStart) - 1);
>+      }
>+      host = core._Uri._makeHost(uri, hostStart, portStart, false);
>+      if (dart.notNull(portStart) + 1 < dart.notNull(pathStart)) {
>+        port = core.int.parse(uri[$substring](dart.notNull(portStart) + 1, pathStart), {onError: dart.fn(_ => {
>+            dart.throw(new core.FormatException.new("Invalid port", uri, dart.notNull(portStart) + 1));
>+          }, StringToNull())});
>+        port = core._Uri._makePort(port, scheme);
>+      }
>+    }
>+    let path = core._Uri._makePath(uri, pathStart, queryStart, null, scheme, host != null);
>+    let query = null;
>+    if (dart.notNull(queryStart) < dart.notNull(fragmentStart)) {
>+      query = core._Uri._makeQuery(uri, dart.notNull(queryStart) + 1, fragmentStart, null);
>+    }
>+    let fragment = null;
>+    if (dart.notNull(fragmentStart) < dart.notNull(end)) {
>+      fragment = core._Uri._makeFragment(uri, dart.notNull(fragmentStart) + 1, end);
>+    }
>+    return new core._Uri._internal(scheme, userInfo, host, port, path, query, fragment);
>+  }
>+  static new(opts) {
>+    let scheme = opts && 'scheme' in opts ? opts.scheme : null;
>+    let userInfo = opts && 'userInfo' in opts ? opts.userInfo : null;
>+    let host = opts && 'host' in opts ? opts.host : null;
>+    let port = opts && 'port' in opts ? opts.port : null;
>+    let path = opts && 'path' in opts ? opts.path : null;
>+    let pathSegments = opts && 'pathSegments' in opts ? opts.pathSegments : null;
>+    let query = opts && 'query' in opts ? opts.query : null;
>+    let queryParameters = opts && 'queryParameters' in opts ? opts.queryParameters : null;
>+    let fragment = opts && 'fragment' in opts ? opts.fragment : null;
>+    scheme = core._Uri._makeScheme(scheme, 0, core._stringOrNullLength(scheme));
>+    userInfo = core._Uri._makeUserInfo(userInfo, 0, core._stringOrNullLength(userInfo));
>+    host = core._Uri._makeHost(host, 0, core._stringOrNullLength(host), false);
>+    if (query === "") query = null;
>+    query = core._Uri._makeQuery(query, 0, core._stringOrNullLength(query), queryParameters);
>+    fragment = core._Uri._makeFragment(fragment, 0, core._stringOrNullLength(fragment));
>+    port = core._Uri._makePort(port, scheme);
>+    let isFile = scheme === "file";
>+    if (host == null && (userInfo[$isNotEmpty] || port != null || isFile)) {
>+      host = "";
>+    }
>+    let hasAuthority = host != null;
>+    path = core._Uri._makePath(path, 0, core._stringOrNullLength(path), pathSegments, scheme, hasAuthority);
>+    if (scheme[$isEmpty] && host == null && !path[$startsWith]("/")) {
>+      let allowScheme = scheme[$isNotEmpty] || host != null;
>+      path = core._Uri._normalizeRelativePath(path, allowScheme);
>+    } else {
>+      path = core._Uri._removeDotSegments(path);
>+    }
>+    if (host == null && path[$startsWith]("//")) {
>+      host = "";
>+    }
>+    return new core._Uri._internal(scheme, userInfo, host, port, path, query, fragment);
>+  }
>+  static http(authority, unencodedPath, queryParameters) {
>+    if (queryParameters === void 0) queryParameters = null;
>+    return core._Uri._check(core._Uri._makeHttpUri("http", authority, unencodedPath, queryParameters));
>+  }
>+  static https(authority, unencodedPath, queryParameters) {
>+    if (queryParameters === void 0) queryParameters = null;
>+    return core._Uri._check(core._Uri._makeHttpUri("https", authority, unencodedPath, queryParameters));
>+  }
>+  get authority() {
>+    if (!dart.test(this.hasAuthority)) return "";
>+    let sb = new core.StringBuffer.new();
>+    this[_writeAuthority](sb);
>+    return sb.toString();
>+  }
>+  get userInfo() {
>+    return this[_userInfo];
>+  }
>+  get host() {
>+    if (this[_host] == null) return "";
>+    if (this[_host][$startsWith]("[")) {
>+      return this[_host][$substring](1, this[_host].length - 1);
>+    }
>+    return this[_host];
>+  }
>+  get port() {
>+    if (this[_port] == null) return core._Uri._defaultPort(this.scheme);
>+    return this[_port];
>+  }
>+  static _defaultPort(scheme) {
>+    if (scheme === "http") return 80;
>+    if (scheme === "https") return 443;
>+    return 0;
>+  }
>+  get query() {
>+    return this[_query] != null ? this[_query] : "";
>+  }
>+  get fragment() {
>+    return this[_fragment] != null ? this[_fragment] : "";
>+  }
>+  isScheme(scheme) {
>+    let thisScheme = this.scheme;
>+    if (scheme == null) return thisScheme[$isEmpty];
>+    if (scheme.length !== thisScheme.length) return false;
>+    return core._Uri._compareScheme(scheme, thisScheme);
>+  }
>+  static _compareScheme(scheme, uri) {
>+    for (let i = 0; i < scheme.length; i++) {
>+      let schemeChar = scheme[$codeUnitAt](i);
>+      let uriChar = uri[$codeUnitAt](i);
>+      let delta = (schemeChar ^ uriChar) >>> 0;
>+      if (delta !== 0) {
>+        if (delta === 32) {
>+          let lowerChar = (uriChar | delta) >>> 0;
>+          if (97 <= lowerChar && lowerChar <= 122) {
>+            continue;
>+          }
>+        }
>+        return false;
>+      }
>+    }
>+    return true;
>+  }
>+  static _fail(uri, index, message) {
>+    dart.throw(new core.FormatException.new(message, uri, index));
>+  }
>+  static _makeHttpUri(scheme, authority, unencodedPath, queryParameters) {
>+    let userInfo = "";
>+    let host = null;
>+    let port = null;
>+    if (authority != null && authority[$isNotEmpty]) {
>+      let hostStart = 0;
>+      let hasUserInfo = false;
>+      for (let i = 0; i < authority.length; i++) {
>+        let atSign = 64;
>+        if (authority[$codeUnitAt](i) === atSign) {
>+          hasUserInfo = true;
>+          userInfo = authority[$substring](0, i);
>+          hostStart = i + 1;
>+          break;
>+        }
>+      }
>+      let hostEnd = hostStart;
>+      if (hostStart < authority.length && authority[$codeUnitAt](hostStart) === 91) {
>+        for (; hostEnd < authority.length; hostEnd++) {
>+          if (authority[$codeUnitAt](hostEnd) === 93) break;
>+        }
>+        if (hostEnd === authority.length) {
>+          dart.throw(new core.FormatException.new("Invalid IPv6 host entry.", authority, hostStart));
>+        }
>+        core.Uri.parseIPv6Address(authority, hostStart + 1, hostEnd);
>+        hostEnd++;
>+        if (hostEnd !== authority.length && authority[$codeUnitAt](hostEnd) !== 58) {
>+          dart.throw(new core.FormatException.new("Invalid end of authority", authority, hostEnd));
>+        }
>+      }
>+      let hasPort = false;
>+      for (; hostEnd < authority.length; hostEnd++) {
>+        if (authority[$codeUnitAt](hostEnd) === 58) {
>+          let portString = authority[$substring](hostEnd + 1);
>+          if (portString[$isNotEmpty]) port = core.int.parse(portString);
>+          break;
>+        }
>+      }
>+      host = authority[$substring](hostStart, hostEnd);
>+    }
>+    return core.Uri.new({scheme: scheme, userInfo: userInfo, host: host, port: port, pathSegments: unencodedPath[$split]("/"), queryParameters: queryParameters});
>+  }
>+  static file(path, opts) {
>+    let windows = opts && 'windows' in opts ? opts.windows : null;
>+    windows = windows == null ? core._Uri._isWindows : windows;
>+    return core._Uri._check(dart.test(windows) ? core._Uri._makeWindowsFileUrl(path, false) : core._Uri._makeFileUri(path, false));
>+  }
>+  static directory(path, opts) {
>+    let windows = opts && 'windows' in opts ? opts.windows : null;
>+    windows = windows == null ? core._Uri._isWindows : windows;
>+    return core._Uri._check(dart.test(windows) ? core._Uri._makeWindowsFileUrl(path, true) : core._Uri._makeFileUri(path, true));
>+  }
>+  static get _isWindows() {
>+    return core._Uri._isWindowsCached;
>+  }
>+  static _checkNonWindowsPathReservedCharacters(segments, argumentError) {
>+    segments[$forEach](dart.fn(segment => {
>+      if (segment[$contains]("/")) {
>+        if (dart.test(argumentError)) {
>+          dart.throw(new core.ArgumentError.new("Illegal path character " + dart.str(segment)));
>+        } else {
>+          dart.throw(new core.UnsupportedError.new("Illegal path character " + dart.str(segment)));
>+        }
>+      }
>+    }, StringToNull()));
>+  }
>+  static _checkWindowsPathReservedCharacters(segments, argumentError, firstSegment) {
>+    if (firstSegment === void 0) firstSegment = 0;
>+    for (let segment of segments[$skip](firstSegment)) {
>+      if (segment[$contains](core.RegExp.new("[\"*/:<>?\\\\|]"))) {
>+        if (dart.test(argumentError)) {
>+          dart.throw(new core.ArgumentError.new("Illegal character in path"));
>+        } else {
>+          dart.throw(new core.UnsupportedError.new("Illegal character in path: " + dart.str(segment)));
>+        }
>+      }
>+    }
>+  }
>+  static _checkWindowsDriveLetter(charCode, argumentError) {
>+    if (65 <= dart.notNull(charCode) && dart.notNull(charCode) <= 90 || 97 <= dart.notNull(charCode) && dart.notNull(charCode) <= 122) {
>+      return;
>+    }
>+    if (dart.test(argumentError)) {
>+      dart.throw(new core.ArgumentError.new("Illegal drive letter " + core.String.fromCharCode(charCode)));
>+    } else {
>+      dart.throw(new core.UnsupportedError.new("Illegal drive letter " + core.String.fromCharCode(charCode)));
>+    }
>+  }
>+  static _makeFileUri(path, slashTerminated) {
>+    let sep = "/";
>+    let segments = path[$split](sep);
>+    if (dart.test(slashTerminated) && dart.test(segments[$isNotEmpty]) && segments[$last][$isNotEmpty]) {
>+      segments[$add]("");
>+    }
>+    if (path[$startsWith](sep)) {
>+      return core.Uri.new({scheme: "file", pathSegments: segments});
>+    } else {
>+      return core.Uri.new({pathSegments: segments});
>+    }
>+  }
>+  static _makeWindowsFileUrl(path, slashTerminated) {
>+    if (path[$startsWith]("\\\\?\\")) {
>+      if (path[$startsWith]("UNC\\", 4)) {
>+        path = path[$replaceRange](0, 7, "\\");
>+      } else {
>+        path = path[$substring](4);
>+        if (path.length < 3 || path[$codeUnitAt](1) !== 58 || path[$codeUnitAt](2) !== 92) {
>+          dart.throw(new core.ArgumentError.new("Windows paths with \\\\?\\ prefix must be absolute"));
>+        }
>+      }
>+    } else {
>+      path = path[$replaceAll]("/", "\\");
>+    }
>+    let sep = "\\";
>+    if (path.length > 1 && path[$codeUnitAt](1) === 58) {
>+      core._Uri._checkWindowsDriveLetter(path[$codeUnitAt](0), true);
>+      if (path.length === 2 || path[$codeUnitAt](2) !== 92) {
>+        dart.throw(new core.ArgumentError.new("Windows paths with drive letter must be absolute"));
>+      }
>+      let pathSegments = path[$split](sep);
>+      if (dart.test(slashTerminated) && pathSegments[$last][$isNotEmpty]) {
>+        pathSegments[$add]("");
>+      }
>+      core._Uri._checkWindowsPathReservedCharacters(pathSegments, true, 1);
>+      return core.Uri.new({scheme: "file", pathSegments: pathSegments});
>+    }
>+    if (path[$startsWith](sep)) {
>+      if (path[$startsWith](sep, 1)) {
>+        let pathStart = path[$indexOf]("\\", 2);
>+        let hostPart = pathStart < 0 ? path[$substring](2) : path[$substring](2, pathStart);
>+        let pathPart = pathStart < 0 ? "" : path[$substring](pathStart + 1);
>+        let pathSegments = pathPart[$split](sep);
>+        core._Uri._checkWindowsPathReservedCharacters(pathSegments, true);
>+        if (dart.test(slashTerminated) && pathSegments[$last][$isNotEmpty]) {
>+          pathSegments[$add]("");
>+        }
>+        return core.Uri.new({scheme: "file", host: hostPart, pathSegments: pathSegments});
>+      } else {
>+        let pathSegments = path[$split](sep);
>+        if (dart.test(slashTerminated) && pathSegments[$last][$isNotEmpty]) {
>+          pathSegments[$add]("");
>+        }
>+        core._Uri._checkWindowsPathReservedCharacters(pathSegments, true);
>+        return core.Uri.new({scheme: "file", pathSegments: pathSegments});
>+      }
>+    } else {
>+      let pathSegments = path[$split](sep);
>+      core._Uri._checkWindowsPathReservedCharacters(pathSegments, true);
>+      if (dart.test(slashTerminated) && dart.test(pathSegments[$isNotEmpty]) && pathSegments[$last][$isNotEmpty]) {
>+        pathSegments[$add]("");
>+      }
>+      return core.Uri.new({pathSegments: pathSegments});
>+    }
>+  }
>+  replace(opts) {
>+    let scheme = opts && 'scheme' in opts ? opts.scheme : null;
>+    let userInfo = opts && 'userInfo' in opts ? opts.userInfo : null;
>+    let host = opts && 'host' in opts ? opts.host : null;
>+    let port = opts && 'port' in opts ? opts.port : null;
>+    let path = opts && 'path' in opts ? opts.path : null;
>+    let pathSegments = opts && 'pathSegments' in opts ? opts.pathSegments : null;
>+    let query = opts && 'query' in opts ? opts.query : null;
>+    let queryParameters = opts && 'queryParameters' in opts ? opts.queryParameters : null;
>+    let fragment = opts && 'fragment' in opts ? opts.fragment : null;
>+    let schemeChanged = false;
>+    if (scheme != null) {
>+      scheme = core._Uri._makeScheme(scheme, 0, scheme.length);
>+      schemeChanged = scheme != this.scheme;
>+    } else {
>+      scheme = this.scheme;
>+    }
>+    let isFile = scheme === "file";
>+    if (userInfo != null) {
>+      userInfo = core._Uri._makeUserInfo(userInfo, 0, userInfo.length);
>+    } else {
>+      userInfo = this[_userInfo];
>+    }
>+    if (port != null) {
>+      port = core._Uri._makePort(port, scheme);
>+    } else {
>+      port = this[_port];
>+      if (schemeChanged) {
>+        port = core._Uri._makePort(port, scheme);
>+      }
>+    }
>+    if (host != null) {
>+      host = core._Uri._makeHost(host, 0, host.length, false);
>+    } else if (dart.test(this.hasAuthority)) {
>+      host = this[_host];
>+    } else if (userInfo[$isNotEmpty] || port != null || isFile) {
>+      host = "";
>+    }
>+    let hasAuthority = host != null;
>+    if (path != null || pathSegments != null) {
>+      path = core._Uri._makePath(path, 0, core._stringOrNullLength(path), pathSegments, scheme, hasAuthority);
>+    } else {
>+      path = this.path;
>+      if ((isFile || hasAuthority && !path[$isEmpty]) && !path[$startsWith]("/")) {
>+        path = "/" + dart.notNull(path);
>+      }
>+    }
>+    if (query != null || queryParameters != null) {
>+      query = core._Uri._makeQuery(query, 0, core._stringOrNullLength(query), queryParameters);
>+    } else {
>+      query = this[_query];
>+    }
>+    if (fragment != null) {
>+      fragment = core._Uri._makeFragment(fragment, 0, fragment.length);
>+    } else {
>+      fragment = this[_fragment];
>+    }
>+    return new core._Uri._internal(scheme, userInfo, host, port, path, query, fragment);
>+  }
>+  removeFragment() {
>+    if (!dart.test(this.hasFragment)) return this;
>+    return new core._Uri._internal(this.scheme, this[_userInfo], this[_host], this[_port], this.path, this[_query], null);
>+  }
>+  get pathSegments() {
>+    let result = this[_pathSegments];
>+    if (result != null) return result;
>+    let pathToSplit = this.path;
>+    if (pathToSplit[$isNotEmpty] && pathToSplit[$codeUnitAt](0) === 47) {
>+      pathToSplit = pathToSplit[$substring](1);
>+    }
>+    result = pathToSplit === "" ? const$60 || (const$60 = dart.constList([], core.String)) : ListOfString().unmodifiable(pathToSplit[$split]("/")[$map](dart.dynamic, dart.fn(core.Uri.decodeComponent, StringToString())));
>+    this[_pathSegments] = result;
>+    return result;
>+  }
>+  get queryParameters() {
>+    let t = this[_queryParameters];
>+    t == null ? this[_queryParameters] = new (UnmodifiableMapViewOfString$String()).new(core.Uri.splitQueryString(this.query)) : t;
>+    return this[_queryParameters];
>+  }
>+  get queryParametersAll() {
>+    if (this[_queryParameterLists] == null) {
>+      let queryParameterLists = core._Uri._splitQueryStringAll(this.query);
>+      for (let key of queryParameterLists[$keys]) {
>+        queryParameterLists[$_set](key, ListOfString().unmodifiable(core.Iterable._check(queryParameterLists[$_get](key))));
>+      }
>+      this[_queryParameterLists] = MapOfString$ListOfString().unmodifiable(queryParameterLists);
>+    }
>+    return this[_queryParameterLists];
>+  }
>+  normalizePath() {
>+    let path = core._Uri._normalizePath(this.path, this.scheme, this.hasAuthority);
>+    if (path == this.path) return this;
>+    return this.replace({path: path});
>+  }
>+  static _makePort(port, scheme) {
>+    if (port != null && port == core._Uri._defaultPort(scheme)) return null;
>+    return port;
>+  }
>+  static _makeHost(host, start, end, strictIPv6) {
>+    if (host == null) return null;
>+    if (start == end) return "";
>+    if (host[$codeUnitAt](start) === 91) {
>+      if (host[$codeUnitAt](dart.notNull(end) - 1) !== 93) {
>+        core._Uri._fail(host, start, "Missing end `]` to match `[` in host");
>+      }
>+      core.Uri.parseIPv6Address(host, dart.notNull(start) + 1, dart.notNull(end) - 1);
>+      return host[$substring](start, end)[$toLowerCase]();
>+    }
>+    if (!dart.test(strictIPv6)) {
>+      for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
>+        if (host[$codeUnitAt](i) === 58) {
>+          core.Uri.parseIPv6Address(host, start, end);
>+          return "[" + dart.str(host) + "]";
>+        }
>+      }
>+    }
>+    return core._Uri._normalizeRegName(host, start, end);
>+  }
>+  static _isRegNameChar(char) {
>+    return dart.notNull(char) < 127 && (dart.notNull(core._Uri._regNameTable[$_get](char[$rightShift](4))) & 1 << (dart.notNull(char) & 15)) !== 0;
>+  }
>+  static _normalizeRegName(host, start, end) {
>+    let buffer = null;
>+    let sectionStart = start;
>+    let index = start;
>+    let isNormalized = true;
>+    while (dart.notNull(index) < dart.notNull(end)) {
>+      let char = host[$codeUnitAt](index);
>+      if (char === 37) {
>+        let replacement = core._Uri._normalizeEscape(host, index, true);
>+        if (replacement == null && isNormalized) {
>+          index = dart.notNull(index) + 3;
>+          continue;
>+        }
>+        let t = buffer;
>+        t == null ? buffer = new core.StringBuffer.new() : t;
>+        let slice = host[$substring](sectionStart, index);
>+        if (!isNormalized) slice = slice[$toLowerCase]();
>+        buffer.write(slice);
>+        let sourceLength = 3;
>+        if (replacement == null) {
>+          replacement = host[$substring](index, dart.notNull(index) + 3);
>+        } else if (replacement === "%") {
>+          replacement = "%25";
>+          sourceLength = 1;
>+        }
>+        buffer.write(replacement);
>+        index = dart.notNull(index) + sourceLength;
>+        sectionStart = index;
>+        isNormalized = true;
>+      } else if (dart.test(core._Uri._isRegNameChar(char))) {
>+        if (isNormalized && 65 <= char && 90 >= char) {
>+          let t$ = buffer;
>+          t$ == null ? buffer = new core.StringBuffer.new() : t$;
>+          if (dart.notNull(sectionStart) < dart.notNull(index)) {
>+            buffer.write(host[$substring](sectionStart, index));
>+            sectionStart = index;
>+          }
>+          isNormalized = false;
>+        }
>+        index = dart.notNull(index) + 1;
>+      } else if (dart.test(core._Uri._isGeneralDelimiter(char))) {
>+        core._Uri._fail(host, index, "Invalid character");
>+      } else {
>+        let sourceLength = 1;
>+        if ((char & 64512) === 55296 && dart.notNull(index) + 1 < dart.notNull(end)) {
>+          let tail = host[$codeUnitAt](dart.notNull(index) + 1);
>+          if ((tail & 64512) === 56320) {
>+            char = 65536 | (char & 1023) << 10 | tail & 1023;
>+            sourceLength = 2;
>+          }
>+        }
>+        let t$0 = buffer;
>+        t$0 == null ? buffer = new core.StringBuffer.new() : t$0;
>+        let slice = host[$substring](sectionStart, index);
>+        if (!isNormalized) slice = slice[$toLowerCase]();
>+        buffer.write(slice);
>+        buffer.write(core._Uri._escapeChar(char));
>+        index = dart.notNull(index) + sourceLength;
>+        sectionStart = index;
>+      }
>+    }
>+    if (buffer == null) return host[$substring](start, end);
>+    if (dart.notNull(sectionStart) < dart.notNull(end)) {
>+      let slice = host[$substring](sectionStart, end);
>+      if (!isNormalized) slice = slice[$toLowerCase]();
>+      buffer.write(slice);
>+    }
>+    return dart.toString(buffer);
>+  }
>+  static _makeScheme(scheme, start, end) {
>+    if (start == end) return "";
>+    let firstCodeUnit = scheme[$codeUnitAt](start);
>+    if (!dart.test(core._Uri._isAlphabeticCharacter(firstCodeUnit))) {
>+      core._Uri._fail(scheme, start, "Scheme not starting with alphabetic character");
>+    }
>+    let containsUpperCase = false;
>+    for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
>+      let codeUnit = scheme[$codeUnitAt](i);
>+      if (!dart.test(core._Uri._isSchemeCharacter(codeUnit))) {
>+        core._Uri._fail(scheme, i, "Illegal scheme character");
>+      }
>+      if (65 <= codeUnit && codeUnit <= 90) {
>+        containsUpperCase = true;
>+      }
>+    }
>+    scheme = scheme[$substring](start, end);
>+    if (containsUpperCase) scheme = scheme[$toLowerCase]();
>+    return core._Uri._canonicalizeScheme(scheme);
>+  }
>+  static _canonicalizeScheme(scheme) {
>+    if (scheme === "http") return "http";
>+    if (scheme === "file") return "file";
>+    if (scheme === "https") return "https";
>+    if (scheme === "package") return "package";
>+    return scheme;
>+  }
>+  static _makeUserInfo(userInfo, start, end) {
>+    if (userInfo == null) return "";
>+    return core._Uri._normalizeOrSubstring(userInfo, start, end, core._Uri._userinfoTable);
>+  }
>+  static _makePath(path, start, end, pathSegments, scheme, hasAuthority) {
>+    let isFile = scheme === "file";
>+    let ensureLeadingSlash = isFile || dart.test(hasAuthority);
>+    if (path == null && pathSegments == null) return isFile ? "/" : "";
>+    if (path != null && pathSegments != null) {
>+      dart.throw(new core.ArgumentError.new("Both path and pathSegments specified"));
>+    }
>+    let result = null;
>+    if (path != null) {
>+      result = core._Uri._normalizeOrSubstring(path, start, end, core._Uri._pathCharOrSlashTable, {escapeDelimiters: true});
>+    } else {
>+      result = IterableOfString()._check(pathSegments[$map](core.String, dart.fn(s => core._Uri._uriEncode(core._Uri._pathCharTable, s, convert.utf8, false), StringToString())))[$join]("/");
>+    }
>+    if (result[$isEmpty]) {
>+      if (isFile) return "/";
>+    } else if (ensureLeadingSlash && !result[$startsWith]("/")) {
>+      result = "/" + dart.notNull(result);
>+    }
>+    result = core._Uri._normalizePath(result, scheme, hasAuthority);
>+    return result;
>+  }
>+  static _normalizePath(path, scheme, hasAuthority) {
>+    if (scheme[$isEmpty] && !dart.test(hasAuthority) && !path[$startsWith]("/")) {
>+      return core._Uri._normalizeRelativePath(path, scheme[$isNotEmpty] || dart.test(hasAuthority));
>+    }
>+    return core._Uri._removeDotSegments(path);
>+  }
>+  static _makeQuery(query, start, end, queryParameters) {
>+    if (query != null) {
>+      if (queryParameters != null) {
>+        dart.throw(new core.ArgumentError.new("Both query and queryParameters specified"));
>+      }
>+      return core._Uri._normalizeOrSubstring(query, start, end, core._Uri._queryCharTable, {escapeDelimiters: true});
>+    }
>+    if (queryParameters == null) return null;
>+    let result = new core.StringBuffer.new();
>+    let separator = "";
>+    function writeParameter(key, value) {
>+      result.write(separator);
>+      separator = "&";
>+      result.write(core.Uri.encodeQueryComponent(key));
>+      if (value != null && value[$isNotEmpty]) {
>+        result.write("=");
>+        result.write(core.Uri.encodeQueryComponent(value));
>+      }
>+    }
>+    dart.fn(writeParameter, StringAndStringTovoid());
>+    queryParameters[$forEach](dart.fn((key, value) => {
>+      if (value == null || typeof value == 'string') {
>+        writeParameter(key, core.String._check(value));
>+      } else {
>+        let values = core.Iterable._check(value);
>+        for (let value of values) {
>+          core.String._check(value);
>+          writeParameter(key, value);
>+        }
>+      }
>+    }, StringAnddynamicToNull()));
>+    return result.toString();
>+  }
>+  static _makeFragment(fragment, start, end) {
>+    if (fragment == null) return null;
>+    return core._Uri._normalizeOrSubstring(fragment, start, end, core._Uri._queryCharTable, {escapeDelimiters: true});
>+  }
>+  static _normalizeEscape(source, index, lowerCase) {
>+    if (!(source[$codeUnitAt](index) === 37)) dart.assertFailed(null, "dart:core/uri.dart", 2201, 12, "source.codeUnitAt(index) == _PERCENT");
>+    if (dart.notNull(index) + 2 >= source.length) {
>+      return "%";
>+    }
>+    let firstDigit = source[$codeUnitAt](dart.notNull(index) + 1);
>+    let secondDigit = source[$codeUnitAt](dart.notNull(index) + 2);
>+    let firstDigitValue = _internal.hexDigitValue(firstDigit);
>+    let secondDigitValue = _internal.hexDigitValue(secondDigit);
>+    if (dart.notNull(firstDigitValue) < 0 || dart.notNull(secondDigitValue) < 0) {
>+      return "%";
>+    }
>+    let value = dart.notNull(firstDigitValue) * 16 + dart.notNull(secondDigitValue);
>+    if (dart.test(core._Uri._isUnreservedChar(value))) {
>+      if (dart.test(lowerCase) && 65 <= value && 90 >= value) {
>+        value = (value | 32) >>> 0;
>+      }
>+      return core.String.fromCharCode(value);
>+    }
>+    if (firstDigit >= 97 || secondDigit >= 97) {
>+      return source[$substring](index, dart.notNull(index) + 3)[$toUpperCase]();
>+    }
>+    return null;
>+  }
>+  static _escapeChar(char) {
>+    if (!(dart.notNull(char) <= 1114111)) dart.assertFailed(null, "dart:core/uri.dart", 2229, 12, "char <= 0x10ffff");
>+    let codeUnits = null;
>+    if (dart.notNull(char) < 128) {
>+      codeUnits = ListOfint().new(3);
>+      codeUnits[$_set](0, 37);
>+      codeUnits[$_set](1, "0123456789ABCDEF"[$codeUnitAt](char[$rightShift](4)));
>+      codeUnits[$_set](2, "0123456789ABCDEF"[$codeUnitAt](dart.notNull(char) & 15));
>+    } else {
>+      let flag = 192;
>+      let encodedBytes = 2;
>+      if (dart.notNull(char) > 2047) {
>+        flag = 224;
>+        encodedBytes = 3;
>+        if (dart.notNull(char) > 65535) {
>+          encodedBytes = 4;
>+          flag = 240;
>+        }
>+      }
>+      codeUnits = ListOfint().new(3 * encodedBytes);
>+      let index = 0;
>+      while (--encodedBytes >= 0) {
>+        let byte = (char[$rightShift](6 * encodedBytes) & 63 | flag) >>> 0;
>+        codeUnits[$_set](index, 37);
>+        codeUnits[$_set](index + 1, "0123456789ABCDEF"[$codeUnitAt](byte[$rightShift](4)));
>+        codeUnits[$_set](index + 2, "0123456789ABCDEF"[$codeUnitAt](byte & 15));
>+        index = index + 3;
>+        flag = 128;
>+      }
>+    }
>+    return core.String.fromCharCodes(codeUnits);
>+  }
>+  static _normalizeOrSubstring(component, start, end, charTable, opts) {
>+    let escapeDelimiters = opts && 'escapeDelimiters' in opts ? opts.escapeDelimiters : false;
>+    let l = core._Uri._normalize(component, start, end, charTable, {escapeDelimiters: escapeDelimiters});
>+    return l != null ? l : component[$substring](start, end);
>+  }
>+  static _normalize(component, start, end, charTable, opts) {
>+    let escapeDelimiters = opts && 'escapeDelimiters' in opts ? opts.escapeDelimiters : false;
>+    let buffer = null;
>+    let sectionStart = start;
>+    let index = start;
>+    while (dart.notNull(index) < dart.notNull(end)) {
>+      let char = component[$codeUnitAt](index);
>+      if (char < 127 && (dart.notNull(charTable[$_get](char[$rightShift](4))) & 1 << (char & 15)) !== 0) {
>+        index = dart.notNull(index) + 1;
>+      } else {
>+        let replacement = null;
>+        let sourceLength = null;
>+        if (char === 37) {
>+          replacement = core._Uri._normalizeEscape(component, index, false);
>+          if (replacement == null) {
>+            index = dart.notNull(index) + 3;
>+            continue;
>+          }
>+          if ("%" === replacement) {
>+            replacement = "%25";
>+            sourceLength = 1;
>+          } else {
>+            sourceLength = 3;
>+          }
>+        } else if (!dart.test(escapeDelimiters) && dart.test(core._Uri._isGeneralDelimiter(char))) {
>+          core._Uri._fail(component, index, "Invalid character");
>+        } else {
>+          sourceLength = 1;
>+          if ((char & 64512) === 55296) {
>+            if (dart.notNull(index) + 1 < dart.notNull(end)) {
>+              let tail = component[$codeUnitAt](dart.notNull(index) + 1);
>+              if ((tail & 64512) === 56320) {
>+                sourceLength = 2;
>+                char = 65536 | (char & 1023) << 10 | tail & 1023;
>+              }
>+            }
>+          }
>+          replacement = core._Uri._escapeChar(char);
>+        }
>+        let t = buffer;
>+        t == null ? buffer = new core.StringBuffer.new() : t;
>+        buffer.write(component[$substring](sectionStart, index));
>+        buffer.write(replacement);
>+        index = dart.notNull(index) + dart.notNull(sourceLength);
>+        sectionStart = index;
>+      }
>+    }
>+    if (buffer == null) {
>+      return null;
>+    }
>+    if (dart.notNull(sectionStart) < dart.notNull(end)) {
>+      buffer.write(component[$substring](sectionStart, end));
>+    }
>+    return dart.toString(buffer);
>+  }
>+  static _isSchemeCharacter(ch) {
>+    return dart.notNull(ch) < 128 && (dart.notNull(core._Uri._schemeTable[$_get](ch[$rightShift](4))) & 1 << (dart.notNull(ch) & 15)) !== 0;
>+  }
>+  static _isGeneralDelimiter(ch) {
>+    return dart.notNull(ch) <= 93 && (dart.notNull(core._Uri._genDelimitersTable[$_get](ch[$rightShift](4))) & 1 << (dart.notNull(ch) & 15)) !== 0;
>+  }
>+  get isAbsolute() {
>+    return this.scheme !== "" && this.fragment === "";
>+  }
>+  [_mergePaths](base, reference) {
>+    let backCount = 0;
>+    let refStart = 0;
>+    while (reference[$startsWith]("../", refStart)) {
>+      refStart = refStart + 3;
>+      backCount++;
>+    }
>+    let baseEnd = base[$lastIndexOf]("/");
>+    while (baseEnd > 0 && backCount > 0) {
>+      let newEnd = base[$lastIndexOf]("/", baseEnd - 1);
>+      if (newEnd < 0) {
>+        break;
>+      }
>+      let delta = baseEnd - newEnd;
>+      if ((delta === 2 || delta === 3) && base[$codeUnitAt](newEnd + 1) === 46 && (delta === 2 || base[$codeUnitAt](newEnd + 2) === 46)) {
>+        break;
>+      }
>+      baseEnd = newEnd;
>+      backCount--;
>+    }
>+    return base[$replaceRange](baseEnd + 1, null, reference[$substring](refStart - 3 * backCount));
>+  }
>+  static _mayContainDotSegments(path) {
>+    if (path[$startsWith](".")) return true;
>+    let index = path[$indexOf]("/.");
>+    return index !== -1;
>+  }
>+  static _removeDotSegments(path) {
>+    if (!dart.test(core._Uri._mayContainDotSegments(path))) return path;
>+    if (!path[$isNotEmpty]) dart.assertFailed(null, "dart:core/uri.dart", 2414, 12, "path.isNotEmpty");
>+    let output = JSArrayOfString().of([]);
>+    let appendSlash = false;
>+    for (let segment of path[$split]("/")) {
>+      appendSlash = false;
>+      if (segment === "..") {
>+        if (dart.test(output[$isNotEmpty])) {
>+          output[$removeLast]();
>+          if (dart.test(output[$isEmpty])) {
>+            output[$add]("");
>+          }
>+        }
>+        appendSlash = true;
>+      } else if ("." === segment) {
>+        appendSlash = true;
>+      } else {
>+        output[$add](segment);
>+      }
>+    }
>+    if (appendSlash) output[$add]("");
>+    return output[$join]("/");
>+  }
>+  static _normalizeRelativePath(path, allowScheme) {
>+    if (!!path[$startsWith]("/")) dart.assertFailed(null, "dart:core/uri.dart", 2449, 12, "!path.startsWith('/')");
>+    if (!dart.test(core._Uri._mayContainDotSegments(path))) {
>+      if (!dart.test(allowScheme)) path = core._Uri._escapeScheme(path);
>+      return path;
>+    }
>+    if (!path[$isNotEmpty]) dart.assertFailed(null, "dart:core/uri.dart", 2454, 12, "path.isNotEmpty");
>+    let output = JSArrayOfString().of([]);
>+    let appendSlash = false;
>+    for (let segment of path[$split]("/")) {
>+      appendSlash = false;
>+      if (".." === segment) {
>+        if (!dart.test(output[$isEmpty]) && output[$last] !== "..") {
>+          output[$removeLast]();
>+          appendSlash = true;
>+        } else {
>+          output[$add]("..");
>+        }
>+      } else if ("." === segment) {
>+        appendSlash = true;
>+      } else {
>+        output[$add](segment);
>+      }
>+    }
>+    if (dart.test(output[$isEmpty]) || output[$length] === 1 && output[$_get](0)[$isEmpty]) {
>+      return "./";
>+    }
>+    if (appendSlash || output[$last] === "..") output[$add]("");
>+    if (!dart.test(allowScheme)) output[$_set](0, core._Uri._escapeScheme(output[$_get](0)));
>+    return output[$join]("/");
>+  }
>+  static _escapeScheme(path) {
>+    if (path.length >= 2 && dart.test(core._Uri._isAlphabeticCharacter(path[$codeUnitAt](0)))) {
>+      for (let i = 1; i < path.length; i++) {
>+        let char = path[$codeUnitAt](i);
>+        if (char === 58) {
>+          return path[$substring](0, i) + "%3A" + path[$substring](i + 1);
>+        }
>+        if (char > 127 || (dart.notNull(core._Uri._schemeTable[$_get](char[$rightShift](4))) & 1 << (char & 15)) === 0) {
>+          break;
>+        }
>+      }
>+    }
>+    return path;
>+  }
>+  resolve(reference) {
>+    return this.resolveUri(core.Uri.parse(reference));
>+  }
>+  resolveUri(reference) {
>+    let targetScheme = null;
>+    let targetUserInfo = "";
>+    let targetHost = null;
>+    let targetPort = null;
>+    let targetPath = null;
>+    let targetQuery = null;
>+    if (reference.scheme[$isNotEmpty]) {
>+      targetScheme = reference.scheme;
>+      if (dart.test(reference.hasAuthority)) {
>+        targetUserInfo = reference.userInfo;
>+        targetHost = reference.host;
>+        targetPort = dart.test(reference.hasPort) ? reference.port : null;
>+      }
>+      targetPath = core._Uri._removeDotSegments(reference.path);
>+      if (dart.test(reference.hasQuery)) {
>+        targetQuery = reference.query;
>+      }
>+    } else {
>+      targetScheme = this.scheme;
>+      if (dart.test(reference.hasAuthority)) {
>+        targetUserInfo = reference.userInfo;
>+        targetHost = reference.host;
>+        targetPort = core._Uri._makePort(dart.test(reference.hasPort) ? reference.port : null, targetScheme);
>+        targetPath = core._Uri._removeDotSegments(reference.path);
>+        if (dart.test(reference.hasQuery)) targetQuery = reference.query;
>+      } else {
>+        targetUserInfo = this[_userInfo];
>+        targetHost = this[_host];
>+        targetPort = this[_port];
>+        if (reference.path === "") {
>+          targetPath = this.path;
>+          if (dart.test(reference.hasQuery)) {
>+            targetQuery = reference.query;
>+          } else {
>+            targetQuery = this[_query];
>+          }
>+        } else {
>+          if (dart.test(reference.hasAbsolutePath)) {
>+            targetPath = core._Uri._removeDotSegments(reference.path);
>+          } else {
>+            if (dart.test(this.hasEmptyPath)) {
>+              if (!dart.test(this.hasAuthority)) {
>+                if (!dart.test(this.hasScheme)) {
>+                  targetPath = reference.path;
>+                } else {
>+                  targetPath = core._Uri._removeDotSegments(reference.path);
>+                }
>+              } else {
>+                targetPath = core._Uri._removeDotSegments("/" + dart.notNull(reference.path));
>+              }
>+            } else {
>+              let mergedPath = this[_mergePaths](this.path, reference.path);
>+              if (dart.test(this.hasScheme) || dart.test(this.hasAuthority) || dart.test(this.hasAbsolutePath)) {
>+                targetPath = core._Uri._removeDotSegments(mergedPath);
>+              } else {
>+                targetPath = core._Uri._normalizeRelativePath(mergedPath, dart.test(this.hasScheme) || dart.test(this.hasAuthority));
>+              }
>+            }
>+          }
>+          if (dart.test(reference.hasQuery)) targetQuery = reference.query;
>+        }
>+      }
>+    }
>+    let fragment = dart.test(reference.hasFragment) ? reference.fragment : null;
>+    return new core._Uri._internal(targetScheme, targetUserInfo, targetHost, targetPort, targetPath, targetQuery, fragment);
>+  }
>+  get hasScheme() {
>+    return this.scheme[$isNotEmpty];
>+  }
>+  get hasAuthority() {
>+    return this[_host] != null;
>+  }
>+  get hasPort() {
>+    return this[_port] != null;
>+  }
>+  get hasQuery() {
>+    return this[_query] != null;
>+  }
>+  get hasFragment() {
>+    return this[_fragment] != null;
>+  }
>+  get hasEmptyPath() {
>+    return this.path[$isEmpty];
>+  }
>+  get hasAbsolutePath() {
>+    return this.path[$startsWith]("/");
>+  }
>+  get origin() {
>+    if (this.scheme === "") {
>+      dart.throw(new core.StateError.new("Cannot use origin without a scheme: " + dart.str(this)));
>+    }
>+    if (this.scheme !== "http" && this.scheme !== "https") {
>+      dart.throw(new core.StateError.new("Origin is only applicable schemes http and https: " + dart.str(this)));
>+    }
>+    if (this[_host] == null || this[_host] === "") {
>+      dart.throw(new core.StateError.new("A " + dart.str(this.scheme) + ": URI should have a non-empty host name: " + dart.str(this)));
>+    }
>+    if (this[_port] == null) return dart.str(this.scheme) + "://" + dart.str(this[_host]);
>+    return dart.str(this.scheme) + "://" + dart.str(this[_host]) + ":" + dart.str(this[_port]);
>+  }
>+  toFilePath(opts) {
>+    let windows = opts && 'windows' in opts ? opts.windows : null;
>+    if (this.scheme !== "" && this.scheme !== "file") {
>+      dart.throw(new core.UnsupportedError.new("Cannot extract a file path from a " + dart.str(this.scheme) + " URI"));
>+    }
>+    if (this.query !== "") {
>+      dart.throw(new core.UnsupportedError.new("Cannot extract a file path from a URI with a query component"));
>+    }
>+    if (this.fragment !== "") {
>+      dart.throw(new core.UnsupportedError.new("Cannot extract a file path from a URI with a fragment component"));
>+    }
>+    let t = windows;
>+    t == null ? windows = core._Uri._isWindows : t;
>+    return dart.test(windows) ? core._Uri._toWindowsFilePath(this) : this[_toFilePath]();
>+  }
>+  [_toFilePath]() {
>+    if (dart.test(this.hasAuthority) && this.host !== "") {
>+      dart.throw(new core.UnsupportedError.new("Cannot extract a non-Windows file path from a file URI " + "with an authority"));
>+    }
>+    let pathSegments = this.pathSegments;
>+    core._Uri._checkNonWindowsPathReservedCharacters(pathSegments, false);
>+    let result = new core.StringBuffer.new();
>+    if (dart.test(this.hasAbsolutePath)) result.write("/");
>+    result.writeAll(pathSegments, "/");
>+    return result.toString();
>+  }
>+  static _toWindowsFilePath(uri) {
>+    let hasDriveLetter = false;
>+    let segments = uri.pathSegments;
>+    if (dart.notNull(segments[$length]) > 0 && segments[$_get](0).length === 2 && segments[$_get](0)[$codeUnitAt](1) === 58) {
>+      core._Uri._checkWindowsDriveLetter(segments[$_get](0)[$codeUnitAt](0), false);
>+      core._Uri._checkWindowsPathReservedCharacters(segments, false, 1);
>+      hasDriveLetter = true;
>+    } else {
>+      core._Uri._checkWindowsPathReservedCharacters(segments, false, 0);
>+    }
>+    let result = new core.StringBuffer.new();
>+    if (dart.test(uri.hasAbsolutePath) && !hasDriveLetter) result.write("\\");
>+    if (dart.test(uri.hasAuthority)) {
>+      let host = uri.host;
>+      if (host[$isNotEmpty]) {
>+        result.write("\\");
>+        result.write(host);
>+        result.write("\\");
>+      }
>+    }
>+    result.writeAll(segments, "\\");
>+    if (hasDriveLetter && segments[$length] === 1) result.write("\\");
>+    return result.toString();
>+  }
>+  get [_isPathAbsolute]() {
>+    return this.path != null && this.path[$startsWith]("/");
>+  }
>+  [_writeAuthority](ss) {
>+    if (this[_userInfo][$isNotEmpty]) {
>+      ss.write(this[_userInfo]);
>+      ss.write("@");
>+    }
>+    if (this[_host] != null) ss.write(this[_host]);
>+    if (this[_port] != null) {
>+      ss.write(":");
>+      ss.write(this[_port]);
>+    }
>+  }
>+  get data() {
>+    return this.scheme === "data" ? core.UriData.fromUri(this) : null;
>+  }
>+  toString() {
>+    let t = this[_text];
>+    return t == null ? this[_text] = this[_initializeText]() : t;
>+  }
>+  [_initializeText]() {
>+    if (!(this[_text] == null)) dart.assertFailed(null, "dart:core/uri.dart", 2701, 12, "_text == null");
>+    let sb = new core.StringBuffer.new();
>+    if (this.scheme[$isNotEmpty]) {
>+      sb.write(this.scheme);
>+      sb.write(":");
>+    }
>+    if (dart.test(this.hasAuthority) || this.scheme === "file") {
>+      sb.write("//");
>+      this[_writeAuthority](sb);
>+    }
>+    sb.write(this.path);
>+    if (this[_query] != null) {
>+      sb.write("?");
>+      sb.write(this[_query]);
>+    }
>+    if (this[_fragment] != null) {
>+      sb.write("#");
>+      sb.write(this[_fragment]);
>+    }
>+    return sb.toString();
>+  }
>+  _equals(other) {
>+    if (this === other) return true;
>+    return core.Uri.is(other) && this.scheme == other.scheme && this.hasAuthority == other.hasAuthority && this.userInfo == other.userInfo && this.host == other.host && this.port == other.port && this.path == other.path && this.hasQuery == other.hasQuery && this.query == other.query && this.hasFragment == other.hasFragment && this.fragment == other.fragment;
>+  }
>+  get hashCode() {
>+    let t = this[_hashCodeCache];
>+    return t == null ? this[_hashCodeCache] = dart.hashCode(this.toString()) : t;
>+  }
>+  static _createList() {
>+    return JSArrayOfString().of([]);
>+  }
>+  static _splitQueryStringAll(query, opts) {
>+    let encoding = opts && 'encoding' in opts ? opts.encoding : convert.utf8;
>+    let result = new (IdentityMapOfString$ListOfString()).new();
>+    let i = 0;
>+    let start = 0;
>+    let equalsIndex = -1;
>+    function parsePair(start, equalsIndex, end) {
>+      let key = null;
>+      let value = null;
>+      if (start == end) return;
>+      if (dart.notNull(equalsIndex) < 0) {
>+        key = core._Uri._uriDecode(query, start, end, encoding, true);
>+        value = "";
>+      } else {
>+        key = core._Uri._uriDecode(query, start, equalsIndex, encoding, true);
>+        value = core._Uri._uriDecode(query, dart.notNull(equalsIndex) + 1, end, encoding, true);
>+      }
>+      result[$putIfAbsent](key, dart.fn(core._Uri._createList, VoidToListOfString()))[$add](value);
>+    }
>+    dart.fn(parsePair, intAndintAndintTovoid());
>+    while (i < query.length) {
>+      let char = query[$codeUnitAt](i);
>+      if (char === 61) {
>+        if (equalsIndex < 0) equalsIndex = i;
>+      } else if (char === 38) {
>+        parsePair(start, equalsIndex, i);
>+        start = i + 1;
>+        equalsIndex = -1;
>+      }
>+      i++;
>+    }
>+    parsePair(start, equalsIndex, i);
>+    return result;
>+  }
>+  static _uriEncode(canonicalTable, text, encoding, spaceToPlus) {
>+    if (encoding === convert.utf8 && dart.test(core._Uri._needsNoEncoding.hasMatch(text))) {
>+      return text;
>+    }
>+    let result = new core.StringBuffer.new("");
>+    let bytes = encoding.encode(text);
>+    for (let i = 0; i < dart.notNull(bytes[$length]); i++) {
>+      let byte = bytes[$_get](i);
>+      if (dart.notNull(byte) < 128 && (dart.notNull(canonicalTable[$_get](byte[$rightShift](4))) & 1 << (dart.notNull(byte) & 15)) !== 0) {
>+        result.writeCharCode(byte);
>+      } else if (dart.test(spaceToPlus) && byte === 32) {
>+        result.write("+");
>+      } else {
>+        let hexDigits = "0123456789ABCDEF";
>+        result.write("%");
>+        result.write(hexDigits[$_get](dart.notNull(byte) >> 4 & 15));
>+        result.write(hexDigits[$_get](dart.notNull(byte) & 15));
>+      }
>+    }
>+    return result.toString();
>+  }
>+  static _hexCharPairToByte(s, pos) {
>+    let byte = 0;
>+    for (let i = 0; i < 2; i++) {
>+      let charCode = s[$codeUnitAt](dart.notNull(pos) + i);
>+      if (48 <= charCode && charCode <= 57) {
>+        byte = byte * 16 + charCode - 48;
>+      } else {
>+        charCode = (charCode | 32) >>> 0;
>+        if (97 <= charCode && charCode <= 102) {
>+          byte = byte * 16 + charCode - 87;
>+        } else {
>+          dart.throw(new core.ArgumentError.new("Invalid URL encoding"));
>+        }
>+      }
>+    }
>+    return byte;
>+  }
>+  static _uriDecode(text, start, end, encoding, plusToSpace) {
>+    if (!(0 <= dart.notNull(start))) dart.assertFailed(null, "dart:core/uri.dart", 2837, 12, "0 <= start");
>+    if (!(dart.notNull(start) <= dart.notNull(end))) dart.assertFailed(null, "dart:core/uri.dart", 2838, 12, "start <= end");
>+    if (!(dart.notNull(end) <= text.length)) dart.assertFailed(null, "dart:core/uri.dart", 2839, 12, "end <= text.length");
>+    if (!(encoding != null)) dart.assertFailed(null, "dart:core/uri.dart", 2840, 12, "encoding != null");
>+    let simple = true;
>+    for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
>+      let codeUnit = text[$codeUnitAt](i);
>+      if (codeUnit > 127 || codeUnit === 37 || dart.test(plusToSpace) && codeUnit === 43) {
>+        simple = false;
>+        break;
>+      }
>+    }
>+    let bytes = null;
>+    if (simple) {
>+      if (convert.utf8._equals(encoding) || convert.latin1._equals(encoding) || convert.ascii._equals(encoding)) {
>+        return text[$substring](start, end);
>+      } else {
>+        bytes = text[$substring](start, end)[$codeUnits];
>+      }
>+    } else {
>+      bytes = JSArrayOfint().of([]);
>+      for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
>+        let codeUnit = text[$codeUnitAt](i);
>+        if (codeUnit > 127) {
>+          dart.throw(new core.ArgumentError.new("Illegal percent encoding in URI"));
>+        }
>+        if (codeUnit === 37) {
>+          if (dart.notNull(i) + 3 > text.length) {
>+            dart.throw(new core.ArgumentError.new("Truncated URI"));
>+          }
>+          bytes[$add](core._Uri._hexCharPairToByte(text, dart.notNull(i) + 1));
>+          i = dart.notNull(i) + 2;
>+        } else if (dart.test(plusToSpace) && codeUnit === 43) {
>+          bytes[$add](32);
>+        } else {
>+          bytes[$add](codeUnit);
>+        }
>+      }
>+    }
>+    return encoding.decode(bytes);
>+  }
>+  static _isAlphabeticCharacter(codeUnit) {
>+    let lowerCase = (dart.notNull(codeUnit) | 32) >>> 0;
>+    return 97 <= lowerCase && lowerCase <= 122;
>+  }
>+  static _isUnreservedChar(char) {
>+    return dart.notNull(char) < 127 && (dart.notNull(core._Uri._unreservedTable[$_get](char[$rightShift](4))) & 1 << (dart.notNull(char) & 15)) !== 0;
>+  }
>+};
>+(core._Uri._internal = function(scheme, userInfo, host, port, path, query, fragment) {
>+  this[_pathSegments] = null;
>+  this[_text] = null;
>+  this[_hashCodeCache] = null;
>+  this[_queryParameters] = null;
>+  this[_queryParameterLists] = null;
>+  this.scheme = scheme;
>+  this[_userInfo] = userInfo;
>+  this[_host] = host;
>+  this[_port] = port;
>+  this.path = path;
>+  this[_query] = query;
>+  this[_fragment] = fragment;
>+}).prototype = core._Uri.prototype;
>+dart.addTypeTests(core._Uri);
>+core._Uri[dart.implements] = () => [core.Uri];
>+dart.setMethodSignature(core._Uri, () => ({
>+  __proto__: dart.getMethods(core._Uri.__proto__),
>+  isScheme: dart.fnType(core.bool, [core.String]),
>+  replace: dart.fnType(core.Uri, [], {scheme: core.String, userInfo: core.String, host: core.String, port: core.int, path: core.String, pathSegments: core.Iterable$(core.String), query: core.String, queryParameters: core.Map$(core.String, dart.dynamic), fragment: core.String}),
>+  removeFragment: dart.fnType(core.Uri, []),
>+  normalizePath: dart.fnType(core.Uri, []),
>+  [_mergePaths]: dart.fnType(core.String, [core.String, core.String]),
>+  resolve: dart.fnType(core.Uri, [core.String]),
>+  resolveUri: dart.fnType(core.Uri, [core.Uri]),
>+  toFilePath: dart.fnType(core.String, [], {windows: core.bool}),
>+  [_toFilePath]: dart.fnType(core.String, []),
>+  [_writeAuthority]: dart.fnType(dart.void, [core.StringSink]),
>+  [_initializeText]: dart.fnType(core.String, []),
>+  _equals: dart.fnType(core.bool, [core.Object]),
>+  [$_equals]: dart.fnType(core.bool, [core.Object])
>+}));
>+dart.setGetterSignature(core._Uri, () => ({
>+  __proto__: dart.getGetters(core._Uri.__proto__),
>+  authority: core.String,
>+  userInfo: core.String,
>+  host: core.String,
>+  port: core.int,
>+  query: core.String,
>+  fragment: core.String,
>+  pathSegments: core.List$(core.String),
>+  queryParameters: core.Map$(core.String, core.String),
>+  queryParametersAll: core.Map$(core.String, core.List$(core.String)),
>+  isAbsolute: core.bool,
>+  hasScheme: core.bool,
>+  hasAuthority: core.bool,
>+  hasPort: core.bool,
>+  hasQuery: core.bool,
>+  hasFragment: core.bool,
>+  hasEmptyPath: core.bool,
>+  hasAbsolutePath: core.bool,
>+  origin: core.String,
>+  [_isPathAbsolute]: core.bool,
>+  data: core.UriData
>+}));
>+dart.setLibraryUri(core._Uri, "dart:core");
>+dart.setFieldSignature(core._Uri, () => ({
>+  __proto__: dart.getFields(core._Uri.__proto__),
>+  scheme: dart.finalFieldType(core.String),
>+  [_userInfo]: dart.finalFieldType(core.String),
>+  [_host]: dart.finalFieldType(core.String),
>+  [_port]: dart.fieldType(core.int),
>+  path: dart.finalFieldType(core.String),
>+  [_query]: dart.finalFieldType(core.String),
>+  [_fragment]: dart.finalFieldType(core.String),
>+  [_pathSegments]: dart.fieldType(ListOfString()),
>+  [_text]: dart.fieldType(core.String),
>+  [_hashCodeCache]: dart.fieldType(core.int),
>+  [_queryParameters]: dart.fieldType(MapOfString$String()),
>+  [_queryParameterLists]: dart.fieldType(MapOfString$ListOfString())
>+}));
>+dart.defineExtensionMethods(core._Uri, ['toString', '_equals']);
>+dart.defineExtensionAccessors(core._Uri, ['hashCode']);
>+dart.defineLazy(core._Uri, {
>+  /*core._Uri._unreservedTable*/get _unreservedTable() {
>+    return dart.constList([0, 0, 24576, 1023, 65534, 34815, 65534, 18431], core.int);
>+  },
>+  /*core._Uri._unreserved2396Table*/get _unreserved2396Table() {
>+    return dart.constList([0, 0, 26498, 1023, 65534, 34815, 65534, 18431], core.int);
>+  },
>+  /*core._Uri._encodeFullTable*/get _encodeFullTable() {
>+    return dart.constList([0, 0, 65498, 45055, 65535, 34815, 65534, 18431], core.int);
>+  },
>+  /*core._Uri._schemeTable*/get _schemeTable() {
>+    return dart.constList([0, 0, 26624, 1023, 65534, 2047, 65534, 2047], core.int);
>+  },
>+  /*core._Uri._schemeLowerTable*/get _schemeLowerTable() {
>+    return dart.constList([0, 0, 26624, 1023, 0, 0, 65534, 2047], core.int);
>+  },
>+  /*core._Uri._subDelimitersTable*/get _subDelimitersTable() {
>+    return dart.constList([0, 0, 32722, 11263, 65534, 34815, 65534, 18431], core.int);
>+  },
>+  /*core._Uri._genDelimitersTable*/get _genDelimitersTable() {
>+    return dart.constList([0, 0, 32776, 33792, 1, 10240, 0, 0], core.int);
>+  },
>+  /*core._Uri._userinfoTable*/get _userinfoTable() {
>+    return dart.constList([0, 0, 32722, 12287, 65534, 34815, 65534, 18431], core.int);
>+  },
>+  /*core._Uri._regNameTable*/get _regNameTable() {
>+    return dart.constList([0, 0, 32754, 11263, 65534, 34815, 65534, 18431], core.int);
>+  },
>+  /*core._Uri._pathCharTable*/get _pathCharTable() {
>+    return dart.constList([0, 0, 32722, 12287, 65535, 34815, 65534, 18431], core.int);
>+  },
>+  /*core._Uri._pathCharOrSlashTable*/get _pathCharOrSlashTable() {
>+    return dart.constList([0, 0, 65490, 12287, 65535, 34815, 65534, 18431], core.int);
>+  },
>+  /*core._Uri._queryCharTable*/get _queryCharTable() {
>+    return dart.constList([0, 0, 65490, 45055, 65535, 34815, 65534, 18431], core.int);
>+  },
>+  /*core._Uri._isWindowsCached*/get _isWindowsCached() {
>+    return typeof process != "undefined" && Object.prototype.toString.call(process) == "[object process]" && process.platform == "win32";
>+  },
>+  /*core._Uri._needsNoEncoding*/get _needsNoEncoding() {
>+    return core.RegExp.new("^[\\-\\.0-9A-Z_a-z~]*$");
>+  }
>+});
>+const _separatorIndices = dart.privateName(core, "_separatorIndices");
>+const _uriCache = dart.privateName(core, "_uriCache");
>+core.UriData = class UriData extends core.Object {
>+  static fromString(content, opts) {
>+    let mimeType = opts && 'mimeType' in opts ? opts.mimeType : null;
>+    let encoding = opts && 'encoding' in opts ? opts.encoding : null;
>+    let parameters = opts && 'parameters' in opts ? opts.parameters : null;
>+    let base64 = opts && 'base64' in opts ? opts.base64 : false;
>+    let buffer = new core.StringBuffer.new();
>+    let indices = JSArrayOfint().of([-1]);
>+    let charsetName = null;
>+    let encodingName = null;
>+    if (parameters != null) charsetName = parameters[$_get]("charset");
>+    if (encoding == null) {
>+      if (charsetName != null) {
>+        encoding = convert.Encoding.getByName(charsetName);
>+      }
>+    } else if (charsetName == null) {
>+      encodingName = encoding.name;
>+    }
>+    let t = encoding;
>+    t == null ? encoding = convert.ascii : t;
>+    core.UriData._writeUri(mimeType, encodingName, parameters, buffer, indices);
>+    indices[$add](buffer.length);
>+    if (dart.test(base64)) {
>+      buffer.write(";base64,");
>+      indices[$add](dart.notNull(buffer.length) - 1);
>+      buffer.write(encoding.fuse(core.String, core.UriData._base64).encode(content));
>+    } else {
>+      buffer.write(",");
>+      core.UriData._uriEncodeBytes(core.UriData._uricTable, encoding.encode(content), buffer);
>+    }
>+    return new core.UriData.__(buffer.toString(), indices, null);
>+  }
>+  static fromBytes(bytes, opts) {
>+    let mimeType = opts && 'mimeType' in opts ? opts.mimeType : "application/octet-stream";
>+    let parameters = opts && 'parameters' in opts ? opts.parameters : null;
>+    let percentEncoded = opts && 'percentEncoded' in opts ? opts.percentEncoded : false;
>+    let buffer = new core.StringBuffer.new();
>+    let indices = JSArrayOfint().of([-1]);
>+    core.UriData._writeUri(core.String._check(mimeType), null, parameters, buffer, indices);
>+    indices[$add](buffer.length);
>+    if (dart.dtest(percentEncoded)) {
>+      buffer.write(",");
>+      core.UriData._uriEncodeBytes(core.UriData._uricTable, bytes, buffer);
>+    } else {
>+      buffer.write(";base64,");
>+      indices[$add](dart.notNull(buffer.length) - 1);
>+      core.UriData._base64.encoder.startChunkedConversion(convert.StringConversionSink.fromStringSink(buffer)).addSlice(bytes, 0, bytes[$length], true);
>+    }
>+    return new core.UriData.__(buffer.toString(), indices, null);
>+  }
>+  static fromUri(uri) {
>+    if (uri.scheme !== "data") {
>+      dart.throw(new core.ArgumentError.value(uri, "uri", "Scheme must be 'data'"));
>+    }
>+    if (dart.test(uri.hasAuthority)) {
>+      dart.throw(new core.ArgumentError.value(uri, "uri", "Data uri must not have authority"));
>+    }
>+    if (dart.test(uri.hasFragment)) {
>+      dart.throw(new core.ArgumentError.value(uri, "uri", "Data uri must not have a fragment part"));
>+    }
>+    if (!dart.test(uri.hasQuery)) {
>+      return core.UriData._parse(uri.path, 0, uri);
>+    }
>+    return core.UriData._parse(dart.str(uri), 5, uri);
>+  }
>+  static _writeUri(mimeType, charsetName, parameters, buffer, indices) {
>+    if (mimeType == null || mimeType === "text/plain") {
>+      mimeType = "";
>+    }
>+    if (mimeType[$isEmpty] || mimeType === "application/octet-stream") {
>+      buffer.write(mimeType);
>+    } else {
>+      let slashIndex = core.UriData._validateMimeType(mimeType);
>+      if (dart.notNull(slashIndex) < 0) {
>+        dart.throw(new core.ArgumentError.value(mimeType, "mimeType", "Invalid MIME type"));
>+      }
>+      buffer.write(core._Uri._uriEncode(core.UriData._tokenCharTable, mimeType[$substring](0, slashIndex), convert.utf8, false));
>+      buffer.write("/");
>+      buffer.write(core._Uri._uriEncode(core.UriData._tokenCharTable, mimeType[$substring](dart.notNull(slashIndex) + 1), convert.utf8, false));
>+    }
>+    if (charsetName != null) {
>+      if (indices != null) {
>+        indices[$add](buffer.length);
>+        indices[$add](dart.notNull(buffer.length) + 8);
>+      }
>+      buffer.write(";charset=");
>+      buffer.write(core._Uri._uriEncode(core.UriData._tokenCharTable, charsetName, convert.utf8, false));
>+    }
>+    parameters == null ? null : parameters[$forEach](dart.fn((key, value) => {
>+      if (key[$isEmpty]) {
>+        dart.throw(new core.ArgumentError.value("", "Parameter names must not be empty"));
>+      }
>+      if (value[$isEmpty]) {
>+        dart.throw(new core.ArgumentError.value("", "Parameter values must not be empty", "parameters[\"" + dart.str(key) + "\"]"));
>+      }
>+      if (indices != null) indices[$add](buffer.length);
>+      buffer.write(";");
>+      buffer.write(core._Uri._uriEncode(core.UriData._tokenCharTable, key, convert.utf8, false));
>+      if (indices != null) indices[$add](buffer.length);
>+      buffer.write("=");
>+      buffer.write(core._Uri._uriEncode(core.UriData._tokenCharTable, value, convert.utf8, false));
>+    }, StringAndStringToNull()));
>+  }
>+  static _validateMimeType(mimeType) {
>+    let slashIndex = -1;
>+    for (let i = 0; i < mimeType.length; i++) {
>+      let char = mimeType[$codeUnitAt](i);
>+      if (char !== 47) continue;
>+      if (slashIndex < 0) {
>+        slashIndex = i;
>+        continue;
>+      }
>+      return -1;
>+    }
>+    return slashIndex;
>+  }
>+  static parse(uri) {
>+    if (uri.length >= 5) {
>+      let dataDelta = core._startsWithData(uri, 0);
>+      if (dataDelta === 0) {
>+        return core.UriData._parse(uri, 5, null);
>+      }
>+      if (dataDelta === 32) {
>+        return core.UriData._parse(uri[$substring](5), 0, null);
>+      }
>+    }
>+    dart.throw(new core.FormatException.new("Does not start with 'data:'", uri, 0));
>+  }
>+  get uri() {
>+    if (this[_uriCache] != null) return this[_uriCache];
>+    let path = this[_text];
>+    let query = null;
>+    let colonIndex = this[_separatorIndices][$_get](0);
>+    let queryIndex = this[_text][$indexOf]("?", dart.notNull(colonIndex) + 1);
>+    let end = this[_text].length;
>+    if (queryIndex >= 0) {
>+      query = core._Uri._normalizeOrSubstring(this[_text], queryIndex + 1, end, core._Uri._queryCharTable);
>+      end = queryIndex;
>+    }
>+    path = core._Uri._normalizeOrSubstring(this[_text], dart.notNull(colonIndex) + 1, end, core._Uri._pathCharOrSlashTable);
>+    this[_uriCache] = new core._DataUri.new(this, path, query);
>+    return this[_uriCache];
>+  }
>+  get mimeType() {
>+    let start = dart.notNull(this[_separatorIndices][$_get](0)) + 1;
>+    let end = this[_separatorIndices][$_get](1);
>+    if (start === end) return "text/plain";
>+    return core._Uri._uriDecode(this[_text], start, end, convert.utf8, false);
>+  }
>+  get charset() {
>+    let parameterStart = 1;
>+    let parameterEnd = dart.notNull(this[_separatorIndices][$length]) - 1;
>+    if (dart.test(this.isBase64)) {
>+      parameterEnd = parameterEnd - 1;
>+    }
>+    for (let i = parameterStart; i < parameterEnd; i = i + 2) {
>+      let keyStart = dart.notNull(this[_separatorIndices][$_get](i)) + 1;
>+      let keyEnd = this[_separatorIndices][$_get](i + 1);
>+      if (keyEnd === keyStart + 7 && this[_text][$startsWith]("charset", keyStart)) {
>+        return core._Uri._uriDecode(this[_text], dart.notNull(keyEnd) + 1, this[_separatorIndices][$_get](i + 2), convert.utf8, false);
>+      }
>+    }
>+    return "US-ASCII";
>+  }
>+  get isBase64() {
>+    return this[_separatorIndices][$length][$isOdd];
>+  }
>+  get contentText() {
>+    return this[_text][$substring](dart.notNull(this[_separatorIndices][$last]) + 1);
>+  }
>+  contentAsBytes() {
>+    let text = this[_text];
>+    let start = dart.notNull(this[_separatorIndices][$last]) + 1;
>+    if (dart.test(this.isBase64)) {
>+      return convert.base64.decoder.convert(text, start);
>+    }
>+    let percent = 37;
>+    let length = text.length - start;
>+    for (let i = start; i < text.length; i++) {
>+      let codeUnit = text[$codeUnitAt](i);
>+      if (codeUnit === percent) {
>+        i = i + 2;
>+        length = length - 2;
>+      }
>+    }
>+    let result = typed_data.Uint8List.new(length);
>+    if (length === text.length) {
>+      result[$setRange](0, length, text[$codeUnits], start);
>+      return result;
>+    }
>+    let index = 0;
>+    for (let i = start; i < text.length; i++) {
>+      let codeUnit = text[$codeUnitAt](i);
>+      if (codeUnit !== percent) {
>+        result[$_set](index++, codeUnit);
>+      } else {
>+        if (i + 2 < text.length) {
>+          let byte = _internal.parseHexByte(text, i + 1);
>+          if (dart.notNull(byte) >= 0) {
>+            result[$_set](index++, byte);
>+            i = i + 2;
>+            continue;
>+          }
>+        }
>+        dart.throw(new core.FormatException.new("Invalid percent escape", text, i));
>+      }
>+    }
>+    if (!(index === result[$length])) dart.assertFailed(null, "dart:core/uri.dart", 3569, 12, "index == result.length");
>+    return result;
>+  }
>+  contentAsString(opts) {
>+    let encoding = opts && 'encoding' in opts ? opts.encoding : null;
>+    if (encoding == null) {
>+      let charset = this.charset;
>+      encoding = convert.Encoding.getByName(charset);
>+      if (encoding == null) {
>+        dart.throw(new core.UnsupportedError.new("Unknown charset: " + dart.str(charset)));
>+      }
>+    }
>+    let text = this[_text];
>+    let start = dart.notNull(this[_separatorIndices][$last]) + 1;
>+    if (dart.test(this.isBase64)) {
>+      let converter = convert.base64.decoder.fuse(core.String, encoding.decoder);
>+      return converter.convert(text[$substring](start));
>+    }
>+    return core._Uri._uriDecode(text, start, text.length, encoding, false);
>+  }
>+  get parameters() {
>+    let result = new (IdentityMapOfString$String()).new();
>+    for (let i = 3; i < dart.notNull(this[_separatorIndices][$length]); i = i + 2) {
>+      let start = dart.notNull(this[_separatorIndices][$_get](i - 2)) + 1;
>+      let equals = this[_separatorIndices][$_get](i - 1);
>+      let end = this[_separatorIndices][$_get](i);
>+      let key = core._Uri._uriDecode(this[_text], start, equals, convert.utf8, false);
>+      let value = core._Uri._uriDecode(this[_text], dart.notNull(equals) + 1, end, convert.utf8, false);
>+      result[$_set](key, value);
>+    }
>+    return result;
>+  }
>+  static _parse(text, start, sourceUri) {
>+    if (!(start === 0 || start === 5)) dart.assertFailed(null, "dart:core/uri.dart", 3632, 12, "start == 0 || start == 5");
>+    if (!(start === 5 === text[$startsWith]("data:"))) dart.assertFailed(null, "dart:core/uri.dart", 3633, 12, "(start == 5) == text.startsWith(\"data:\")");
>+    let comma = 44;
>+    let slash = 47;
>+    let semicolon = 59;
>+    let equals = 61;
>+    let indices = JSArrayOfint().of([dart.notNull(start) - 1]);
>+    let slashIndex = -1;
>+    let char = null;
>+    let i = start;
>+    for (; dart.notNull(i) < text.length; i = dart.notNull(i) + 1) {
>+      char = text[$codeUnitAt](i);
>+      if (dart.equals(char, comma) || dart.equals(char, semicolon)) break;
>+      if (dart.equals(char, slash)) {
>+        if (dart.notNull(slashIndex) < 0) {
>+          slashIndex = i;
>+          continue;
>+        }
>+        dart.throw(new core.FormatException.new("Invalid MIME type", text, i));
>+      }
>+    }
>+    if (dart.notNull(slashIndex) < 0 && dart.notNull(i) > dart.notNull(start)) {
>+      dart.throw(new core.FormatException.new("Invalid MIME type", text, i));
>+    }
>+    while (!dart.equals(char, comma)) {
>+      indices[$add](i);
>+      i = dart.notNull(i) + 1;
>+      let equalsIndex = -1;
>+      for (; dart.notNull(i) < text.length; i = dart.notNull(i) + 1) {
>+        char = text[$codeUnitAt](i);
>+        if (dart.equals(char, equals)) {
>+          if (dart.notNull(equalsIndex) < 0) equalsIndex = i;
>+        } else if (dart.equals(char, semicolon) || dart.equals(char, comma)) {
>+          break;
>+        }
>+      }
>+      if (dart.notNull(equalsIndex) >= 0) {
>+        indices[$add](equalsIndex);
>+      } else {
>+        let lastSeparator = indices[$last];
>+        if (!dart.equals(char, comma) || i !== dart.notNull(lastSeparator) + 7 || !text[$startsWith]("base64", dart.notNull(lastSeparator) + 1)) {
>+          dart.throw(new core.FormatException.new("Expecting '='", text, i));
>+        }
>+        break;
>+      }
>+    }
>+    indices[$add](i);
>+    let isBase64 = indices[$length][$isOdd];
>+    if (isBase64) {
>+      text = convert.base64.normalize(text, dart.notNull(i) + 1, text.length);
>+    } else {
>+      let data = core._Uri._normalize(text, dart.notNull(i) + 1, text.length, core.UriData._uricTable, {escapeDelimiters: true});
>+      if (data != null) {
>+        text = text[$replaceRange](dart.notNull(i) + 1, text.length, data);
>+      }
>+    }
>+    return new core.UriData.__(text, indices, sourceUri);
>+  }
>+  static _uriEncodeBytes(canonicalTable, bytes, buffer) {
>+    let byteOr = 0;
>+    for (let i = 0; i < dart.notNull(bytes[$length]); i++) {
>+      let byte = bytes[$_get](i);
>+      byteOr = (byteOr | dart.notNull(byte)) >>> 0;
>+      if (dart.notNull(byte) < 128 && (dart.notNull(canonicalTable[$_get](byte[$rightShift](4))) & 1 << (dart.notNull(byte) & 15)) !== 0) {
>+        buffer.writeCharCode(byte);
>+      } else {
>+        buffer.writeCharCode(37);
>+        buffer.writeCharCode("0123456789ABCDEF"[$codeUnitAt](byte[$rightShift](4)));
>+        buffer.writeCharCode("0123456789ABCDEF"[$codeUnitAt](dart.notNull(byte) & 15));
>+      }
>+    }
>+    if ((byteOr & ~255) !== 0) {
>+      for (let i = 0; i < dart.notNull(bytes[$length]); i++) {
>+        let byte = bytes[$_get](i);
>+        if (dart.notNull(byte) < 0 || dart.notNull(byte) > 255) {
>+          dart.throw(new core.ArgumentError.value(byte, "non-byte value"));
>+        }
>+      }
>+    }
>+  }
>+  toString() {
>+    return this[_separatorIndices][$_get](0) === -1 ? "data:" + dart.str(this[_text]) : this[_text];
>+  }
>+};
>+(core.UriData.__ = function(text, separatorIndices, uriCache) {
>+  this[_text] = text;
>+  this[_separatorIndices] = separatorIndices;
>+  this[_uriCache] = uriCache;
>+}).prototype = core.UriData.prototype;
>+dart.addTypeTests(core.UriData);
>+dart.setMethodSignature(core.UriData, () => ({
>+  __proto__: dart.getMethods(core.UriData.__proto__),
>+  contentAsBytes: dart.fnType(typed_data.Uint8List, []),
>+  contentAsString: dart.fnType(core.String, [], {encoding: convert.Encoding})
>+}));
>+dart.setGetterSignature(core.UriData, () => ({
>+  __proto__: dart.getGetters(core.UriData.__proto__),
>+  uri: core.Uri,
>+  mimeType: core.String,
>+  charset: core.String,
>+  isBase64: core.bool,
>+  contentText: core.String,
>+  parameters: core.Map$(core.String, core.String)
>+}));
>+dart.setLibraryUri(core.UriData, "dart:core");
>+dart.setFieldSignature(core.UriData, () => ({
>+  __proto__: dart.getFields(core.UriData.__proto__),
>+  [_text]: dart.finalFieldType(core.String),
>+  [_separatorIndices]: dart.finalFieldType(ListOfint()),
>+  [_uriCache]: dart.fieldType(core.Uri)
>+}));
>+dart.defineExtensionMethods(core.UriData, ['toString']);
>+dart.defineLazy(core.UriData, {
>+  /*core.UriData._noScheme*/get _noScheme() {
>+    return -1;
>+  },
>+  /*core.UriData._base64*/get _base64() {
>+    return convert.base64;
>+  },
>+  /*core.UriData._tokenCharTable*/get _tokenCharTable() {
>+    return dart.constList([0, 0, 27858, 1023, 65534, 51199, 65535, 32767], core.int);
>+  },
>+  /*core.UriData._uricTable*/get _uricTable() {
>+    return core._Uri._queryCharTable;
>+  },
>+  /*core.UriData._base64Table*/get _base64Table() {
>+    return dart.constList([0, 0, 34816, 1023, 65534, 2047, 65534, 2047], core.int);
>+  }
>+});
>+dart.defineLazy(core, {
>+  /*core._schemeEndIndex*/get _schemeEndIndex() {
>+    return 1;
>+  },
>+  /*core._hostStartIndex*/get _hostStartIndex() {
>+    return 2;
>+  },
>+  /*core._portStartIndex*/get _portStartIndex() {
>+    return 3;
>+  },
>+  /*core._pathStartIndex*/get _pathStartIndex() {
>+    return 4;
>+  },
>+  /*core._queryStartIndex*/get _queryStartIndex() {
>+    return 5;
>+  },
>+  /*core._fragmentStartIndex*/get _fragmentStartIndex() {
>+    return 6;
>+  },
>+  /*core._notSimpleIndex*/get _notSimpleIndex() {
>+    return 7;
>+  },
>+  /*core._uriStart*/get _uriStart() {
>+    return 0;
>+  },
>+  /*core._nonSimpleEndStates*/get _nonSimpleEndStates() {
>+    return 14;
>+  },
>+  /*core._schemeStart*/get _schemeStart() {
>+    return 20;
>+  },
>+  /*core._scannerTables*/get _scannerTables() {
>+    return core._createTables();
>+  }
>+});
>+core._createTables = function() {
>+  let stateCount = 22;
>+  let schemeOrPath = 1;
>+  let authOrPath = 2;
>+  let authOrPathSlash = 3;
>+  let uinfoOrHost0 = 4;
>+  let uinfoOrHost = 5;
>+  let uinfoOrPort0 = 6;
>+  let uinfoOrPort = 7;
>+  let ipv6Host = 8;
>+  let relPathSeg = 9;
>+  let pathSeg = 10;
>+  let path = 11;
>+  let query = 12;
>+  let fragment = 13;
>+  let schemeOrPathDot = 14;
>+  let schemeOrPathDot2 = 15;
>+  let relPathSegDot = 16;
>+  let relPathSegDot2 = 17;
>+  let pathSegDot = 18;
>+  let pathSegDot2 = 19;
>+  let scheme0 = 20;
>+  let scheme = 21;
>+  let schemeEnd = 1 << 5;
>+  let hostStart = 2 << 5;
>+  let portStart = 3 << 5;
>+  let pathStart = 4 << 5;
>+  let queryStart = 5 << 5;
>+  let fragmentStart = 6 << 5;
>+  let notSimple = 7 << 5;
>+  let unreserved = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-._~";
>+  let subDelims = "!$&'()*+,;=";
>+  let pchar = unreserved + subDelims;
>+  let tables = ListOfUint8List().generate(stateCount, dart.fn(_ => typed_data.Uint8List.new(96), intToUint8List()));
>+  function build(state, defaultTransition) {
>+    let _ = tables[$_get](core.int._check(state));
>+    _[$fillRange](0, 96, core.int._check(defaultTransition));
>+    return _;
>+  }
>+  dart.fn(build, dynamicAnddynamicToUint8List());
>+  function setChars(target, chars, transition) {
>+    for (let i = 0; i < chars.length; i++) {
>+      let char = chars[$codeUnitAt](i);
>+      target[$_set]((char ^ 96) >>> 0, transition);
>+    }
>+  }
>+  dart.fn(setChars, Uint8ListAndStringAndintTovoid());
>+  function setRange(target, range, transition) {
>+    for (let i = range[$codeUnitAt](0), n = range[$codeUnitAt](1); i <= n; i++) {
>+      target[$_set]((i ^ 96) >>> 0, transition);
>+    }
>+  }
>+  dart.fn(setRange, Uint8ListAndStringAndintTovoid());
>+  let b = null;
>+  b = build(0, (schemeOrPath | notSimple) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), pchar, schemeOrPath);
>+  setChars(typed_data.Uint8List._check(b), ".", schemeOrPathDot);
>+  setChars(typed_data.Uint8List._check(b), ":", (authOrPath | schemeEnd) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "/", authOrPathSlash);
>+  setChars(typed_data.Uint8List._check(b), "?", (query | queryStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "#", (fragment | fragmentStart) >>> 0);
>+  b = build(schemeOrPathDot, (schemeOrPath | notSimple) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), pchar, schemeOrPath);
>+  setChars(typed_data.Uint8List._check(b), ".", schemeOrPathDot2);
>+  setChars(typed_data.Uint8List._check(b), ":", (authOrPath | schemeEnd) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "/", (pathSeg | notSimple) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "?", (query | queryStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "#", (fragment | fragmentStart) >>> 0);
>+  b = build(schemeOrPathDot2, (schemeOrPath | notSimple) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), pchar, schemeOrPath);
>+  setChars(typed_data.Uint8List._check(b), "%", (schemeOrPath | notSimple) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), ":", (authOrPath | schemeEnd) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "/", relPathSeg);
>+  setChars(typed_data.Uint8List._check(b), "?", (query | queryStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "#", (fragment | fragmentStart) >>> 0);
>+  b = build(schemeOrPath, (schemeOrPath | notSimple) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), pchar, schemeOrPath);
>+  setChars(typed_data.Uint8List._check(b), ":", (authOrPath | schemeEnd) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "/", pathSeg);
>+  setChars(typed_data.Uint8List._check(b), "?", (query | queryStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "#", (fragment | fragmentStart) >>> 0);
>+  b = build(authOrPath, (path | notSimple) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), pchar, (path | pathStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "/", (authOrPathSlash | pathStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), ".", (pathSegDot | pathStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "?", (query | queryStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "#", (fragment | fragmentStart) >>> 0);
>+  b = build(authOrPathSlash, (path | notSimple) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), pchar, path);
>+  setChars(typed_data.Uint8List._check(b), "/", (uinfoOrHost0 | hostStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), ".", pathSegDot);
>+  setChars(typed_data.Uint8List._check(b), "?", (query | queryStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "#", (fragment | fragmentStart) >>> 0);
>+  b = build(uinfoOrHost0, (uinfoOrHost | notSimple) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), pchar, uinfoOrHost);
>+  setRange(typed_data.Uint8List._check(b), "AZ", (uinfoOrHost | notSimple) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), ":", (uinfoOrPort0 | portStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "@", (uinfoOrHost0 | hostStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "[", (ipv6Host | notSimple) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "/", (pathSeg | pathStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "?", (query | queryStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "#", (fragment | fragmentStart) >>> 0);
>+  b = build(uinfoOrHost, (uinfoOrHost | notSimple) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), pchar, uinfoOrHost);
>+  setRange(typed_data.Uint8List._check(b), "AZ", (uinfoOrHost | notSimple) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), ":", (uinfoOrPort0 | portStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "@", (uinfoOrHost0 | hostStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "/", (pathSeg | pathStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "?", (query | queryStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "#", (fragment | fragmentStart) >>> 0);
>+  b = build(uinfoOrPort0, (uinfoOrPort | notSimple) >>> 0);
>+  setRange(typed_data.Uint8List._check(b), "19", uinfoOrPort);
>+  setChars(typed_data.Uint8List._check(b), "@", (uinfoOrHost0 | hostStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "/", (pathSeg | pathStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "?", (query | queryStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "#", (fragment | fragmentStart) >>> 0);
>+  b = build(uinfoOrPort, (uinfoOrPort | notSimple) >>> 0);
>+  setRange(typed_data.Uint8List._check(b), "09", uinfoOrPort);
>+  setChars(typed_data.Uint8List._check(b), "@", (uinfoOrHost0 | hostStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "/", (pathSeg | pathStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "?", (query | queryStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "#", (fragment | fragmentStart) >>> 0);
>+  b = build(ipv6Host, ipv6Host);
>+  setChars(typed_data.Uint8List._check(b), "]", uinfoOrHost);
>+  b = build(relPathSeg, (path | notSimple) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), pchar, path);
>+  setChars(typed_data.Uint8List._check(b), ".", relPathSegDot);
>+  setChars(typed_data.Uint8List._check(b), "/", (pathSeg | notSimple) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "?", (query | queryStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "#", (fragment | fragmentStart) >>> 0);
>+  b = build(relPathSegDot, (path | notSimple) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), pchar, path);
>+  setChars(typed_data.Uint8List._check(b), ".", relPathSegDot2);
>+  setChars(typed_data.Uint8List._check(b), "/", (pathSeg | notSimple) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "?", (query | queryStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "#", (fragment | fragmentStart) >>> 0);
>+  b = build(relPathSegDot2, (path | notSimple) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), pchar, path);
>+  setChars(typed_data.Uint8List._check(b), "/", relPathSeg);
>+  setChars(typed_data.Uint8List._check(b), "?", (query | queryStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "#", (fragment | fragmentStart) >>> 0);
>+  b = build(pathSeg, (path | notSimple) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), pchar, path);
>+  setChars(typed_data.Uint8List._check(b), ".", pathSegDot);
>+  setChars(typed_data.Uint8List._check(b), "/", (pathSeg | notSimple) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "?", (query | queryStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "#", (fragment | fragmentStart) >>> 0);
>+  b = build(pathSegDot, (path | notSimple) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), pchar, path);
>+  setChars(typed_data.Uint8List._check(b), ".", pathSegDot2);
>+  setChars(typed_data.Uint8List._check(b), "/", (pathSeg | notSimple) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "?", (query | queryStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "#", (fragment | fragmentStart) >>> 0);
>+  b = build(pathSegDot2, (path | notSimple) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), pchar, path);
>+  setChars(typed_data.Uint8List._check(b), "/", (pathSeg | notSimple) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "?", (query | queryStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "#", (fragment | fragmentStart) >>> 0);
>+  b = build(path, (path | notSimple) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), pchar, path);
>+  setChars(typed_data.Uint8List._check(b), "/", pathSeg);
>+  setChars(typed_data.Uint8List._check(b), "?", (query | queryStart) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), "#", (fragment | fragmentStart) >>> 0);
>+  b = build(query, (query | notSimple) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), pchar, query);
>+  setChars(typed_data.Uint8List._check(b), "?", query);
>+  setChars(typed_data.Uint8List._check(b), "#", (fragment | fragmentStart) >>> 0);
>+  b = build(fragment, (fragment | notSimple) >>> 0);
>+  setChars(typed_data.Uint8List._check(b), pchar, fragment);
>+  setChars(typed_data.Uint8List._check(b), "?", fragment);
>+  b = build(scheme0, (scheme | notSimple) >>> 0);
>+  setRange(typed_data.Uint8List._check(b), "az", scheme);
>+  b = build(scheme, (scheme | notSimple) >>> 0);
>+  setRange(typed_data.Uint8List._check(b), "az", scheme);
>+  setRange(typed_data.Uint8List._check(b), "09", scheme);
>+  setChars(typed_data.Uint8List._check(b), "+-.", scheme);
>+  return tables;
>+};
>+core._scan = function(uri, start, end, state, indices) {
>+  let tables = core._scannerTables;
>+  if (!(dart.notNull(end) <= uri.length)) dart.assertFailed(null, "dart:core/uri.dart", 4170, 10, "end <= uri.length");
>+  for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
>+    let table = tables[$_get](state);
>+    let char = (uri[$codeUnitAt](i) ^ 96) >>> 0;
>+    if (char > 95) char = 31;
>+    let transition = table[$_get](char);
>+    state = dart.notNull(transition) & 31;
>+    indices[$_set](transition[$rightShift](5), i);
>+  }
>+  return state;
>+};
>+const _uri = dart.privateName(core, "_uri");
>+const _schemeEnd = dart.privateName(core, "_schemeEnd");
>+const _hostStart = dart.privateName(core, "_hostStart");
>+const _portStart = dart.privateName(core, "_portStart");
>+const _pathStart = dart.privateName(core, "_pathStart");
>+const _queryStart = dart.privateName(core, "_queryStart");
>+const _fragmentStart = dart.privateName(core, "_fragmentStart");
>+const _schemeCache = dart.privateName(core, "_schemeCache");
>+const _isFile = dart.privateName(core, "_isFile");
>+const _isHttp = dart.privateName(core, "_isHttp");
>+const _isHttps = dart.privateName(core, "_isHttps");
>+const _isPackage = dart.privateName(core, "_isPackage");
>+const _isScheme = dart.privateName(core, "_isScheme");
>+let const$61;
>+let const$62;
>+let const$63;
>+const _isPort = dart.privateName(core, "_isPort");
>+const _simpleMerge = dart.privateName(core, "_simpleMerge");
>+const _toNonSimple = dart.privateName(core, "_toNonSimple");
>+core._SimpleUri = class _SimpleUri extends core.Object {
>+  get hasScheme() {
>+    return dart.notNull(this[_schemeEnd]) > 0;
>+  }
>+  get hasAuthority() {
>+    return dart.notNull(this[_hostStart]) > 0;
>+  }
>+  get hasUserInfo() {
>+    return dart.notNull(this[_hostStart]) > dart.notNull(this[_schemeEnd]) + 4;
>+  }
>+  get hasPort() {
>+    return dart.notNull(this[_hostStart]) > 0 && dart.notNull(this[_portStart]) + 1 < dart.notNull(this[_pathStart]);
>+  }
>+  get hasQuery() {
>+    return dart.notNull(this[_queryStart]) < dart.notNull(this[_fragmentStart]);
>+  }
>+  get hasFragment() {
>+    return dart.notNull(this[_fragmentStart]) < this[_uri].length;
>+  }
>+  get [_isFile]() {
>+    return this[_schemeEnd] === 4 && this[_uri][$startsWith]("file");
>+  }
>+  get [_isHttp]() {
>+    return this[_schemeEnd] === 4 && this[_uri][$startsWith]("http");
>+  }
>+  get [_isHttps]() {
>+    return this[_schemeEnd] === 5 && this[_uri][$startsWith]("https");
>+  }
>+  get [_isPackage]() {
>+    return this[_schemeEnd] === 7 && this[_uri][$startsWith]("package");
>+  }
>+  [_isScheme](scheme) {
>+    return this[_schemeEnd] === scheme.length && this[_uri][$startsWith](scheme);
>+  }
>+  get hasAbsolutePath() {
>+    return this[_uri][$startsWith]("/", this[_pathStart]);
>+  }
>+  get hasEmptyPath() {
>+    return this[_pathStart] == this[_queryStart];
>+  }
>+  get isAbsolute() {
>+    return dart.test(this.hasScheme) && !dart.test(this.hasFragment);
>+  }
>+  isScheme(scheme) {
>+    if (scheme == null || scheme[$isEmpty]) return dart.notNull(this[_schemeEnd]) < 0;
>+    if (scheme.length !== this[_schemeEnd]) return false;
>+    return core._Uri._compareScheme(scheme, this[_uri]);
>+  }
>+  get scheme() {
>+    if (dart.notNull(this[_schemeEnd]) <= 0) return "";
>+    if (this[_schemeCache] != null) return this[_schemeCache];
>+    if (dart.test(this[_isHttp])) {
>+      this[_schemeCache] = "http";
>+    } else if (dart.test(this[_isHttps])) {
>+      this[_schemeCache] = "https";
>+    } else if (dart.test(this[_isFile])) {
>+      this[_schemeCache] = "file";
>+    } else if (dart.test(this[_isPackage])) {
>+      this[_schemeCache] = "package";
>+    } else {
>+      this[_schemeCache] = this[_uri][$substring](0, this[_schemeEnd]);
>+    }
>+    return this[_schemeCache];
>+  }
>+  get authority() {
>+    return dart.notNull(this[_hostStart]) > 0 ? this[_uri][$substring](dart.notNull(this[_schemeEnd]) + 3, this[_pathStart]) : "";
>+  }
>+  get userInfo() {
>+    return dart.notNull(this[_hostStart]) > dart.notNull(this[_schemeEnd]) + 3 ? this[_uri][$substring](dart.notNull(this[_schemeEnd]) + 3, dart.notNull(this[_hostStart]) - 1) : "";
>+  }
>+  get host() {
>+    return dart.notNull(this[_hostStart]) > 0 ? this[_uri][$substring](this[_hostStart], this[_portStart]) : "";
>+  }
>+  get port() {
>+    if (dart.test(this.hasPort)) return core.int.parse(this[_uri][$substring](dart.notNull(this[_portStart]) + 1, this[_pathStart]));
>+    if (dart.test(this[_isHttp])) return 80;
>+    if (dart.test(this[_isHttps])) return 443;
>+    return 0;
>+  }
>+  get path() {
>+    return this[_uri][$substring](this[_pathStart], this[_queryStart]);
>+  }
>+  get query() {
>+    return dart.notNull(this[_queryStart]) < dart.notNull(this[_fragmentStart]) ? this[_uri][$substring](dart.notNull(this[_queryStart]) + 1, this[_fragmentStart]) : "";
>+  }
>+  get fragment() {
>+    return dart.notNull(this[_fragmentStart]) < this[_uri].length ? this[_uri][$substring](dart.notNull(this[_fragmentStart]) + 1) : "";
>+  }
>+  get origin() {
>+    let isHttp = this[_isHttp];
>+    if (dart.notNull(this[_schemeEnd]) < 0) {
>+      dart.throw(new core.StateError.new("Cannot use origin without a scheme: " + dart.str(this)));
>+    }
>+    if (!dart.test(isHttp) && !dart.test(this[_isHttps])) {
>+      dart.throw(new core.StateError.new("Origin is only applicable to schemes http and https: " + dart.str(this)));
>+    }
>+    if (this[_hostStart] == this[_portStart]) {
>+      dart.throw(new core.StateError.new("A " + dart.str(this.scheme) + ": URI should have a non-empty host name: " + dart.str(this)));
>+    }
>+    if (this[_hostStart] === dart.notNull(this[_schemeEnd]) + 3) {
>+      return this[_uri][$substring](0, this[_pathStart]);
>+    }
>+    return this[_uri][$substring](0, dart.notNull(this[_schemeEnd]) + 3) + this[_uri][$substring](this[_hostStart], this[_pathStart]);
>+  }
>+  get pathSegments() {
>+    let start = this[_pathStart];
>+    let end = this[_queryStart];
>+    if (this[_uri][$startsWith]("/", start)) {
>+      start = dart.notNull(start) + 1;
>+    }
>+    if (start == end) return const$61 || (const$61 = dart.constList([], core.String));
>+    let parts = JSArrayOfString().of([]);
>+    for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
>+      let char = this[_uri][$codeUnitAt](i);
>+      if (char === 47) {
>+        parts[$add](this[_uri][$substring](start, i));
>+        start = dart.notNull(i) + 1;
>+      }
>+    }
>+    parts[$add](this[_uri][$substring](start, end));
>+    return ListOfString().unmodifiable(parts);
>+  }
>+  get queryParameters() {
>+    if (!dart.test(this.hasQuery)) return const$62 || (const$62 = dart.constMap(core.String, core.String, []));
>+    return new (UnmodifiableMapViewOfString$String()).new(core.Uri.splitQueryString(this.query));
>+  }
>+  get queryParametersAll() {
>+    if (!dart.test(this.hasQuery)) return const$63 || (const$63 = dart.constMap(core.String, ListOfString(), []));
>+    let queryParameterLists = core._Uri._splitQueryStringAll(this.query);
>+    for (let key of queryParameterLists[$keys]) {
>+      queryParameterLists[$_set](key, ListOfString().unmodifiable(core.Iterable._check(queryParameterLists[$_get](key))));
>+    }
>+    return MapOfString$ListOfString().unmodifiable(queryParameterLists);
>+  }
>+  [_isPort](port) {
>+    let portDigitStart = dart.notNull(this[_portStart]) + 1;
>+    return portDigitStart + port.length === this[_pathStart] && this[_uri][$startsWith](port, portDigitStart);
>+  }
>+  normalizePath() {
>+    return this;
>+  }
>+  removeFragment() {
>+    if (!dart.test(this.hasFragment)) return this;
>+    return new core._SimpleUri.new(this[_uri][$substring](0, this[_fragmentStart]), this[_schemeEnd], this[_hostStart], this[_portStart], this[_pathStart], this[_queryStart], this[_fragmentStart], this[_schemeCache]);
>+  }
>+  replace(opts) {
>+    let scheme = opts && 'scheme' in opts ? opts.scheme : null;
>+    let userInfo = opts && 'userInfo' in opts ? opts.userInfo : null;
>+    let host = opts && 'host' in opts ? opts.host : null;
>+    let port = opts && 'port' in opts ? opts.port : null;
>+    let path = opts && 'path' in opts ? opts.path : null;
>+    let pathSegments = opts && 'pathSegments' in opts ? opts.pathSegments : null;
>+    let query = opts && 'query' in opts ? opts.query : null;
>+    let queryParameters = opts && 'queryParameters' in opts ? opts.queryParameters : null;
>+    let fragment = opts && 'fragment' in opts ? opts.fragment : null;
>+    let schemeChanged = false;
>+    if (scheme != null) {
>+      scheme = core._Uri._makeScheme(scheme, 0, scheme.length);
>+      schemeChanged = !dart.test(this[_isScheme](scheme));
>+    } else {
>+      scheme = this.scheme;
>+    }
>+    let isFile = scheme === "file";
>+    if (userInfo != null) {
>+      userInfo = core._Uri._makeUserInfo(userInfo, 0, userInfo.length);
>+    } else if (dart.notNull(this[_hostStart]) > 0) {
>+      userInfo = this[_uri][$substring](dart.notNull(this[_schemeEnd]) + 3, this[_hostStart]);
>+    } else {
>+      userInfo = "";
>+    }
>+    if (port != null) {
>+      port = core._Uri._makePort(port, scheme);
>+    } else {
>+      port = dart.test(this.hasPort) ? this.port : null;
>+      if (schemeChanged) {
>+        port = core._Uri._makePort(port, scheme);
>+      }
>+    }
>+    if (host != null) {
>+      host = core._Uri._makeHost(host, 0, host.length, false);
>+    } else if (dart.notNull(this[_hostStart]) > 0) {
>+      host = this[_uri][$substring](this[_hostStart], this[_portStart]);
>+    } else if (userInfo[$isNotEmpty] || port != null || isFile) {
>+      host = "";
>+    }
>+    let hasAuthority = host != null;
>+    if (path != null || pathSegments != null) {
>+      path = core._Uri._makePath(path, 0, core._stringOrNullLength(path), pathSegments, scheme, hasAuthority);
>+    } else {
>+      path = this[_uri][$substring](this[_pathStart], this[_queryStart]);
>+      if ((isFile || hasAuthority && !path[$isEmpty]) && !path[$startsWith]("/")) {
>+        path = "/" + dart.notNull(path);
>+      }
>+    }
>+    if (query != null || queryParameters != null) {
>+      query = core._Uri._makeQuery(query, 0, core._stringOrNullLength(query), queryParameters);
>+    } else if (dart.notNull(this[_queryStart]) < dart.notNull(this[_fragmentStart])) {
>+      query = this[_uri][$substring](dart.notNull(this[_queryStart]) + 1, this[_fragmentStart]);
>+    }
>+    if (fragment != null) {
>+      fragment = core._Uri._makeFragment(fragment, 0, fragment.length);
>+    } else if (dart.notNull(this[_fragmentStart]) < this[_uri].length) {
>+      fragment = this[_uri][$substring](dart.notNull(this[_fragmentStart]) + 1);
>+    }
>+    return new core._Uri._internal(scheme, userInfo, host, port, path, query, fragment);
>+  }
>+  resolve(reference) {
>+    return this.resolveUri(core.Uri.parse(reference));
>+  }
>+  resolveUri(reference) {
>+    if (core._SimpleUri.is(reference)) {
>+      return this[_simpleMerge](this, reference);
>+    }
>+    return this[_toNonSimple]().resolveUri(reference);
>+  }
>+  [_simpleMerge](base, ref) {
>+    if (dart.test(ref.hasScheme)) return ref;
>+    if (dart.test(ref.hasAuthority)) {
>+      if (!dart.test(base.hasScheme)) return ref;
>+      let isSimple = true;
>+      if (dart.test(base[_isFile])) {
>+        isSimple = !dart.test(ref.hasEmptyPath);
>+      } else if (dart.test(base[_isHttp])) {
>+        isSimple = !dart.test(ref[_isPort]("80"));
>+      } else if (dart.test(base[_isHttps])) {
>+        isSimple = !dart.test(ref[_isPort]("443"));
>+      }
>+      if (isSimple) {
>+        let delta = dart.notNull(base[_schemeEnd]) + 1;
>+        let newUri = base[_uri][$substring](0, dart.notNull(base[_schemeEnd]) + 1) + ref[_uri][$substring](dart.notNull(ref[_schemeEnd]) + 1);
>+        return new core._SimpleUri.new(newUri, base[_schemeEnd], dart.notNull(ref[_hostStart]) + delta, dart.notNull(ref[_portStart]) + delta, dart.notNull(ref[_pathStart]) + delta, dart.notNull(ref[_queryStart]) + delta, dart.notNull(ref[_fragmentStart]) + delta, base[_schemeCache]);
>+      } else {
>+        return this[_toNonSimple]().resolveUri(ref);
>+      }
>+    }
>+    if (dart.test(ref.hasEmptyPath)) {
>+      if (dart.test(ref.hasQuery)) {
>+        let delta = dart.notNull(base[_queryStart]) - dart.notNull(ref[_queryStart]);
>+        let newUri = base[_uri][$substring](0, base[_queryStart]) + ref[_uri][$substring](ref[_queryStart]);
>+        return new core._SimpleUri.new(newUri, base[_schemeEnd], base[_hostStart], base[_portStart], base[_pathStart], dart.notNull(ref[_queryStart]) + delta, dart.notNull(ref[_fragmentStart]) + delta, base[_schemeCache]);
>+      }
>+      if (dart.test(ref.hasFragment)) {
>+        let delta = dart.notNull(base[_fragmentStart]) - dart.notNull(ref[_fragmentStart]);
>+        let newUri = base[_uri][$substring](0, base[_fragmentStart]) + ref[_uri][$substring](ref[_fragmentStart]);
>+        return new core._SimpleUri.new(newUri, base[_schemeEnd], base[_hostStart], base[_portStart], base[_pathStart], base[_queryStart], dart.notNull(ref[_fragmentStart]) + delta, base[_schemeCache]);
>+      }
>+      return base.removeFragment();
>+    }
>+    if (dart.test(ref.hasAbsolutePath)) {
>+      let delta = dart.notNull(base[_pathStart]) - dart.notNull(ref[_pathStart]);
>+      let newUri = base[_uri][$substring](0, base[_pathStart]) + ref[_uri][$substring](ref[_pathStart]);
>+      return new core._SimpleUri.new(newUri, base[_schemeEnd], base[_hostStart], base[_portStart], base[_pathStart], dart.notNull(ref[_queryStart]) + delta, dart.notNull(ref[_fragmentStart]) + delta, base[_schemeCache]);
>+    }
>+    if (dart.test(base.hasEmptyPath) && dart.test(base.hasAuthority)) {
>+      let refStart = ref[_pathStart];
>+      while (ref[_uri][$startsWith]("../", refStart)) {
>+        refStart = dart.notNull(refStart) + 3;
>+      }
>+      let delta = dart.notNull(base[_pathStart]) - dart.notNull(refStart) + 1;
>+      let newUri = base[_uri][$substring](0, base[_pathStart]) + "/" + ref[_uri][$substring](refStart);
>+      return new core._SimpleUri.new(newUri, base[_schemeEnd], base[_hostStart], base[_portStart], base[_pathStart], dart.notNull(ref[_queryStart]) + delta, dart.notNull(ref[_fragmentStart]) + delta, base[_schemeCache]);
>+    }
>+    let baseUri = base[_uri];
>+    let refUri = ref[_uri];
>+    let baseStart = base[_pathStart];
>+    let baseEnd = base[_queryStart];
>+    while (baseUri[$startsWith]("../", baseStart)) {
>+      baseStart = dart.notNull(baseStart) + 3;
>+    }
>+    let refStart = ref[_pathStart];
>+    let refEnd = ref[_queryStart];
>+    let backCount = 0;
>+    while (dart.notNull(refStart) + 3 <= dart.notNull(refEnd) && refUri[$startsWith]("../", refStart)) {
>+      refStart = dart.notNull(refStart) + 3;
>+      backCount = backCount + 1;
>+    }
>+    let insert = "";
>+    while (dart.notNull(baseEnd) > dart.notNull(baseStart)) {
>+      baseEnd = dart.notNull(baseEnd) - 1;
>+      let char = baseUri[$codeUnitAt](baseEnd);
>+      if (char === 47) {
>+        insert = "/";
>+        if (backCount === 0) break;
>+        backCount--;
>+      }
>+    }
>+    if (baseEnd == baseStart && !dart.test(base.hasScheme) && !dart.test(base.hasAbsolutePath)) {
>+      insert = "";
>+      refStart = dart.notNull(refStart) - backCount * 3;
>+    }
>+    let delta = dart.notNull(baseEnd) - dart.notNull(refStart) + insert.length;
>+    let newUri = base[_uri][$substring](0, baseEnd) + insert + ref[_uri][$substring](refStart);
>+    return new core._SimpleUri.new(newUri, base[_schemeEnd], base[_hostStart], base[_portStart], base[_pathStart], dart.notNull(ref[_queryStart]) + delta, dart.notNull(ref[_fragmentStart]) + delta, base[_schemeCache]);
>+  }
>+  toFilePath(opts) {
>+    let windows = opts && 'windows' in opts ? opts.windows : null;
>+    if (dart.notNull(this[_schemeEnd]) >= 0 && !dart.test(this[_isFile])) {
>+      dart.throw(new core.UnsupportedError.new("Cannot extract a file path from a " + dart.str(this.scheme) + " URI"));
>+    }
>+    if (dart.notNull(this[_queryStart]) < this[_uri].length) {
>+      if (dart.notNull(this[_queryStart]) < dart.notNull(this[_fragmentStart])) {
>+        dart.throw(new core.UnsupportedError.new("Cannot extract a file path from a URI with a query component"));
>+      }
>+      dart.throw(new core.UnsupportedError.new("Cannot extract a file path from a URI with a fragment component"));
>+    }
>+    let t = windows;
>+    t == null ? windows = core._Uri._isWindows : t;
>+    return dart.test(windows) ? core._Uri._toWindowsFilePath(this) : this[_toFilePath]();
>+  }
>+  [_toFilePath]() {
>+    if (dart.notNull(this[_hostStart]) < dart.notNull(this[_portStart])) {
>+      dart.throw(new core.UnsupportedError.new("Cannot extract a non-Windows file path from a file URI " + "with an authority"));
>+    }
>+    return this.path;
>+  }
>+  get data() {
>+    if (!(this.scheme !== "data")) dart.assertFailed(null, "dart:core/uri.dart", 4630, 12, "scheme != \"data\"");
>+    return null;
>+  }
>+  get hashCode() {
>+    let t = this[_hashCodeCache];
>+    return t == null ? this[_hashCodeCache] = dart.hashCode(this[_uri]) : t;
>+  }
>+  _equals(other) {
>+    if (this === other) return true;
>+    return core.Uri.is(other) && this[_uri] == dart.toString(other);
>+  }
>+  [_toNonSimple]() {
>+    return new core._Uri._internal(this.scheme, this.userInfo, dart.test(this.hasAuthority) ? this.host : null, dart.test(this.hasPort) ? this.port : null, this.path, dart.test(this.hasQuery) ? this.query : null, dart.test(this.hasFragment) ? this.fragment : null);
>+  }
>+  toString() {
>+    return this[_uri];
>+  }
>+};
>+(core._SimpleUri.new = function(uri, schemeEnd, hostStart, portStart, pathStart, queryStart, fragmentStart, schemeCache) {
>+  this[_hashCodeCache] = null;
>+  this[_uri] = uri;
>+  this[_schemeEnd] = schemeEnd;
>+  this[_hostStart] = hostStart;
>+  this[_portStart] = portStart;
>+  this[_pathStart] = pathStart;
>+  this[_queryStart] = queryStart;
>+  this[_fragmentStart] = fragmentStart;
>+  this[_schemeCache] = schemeCache;
>+}).prototype = core._SimpleUri.prototype;
>+dart.addTypeTests(core._SimpleUri);
>+core._SimpleUri[dart.implements] = () => [core.Uri];
>+dart.setMethodSignature(core._SimpleUri, () => ({
>+  __proto__: dart.getMethods(core._SimpleUri.__proto__),
>+  [_isScheme]: dart.fnType(core.bool, [core.String]),
>+  isScheme: dart.fnType(core.bool, [core.String]),
>+  [_isPort]: dart.fnType(core.bool, [core.String]),
>+  normalizePath: dart.fnType(core.Uri, []),
>+  removeFragment: dart.fnType(core.Uri, []),
>+  replace: dart.fnType(core.Uri, [], {scheme: core.String, userInfo: core.String, host: core.String, port: core.int, path: core.String, pathSegments: core.Iterable$(core.String), query: core.String, queryParameters: core.Map$(core.String, dart.dynamic), fragment: core.String}),
>+  resolve: dart.fnType(core.Uri, [core.String]),
>+  resolveUri: dart.fnType(core.Uri, [core.Uri]),
>+  [_simpleMerge]: dart.fnType(core.Uri, [core._SimpleUri, core._SimpleUri]),
>+  toFilePath: dart.fnType(core.String, [], {windows: core.bool}),
>+  [_toFilePath]: dart.fnType(core.String, []),
>+  _equals: dart.fnType(core.bool, [core.Object]),
>+  [$_equals]: dart.fnType(core.bool, [core.Object]),
>+  [_toNonSimple]: dart.fnType(core.Uri, [])
>+}));
>+dart.setGetterSignature(core._SimpleUri, () => ({
>+  __proto__: dart.getGetters(core._SimpleUri.__proto__),
>+  hasScheme: core.bool,
>+  hasAuthority: core.bool,
>+  hasUserInfo: core.bool,
>+  hasPort: core.bool,
>+  hasQuery: core.bool,
>+  hasFragment: core.bool,
>+  [_isFile]: core.bool,
>+  [_isHttp]: core.bool,
>+  [_isHttps]: core.bool,
>+  [_isPackage]: core.bool,
>+  hasAbsolutePath: core.bool,
>+  hasEmptyPath: core.bool,
>+  isAbsolute: core.bool,
>+  scheme: core.String,
>+  authority: core.String,
>+  userInfo: core.String,
>+  host: core.String,
>+  port: core.int,
>+  path: core.String,
>+  query: core.String,
>+  fragment: core.String,
>+  origin: core.String,
>+  pathSegments: core.List$(core.String),
>+  queryParameters: core.Map$(core.String, core.String),
>+  queryParametersAll: core.Map$(core.String, core.List$(core.String)),
>+  data: core.UriData
>+}));
>+dart.setLibraryUri(core._SimpleUri, "dart:core");
>+dart.setFieldSignature(core._SimpleUri, () => ({
>+  __proto__: dart.getFields(core._SimpleUri.__proto__),
>+  [_uri]: dart.finalFieldType(core.String),
>+  [_schemeEnd]: dart.finalFieldType(core.int),
>+  [_hostStart]: dart.finalFieldType(core.int),
>+  [_portStart]: dart.finalFieldType(core.int),
>+  [_pathStart]: dart.finalFieldType(core.int),
>+  [_queryStart]: dart.finalFieldType(core.int),
>+  [_fragmentStart]: dart.finalFieldType(core.int),
>+  [_schemeCache]: dart.fieldType(core.String),
>+  [_hashCodeCache]: dart.fieldType(core.int)
>+}));
>+dart.defineExtensionMethods(core._SimpleUri, ['_equals', 'toString']);
>+dart.defineExtensionAccessors(core._SimpleUri, ['hashCode']);
>+const _data$ = dart.privateName(core, "_data");
>+core._DataUri = class _DataUri extends core._Uri {
>+  get data() {
>+    return this[_data$];
>+  }
>+};
>+(core._DataUri.new = function(data, path, query) {
>+  this[_data$] = data;
>+  core._DataUri.__proto__._internal.call(this, "data", null, null, null, path, query, null);
>+}).prototype = core._DataUri.prototype;
>+dart.addTypeTests(core._DataUri);
>+dart.setLibraryUri(core._DataUri, "dart:core");
>+dart.setFieldSignature(core._DataUri, () => ({
>+  __proto__: dart.getFields(core._DataUri.__proto__),
>+  [_data$]: dart.finalFieldType(core.UriData)
>+}));
>+core._startsWithData = function(text, start) {
>+  let delta = ((text[$codeUnitAt](dart.notNull(start) + 4) ^ 58) >>> 0) * 3;
>+  delta = (delta | text[$codeUnitAt](start) ^ 100) >>> 0;
>+  delta = (delta | text[$codeUnitAt](dart.notNull(start) + 1) ^ 97) >>> 0;
>+  delta = (delta | text[$codeUnitAt](dart.notNull(start) + 2) ^ 116) >>> 0;
>+  delta = (delta | text[$codeUnitAt](dart.notNull(start) + 3) ^ 97) >>> 0;
>+  return delta;
>+};
>+core._stringOrNullLength = function(s) {
>+  return s == null ? 0 : s.length;
>+};
>+developer.debugger = function(opts) {
>+  let when = opts && 'when' in opts ? opts.when : true;
>+  let message = opts && 'message' in opts ? opts.message : null;
>+  if (dart.test(when)) {
>+    debugger;
>+  }
>+  return when;
>+};
>+developer.inspect = function(object) {
>+  console.debug("dart.developer.inspect", object);
>+  return object;
>+};
>+developer.log = function(message, opts) {
>+  let time = opts && 'time' in opts ? opts.time : null;
>+  let sequenceNumber = opts && 'sequenceNumber' in opts ? opts.sequenceNumber : null;
>+  let level = opts && 'level' in opts ? opts.level : 0;
>+  let name = opts && 'name' in opts ? opts.name : "";
>+  let zone = opts && 'zone' in opts ? opts.zone : null;
>+  let error = opts && 'error' in opts ? opts.error : null;
>+  let stackTrace = opts && 'stackTrace' in opts ? opts.stackTrace : null;
>+  let items = {message: message, name: name, level: level};
>+  if (time != null) items.time = time;
>+  if (sequenceNumber != null) {
>+    items.sequenceNumber = sequenceNumber;
>+  }
>+  if (zone != null) items.zone = zone;
>+  if (error != null) items.error = error;
>+  if (stackTrace != null) items.stackTrace = stackTrace;
>+  console.debug("dart.developer.log", items);
>+};
>+dart.defineLazy(developer, {
>+  /*developer._extensions*/get _extensions() {
>+    return new (IdentityMapOfString$StringAndMapOfString$StringToFutureOfServiceExtensionResponse()).new();
>+  }
>+});
>+const _toString = dart.privateName(developer, "_toString");
>+developer.invokeExtension = function(methodName, encodedJson) {
>+  return new dart.global.Promise((resolve, reject) => async.async(core.Null, function*() {
>+    try {
>+      let method = developer._lookupExtension(methodName);
>+      let parameters = MapOfString$String()._check(core.Map.as(convert.json.decode(encodedJson))[$cast](core.String, core.String));
>+      let result = (yield method(methodName, parameters));
>+      resolve(result[_toString]());
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      reject(dart.str(e));
>+    }
>+  }));
>+};
>+dart.defineLazy(developer, {
>+  /*developer._clockValue*/get _clockValue() {
>+    return 0;
>+  },
>+  set _clockValue(_) {}
>+});
>+developer._FakeUserTag = class _FakeUserTag extends core.Object {
>+  static new(label) {
>+    let existingTag = developer._FakeUserTag._instances[$_get](label);
>+    if (existingTag != null) {
>+      return developer._FakeUserTag._check(existingTag);
>+    }
>+    if (developer._FakeUserTag._instances[$length] === developer.UserTag.MAX_USER_TAGS) {
>+      dart.throw(new core.UnsupportedError.new("UserTag instance limit (" + dart.str(developer.UserTag.MAX_USER_TAGS) + ") reached."));
>+    }
>+    let instance = new developer._FakeUserTag.real(label);
>+    developer._FakeUserTag._instances[$_set](label, instance);
>+    return instance;
>+  }
>+  makeCurrent() {
>+    let old = developer._currentTag;
>+    developer._currentTag = this;
>+    return old;
>+  }
>+};
>+(developer._FakeUserTag.real = function(label) {
>+  this.label = label;
>+}).prototype = developer._FakeUserTag.prototype;
>+dart.addTypeTests(developer._FakeUserTag);
>+developer._FakeUserTag[dart.implements] = () => [developer.UserTag];
>+dart.setMethodSignature(developer._FakeUserTag, () => ({
>+  __proto__: dart.getMethods(developer._FakeUserTag.__proto__),
>+  makeCurrent: dart.fnType(developer.UserTag, [])
>+}));
>+dart.setLibraryUri(developer._FakeUserTag, "dart:developer");
>+dart.setFieldSignature(developer._FakeUserTag, () => ({
>+  __proto__: dart.getFields(developer._FakeUserTag.__proto__),
>+  label: dart.finalFieldType(core.String)
>+}));
>+dart.defineLazy(developer._FakeUserTag, {
>+  /*developer._FakeUserTag._instances*/get _instances() {
>+    return new _js_helper.LinkedMap.new();
>+  },
>+  set _instances(_) {},
>+  /*developer._FakeUserTag._defaultTag*/get _defaultTag() {
>+    return developer._FakeUserTag.new("Default");
>+  }
>+});
>+dart.defineLazy(developer, {
>+  /*developer._currentTag*/get _currentTag() {
>+    return developer._FakeUserTag._defaultTag;
>+  },
>+  set _currentTag(_) {}
>+});
>+developer.ServiceExtensionResponse = class ServiceExtensionResponse extends core.Object {
>+  get result() {
>+    return this[result$];
>+  }
>+  set result(value) {
>+    super.result = value;
>+  }
>+  get errorCode() {
>+    return this[errorCode$];
>+  }
>+  set errorCode(value) {
>+    super.errorCode = value;
>+  }
>+  get errorDetail() {
>+    return this[errorDetail$];
>+  }
>+  set errorDetail(value) {
>+    super.errorDetail = value;
>+  }
>+  static _errorCodeMessage(errorCode) {
>+    developer.ServiceExtensionResponse._validateErrorCode(errorCode);
>+    if (errorCode === -32602) {
>+      return "Invalid params";
>+    }
>+    return "Server error";
>+  }
>+  static _validateErrorCode(errorCode) {
>+    core.ArgumentError.checkNotNull(errorCode, "errorCode");
>+    if (errorCode === -32602) return;
>+    if (dart.notNull(errorCode) >= -32016 && dart.notNull(errorCode) <= -32000) {
>+      return;
>+    }
>+    dart.throw(new core.ArgumentError.value(errorCode, "errorCode", "Out of range"));
>+  }
>+  isError() {
>+    return this.errorCode != null && this.errorDetail != null;
>+  }
>+  [_toString]() {
>+    if (this.result != null) {
>+      return this.result;
>+    } else {
>+      if (!(this.errorCode != null)) dart.assertFailed(null, "dart:developer/extension.dart", 99, 14, "errorCode != null");
>+      if (!(this.errorDetail != null)) dart.assertFailed(null, "dart:developer/extension.dart", 100, 14, "errorDetail != null");
>+      return convert.json.encode(new (IdentityMapOfString$Object()).from(["code", this.errorCode, "message", developer.ServiceExtensionResponse._errorCodeMessage(this.errorCode), "data", new (IdentityMapOfString$String()).from(["details", this.errorDetail])]));
>+    }
>+  }
>+};
>+(developer.ServiceExtensionResponse.result = function(result) {
>+  this[result$] = result;
>+  this[errorCode$] = null;
>+  this[errorDetail$] = null;
>+  core.ArgumentError.checkNotNull(result, "result");
>+}).prototype = developer.ServiceExtensionResponse.prototype;
>+(developer.ServiceExtensionResponse.error = function(errorCode, errorDetail) {
>+  this[result$] = null;
>+  this[errorCode$] = errorCode;
>+  this[errorDetail$] = errorDetail;
>+  developer.ServiceExtensionResponse._validateErrorCode(errorCode);
>+  core.ArgumentError.checkNotNull(errorDetail, "errorDetail");
>+}).prototype = developer.ServiceExtensionResponse.prototype;
>+dart.addTypeTests(developer.ServiceExtensionResponse);
>+const result$ = Symbol("ServiceExtensionResponse.result");
>+const errorCode$ = Symbol("ServiceExtensionResponse.errorCode");
>+const errorDetail$ = Symbol("ServiceExtensionResponse.errorDetail");
>+dart.setMethodSignature(developer.ServiceExtensionResponse, () => ({
>+  __proto__: dart.getMethods(developer.ServiceExtensionResponse.__proto__),
>+  isError: dart.fnType(core.bool, []),
>+  [_toString]: dart.fnType(core.String, [])
>+}));
>+dart.setLibraryUri(developer.ServiceExtensionResponse, "dart:developer");
>+dart.setFieldSignature(developer.ServiceExtensionResponse, () => ({
>+  __proto__: dart.getFields(developer.ServiceExtensionResponse.__proto__),
>+  result: dart.finalFieldType(core.String),
>+  errorCode: dart.finalFieldType(core.int),
>+  errorDetail: dart.finalFieldType(core.String)
>+}));
>+dart.defineLazy(developer.ServiceExtensionResponse, {
>+  /*developer.ServiceExtensionResponse.kInvalidParams*/get kInvalidParams() {
>+    return -32602;
>+  },
>+  /*developer.ServiceExtensionResponse.kExtensionError*/get kExtensionError() {
>+    return -32000;
>+  },
>+  /*developer.ServiceExtensionResponse.kExtensionErrorMax*/get kExtensionErrorMax() {
>+    return -32000;
>+  },
>+  /*developer.ServiceExtensionResponse.kExtensionErrorMin*/get kExtensionErrorMin() {
>+    return -32016;
>+  },
>+  /*developer.ServiceExtensionResponse.invalidParams*/get invalidParams() {
>+    return -32602;
>+  },
>+  /*developer.ServiceExtensionResponse.extensionError*/get extensionError() {
>+    return -32000;
>+  },
>+  /*developer.ServiceExtensionResponse.extensionErrorMax*/get extensionErrorMax() {
>+    return -32000;
>+  },
>+  /*developer.ServiceExtensionResponse.extensionErrorMin*/get extensionErrorMin() {
>+    return -32016;
>+  }
>+});
>+developer.registerExtension = function(method, handler) {
>+  core.ArgumentError.checkNotNull(method, "method");
>+  if (!method[$startsWith]("ext.")) {
>+    dart.throw(new core.ArgumentError.value(method, "method", "Must begin with ext."));
>+  }
>+  if (developer._lookupExtension(method) != null) {
>+    dart.throw(new core.ArgumentError.new("Extension already registered: " + dart.str(method)));
>+  }
>+  core.ArgumentError.checkNotNull(handler, "handler");
>+  developer._registerExtension(method, handler);
>+};
>+developer.postEvent = function(eventKind, eventData) {
>+  core.ArgumentError.checkNotNull(eventKind, "eventKind");
>+  core.ArgumentError.checkNotNull(eventData, "eventData");
>+  let eventDataAsString = convert.json.encode(eventData);
>+  developer._postEvent(eventKind, eventDataAsString);
>+};
>+developer._postEvent = function(eventKind, eventData) {
>+  console.debug("dart.developer.postEvent", eventKind, eventData);
>+};
>+developer._lookupExtension = function(method) {
>+  return developer._extensions[$_get](method);
>+};
>+developer._registerExtension = function(method, handler) {
>+  developer._extensions[$_set](method, handler);
>+  console.debug("dart.developer.registerExtension", method);
>+};
>+developer.UserTag = class UserTag extends core.Object {
>+  static new(label) {
>+    return developer._FakeUserTag.new(label);
>+  }
>+  static get defaultTag() {
>+    return developer._FakeUserTag._defaultTag;
>+  }
>+};
>+(developer.UserTag[dart.mixinNew] = function() {
>+}).prototype = developer.UserTag.prototype;
>+dart.addTypeTests(developer.UserTag);
>+dart.setLibraryUri(developer.UserTag, "dart:developer");
>+dart.defineLazy(developer.UserTag, {
>+  /*developer.UserTag.MAX_USER_TAGS*/get MAX_USER_TAGS() {
>+    return 64;
>+  }
>+});
>+developer.getCurrentTag = function() {
>+  return developer._currentTag;
>+};
>+developer.Metric = class Metric extends core.Object {
>+  get name() {
>+    return this[name$2];
>+  }
>+  set name(value) {
>+    super.name = value;
>+  }
>+  get description() {
>+    return this[description$];
>+  }
>+  set description(value) {
>+    super.description = value;
>+  }
>+};
>+(developer.Metric.new = function(name, description) {
>+  this[name$2] = name;
>+  this[description$] = description;
>+  if (this.name === "vm" || this.name[$contains]("/")) {
>+    dart.throw(new core.ArgumentError.new("Invalid Metric name."));
>+  }
>+}).prototype = developer.Metric.prototype;
>+dart.addTypeTests(developer.Metric);
>+const name$2 = Symbol("Metric.name");
>+const description$ = Symbol("Metric.description");
>+dart.setLibraryUri(developer.Metric, "dart:developer");
>+dart.setFieldSignature(developer.Metric, () => ({
>+  __proto__: dart.getFields(developer.Metric.__proto__),
>+  name: dart.finalFieldType(core.String),
>+  description: dart.finalFieldType(core.String)
>+}));
>+const _value$1 = dart.privateName(developer, "_value");
>+const _toJSON = dart.privateName(developer, "_toJSON");
>+developer.Gauge = class Gauge extends developer.Metric {
>+  get min() {
>+    return this[min$];
>+  }
>+  set min(value) {
>+    super.min = value;
>+  }
>+  get max() {
>+    return this[max$];
>+  }
>+  set max(value) {
>+    super.max = value;
>+  }
>+  get value() {
>+    return this[_value$1];
>+  }
>+  set value(v) {
>+    if (dart.notNull(v) < dart.notNull(this.min)) {
>+      v = this.min;
>+    } else if (dart.notNull(v) > dart.notNull(this.max)) {
>+      v = this.max;
>+    }
>+    this[_value$1] = v;
>+  }
>+  [_toJSON]() {
>+    let map = new (IdentityMapOfString$Object()).from(["type", "Gauge", "id", "metrics/" + dart.str(this.name), "name", this.name, "description", this.description, "value", this.value, "min", this.min, "max", this.max]);
>+    return map;
>+  }
>+};
>+(developer.Gauge.new = function(name, description, min, max) {
>+  this[_value$1] = null;
>+  this[min$] = min;
>+  this[max$] = max;
>+  developer.Gauge.__proto__.new.call(this, name, description);
>+  core.ArgumentError.checkNotNull(this.min, "min");
>+  core.ArgumentError.checkNotNull(this.max, "max");
>+  if (!(dart.notNull(this.min) < dart.notNull(this.max))) dart.throw(new core.ArgumentError.new("min must be less than max"));
>+  this[_value$1] = this.min;
>+}).prototype = developer.Gauge.prototype;
>+dart.addTypeTests(developer.Gauge);
>+const min$ = Symbol("Gauge.min");
>+const max$ = Symbol("Gauge.max");
>+dart.setMethodSignature(developer.Gauge, () => ({
>+  __proto__: dart.getMethods(developer.Gauge.__proto__),
>+  [_toJSON]: dart.fnType(core.Map, [])
>+}));
>+dart.setGetterSignature(developer.Gauge, () => ({
>+  __proto__: dart.getGetters(developer.Gauge.__proto__),
>+  value: core.double
>+}));
>+dart.setSetterSignature(developer.Gauge, () => ({
>+  __proto__: dart.getSetters(developer.Gauge.__proto__),
>+  value: core.double
>+}));
>+dart.setLibraryUri(developer.Gauge, "dart:developer");
>+dart.setFieldSignature(developer.Gauge, () => ({
>+  __proto__: dart.getFields(developer.Gauge.__proto__),
>+  min: dart.finalFieldType(core.double),
>+  max: dart.finalFieldType(core.double),
>+  [_value$1]: dart.fieldType(core.double)
>+}));
>+developer.Counter = class Counter extends developer.Metric {
>+  get value() {
>+    return this[_value$1];
>+  }
>+  set value(v) {
>+    this[_value$1] = v;
>+  }
>+  [_toJSON]() {
>+    let map = new (IdentityMapOfString$Object()).from(["type", "Counter", "id", "metrics/" + dart.str(this.name), "name", this.name, "description", this.description, "value", this.value]);
>+    return map;
>+  }
>+};
>+(developer.Counter.new = function(name, description) {
>+  this[_value$1] = 0.0;
>+  developer.Counter.__proto__.new.call(this, name, description);
>+}).prototype = developer.Counter.prototype;
>+dart.addTypeTests(developer.Counter);
>+dart.setMethodSignature(developer.Counter, () => ({
>+  __proto__: dart.getMethods(developer.Counter.__proto__),
>+  [_toJSON]: dart.fnType(core.Map, [])
>+}));
>+dart.setGetterSignature(developer.Counter, () => ({
>+  __proto__: dart.getGetters(developer.Counter.__proto__),
>+  value: core.double
>+}));
>+dart.setSetterSignature(developer.Counter, () => ({
>+  __proto__: dart.getSetters(developer.Counter.__proto__),
>+  value: core.double
>+}));
>+dart.setLibraryUri(developer.Counter, "dart:developer");
>+dart.setFieldSignature(developer.Counter, () => ({
>+  __proto__: dart.getFields(developer.Counter.__proto__),
>+  [_value$1]: dart.fieldType(core.double)
>+}));
>+developer.Metrics = class Metrics extends core.Object {
>+  static register(metric) {
>+    core.ArgumentError.checkNotNull(metric, "metric");
>+    if (developer.Metrics._metrics[$_get](metric.name) != null) {
>+      dart.throw(new core.ArgumentError.new("Registered metrics have unique names"));
>+    }
>+    developer.Metrics._metrics[$_set](metric.name, metric);
>+  }
>+  static deregister(metric) {
>+    core.ArgumentError.checkNotNull(metric, "metric");
>+    developer.Metrics._metrics[$remove](metric.name);
>+  }
>+  static _printMetric(id) {
>+    let metric = developer.Metrics._metrics[$_get](id);
>+    if (metric == null) {
>+      return null;
>+    }
>+    return convert.json.encode(metric[_toJSON]());
>+  }
>+  static _printMetrics() {
>+    let metrics = [];
>+    for (let metric of developer.Metrics._metrics[$values]) {
>+      metrics[$add](metric[_toJSON]());
>+    }
>+    let map = new (IdentityMapOfString$Object()).from(["type", "MetricList", "metrics", metrics]);
>+    return convert.json.encode(map);
>+  }
>+};
>+(developer.Metrics.new = function() {
>+}).prototype = developer.Metrics.prototype;
>+dart.addTypeTests(developer.Metrics);
>+dart.setLibraryUri(developer.Metrics, "dart:developer");
>+dart.defineLazy(developer.Metrics, {
>+  /*developer.Metrics._metrics*/get _metrics() {
>+    return new (IdentityMapOfString$Metric()).new();
>+  }
>+});
>+developer.ServiceProtocolInfo = class ServiceProtocolInfo extends core.Object {
>+  get majorVersion() {
>+    return this[majorVersion];
>+  }
>+  set majorVersion(value) {
>+    super.majorVersion = value;
>+  }
>+  get minorVersion() {
>+    return this[minorVersion];
>+  }
>+  set minorVersion(value) {
>+    super.minorVersion = value;
>+  }
>+  get serverUri() {
>+    return this[serverUri$];
>+  }
>+  set serverUri(value) {
>+    super.serverUri = value;
>+  }
>+  toString() {
>+    if (this.serverUri != null) {
>+      return "Dart VM Service Protocol v" + dart.str(this.majorVersion) + "." + dart.str(this.minorVersion) + " " + ("listening on " + dart.str(this.serverUri));
>+    } else {
>+      return "Dart VM Service Protocol v" + dart.str(this.majorVersion) + "." + dart.str(this.minorVersion);
>+    }
>+  }
>+};
>+(developer.ServiceProtocolInfo.new = function(serverUri) {
>+  this[majorVersion] = developer._getServiceMajorVersion();
>+  this[minorVersion] = developer._getServiceMinorVersion();
>+  this[serverUri$] = serverUri;
>+}).prototype = developer.ServiceProtocolInfo.prototype;
>+dart.addTypeTests(developer.ServiceProtocolInfo);
>+const majorVersion = Symbol("ServiceProtocolInfo.majorVersion");
>+const minorVersion = Symbol("ServiceProtocolInfo.minorVersion");
>+const serverUri$ = Symbol("ServiceProtocolInfo.serverUri");
>+dart.setLibraryUri(developer.ServiceProtocolInfo, "dart:developer");
>+dart.setFieldSignature(developer.ServiceProtocolInfo, () => ({
>+  __proto__: dart.getFields(developer.ServiceProtocolInfo.__proto__),
>+  majorVersion: dart.finalFieldType(core.int),
>+  minorVersion: dart.finalFieldType(core.int),
>+  serverUri: dart.finalFieldType(core.Uri)
>+}));
>+dart.defineExtensionMethods(developer.ServiceProtocolInfo, ['toString']);
>+developer.Service = class Service extends core.Object {
>+  static getInfo() {
>+    return async.async(developer.ServiceProtocolInfo, function* getInfo() {
>+      let receivePort = isolate.RawReceivePort.new();
>+      let uriCompleter = CompleterOfUri().new();
>+      receivePort.handler = dart.fn(uri => uriCompleter.complete(uri), UriTovoid());
>+      developer._getServerInfo(receivePort.sendPort);
>+      let uri = (yield uriCompleter.future);
>+      receivePort.close();
>+      return new developer.ServiceProtocolInfo.new(uri);
>+    });
>+  }
>+  static controlWebServer(opts) {
>+    let enable = opts && 'enable' in opts ? opts.enable : false;
>+    return async.async(developer.ServiceProtocolInfo, function* controlWebServer() {
>+      core.ArgumentError.checkNotNull(enable, "enable");
>+      let receivePort = isolate.RawReceivePort.new();
>+      let uriCompleter = CompleterOfUri().new();
>+      receivePort.handler = dart.fn(uri => uriCompleter.complete(uri), UriTovoid());
>+      developer._webServerControl(receivePort.sendPort, enable);
>+      let uri = (yield uriCompleter.future);
>+      receivePort.close();
>+      return new developer.ServiceProtocolInfo.new(uri);
>+    });
>+  }
>+  static getIsolateID(isolate) {
>+    core.ArgumentError.checkNotNull(isolate, "isolate");
>+    return developer._getIsolateIDFromSendPort(isolate.controlPort);
>+  }
>+};
>+(developer.Service.new = function() {
>+}).prototype = developer.Service.prototype;
>+dart.addTypeTests(developer.Service);
>+dart.setLibraryUri(developer.Service, "dart:developer");
>+developer._getServerInfo = function(sendPort) {
>+  sendPort.send(null);
>+};
>+developer._webServerControl = function(sendPort, enable) {
>+  sendPort.send(null);
>+};
>+developer._getServiceMajorVersion = function() {
>+  return 0;
>+};
>+developer._getServiceMinorVersion = function() {
>+  return 0;
>+};
>+developer._getIsolateIDFromSendPort = function(sendPort) {
>+  return null;
>+};
>+dart.defineLazy(developer, {
>+  /*developer._hasTimeline*/get _hasTimeline() {
>+    return true;
>+  }
>+});
>+const _type$ = dart.privateName(developer, "_type");
>+developer.Flow = class Flow extends core.Object {
>+  get id() {
>+    return this[id$];
>+  }
>+  set id(value) {
>+    super.id = value;
>+  }
>+  static begin(opts) {
>+    let id = opts && 'id' in opts ? opts.id : null;
>+    return new developer.Flow.__(9, id != null ? id : developer._getNextAsyncId());
>+  }
>+  static step(id) {
>+    return new developer.Flow.__(10, id);
>+  }
>+  static end(id) {
>+    return new developer.Flow.__(11, id);
>+  }
>+};
>+(developer.Flow.__ = function(type, id) {
>+  this[_type$] = type;
>+  this[id$] = id;
>+}).prototype = developer.Flow.prototype;
>+dart.addTypeTests(developer.Flow);
>+const id$ = Symbol("Flow.id");
>+dart.setLibraryUri(developer.Flow, "dart:developer");
>+dart.setFieldSignature(developer.Flow, () => ({
>+  __proto__: dart.getFields(developer.Flow.__proto__),
>+  [_type$]: dart.finalFieldType(core.int),
>+  id: dart.finalFieldType(core.int)
>+}));
>+dart.defineLazy(developer.Flow, {
>+  /*developer.Flow._begin*/get _begin() {
>+    return 9;
>+  },
>+  /*developer.Flow._step*/get _step() {
>+    return 10;
>+  },
>+  /*developer.Flow._end*/get _end() {
>+    return 11;
>+  }
>+});
>+const _arguments$ = dart.privateName(developer, "_arguments");
>+developer.Timeline = class Timeline extends core.Object {
>+  static startSync(name, opts) {
>+    let arguments$0 = opts && 'arguments' in opts ? opts.arguments : null;
>+    let flow = opts && 'flow' in opts ? opts.flow : null;
>+    if (!true) return;
>+    core.ArgumentError.checkNotNull(name, "name");
>+    if (!dart.test(developer._isDartStreamEnabled())) {
>+      developer.Timeline._stack[$add](null);
>+      return;
>+    }
>+    let block = new developer._SyncBlock.__(name, developer._getTraceClock(), developer._getThreadCpuClock());
>+    if (arguments$0 != null) {
>+      block[_arguments$] = arguments$0;
>+    }
>+    if (flow != null) {
>+      block.flow = flow;
>+    }
>+    developer.Timeline._stack[$add](block);
>+  }
>+  static finishSync() {
>+    if (!true) {
>+      return;
>+    }
>+    if (developer.Timeline._stack[$length] === 0) {
>+      dart.throw(new core.StateError.new("Uneven calls to startSync and finishSync"));
>+    }
>+    let block = developer.Timeline._stack[$removeLast]();
>+    if (block == null) {
>+      return;
>+    }
>+    block.finish();
>+  }
>+  static instantSync(name, opts) {
>+    let arguments$0 = opts && 'arguments' in opts ? opts.arguments : null;
>+    if (!true) return;
>+    core.ArgumentError.checkNotNull(name, "name");
>+    if (!dart.test(developer._isDartStreamEnabled())) {
>+      return;
>+    }
>+    let instantArguments = null;
>+    if (arguments$0 != null) {
>+      instantArguments = core.Map.from(arguments$0);
>+    }
>+    developer._reportInstantEvent(developer._getTraceClock(), "Dart", name, developer._argumentsAsJson(instantArguments));
>+  }
>+  static timeSync(T, name, func, opts) {
>+    let arguments$0 = opts && 'arguments' in opts ? opts.arguments : null;
>+    let flow = opts && 'flow' in opts ? opts.flow : null;
>+    developer.Timeline.startSync(name, {arguments: arguments$0, flow: flow});
>+    try {
>+      return func();
>+    } finally {
>+      developer.Timeline.finishSync();
>+    }
>+  }
>+  static get now() {
>+    return developer._getTraceClock();
>+  }
>+};
>+(developer.Timeline.new = function() {
>+}).prototype = developer.Timeline.prototype;
>+dart.addTypeTests(developer.Timeline);
>+dart.setLibraryUri(developer.Timeline, "dart:developer");
>+dart.defineLazy(developer.Timeline, {
>+  /*developer.Timeline._stack*/get _stack() {
>+    return JSArrayOf_SyncBlock().of([]);
>+  }
>+});
>+const _taskId = dart.privateName(developer, "_taskId");
>+const _stack = dart.privateName(developer, "_stack");
>+const _start$1 = dart.privateName(developer, "_start");
>+const _finish = dart.privateName(developer, "_finish");
>+developer.TimelineTask = class TimelineTask extends core.Object {
>+  start(name, opts) {
>+    let arguments$0 = opts && 'arguments' in opts ? opts.arguments : null;
>+    if (!true) return;
>+    core.ArgumentError.checkNotNull(name, "name");
>+    let block = new developer._AsyncBlock.__(name, this[_taskId]);
>+    if (arguments$0 != null) {
>+      block[_arguments$] = arguments$0;
>+    }
>+    this[_stack][$add](block);
>+    block[_start$1]();
>+  }
>+  instant(name, opts) {
>+    let arguments$0 = opts && 'arguments' in opts ? opts.arguments : null;
>+    if (!true) return;
>+    core.ArgumentError.checkNotNull(name, "name");
>+    let instantArguments = null;
>+    if (arguments$0 != null) {
>+      instantArguments = core.Map.from(arguments$0);
>+    }
>+    developer._reportTaskEvent(developer._getTraceClock(), this[_taskId], "n", "Dart", name, developer._argumentsAsJson(instantArguments));
>+  }
>+  finish() {
>+    if (!true) {
>+      return;
>+    }
>+    if (this[_stack][$length] === 0) {
>+      dart.throw(new core.StateError.new("Uneven calls to start and finish"));
>+    }
>+    let block = this[_stack][$removeLast]();
>+    block[_finish]();
>+  }
>+  pass() {
>+    if (dart.notNull(this[_stack][$length]) > 0) {
>+      dart.throw(new core.StateError.new("You cannot pass a TimelineTask without finishing all started " + "operations"));
>+    }
>+    let r = this[_taskId];
>+    return r;
>+  }
>+};
>+(developer.TimelineTask.new = function() {
>+  this[_stack] = JSArrayOf_AsyncBlock().of([]);
>+  this[_taskId] = developer._getNextAsyncId();
>+}).prototype = developer.TimelineTask.prototype;
>+(developer.TimelineTask.withTaskId = function(taskId) {
>+  this[_stack] = JSArrayOf_AsyncBlock().of([]);
>+  this[_taskId] = taskId;
>+  core.ArgumentError.checkNotNull(taskId, "taskId");
>+}).prototype = developer.TimelineTask.prototype;
>+dart.addTypeTests(developer.TimelineTask);
>+dart.setMethodSignature(developer.TimelineTask, () => ({
>+  __proto__: dart.getMethods(developer.TimelineTask.__proto__),
>+  start: dart.fnType(dart.void, [core.String], {arguments: core.Map}),
>+  instant: dart.fnType(dart.void, [core.String], {arguments: core.Map}),
>+  finish: dart.fnType(dart.void, []),
>+  pass: dart.fnType(core.int, [])
>+}));
>+dart.setLibraryUri(developer.TimelineTask, "dart:developer");
>+dart.setFieldSignature(developer.TimelineTask, () => ({
>+  __proto__: dart.getFields(developer.TimelineTask.__proto__),
>+  [_taskId]: dart.finalFieldType(core.int),
>+  [_stack]: dart.finalFieldType(ListOf_AsyncBlock())
>+}));
>+developer._AsyncBlock = class _AsyncBlock extends core.Object {
>+  [_start$1]() {
>+    developer._reportTaskEvent(developer._getTraceClock(), this[_taskId], "b", this.category, this.name, developer._argumentsAsJson(null));
>+  }
>+  [_finish]() {
>+    developer._reportTaskEvent(developer._getTraceClock(), this[_taskId], "e", this.category, this.name, developer._argumentsAsJson(this[_arguments$]));
>+  }
>+};
>+(developer._AsyncBlock.__ = function(name, taskId) {
>+  this.category = "Dart";
>+  this[_arguments$] = null;
>+  this.name = name;
>+  this[_taskId] = taskId;
>+}).prototype = developer._AsyncBlock.prototype;
>+dart.addTypeTests(developer._AsyncBlock);
>+dart.setMethodSignature(developer._AsyncBlock, () => ({
>+  __proto__: dart.getMethods(developer._AsyncBlock.__proto__),
>+  [_start$1]: dart.fnType(dart.void, []),
>+  [_finish]: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(developer._AsyncBlock, "dart:developer");
>+dart.setFieldSignature(developer._AsyncBlock, () => ({
>+  __proto__: dart.getFields(developer._AsyncBlock.__proto__),
>+  category: dart.finalFieldType(core.String),
>+  name: dart.finalFieldType(core.String),
>+  [_taskId]: dart.finalFieldType(core.int),
>+  [_arguments$]: dart.fieldType(core.Map)
>+}));
>+const _startCpu = dart.privateName(developer, "_startCpu");
>+const _flow = dart.privateName(developer, "_flow");
>+developer._SyncBlock = class _SyncBlock extends core.Object {
>+  finish() {
>+    developer._reportCompleteEvent(this[_start$1], this[_startCpu], this.category, this.name, developer._argumentsAsJson(this[_arguments$]));
>+    if (this[_flow] != null) {
>+      developer._reportFlowEvent(this[_start$1], this[_startCpu], this.category, this.name, this[_flow][_type$], this[_flow].id, developer._argumentsAsJson(null));
>+    }
>+  }
>+  set flow(f) {
>+    this[_flow] = f;
>+  }
>+};
>+(developer._SyncBlock.__ = function(name, start, startCpu) {
>+  this.category = "Dart";
>+  this[_arguments$] = null;
>+  this[_flow] = null;
>+  this.name = name;
>+  this[_start$1] = start;
>+  this[_startCpu] = startCpu;
>+}).prototype = developer._SyncBlock.prototype;
>+dart.addTypeTests(developer._SyncBlock);
>+dart.setMethodSignature(developer._SyncBlock, () => ({
>+  __proto__: dart.getMethods(developer._SyncBlock.__proto__),
>+  finish: dart.fnType(dart.void, [])
>+}));
>+dart.setSetterSignature(developer._SyncBlock, () => ({
>+  __proto__: dart.getSetters(developer._SyncBlock.__proto__),
>+  flow: developer.Flow
>+}));
>+dart.setLibraryUri(developer._SyncBlock, "dart:developer");
>+dart.setFieldSignature(developer._SyncBlock, () => ({
>+  __proto__: dart.getFields(developer._SyncBlock.__proto__),
>+  category: dart.finalFieldType(core.String),
>+  name: dart.finalFieldType(core.String),
>+  [_arguments$]: dart.fieldType(core.Map),
>+  [_start$1]: dart.finalFieldType(core.int),
>+  [_startCpu]: dart.finalFieldType(core.int),
>+  [_flow]: dart.fieldType(developer.Flow)
>+}));
>+developer._argumentsAsJson = function(arguments$0) {
>+  if (arguments$0 == null || arguments$0[$length] === 0) {
>+    return "{}";
>+  }
>+  return convert.json.encode(arguments$0);
>+};
>+developer._isDartStreamEnabled = function() {
>+  return false;
>+};
>+developer._getNextAsyncId = function() {
>+  return 0;
>+};
>+developer._getTraceClock = function() {
>+  let x = developer._clockValue;
>+  developer._clockValue = dart.notNull(x) + 1;
>+  return x;
>+};
>+developer._getThreadCpuClock = function() {
>+  return -1;
>+};
>+developer._reportTaskEvent = function(start, taskId, phase, category, name, argumentsAsJson) {
>+};
>+developer._reportCompleteEvent = function(start, startCpu, category, name, argumentsAsJson) {
>+};
>+developer._reportFlowEvent = function(start, startCpu, category, name, type, id, argumentsAsJson) {
>+};
>+developer._reportInstantEvent = function(start, category, name, argumentsAsJson) {
>+};
>+io.BytesBuilder = class BytesBuilder extends core.Object {
>+  static new(opts) {
>+    let copy = opts && 'copy' in opts ? opts.copy : true;
>+    if (dart.test(copy)) {
>+      return new io._CopyingBytesBuilder.new();
>+    } else {
>+      return new io._BytesBuilder.new();
>+    }
>+  }
>+};
>+(io.BytesBuilder[dart.mixinNew] = function() {
>+}).prototype = io.BytesBuilder.prototype;
>+dart.addTypeTests(io.BytesBuilder);
>+dart.setLibraryUri(io.BytesBuilder, "dart:io");
>+const _buffer$ = dart.privateName(io, "_buffer");
>+const _length$1 = dart.privateName(io, "_length");
>+const _grow$ = dart.privateName(io, "_grow");
>+io._CopyingBytesBuilder = class _CopyingBytesBuilder extends core.Object {
>+  add(bytes) {
>+    let bytesLength = bytes[$length];
>+    if (bytesLength === 0) return;
>+    let required = dart.notNull(this[_length$1]) + dart.notNull(bytesLength);
>+    if (dart.notNull(this[_buffer$][$length]) < required) {
>+      this[_grow$](required);
>+    }
>+    if (!(dart.notNull(this[_buffer$][$length]) >= required)) dart.assertFailed(null, "dart:io/bytes_builder.dart", 102, 12, "_buffer.length >= required");
>+    if (typed_data.Uint8List.is(bytes)) {
>+      this[_buffer$][$setRange](this[_length$1], required, bytes);
>+    } else {
>+      for (let i = 0; i < dart.notNull(bytesLength); i++) {
>+        this[_buffer$][$_set](dart.notNull(this[_length$1]) + i, bytes[$_get](i));
>+      }
>+    }
>+    this[_length$1] = required;
>+  }
>+  addByte(byte) {
>+    if (this[_buffer$][$length] == this[_length$1]) {
>+      this[_grow$](this[_length$1]);
>+    }
>+    if (!(dart.notNull(this[_buffer$][$length]) > dart.notNull(this[_length$1]))) dart.assertFailed(null, "dart:io/bytes_builder.dart", 119, 12, "_buffer.length > _length");
>+    this[_buffer$][$_set](this[_length$1], byte);
>+    this[_length$1] = dart.notNull(this[_length$1]) + 1;
>+  }
>+  [_grow$](required) {
>+    let newSize = dart.notNull(required) * 2;
>+    if (dart.notNull(newSize) < 1024) {
>+      newSize = 1024;
>+    } else {
>+      newSize = io._CopyingBytesBuilder._pow2roundup(newSize);
>+    }
>+    let newBuffer = typed_data.Uint8List.new(newSize);
>+    newBuffer[$setRange](0, this[_buffer$][$length], this[_buffer$]);
>+    this[_buffer$] = newBuffer;
>+  }
>+  takeBytes() {
>+    if (this[_length$1] === 0) return io._CopyingBytesBuilder._emptyList;
>+    let buffer = typed_data.Uint8List.view(this[_buffer$][$buffer], 0, this[_length$1]);
>+    this.clear();
>+    return buffer;
>+  }
>+  toBytes() {
>+    if (this[_length$1] === 0) return io._CopyingBytesBuilder._emptyList;
>+    return typed_data.Uint8List.fromList(typed_data.Uint8List.view(this[_buffer$][$buffer], 0, this[_length$1]));
>+  }
>+  get length() {
>+    return this[_length$1];
>+  }
>+  get isEmpty() {
>+    return this[_length$1] === 0;
>+  }
>+  get isNotEmpty() {
>+    return this[_length$1] !== 0;
>+  }
>+  clear() {
>+    this[_length$1] = 0;
>+    this[_buffer$] = io._CopyingBytesBuilder._emptyList;
>+  }
>+  static _pow2roundup(x) {
>+    if (!(dart.notNull(x) > 0)) dart.assertFailed(null, "dart:io/bytes_builder.dart", 163, 12, "x > 0");
>+    x = dart.notNull(x) - 1;
>+    x = (dart.notNull(x) | x[$rightShift](1)) >>> 0;
>+    x = (dart.notNull(x) | x[$rightShift](2)) >>> 0;
>+    x = (dart.notNull(x) | x[$rightShift](4)) >>> 0;
>+    x = (dart.notNull(x) | x[$rightShift](8)) >>> 0;
>+    x = (dart.notNull(x) | x[$rightShift](16)) >>> 0;
>+    return dart.notNull(x) + 1;
>+  }
>+};
>+(io._CopyingBytesBuilder.new = function(initialCapacity) {
>+  if (initialCapacity === void 0) initialCapacity = 0;
>+  this[_length$1] = 0;
>+  this[_buffer$] = dart.notNull(initialCapacity) <= 0 ? io._CopyingBytesBuilder._emptyList : typed_data.Uint8List.new(io._CopyingBytesBuilder._pow2roundup(initialCapacity));
>+}).prototype = io._CopyingBytesBuilder.prototype;
>+dart.addTypeTests(io._CopyingBytesBuilder);
>+io._CopyingBytesBuilder[dart.implements] = () => [io.BytesBuilder];
>+dart.setMethodSignature(io._CopyingBytesBuilder, () => ({
>+  __proto__: dart.getMethods(io._CopyingBytesBuilder.__proto__),
>+  add: dart.fnType(dart.void, [core.List$(core.int)]),
>+  addByte: dart.fnType(dart.void, [core.int]),
>+  [_grow$]: dart.fnType(dart.void, [core.int]),
>+  takeBytes: dart.fnType(core.List$(core.int), []),
>+  toBytes: dart.fnType(core.List$(core.int), []),
>+  clear: dart.fnType(dart.void, [])
>+}));
>+dart.setGetterSignature(io._CopyingBytesBuilder, () => ({
>+  __proto__: dart.getGetters(io._CopyingBytesBuilder.__proto__),
>+  length: core.int,
>+  isEmpty: core.bool,
>+  isNotEmpty: core.bool
>+}));
>+dart.setLibraryUri(io._CopyingBytesBuilder, "dart:io");
>+dart.setFieldSignature(io._CopyingBytesBuilder, () => ({
>+  __proto__: dart.getFields(io._CopyingBytesBuilder.__proto__),
>+  [_length$1]: dart.fieldType(core.int),
>+  [_buffer$]: dart.fieldType(typed_data.Uint8List)
>+}));
>+dart.defineLazy(io._CopyingBytesBuilder, {
>+  /*io._CopyingBytesBuilder._initSize*/get _initSize() {
>+    return 1024;
>+  },
>+  /*io._CopyingBytesBuilder._emptyList*/get _emptyList() {
>+    return typed_data.Uint8List.new(0);
>+  }
>+});
>+const _chunks = dart.privateName(io, "_chunks");
>+io._BytesBuilder = class _BytesBuilder extends core.Object {
>+  add(bytes) {
>+    let typedBytes = null;
>+    if (typed_data.Uint8List.is(bytes)) {
>+      typedBytes = bytes;
>+    } else {
>+      typedBytes = typed_data.Uint8List.fromList(bytes);
>+    }
>+    this[_chunks][$add](typedBytes);
>+    this[_length$1] = dart.notNull(this[_length$1]) + dart.notNull(typedBytes[$length]);
>+  }
>+  addByte(byte) {
>+    this[_chunks][$add]((() => {
>+      let _ = typed_data.Uint8List.new(1);
>+      _[$_set](0, byte);
>+      return _;
>+    })());
>+    this[_length$1] = dart.notNull(this[_length$1]) + 1;
>+  }
>+  takeBytes() {
>+    if (this[_length$1] === 0) return io._CopyingBytesBuilder._emptyList;
>+    if (this[_chunks][$length] === 1) {
>+      let buffer = this[_chunks][$_get](0);
>+      this.clear();
>+      return buffer;
>+    }
>+    let buffer = typed_data.Uint8List.new(this[_length$1]);
>+    let offset = 0;
>+    for (let chunk of this[_chunks]) {
>+      buffer[$setRange](offset, offset + dart.notNull(chunk[$length]), chunk);
>+      offset = offset + dart.notNull(chunk[$length]);
>+    }
>+    this.clear();
>+    return buffer;
>+  }
>+  toBytes() {
>+    if (this[_length$1] === 0) return io._CopyingBytesBuilder._emptyList;
>+    let buffer = typed_data.Uint8List.new(this[_length$1]);
>+    let offset = 0;
>+    for (let chunk of this[_chunks]) {
>+      buffer[$setRange](offset, offset + dart.notNull(chunk[$length]), chunk);
>+      offset = offset + dart.notNull(chunk[$length]);
>+    }
>+    return buffer;
>+  }
>+  get length() {
>+    return this[_length$1];
>+  }
>+  get isEmpty() {
>+    return this[_length$1] === 0;
>+  }
>+  get isNotEmpty() {
>+    return this[_length$1] !== 0;
>+  }
>+  clear() {
>+    this[_length$1] = 0;
>+    this[_chunks][$clear]();
>+  }
>+};
>+(io._BytesBuilder.new = function() {
>+  this[_length$1] = 0;
>+  this[_chunks] = JSArrayOfUint8List().of([]);
>+}).prototype = io._BytesBuilder.prototype;
>+dart.addTypeTests(io._BytesBuilder);
>+io._BytesBuilder[dart.implements] = () => [io.BytesBuilder];
>+dart.setMethodSignature(io._BytesBuilder, () => ({
>+  __proto__: dart.getMethods(io._BytesBuilder.__proto__),
>+  add: dart.fnType(dart.void, [core.List$(core.int)]),
>+  addByte: dart.fnType(dart.void, [core.int]),
>+  takeBytes: dart.fnType(core.List$(core.int), []),
>+  toBytes: dart.fnType(core.List$(core.int), []),
>+  clear: dart.fnType(dart.void, [])
>+}));
>+dart.setGetterSignature(io._BytesBuilder, () => ({
>+  __proto__: dart.getGetters(io._BytesBuilder.__proto__),
>+  length: core.int,
>+  isEmpty: core.bool,
>+  isNotEmpty: core.bool
>+}));
>+dart.setLibraryUri(io._BytesBuilder, "dart:io");
>+dart.setFieldSignature(io._BytesBuilder, () => ({
>+  __proto__: dart.getFields(io._BytesBuilder.__proto__),
>+  [_length$1]: dart.fieldType(core.int),
>+  [_chunks]: dart.finalFieldType(ListOfUint8List())
>+}));
>+dart.defineLazy(io, {
>+  /*io._successResponse*/get _successResponse() {
>+    return 0;
>+  },
>+  /*io._illegalArgumentResponse*/get _illegalArgumentResponse() {
>+    return 1;
>+  },
>+  /*io._osErrorResponse*/get _osErrorResponse() {
>+    return 2;
>+  },
>+  /*io._fileClosedResponse*/get _fileClosedResponse() {
>+    return 3;
>+  },
>+  /*io._errorResponseErrorType*/get _errorResponseErrorType() {
>+    return 0;
>+  },
>+  /*io._osErrorResponseErrorCode*/get _osErrorResponseErrorCode() {
>+    return 1;
>+  },
>+  /*io._osErrorResponseMessage*/get _osErrorResponseMessage() {
>+    return 2;
>+  }
>+});
>+io._isErrorResponse = function(response) {
>+  return core.List.is(response) && !dart.equals(response[$_get](0), 0);
>+};
>+io._exceptionFromResponse = function(response, message, path) {
>+  if (!dart.test(io._isErrorResponse(response))) dart.assertFailed(null, "dart:io/common.dart", 26, 10, "_isErrorResponse(response)");
>+  switch (dart.dindex(response, 0)) {
>+    case 1:
>+    {
>+      return new core.ArgumentError.new(dart.str(message) + ": " + dart.str(path));
>+    }
>+    case 2:
>+    {
>+      let err = new io.OSError.new(core.String._check(dart.dindex(response, 2)), core.int._check(dart.dindex(response, 1)));
>+      return new io.FileSystemException.new(message, path, err);
>+    }
>+    case 3:
>+    {
>+      return new io.FileSystemException.new("File closed", path);
>+    }
>+    default:
>+    {
>+      return core.Exception.new("Unknown error");
>+    }
>+  }
>+};
>+io.IOException = class IOException extends core.Object {
>+  toString() {
>+    return "IOException";
>+  }
>+};
>+(io.IOException.new = function() {
>+}).prototype = io.IOException.prototype;
>+dart.addTypeTests(io.IOException);
>+io.IOException[dart.implements] = () => [core.Exception];
>+dart.setLibraryUri(io.IOException, "dart:io");
>+dart.defineExtensionMethods(io.IOException, ['toString']);
>+io.OSError = class OSError extends core.Object {
>+  get message() {
>+    return this[message$7];
>+  }
>+  set message(value) {
>+    super.message = value;
>+  }
>+  get errorCode() {
>+    return this[errorCode$0];
>+  }
>+  set errorCode(value) {
>+    super.errorCode = value;
>+  }
>+  toString() {
>+    let sb = new core.StringBuffer.new();
>+    sb.write("OS Error");
>+    if (this.message[$isNotEmpty]) {
>+      sb.write(": ");
>+      sb.write(this.message);
>+      if (this.errorCode !== -1) {
>+        sb.write(", errno = ");
>+        sb.write(dart.toString(this.errorCode));
>+      }
>+    } else if (this.errorCode !== -1) {
>+      sb.write(": errno = ");
>+      sb.write(dart.toString(this.errorCode));
>+    }
>+    return sb.toString();
>+  }
>+};
>+(io.OSError.new = function(message, errorCode) {
>+  if (message === void 0) message = "";
>+  if (errorCode === void 0) errorCode = -1;
>+  this[message$7] = message;
>+  this[errorCode$0] = errorCode;
>+}).prototype = io.OSError.prototype;
>+dart.addTypeTests(io.OSError);
>+const message$7 = Symbol("OSError.message");
>+const errorCode$0 = Symbol("OSError.errorCode");
>+dart.setLibraryUri(io.OSError, "dart:io");
>+dart.setFieldSignature(io.OSError, () => ({
>+  __proto__: dart.getFields(io.OSError.__proto__),
>+  message: dart.finalFieldType(core.String),
>+  errorCode: dart.finalFieldType(core.int)
>+}));
>+dart.defineExtensionMethods(io.OSError, ['toString']);
>+dart.defineLazy(io.OSError, {
>+  /*io.OSError.noErrorCode*/get noErrorCode() {
>+    return -1;
>+  }
>+});
>+io._BufferAndStart = class _BufferAndStart extends core.Object {};
>+(io._BufferAndStart.new = function(buffer, start) {
>+  this.buffer = buffer;
>+  this.start = start;
>+}).prototype = io._BufferAndStart.prototype;
>+dart.addTypeTests(io._BufferAndStart);
>+dart.setLibraryUri(io._BufferAndStart, "dart:io");
>+dart.setFieldSignature(io._BufferAndStart, () => ({
>+  __proto__: dart.getFields(io._BufferAndStart.__proto__),
>+  buffer: dart.fieldType(ListOfint()),
>+  start: dart.fieldType(core.int)
>+}));
>+io._ensureFastAndSerializableByteData = function(buffer, start, end) {
>+  if (typed_data.Uint8List.is(buffer) || typed_data.Int8List.is(buffer)) {
>+    return new io._BufferAndStart.new(buffer, start);
>+  }
>+  let length = dart.notNull(end) - dart.notNull(start);
>+  let newBuffer = typed_data.Uint8List.new(length);
>+  let j = start;
>+  for (let i = 0; i < length; i++) {
>+    let value = buffer[$_get](j);
>+    if (value == null) dart.throw(new core.ArgumentError.new("List element is null at index " + dart.str(j)));
>+    newBuffer[$_set](i, value);
>+    j = dart.notNull(j) + 1;
>+  }
>+  return new io._BufferAndStart.new(newBuffer, 0);
>+};
>+io._IOCrypto = class _IOCrypto extends core.Object {
>+  static getRandomBytes(count) {
>+    dart.throw(new core.UnsupportedError.new("_IOCrypto.getRandomBytes"));
>+  }
>+};
>+(io._IOCrypto.new = function() {
>+}).prototype = io._IOCrypto.prototype;
>+dart.addTypeTests(io._IOCrypto);
>+dart.setLibraryUri(io._IOCrypto, "dart:io");
>+io.ZLibOption = class ZLibOption extends core.Object {};
>+(io.ZLibOption.new = function() {
>+}).prototype = io.ZLibOption.prototype;
>+dart.addTypeTests(io.ZLibOption);
>+dart.setLibraryUri(io.ZLibOption, "dart:io");
>+dart.defineLazy(io.ZLibOption, {
>+  /*io.ZLibOption.minWindowBits*/get minWindowBits() {
>+    return 8;
>+  },
>+  /*io.ZLibOption.MIN_WINDOW_BITS*/get MIN_WINDOW_BITS() {
>+    return 8;
>+  },
>+  /*io.ZLibOption.maxWindowBits*/get maxWindowBits() {
>+    return 15;
>+  },
>+  /*io.ZLibOption.MAX_WINDOW_BITS*/get MAX_WINDOW_BITS() {
>+    return 15;
>+  },
>+  /*io.ZLibOption.defaultWindowBits*/get defaultWindowBits() {
>+    return 15;
>+  },
>+  /*io.ZLibOption.DEFAULT_WINDOW_BITS*/get DEFAULT_WINDOW_BITS() {
>+    return 15;
>+  },
>+  /*io.ZLibOption.minLevel*/get minLevel() {
>+    return -1;
>+  },
>+  /*io.ZLibOption.MIN_LEVEL*/get MIN_LEVEL() {
>+    return -1;
>+  },
>+  /*io.ZLibOption.maxLevel*/get maxLevel() {
>+    return 9;
>+  },
>+  /*io.ZLibOption.MAX_LEVEL*/get MAX_LEVEL() {
>+    return 9;
>+  },
>+  /*io.ZLibOption.defaultLevel*/get defaultLevel() {
>+    return 6;
>+  },
>+  /*io.ZLibOption.DEFAULT_LEVEL*/get DEFAULT_LEVEL() {
>+    return 6;
>+  },
>+  /*io.ZLibOption.minMemLevel*/get minMemLevel() {
>+    return 1;
>+  },
>+  /*io.ZLibOption.MIN_MEM_LEVEL*/get MIN_MEM_LEVEL() {
>+    return 1;
>+  },
>+  /*io.ZLibOption.maxMemLevel*/get maxMemLevel() {
>+    return 9;
>+  },
>+  /*io.ZLibOption.MAX_MEM_LEVEL*/get MAX_MEM_LEVEL() {
>+    return 9;
>+  },
>+  /*io.ZLibOption.defaultMemLevel*/get defaultMemLevel() {
>+    return 8;
>+  },
>+  /*io.ZLibOption.DEFAULT_MEM_LEVEL*/get DEFAULT_MEM_LEVEL() {
>+    return 8;
>+  },
>+  /*io.ZLibOption.strategyFiltered*/get strategyFiltered() {
>+    return 1;
>+  },
>+  /*io.ZLibOption.STRATEGY_FILTERED*/get STRATEGY_FILTERED() {
>+    return 1;
>+  },
>+  /*io.ZLibOption.strategyHuffmanOnly*/get strategyHuffmanOnly() {
>+    return 2;
>+  },
>+  /*io.ZLibOption.STRATEGY_HUFFMAN_ONLY*/get STRATEGY_HUFFMAN_ONLY() {
>+    return 2;
>+  },
>+  /*io.ZLibOption.strategyRle*/get strategyRle() {
>+    return 3;
>+  },
>+  /*io.ZLibOption.STRATEGY_RLE*/get STRATEGY_RLE() {
>+    return 3;
>+  },
>+  /*io.ZLibOption.strategyFixed*/get strategyFixed() {
>+    return 4;
>+  },
>+  /*io.ZLibOption.STRATEGY_FIXED*/get STRATEGY_FIXED() {
>+    return 4;
>+  },
>+  /*io.ZLibOption.strategyDefault*/get strategyDefault() {
>+    return 0;
>+  },
>+  /*io.ZLibOption.STRATEGY_DEFAULT*/get STRATEGY_DEFAULT() {
>+    return 0;
>+  }
>+});
>+dart.defineLazy(io, {
>+  /*io.zlib*/get zlib() {
>+    return dart.const(new io.ZLibCodec._default());
>+  },
>+  /*io.ZLIB*/get ZLIB() {
>+    return io.zlib;
>+  }
>+});
>+io.ZLibCodec = class ZLibCodec extends convert.Codec$(core.List$(core.int), core.List$(core.int)) {
>+  get gzip() {
>+    return this[gzip$];
>+  }
>+  set gzip(value) {
>+    super.gzip = value;
>+  }
>+  get level() {
>+    return this[level$];
>+  }
>+  set level(value) {
>+    super.level = value;
>+  }
>+  get memLevel() {
>+    return this[memLevel$];
>+  }
>+  set memLevel(value) {
>+    super.memLevel = value;
>+  }
>+  get strategy() {
>+    return this[strategy$];
>+  }
>+  set strategy(value) {
>+    super.strategy = value;
>+  }
>+  get windowBits() {
>+    return this[windowBits$];
>+  }
>+  set windowBits(value) {
>+    super.windowBits = value;
>+  }
>+  get raw() {
>+    return this[raw$];
>+  }
>+  set raw(value) {
>+    super.raw = value;
>+  }
>+  get dictionary() {
>+    return this[dictionary$];
>+  }
>+  set dictionary(value) {
>+    super.dictionary = value;
>+  }
>+  get encoder() {
>+    return new io.ZLibEncoder.new({gzip: false, level: this.level, windowBits: this.windowBits, memLevel: this.memLevel, strategy: this.strategy, dictionary: this.dictionary, raw: this.raw});
>+  }
>+  get decoder() {
>+    return new io.ZLibDecoder.new({windowBits: this.windowBits, dictionary: this.dictionary, raw: this.raw});
>+  }
>+};
>+(io.ZLibCodec.new = function(opts) {
>+  let level = opts && 'level' in opts ? opts.level : io.ZLibOption.defaultLevel;
>+  let windowBits = opts && 'windowBits' in opts ? opts.windowBits : io.ZLibOption.defaultWindowBits;
>+  let memLevel = opts && 'memLevel' in opts ? opts.memLevel : io.ZLibOption.defaultMemLevel;
>+  let strategy = opts && 'strategy' in opts ? opts.strategy : io.ZLibOption.strategyDefault;
>+  let dictionary = opts && 'dictionary' in opts ? opts.dictionary : null;
>+  let raw = opts && 'raw' in opts ? opts.raw : false;
>+  let gzip = opts && 'gzip' in opts ? opts.gzip : false;
>+  this[level$] = level;
>+  this[windowBits$] = windowBits;
>+  this[memLevel$] = memLevel;
>+  this[strategy$] = strategy;
>+  this[dictionary$] = dictionary;
>+  this[raw$] = raw;
>+  this[gzip$] = gzip;
>+  io.ZLibCodec.__proto__.new.call(this);
>+  io._validateZLibeLevel(this.level);
>+  io._validateZLibMemLevel(this.memLevel);
>+  io._validateZLibStrategy(this.strategy);
>+  io._validateZLibWindowBits(this.windowBits);
>+}).prototype = io.ZLibCodec.prototype;
>+(io.ZLibCodec._default = function() {
>+  this[level$] = io.ZLibOption.defaultLevel;
>+  this[windowBits$] = io.ZLibOption.defaultWindowBits;
>+  this[memLevel$] = io.ZLibOption.defaultMemLevel;
>+  this[strategy$] = io.ZLibOption.strategyDefault;
>+  this[raw$] = false;
>+  this[gzip$] = false;
>+  this[dictionary$] = null;
>+  io.ZLibCodec.__proto__.new.call(this);
>+}).prototype = io.ZLibCodec.prototype;
>+dart.addTypeTests(io.ZLibCodec);
>+const gzip$ = Symbol("ZLibCodec.gzip");
>+const level$ = Symbol("ZLibCodec.level");
>+const memLevel$ = Symbol("ZLibCodec.memLevel");
>+const strategy$ = Symbol("ZLibCodec.strategy");
>+const windowBits$ = Symbol("ZLibCodec.windowBits");
>+const raw$ = Symbol("ZLibCodec.raw");
>+const dictionary$ = Symbol("ZLibCodec.dictionary");
>+dart.setGetterSignature(io.ZLibCodec, () => ({
>+  __proto__: dart.getGetters(io.ZLibCodec.__proto__),
>+  encoder: io.ZLibEncoder,
>+  decoder: io.ZLibDecoder
>+}));
>+dart.setLibraryUri(io.ZLibCodec, "dart:io");
>+dart.setFieldSignature(io.ZLibCodec, () => ({
>+  __proto__: dart.getFields(io.ZLibCodec.__proto__),
>+  gzip: dart.finalFieldType(core.bool),
>+  level: dart.finalFieldType(core.int),
>+  memLevel: dart.finalFieldType(core.int),
>+  strategy: dart.finalFieldType(core.int),
>+  windowBits: dart.finalFieldType(core.int),
>+  raw: dart.finalFieldType(core.bool),
>+  dictionary: dart.finalFieldType(ListOfint())
>+}));
>+dart.defineLazy(io, {
>+  /*io.gzip*/get gzip() {
>+    return dart.const(new io.GZipCodec._default());
>+  },
>+  /*io.GZIP*/get GZIP() {
>+    return io.gzip;
>+  }
>+});
>+io.GZipCodec = class GZipCodec extends convert.Codec$(core.List$(core.int), core.List$(core.int)) {
>+  get gzip() {
>+    return this[gzip$0];
>+  }
>+  set gzip(value) {
>+    super.gzip = value;
>+  }
>+  get level() {
>+    return this[level$0];
>+  }
>+  set level(value) {
>+    super.level = value;
>+  }
>+  get memLevel() {
>+    return this[memLevel$0];
>+  }
>+  set memLevel(value) {
>+    super.memLevel = value;
>+  }
>+  get strategy() {
>+    return this[strategy$0];
>+  }
>+  set strategy(value) {
>+    super.strategy = value;
>+  }
>+  get windowBits() {
>+    return this[windowBits$0];
>+  }
>+  set windowBits(value) {
>+    super.windowBits = value;
>+  }
>+  get dictionary() {
>+    return this[dictionary$0];
>+  }
>+  set dictionary(value) {
>+    super.dictionary = value;
>+  }
>+  get raw() {
>+    return this[raw$0];
>+  }
>+  set raw(value) {
>+    super.raw = value;
>+  }
>+  get encoder() {
>+    return new io.ZLibEncoder.new({gzip: true, level: this.level, windowBits: this.windowBits, memLevel: this.memLevel, strategy: this.strategy, dictionary: this.dictionary, raw: this.raw});
>+  }
>+  get decoder() {
>+    return new io.ZLibDecoder.new({windowBits: this.windowBits, dictionary: this.dictionary, raw: this.raw});
>+  }
>+};
>+(io.GZipCodec.new = function(opts) {
>+  let level = opts && 'level' in opts ? opts.level : io.ZLibOption.defaultLevel;
>+  let windowBits = opts && 'windowBits' in opts ? opts.windowBits : io.ZLibOption.defaultWindowBits;
>+  let memLevel = opts && 'memLevel' in opts ? opts.memLevel : io.ZLibOption.defaultMemLevel;
>+  let strategy = opts && 'strategy' in opts ? opts.strategy : io.ZLibOption.strategyDefault;
>+  let dictionary = opts && 'dictionary' in opts ? opts.dictionary : null;
>+  let raw = opts && 'raw' in opts ? opts.raw : false;
>+  let gzip = opts && 'gzip' in opts ? opts.gzip : true;
>+  this[level$0] = level;
>+  this[windowBits$0] = windowBits;
>+  this[memLevel$0] = memLevel;
>+  this[strategy$0] = strategy;
>+  this[dictionary$0] = dictionary;
>+  this[raw$0] = raw;
>+  this[gzip$0] = gzip;
>+  io.GZipCodec.__proto__.new.call(this);
>+  io._validateZLibeLevel(this.level);
>+  io._validateZLibMemLevel(this.memLevel);
>+  io._validateZLibStrategy(this.strategy);
>+  io._validateZLibWindowBits(this.windowBits);
>+}).prototype = io.GZipCodec.prototype;
>+(io.GZipCodec._default = function() {
>+  this[level$0] = io.ZLibOption.defaultLevel;
>+  this[windowBits$0] = io.ZLibOption.defaultWindowBits;
>+  this[memLevel$0] = io.ZLibOption.defaultMemLevel;
>+  this[strategy$0] = io.ZLibOption.strategyDefault;
>+  this[raw$0] = false;
>+  this[gzip$0] = true;
>+  this[dictionary$0] = null;
>+  io.GZipCodec.__proto__.new.call(this);
>+}).prototype = io.GZipCodec.prototype;
>+dart.addTypeTests(io.GZipCodec);
>+const gzip$0 = Symbol("GZipCodec.gzip");
>+const level$0 = Symbol("GZipCodec.level");
>+const memLevel$0 = Symbol("GZipCodec.memLevel");
>+const strategy$0 = Symbol("GZipCodec.strategy");
>+const windowBits$0 = Symbol("GZipCodec.windowBits");
>+const dictionary$0 = Symbol("GZipCodec.dictionary");
>+const raw$0 = Symbol("GZipCodec.raw");
>+dart.setGetterSignature(io.GZipCodec, () => ({
>+  __proto__: dart.getGetters(io.GZipCodec.__proto__),
>+  encoder: io.ZLibEncoder,
>+  decoder: io.ZLibDecoder
>+}));
>+dart.setLibraryUri(io.GZipCodec, "dart:io");
>+dart.setFieldSignature(io.GZipCodec, () => ({
>+  __proto__: dart.getFields(io.GZipCodec.__proto__),
>+  gzip: dart.finalFieldType(core.bool),
>+  level: dart.finalFieldType(core.int),
>+  memLevel: dart.finalFieldType(core.int),
>+  strategy: dart.finalFieldType(core.int),
>+  windowBits: dart.finalFieldType(core.int),
>+  dictionary: dart.finalFieldType(ListOfint()),
>+  raw: dart.finalFieldType(core.bool)
>+}));
>+io.ZLibEncoder = class ZLibEncoder extends convert.Converter$(core.List$(core.int), core.List$(core.int)) {
>+  get gzip() {
>+    return this[gzip$1];
>+  }
>+  set gzip(value) {
>+    super.gzip = value;
>+  }
>+  get level() {
>+    return this[level$1];
>+  }
>+  set level(value) {
>+    super.level = value;
>+  }
>+  get memLevel() {
>+    return this[memLevel$1];
>+  }
>+  set memLevel(value) {
>+    super.memLevel = value;
>+  }
>+  get strategy() {
>+    return this[strategy$1];
>+  }
>+  set strategy(value) {
>+    super.strategy = value;
>+  }
>+  get windowBits() {
>+    return this[windowBits$1];
>+  }
>+  set windowBits(value) {
>+    super.windowBits = value;
>+  }
>+  get dictionary() {
>+    return this[dictionary$1];
>+  }
>+  set dictionary(value) {
>+    super.dictionary = value;
>+  }
>+  get raw() {
>+    return this[raw$1];
>+  }
>+  set raw(value) {
>+    super.raw = value;
>+  }
>+  convert(bytes) {
>+    ListOfint()._check(bytes);
>+    let sink = new io._BufferSink.new();
>+    let _ = this.startChunkedConversion(sink);
>+    _.add(bytes);
>+    _.close();
>+    return sink.builder.takeBytes();
>+  }
>+  startChunkedConversion(sink) {
>+    SinkOfListOfint()._check(sink);
>+    if (!convert.ByteConversionSink.is(sink)) {
>+      sink = convert.ByteConversionSink.from(sink);
>+    }
>+    return new io._ZLibEncoderSink.new(convert.ByteConversionSink._check(sink), this.gzip, this.level, this.windowBits, this.memLevel, this.strategy, this.dictionary, this.raw);
>+  }
>+};
>+(io.ZLibEncoder.new = function(opts) {
>+  let gzip = opts && 'gzip' in opts ? opts.gzip : false;
>+  let level = opts && 'level' in opts ? opts.level : io.ZLibOption.defaultLevel;
>+  let windowBits = opts && 'windowBits' in opts ? opts.windowBits : io.ZLibOption.defaultWindowBits;
>+  let memLevel = opts && 'memLevel' in opts ? opts.memLevel : io.ZLibOption.defaultMemLevel;
>+  let strategy = opts && 'strategy' in opts ? opts.strategy : io.ZLibOption.strategyDefault;
>+  let dictionary = opts && 'dictionary' in opts ? opts.dictionary : null;
>+  let raw = opts && 'raw' in opts ? opts.raw : false;
>+  this[gzip$1] = gzip;
>+  this[level$1] = level;
>+  this[windowBits$1] = windowBits;
>+  this[memLevel$1] = memLevel;
>+  this[strategy$1] = strategy;
>+  this[dictionary$1] = dictionary;
>+  this[raw$1] = raw;
>+  io.ZLibEncoder.__proto__.new.call(this);
>+  io._validateZLibeLevel(this.level);
>+  io._validateZLibMemLevel(this.memLevel);
>+  io._validateZLibStrategy(this.strategy);
>+  io._validateZLibWindowBits(this.windowBits);
>+}).prototype = io.ZLibEncoder.prototype;
>+dart.addTypeTests(io.ZLibEncoder);
>+const gzip$1 = Symbol("ZLibEncoder.gzip");
>+const level$1 = Symbol("ZLibEncoder.level");
>+const memLevel$1 = Symbol("ZLibEncoder.memLevel");
>+const strategy$1 = Symbol("ZLibEncoder.strategy");
>+const windowBits$1 = Symbol("ZLibEncoder.windowBits");
>+const dictionary$1 = Symbol("ZLibEncoder.dictionary");
>+const raw$1 = Symbol("ZLibEncoder.raw");
>+dart.setMethodSignature(io.ZLibEncoder, () => ({
>+  __proto__: dart.getMethods(io.ZLibEncoder.__proto__),
>+  convert: dart.fnType(core.List$(core.int), [core.Object]),
>+  startChunkedConversion: dart.fnType(convert.ByteConversionSink, [core.Object])
>+}));
>+dart.setLibraryUri(io.ZLibEncoder, "dart:io");
>+dart.setFieldSignature(io.ZLibEncoder, () => ({
>+  __proto__: dart.getFields(io.ZLibEncoder.__proto__),
>+  gzip: dart.finalFieldType(core.bool),
>+  level: dart.finalFieldType(core.int),
>+  memLevel: dart.finalFieldType(core.int),
>+  strategy: dart.finalFieldType(core.int),
>+  windowBits: dart.finalFieldType(core.int),
>+  dictionary: dart.finalFieldType(ListOfint()),
>+  raw: dart.finalFieldType(core.bool)
>+}));
>+io.ZLibDecoder = class ZLibDecoder extends convert.Converter$(core.List$(core.int), core.List$(core.int)) {
>+  get windowBits() {
>+    return this[windowBits$2];
>+  }
>+  set windowBits(value) {
>+    super.windowBits = value;
>+  }
>+  get dictionary() {
>+    return this[dictionary$2];
>+  }
>+  set dictionary(value) {
>+    super.dictionary = value;
>+  }
>+  get raw() {
>+    return this[raw$2];
>+  }
>+  set raw(value) {
>+    super.raw = value;
>+  }
>+  convert(bytes) {
>+    ListOfint()._check(bytes);
>+    let sink = new io._BufferSink.new();
>+    let _ = this.startChunkedConversion(sink);
>+    _.add(bytes);
>+    _.close();
>+    return sink.builder.takeBytes();
>+  }
>+  startChunkedConversion(sink) {
>+    SinkOfListOfint()._check(sink);
>+    if (!convert.ByteConversionSink.is(sink)) {
>+      sink = convert.ByteConversionSink.from(sink);
>+    }
>+    return new io._ZLibDecoderSink.new(convert.ByteConversionSink._check(sink), this.windowBits, this.dictionary, this.raw);
>+  }
>+};
>+(io.ZLibDecoder.new = function(opts) {
>+  let windowBits = opts && 'windowBits' in opts ? opts.windowBits : io.ZLibOption.defaultWindowBits;
>+  let dictionary = opts && 'dictionary' in opts ? opts.dictionary : null;
>+  let raw = opts && 'raw' in opts ? opts.raw : false;
>+  this[windowBits$2] = windowBits;
>+  this[dictionary$2] = dictionary;
>+  this[raw$2] = raw;
>+  io.ZLibDecoder.__proto__.new.call(this);
>+  io._validateZLibWindowBits(this.windowBits);
>+}).prototype = io.ZLibDecoder.prototype;
>+dart.addTypeTests(io.ZLibDecoder);
>+const windowBits$2 = Symbol("ZLibDecoder.windowBits");
>+const dictionary$2 = Symbol("ZLibDecoder.dictionary");
>+const raw$2 = Symbol("ZLibDecoder.raw");
>+dart.setMethodSignature(io.ZLibDecoder, () => ({
>+  __proto__: dart.getMethods(io.ZLibDecoder.__proto__),
>+  convert: dart.fnType(core.List$(core.int), [core.Object]),
>+  startChunkedConversion: dart.fnType(convert.ByteConversionSink, [core.Object])
>+}));
>+dart.setLibraryUri(io.ZLibDecoder, "dart:io");
>+dart.setFieldSignature(io.ZLibDecoder, () => ({
>+  __proto__: dart.getFields(io.ZLibDecoder.__proto__),
>+  windowBits: dart.finalFieldType(core.int),
>+  dictionary: dart.finalFieldType(ListOfint()),
>+  raw: dart.finalFieldType(core.bool)
>+}));
>+io.RawZLibFilter = class RawZLibFilter extends core.Object {
>+  static deflateFilter(opts) {
>+    let gzip = opts && 'gzip' in opts ? opts.gzip : false;
>+    let level = opts && 'level' in opts ? opts.level : io.ZLibOption.defaultLevel;
>+    let windowBits = opts && 'windowBits' in opts ? opts.windowBits : io.ZLibOption.defaultWindowBits;
>+    let memLevel = opts && 'memLevel' in opts ? opts.memLevel : io.ZLibOption.defaultMemLevel;
>+    let strategy = opts && 'strategy' in opts ? opts.strategy : io.ZLibOption.strategyDefault;
>+    let dictionary = opts && 'dictionary' in opts ? opts.dictionary : null;
>+    let raw = opts && 'raw' in opts ? opts.raw : false;
>+    return io.RawZLibFilter._makeZLibDeflateFilter(gzip, level, windowBits, memLevel, strategy, dictionary, raw);
>+  }
>+  static inflateFilter(opts) {
>+    let windowBits = opts && 'windowBits' in opts ? opts.windowBits : io.ZLibOption.defaultWindowBits;
>+    let dictionary = opts && 'dictionary' in opts ? opts.dictionary : null;
>+    let raw = opts && 'raw' in opts ? opts.raw : false;
>+    return io.RawZLibFilter._makeZLibInflateFilter(windowBits, dictionary, raw);
>+  }
>+  static _makeZLibDeflateFilter(gzip, level, windowBits, memLevel, strategy, dictionary, raw) {
>+    dart.throw(new core.UnsupportedError.new("_newZLibDeflateFilter"));
>+  }
>+  static _makeZLibInflateFilter(windowBits, dictionary, raw) {
>+    dart.throw(new core.UnsupportedError.new("_newZLibInflateFilter"));
>+  }
>+};
>+(io.RawZLibFilter[dart.mixinNew] = function() {
>+}).prototype = io.RawZLibFilter.prototype;
>+dart.addTypeTests(io.RawZLibFilter);
>+dart.setLibraryUri(io.RawZLibFilter, "dart:io");
>+io._BufferSink = class _BufferSink extends convert.ByteConversionSink {
>+  add(chunk) {
>+    ListOfint()._check(chunk);
>+    this.builder.add(chunk);
>+  }
>+  addSlice(chunk, start, end, isLast) {
>+    if (typed_data.Uint8List.is(chunk)) {
>+      let list = chunk;
>+      this.builder.add(typed_data.Uint8List.view(list[$buffer], start, dart.notNull(end) - dart.notNull(start)));
>+    } else {
>+      this.builder.add(chunk[$sublist](start, end));
>+    }
>+  }
>+  close() {}
>+};
>+(io._BufferSink.new = function() {
>+  this.builder = io.BytesBuilder.new({copy: false});
>+  io._BufferSink.__proto__.new.call(this);
>+}).prototype = io._BufferSink.prototype;
>+dart.addTypeTests(io._BufferSink);
>+dart.setMethodSignature(io._BufferSink, () => ({
>+  __proto__: dart.getMethods(io._BufferSink.__proto__),
>+  add: dart.fnType(dart.void, [core.Object]),
>+  addSlice: dart.fnType(dart.void, [core.List$(core.int), core.int, core.int, core.bool]),
>+  close: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(io._BufferSink, "dart:io");
>+dart.setFieldSignature(io._BufferSink, () => ({
>+  __proto__: dart.getFields(io._BufferSink.__proto__),
>+  builder: dart.finalFieldType(io.BytesBuilder)
>+}));
>+const _sink$0 = dart.privateName(io, "_sink");
>+const _filter$ = dart.privateName(io, "_filter");
>+const _closed = dart.privateName(io, "_closed");
>+const _empty = dart.privateName(io, "_empty");
>+let const$64;
>+io._FilterSink = class _FilterSink extends convert.ByteConversionSink {
>+  add(data) {
>+    ListOfint()._check(data);
>+    this.addSlice(data, 0, data[$length], false);
>+  }
>+  addSlice(data, start, end, isLast) {
>+    if (dart.test(this[_closed])) return;
>+    if (end == null) dart.throw(new core.ArgumentError.notNull("end"));
>+    core.RangeError.checkValidRange(start, end, data[$length]);
>+    try {
>+      this[_empty] = false;
>+      let bufferAndStart = io._ensureFastAndSerializableByteData(data, start, end);
>+      this[_filter$].process(bufferAndStart.buffer, bufferAndStart.start, dart.notNull(end) - (dart.notNull(start) - dart.notNull(bufferAndStart.start)));
>+      let out = null;
>+      while ((out = this[_filter$].processed({flush: false})) != null) {
>+        this[_sink$0].add(out);
>+      }
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      this[_closed] = true;
>+      dart.rethrow(e$);
>+    }
>+    if (dart.test(isLast)) this.close();
>+  }
>+  close() {
>+    if (dart.test(this[_closed])) return;
>+    if (dart.test(this[_empty])) this[_filter$].process(const$64 || (const$64 = dart.constList([], core.int)), 0, 0);
>+    try {
>+      let out = null;
>+      while ((out = this[_filter$].processed({end: true})) != null) {
>+        this[_sink$0].add(out);
>+      }
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      this[_closed] = true;
>+      dart.throw(e);
>+    }
>+    this[_closed] = true;
>+    this[_sink$0].close();
>+  }
>+};
>+(io._FilterSink.new = function(sink, filter) {
>+  this[_closed] = false;
>+  this[_empty] = true;
>+  this[_sink$0] = sink;
>+  this[_filter$] = filter;
>+  io._FilterSink.__proto__.new.call(this);
>+}).prototype = io._FilterSink.prototype;
>+dart.addTypeTests(io._FilterSink);
>+dart.setMethodSignature(io._FilterSink, () => ({
>+  __proto__: dart.getMethods(io._FilterSink.__proto__),
>+  add: dart.fnType(dart.void, [core.Object]),
>+  addSlice: dart.fnType(dart.void, [core.List$(core.int), core.int, core.int, core.bool]),
>+  close: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(io._FilterSink, "dart:io");
>+dart.setFieldSignature(io._FilterSink, () => ({
>+  __proto__: dart.getFields(io._FilterSink.__proto__),
>+  [_filter$]: dart.finalFieldType(io.RawZLibFilter),
>+  [_sink$0]: dart.finalFieldType(convert.ByteConversionSink),
>+  [_closed]: dart.fieldType(core.bool),
>+  [_empty]: dart.fieldType(core.bool)
>+}));
>+io._ZLibEncoderSink = class _ZLibEncoderSink extends io._FilterSink {};
>+(io._ZLibEncoderSink.new = function(sink, gzip, level, windowBits, memLevel, strategy, dictionary, raw) {
>+  io._ZLibEncoderSink.__proto__.new.call(this, sink, io.RawZLibFilter._makeZLibDeflateFilter(gzip, level, windowBits, memLevel, strategy, dictionary, raw));
>+}).prototype = io._ZLibEncoderSink.prototype;
>+dart.addTypeTests(io._ZLibEncoderSink);
>+dart.setLibraryUri(io._ZLibEncoderSink, "dart:io");
>+io._ZLibDecoderSink = class _ZLibDecoderSink extends io._FilterSink {};
>+(io._ZLibDecoderSink.new = function(sink, windowBits, dictionary, raw) {
>+  io._ZLibDecoderSink.__proto__.new.call(this, sink, io.RawZLibFilter._makeZLibInflateFilter(windowBits, dictionary, raw));
>+}).prototype = io._ZLibDecoderSink.prototype;
>+dart.addTypeTests(io._ZLibDecoderSink);
>+dart.setLibraryUri(io._ZLibDecoderSink, "dart:io");
>+io._validateZLibWindowBits = function(windowBits) {
>+  if (io.ZLibOption.minWindowBits > dart.notNull(windowBits) || io.ZLibOption.maxWindowBits < dart.notNull(windowBits)) {
>+    dart.throw(new core.RangeError.range(windowBits, io.ZLibOption.minWindowBits, io.ZLibOption.maxWindowBits));
>+  }
>+};
>+io._validateZLibeLevel = function(level) {
>+  if (io.ZLibOption.minLevel > dart.notNull(level) || io.ZLibOption.maxLevel < dart.notNull(level)) {
>+    dart.throw(new core.RangeError.range(level, io.ZLibOption.minLevel, io.ZLibOption.maxLevel));
>+  }
>+};
>+io._validateZLibMemLevel = function(memLevel) {
>+  if (io.ZLibOption.minMemLevel > dart.notNull(memLevel) || io.ZLibOption.maxMemLevel < dart.notNull(memLevel)) {
>+    dart.throw(new core.RangeError.range(memLevel, io.ZLibOption.minMemLevel, io.ZLibOption.maxMemLevel));
>+  }
>+};
>+let const$65;
>+io._validateZLibStrategy = function(strategy) {
>+  let strategies = const$65 || (const$65 = dart.constList([io.ZLibOption.strategyFiltered, io.ZLibOption.strategyHuffmanOnly, io.ZLibOption.strategyRle, io.ZLibOption.strategyFixed, io.ZLibOption.strategyDefault], core.int));
>+  if (strategies[$indexOf](strategy) === -1) {
>+    dart.throw(new core.ArgumentError.new("Unsupported 'strategy'"));
>+  }
>+};
>+io.Directory = class Directory extends core.Object {
>+  static new(path) {
>+    let overrides = io.IOOverrides.current;
>+    if (overrides == null) {
>+      return new io._Directory.new(path);
>+    }
>+    return overrides.createDirectory(path);
>+  }
>+  static fromRawPath(path) {
>+    return new io._Directory.fromRawPath(path);
>+  }
>+  static fromUri(uri) {
>+    return io.Directory.new(uri.toFilePath());
>+  }
>+  static get current() {
>+    let overrides = io.IOOverrides.current;
>+    if (overrides == null) {
>+      return io._Directory.current;
>+    }
>+    return overrides.getCurrentDirectory();
>+  }
>+  static set current(path) {
>+    let overrides = io.IOOverrides.current;
>+    if (overrides == null) {
>+      io._Directory.current = path;
>+      return;
>+    }
>+    overrides.setCurrentDirectory(core.String._check(path));
>+  }
>+  static get systemTemp() {
>+    let overrides = io.IOOverrides.current;
>+    if (overrides == null) {
>+      return io._Directory.systemTemp;
>+    }
>+    return overrides.getSystemTempDirectory();
>+  }
>+};
>+(io.Directory[dart.mixinNew] = function() {
>+}).prototype = io.Directory.prototype;
>+dart.addTypeTests(io.Directory);
>+io.Directory[dart.implements] = () => [io.FileSystemEntity];
>+dart.setLibraryUri(io.Directory, "dart:io");
>+const _path = dart.privateName(io, "_path");
>+const _rawPath$ = dart.privateName(io, "_rawPath");
>+const _isErrorResponse = dart.privateName(io, "_isErrorResponse");
>+const _exceptionOrErrorFromResponse = dart.privateName(io, "_exceptionOrErrorFromResponse");
>+const _absolutePath = dart.privateName(io, "_absolutePath");
>+const _delete = dart.privateName(io, "_delete");
>+const _deleteSync = dart.privateName(io, "_deleteSync");
>+const _rawAbsolutePath = dart.privateName(io, "_rawAbsolutePath");
>+io.FileSystemEntity = class FileSystemEntity extends core.Object {
>+  get [_path]() {
>+    return this[_path$];
>+  }
>+  set [_path](value) {
>+    this[_path$] = value;
>+  }
>+  get [_rawPath$]() {
>+    return this[_rawPath];
>+  }
>+  set [_rawPath$](value) {
>+    this[_rawPath] = value;
>+  }
>+  get uri() {
>+    return core.Uri.file(this.path);
>+  }
>+  resolveSymbolicLinks() {
>+    return FutureOfString()._check(io._File._dispatchWithNamespace(io._IOService.fileResolveSymbolicLinks, [null, this[_rawPath$]]).then(core.String, dart.fn(response => {
>+      if (dart.test(io._isErrorResponse(response))) {
>+        dart.throw(io._exceptionFromResponse(response, "Cannot resolve symbolic links", this.path));
>+      }
>+      return FutureOrOfString()._check(response);
>+    }, dynamicToFutureOrOfString())));
>+  }
>+  resolveSymbolicLinksSync() {
>+    let result = io.FileSystemEntity._resolveSymbolicLinks(io._Namespace._namespace, this[_rawPath$]);
>+    io.FileSystemEntity._throwIfError(result, "Cannot resolve symbolic links", this.path);
>+    return core.String._check(result);
>+  }
>+  stat() {
>+    return io.FileStat.stat(this.path);
>+  }
>+  statSync() {
>+    return io.FileStat.statSync(this.path);
>+  }
>+  delete(opts) {
>+    let recursive = opts && 'recursive' in opts ? opts.recursive : false;
>+    return this[_delete]({recursive: recursive});
>+  }
>+  deleteSync(opts) {
>+    let recursive = opts && 'recursive' in opts ? opts.recursive : false;
>+    return this[_deleteSync]({recursive: recursive});
>+  }
>+  watch(opts) {
>+    let events = opts && 'events' in opts ? opts.events : io.FileSystemEvent.all;
>+    let recursive = opts && 'recursive' in opts ? opts.recursive : false;
>+    let trimmedPath = io.FileSystemEntity._trimTrailingPathSeparators(this.path);
>+    let overrides = io.IOOverrides.current;
>+    if (overrides == null) {
>+      return io._FileSystemWatcher._watch(trimmedPath, events, recursive);
>+    }
>+    return overrides.fsWatch(trimmedPath, events, recursive);
>+  }
>+  static _identical(path1, path2) {
>+    return FutureOfbool()._check(io._File._dispatchWithNamespace(io._IOService.fileIdentical, [null, path1, path2]).then(core.bool, dart.fn(response => {
>+      if (dart.test(io._isErrorResponse(response))) {
>+        dart.throw(io._exceptionFromResponse(response, "Error in FileSystemEntity.identical(" + dart.str(path1) + ", " + dart.str(path2) + ")", ""));
>+      }
>+      return FutureOrOfbool()._check(response);
>+    }, dynamicToFutureOrOfbool())));
>+  }
>+  static identical(path1, path2) {
>+    let overrides = io.IOOverrides.current;
>+    if (overrides == null) {
>+      return io.FileSystemEntity._identical(path1, path2);
>+    }
>+    return overrides.fseIdentical(path1, path2);
>+  }
>+  get isAbsolute() {
>+    if (dart.test(io.Platform.isWindows)) {
>+      return this.path[$startsWith](io.FileSystemEntity._absoluteWindowsPathPattern);
>+    } else {
>+      return this.path[$startsWith]("/");
>+    }
>+  }
>+  get [_absolutePath]() {
>+    if (dart.test(this.isAbsolute)) return this.path;
>+    let current = io.Directory.current.path;
>+    if (current[$endsWith]("/") || dart.test(io.Platform.isWindows) && current[$endsWith]("\\")) {
>+      return dart.str(current) + dart.str(this.path);
>+    } else {
>+      return dart.str(current) + dart.str(io.Platform.pathSeparator) + dart.str(this.path);
>+    }
>+  }
>+  get [_rawAbsolutePath]() {
>+    if (dart.test(this.isAbsolute)) return this[_rawPath$];
>+    let current = io.Directory.current[_rawPath$][$toList]();
>+    if (!(current[$last] === 0)) dart.assertFailed(null, "dart:io/file_system_entity.dart", 591, 12, "current.last == 0");
>+    current[$removeLast]();
>+    if (current[$last] === "/"[$codeUnitAt](0) || dart.test(io.Platform.isWindows) && current[$last] === "\\"[$codeUnitAt](0)) {
>+      current[$addAll](this[_rawPath$]);
>+      return typed_data.Uint8List.fromList(current);
>+    } else {
>+      current[$addAll](convert.utf8.encode(io.Platform.pathSeparator));
>+      current[$addAll](this[_rawPath$]);
>+      return typed_data.Uint8List.fromList(current);
>+    }
>+  }
>+  static _identicalSync(path1, path2) {
>+    let result = io.FileSystemEntity._identicalNative(io._Namespace._namespace, path1, path2);
>+    io.FileSystemEntity._throwIfError(result, "Error in FileSystemEntity.identicalSync");
>+    return core.bool._check(result);
>+  }
>+  static identicalSync(path1, path2) {
>+    let overrides = io.IOOverrides.current;
>+    if (overrides == null) {
>+      return io.FileSystemEntity._identicalSync(path1, path2);
>+    }
>+    return overrides.fseIdenticalSync(path1, path2);
>+  }
>+  static get isWatchSupported() {
>+    let overrides = io.IOOverrides.current;
>+    if (overrides == null) {
>+      return io._FileSystemWatcher.isSupported;
>+    }
>+    return overrides.fsWatchIsSupported();
>+  }
>+  static _toUtf8Array(s) {
>+    return io.FileSystemEntity._toNullTerminatedUtf8Array(typed_data.Uint8List._check(convert.utf8.encode(s)));
>+  }
>+  static _toNullTerminatedUtf8Array(l) {
>+    if (l == null) {
>+      return null;
>+    }
>+    if (dart.test(l[$isNotEmpty]) && l[$last] !== 0) {
>+      let tmp = typed_data.Uint8List.new(dart.notNull(l[$length]) + 1);
>+      tmp[$setRange](0, l[$length], l);
>+      return tmp;
>+    } else {
>+      return l;
>+    }
>+  }
>+  static _toStringFromUtf8Array(l) {
>+    if (l == null) {
>+      return "";
>+    }
>+    let nonNullTerminated = l;
>+    if (l[$last] === 0) {
>+      nonNullTerminated = typed_data.Uint8List.view(l[$buffer], 0, dart.notNull(l[$length]) - 1);
>+    }
>+    return convert.utf8.decode(nonNullTerminated, {allowMalformed: true});
>+  }
>+  static type(path, opts) {
>+    let followLinks = opts && 'followLinks' in opts ? opts.followLinks : true;
>+    return io.FileSystemEntity._getType(io.FileSystemEntity._toUtf8Array(path), followLinks);
>+  }
>+  static typeSync(path, opts) {
>+    let followLinks = opts && 'followLinks' in opts ? opts.followLinks : true;
>+    return io.FileSystemEntity._getTypeSync(io.FileSystemEntity._toUtf8Array(path), followLinks);
>+  }
>+  static isLink(path) {
>+    return io.FileSystemEntity._isLinkRaw(io.FileSystemEntity._toUtf8Array(path));
>+  }
>+  static _isLinkRaw(rawPath) {
>+    return FutureOfbool()._check(io.FileSystemEntity._getType(rawPath, false).then(core.bool, dart.fn(type => dart.equals(type, io.FileSystemEntityType.link), FileSystemEntityTypeTobool())));
>+  }
>+  static isFile(path) {
>+    return FutureOfbool()._check(io.FileSystemEntity._getType(io.FileSystemEntity._toUtf8Array(path), true).then(core.bool, dart.fn(type => dart.equals(type, io.FileSystemEntityType.file), FileSystemEntityTypeTobool())));
>+  }
>+  static isDirectory(path) {
>+    return FutureOfbool()._check(io.FileSystemEntity._getType(io.FileSystemEntity._toUtf8Array(path), true).then(core.bool, dart.fn(type => dart.equals(type, io.FileSystemEntityType.directory), FileSystemEntityTypeTobool())));
>+  }
>+  static isLinkSync(path) {
>+    return io.FileSystemEntity._isLinkRawSync(io.FileSystemEntity._toUtf8Array(path));
>+  }
>+  static _isLinkRawSync(rawPath) {
>+    return dart.equals(io.FileSystemEntity._getTypeSync(typed_data.Uint8List._check(rawPath), false), io.FileSystemEntityType.link);
>+  }
>+  static isFileSync(path) {
>+    return dart.equals(io.FileSystemEntity._getTypeSync(io.FileSystemEntity._toUtf8Array(path), true), io.FileSystemEntityType.file);
>+  }
>+  static isDirectorySync(path) {
>+    return dart.equals(io.FileSystemEntity._getTypeSync(io.FileSystemEntity._toUtf8Array(path), true), io.FileSystemEntityType.directory);
>+  }
>+  static _getTypeNative(namespace, rawPath, followLinks) {
>+    dart.throw(new core.UnsupportedError.new("FileSystemEntity._getType"));
>+  }
>+  static _identicalNative(namespace, path1, path2) {
>+    dart.throw(new core.UnsupportedError.new("FileSystemEntity._identical"));
>+  }
>+  static _resolveSymbolicLinks(namespace, rawPath) {
>+    dart.throw(new core.UnsupportedError.new("FileSystemEntity._resolveSymbolicLinks"));
>+  }
>+  static parentOf(path) {
>+    let rootEnd = -1;
>+    if (dart.test(io.Platform.isWindows)) {
>+      if (path[$startsWith](io.FileSystemEntity._absoluteWindowsPathPattern)) {
>+        rootEnd = path[$indexOf](core.RegExp.new("[/\\\\]"), 2);
>+        if (rootEnd === -1) return path;
>+      } else if (path[$startsWith]("\\") || path[$startsWith]("/")) {
>+        rootEnd = 0;
>+      }
>+    } else if (path[$startsWith]("/")) {
>+      rootEnd = 0;
>+    }
>+    let pos = path[$lastIndexOf](io.FileSystemEntity._parentRegExp);
>+    if (pos > rootEnd) {
>+      return path[$substring](0, pos + 1);
>+    } else if (rootEnd > -1) {
>+      return path[$substring](0, rootEnd + 1);
>+    } else {
>+      return ".";
>+    }
>+  }
>+  get parent() {
>+    return io.Directory.new(io.FileSystemEntity.parentOf(this.path));
>+  }
>+  static _getTypeSyncHelper(rawPath, followLinks) {
>+    let result = io.FileSystemEntity._getTypeNative(io._Namespace._namespace, rawPath, followLinks);
>+    io.FileSystemEntity._throwIfError(result, "Error getting type of FileSystemEntity");
>+    return io.FileSystemEntityType._lookup(core.int._check(result));
>+  }
>+  static _getTypeSync(rawPath, followLinks) {
>+    let overrides = io.IOOverrides.current;
>+    if (overrides == null) {
>+      return io.FileSystemEntity._getTypeSyncHelper(rawPath, followLinks);
>+    }
>+    return overrides.fseGetTypeSync(convert.utf8.decode(rawPath, {allowMalformed: true}), followLinks);
>+  }
>+  static _getTypeRequest(rawPath, followLinks) {
>+    return FutureOfFileSystemEntityType()._check(io._File._dispatchWithNamespace(io._IOService.fileType, [null, rawPath, followLinks]).then(io.FileSystemEntityType, dart.fn(response => {
>+      if (dart.test(io._isErrorResponse(response))) {
>+        dart.throw(io._exceptionFromResponse(response, "Error getting type", convert.utf8.decode(rawPath, {allowMalformed: true})));
>+      }
>+      return io.FileSystemEntityType._lookup(core.int._check(response));
>+    }, dynamicToFileSystemEntityType())));
>+  }
>+  static _getType(rawPath, followLinks) {
>+    let overrides = io.IOOverrides.current;
>+    if (overrides == null) {
>+      return io.FileSystemEntity._getTypeRequest(rawPath, followLinks);
>+    }
>+    return overrides.fseGetType(convert.utf8.decode(rawPath, {allowMalformed: true}), followLinks);
>+  }
>+  static _throwIfError(result, msg, path) {
>+    if (path === void 0) path = null;
>+    if (io.OSError.is(result)) {
>+      dart.throw(new io.FileSystemException.new(msg, path, result));
>+    } else if (core.ArgumentError.is(result)) {
>+      dart.throw(result);
>+    }
>+  }
>+  static _trimTrailingPathSeparators(path) {
>+    if (path == null) return path;
>+    if (dart.test(io.Platform.isWindows)) {
>+      while (path.length > 1 && (path[$endsWith](io.Platform.pathSeparator) || path[$endsWith]("/"))) {
>+        path = path[$substring](0, path.length - 1);
>+      }
>+    } else {
>+      while (path.length > 1 && path[$endsWith](io.Platform.pathSeparator)) {
>+        path = path[$substring](0, path.length - 1);
>+      }
>+    }
>+    return path;
>+  }
>+  static _ensureTrailingPathSeparators(path) {
>+    if (path == null) return path;
>+    if (path[$isEmpty]) path = ".";
>+    if (dart.test(io.Platform.isWindows)) {
>+      while (!path[$endsWith](io.Platform.pathSeparator) && !path[$endsWith]("/")) {
>+        path = dart.str(path) + dart.str(io.Platform.pathSeparator);
>+      }
>+    } else {
>+      while (!path[$endsWith](io.Platform.pathSeparator)) {
>+        path = dart.str(path) + dart.str(io.Platform.pathSeparator);
>+      }
>+    }
>+    return path;
>+  }
>+};
>+(io.FileSystemEntity.new = function() {
>+  this[_path$] = null;
>+  this[_rawPath] = null;
>+}).prototype = io.FileSystemEntity.prototype;
>+dart.addTypeTests(io.FileSystemEntity);
>+const _path$ = Symbol("FileSystemEntity._path");
>+const _rawPath = Symbol("FileSystemEntity._rawPath");
>+dart.setMethodSignature(io.FileSystemEntity, () => ({
>+  __proto__: dart.getMethods(io.FileSystemEntity.__proto__),
>+  resolveSymbolicLinks: dart.fnType(async.Future$(core.String), []),
>+  resolveSymbolicLinksSync: dart.fnType(core.String, []),
>+  stat: dart.fnType(async.Future$(io.FileStat), []),
>+  statSync: dart.fnType(io.FileStat, []),
>+  delete: dart.fnType(async.Future$(io.FileSystemEntity), [], {recursive: core.bool}),
>+  deleteSync: dart.fnType(dart.void, [], {recursive: core.bool}),
>+  watch: dart.fnType(async.Stream$(io.FileSystemEvent), [], {events: core.int, recursive: core.bool})
>+}));
>+dart.setGetterSignature(io.FileSystemEntity, () => ({
>+  __proto__: dart.getGetters(io.FileSystemEntity.__proto__),
>+  uri: core.Uri,
>+  isAbsolute: core.bool,
>+  [_absolutePath]: core.String,
>+  [_rawAbsolutePath]: typed_data.Uint8List,
>+  parent: io.Directory
>+}));
>+dart.setLibraryUri(io.FileSystemEntity, "dart:io");
>+dart.setFieldSignature(io.FileSystemEntity, () => ({
>+  __proto__: dart.getFields(io.FileSystemEntity.__proto__),
>+  [_path]: dart.fieldType(core.String),
>+  [_rawPath$]: dart.fieldType(typed_data.Uint8List)
>+}));
>+dart.defineLazy(io.FileSystemEntity, {
>+  /*io.FileSystemEntity._absoluteWindowsPathPattern*/get _absoluteWindowsPathPattern() {
>+    return core.RegExp.new("^(\\\\\\\\|[a-zA-Z]:[/\\\\])");
>+  },
>+  /*io.FileSystemEntity._parentRegExp*/get _parentRegExp() {
>+    return dart.test(io.Platform.isWindows) ? core.RegExp.new("[^/\\\\][/\\\\]+[^/\\\\]") : core.RegExp.new("[^/]/+[^/]");
>+  }
>+});
>+io._Directory = class _Directory extends io.FileSystemEntity {
>+  get [_path]() {
>+    return this[_path$0];
>+  }
>+  set [_path](value) {
>+    this[_path$0] = value;
>+  }
>+  get [_rawPath$]() {
>+    return this[_rawPath$0];
>+  }
>+  set [_rawPath$](value) {
>+    this[_rawPath$0] = value;
>+  }
>+  get path() {
>+    return this[_path];
>+  }
>+  static _current(namespace) {
>+    dart.throw(new core.UnsupportedError.new("Directory._current"));
>+  }
>+  static _setCurrent(namespace, rawPath) {
>+    dart.throw(new core.UnsupportedError.new("Directory_SetCurrent"));
>+  }
>+  static _createTemp(namespace, rawPath) {
>+    dart.throw(new core.UnsupportedError.new("Directory._createTemp"));
>+  }
>+  static _systemTemp(namespace) {
>+    dart.throw(new core.UnsupportedError.new("Directory._systemTemp"));
>+  }
>+  static _exists(namespace, rawPath) {
>+    dart.throw(new core.UnsupportedError.new("Directory._exists"));
>+  }
>+  static _create(namespace, rawPath) {
>+    dart.throw(new core.UnsupportedError.new("Directory._create"));
>+  }
>+  static _deleteNative(namespace, rawPath, recursive) {
>+    dart.throw(new core.UnsupportedError.new("Directory._deleteNative"));
>+  }
>+  static _rename(namespace, rawPath, newPath) {
>+    dart.throw(new core.UnsupportedError.new("Directory._rename"));
>+  }
>+  static _fillWithDirectoryListing(namespace, list, rawPath, recursive, followLinks) {
>+    dart.throw(new core.UnsupportedError.new("Directory._fillWithDirectoryListing"));
>+  }
>+  static get current() {
>+    let result = io._Directory._current(io._Namespace._namespace);
>+    if (io.OSError.is(result)) {
>+      dart.throw(new io.FileSystemException.new("Getting current working directory failed", "", result));
>+    }
>+    return new io._Directory.new(core.String._check(result));
>+  }
>+  static set current(path) {
>+    let _rawPath = null;
>+    if (io._Directory.is(path)) {
>+      _rawPath = path[_rawPath$];
>+    } else if (io.Directory.is(path)) {
>+      _rawPath = io.FileSystemEntity._toUtf8Array(path.path);
>+    } else if (typeof path == 'string') {
>+      _rawPath = io.FileSystemEntity._toUtf8Array(path);
>+    } else {
>+      dart.throw(new core.ArgumentError.new(dart.str(core.Error.safeToString(path)) + " is not a String or" + " Directory"));
>+    }
>+    if (!dart.test(io._EmbedderConfig._mayChdir)) {
>+      dart.throw(new core.UnsupportedError.new("This embedder disallows setting Directory.current"));
>+    }
>+    let result = io._Directory._setCurrent(io._Namespace._namespace, _rawPath);
>+    if (core.ArgumentError.is(result)) dart.throw(result);
>+    if (io.OSError.is(result)) {
>+      dart.throw(new io.FileSystemException.new("Setting current working directory failed", core.String._check(path), result));
>+    }
>+  }
>+  get uri() {
>+    return core.Uri.directory(this.path);
>+  }
>+  exists() {
>+    return FutureOfbool()._check(io._File._dispatchWithNamespace(io._IOService.directoryExists, [null, this[_rawPath$]]).then(core.bool, dart.fn(response => {
>+      if (dart.test(this[_isErrorResponse](response))) {
>+        dart.throw(this[_exceptionOrErrorFromResponse](response, "Exists failed"));
>+      }
>+      return dart.equals(response, 1);
>+    }, dynamicTobool())));
>+  }
>+  existsSync() {
>+    let result = io._Directory._exists(io._Namespace._namespace, this[_rawPath$]);
>+    if (io.OSError.is(result)) {
>+      dart.throw(new io.FileSystemException.new("Exists failed", this.path, result));
>+    }
>+    return dart.equals(result, 1);
>+  }
>+  get absolute() {
>+    return io.Directory.new(this[_absolutePath]);
>+  }
>+  create(opts) {
>+    let recursive = opts && 'recursive' in opts ? opts.recursive : false;
>+    if (dart.test(recursive)) {
>+      return FutureOfDirectory()._check(this.exists().then(io.Directory, dart.fn(exists => {
>+        if (dart.test(exists)) return this;
>+        if (this.path != this.parent.path) {
>+          return FutureOfDirectory()._check(this.parent.create({recursive: true}).then(io.Directory, dart.fn(_ => this.create(), DirectoryToFutureOfDirectory())));
>+        } else {
>+          return this.create();
>+        }
>+      }, boolToFutureOrOfDirectory())));
>+    } else {
>+      return FutureOfDirectory()._check(io._File._dispatchWithNamespace(io._IOService.directoryCreate, [null, this[_rawPath$]]).then(io.Directory, dart.fn(response => {
>+        if (dart.test(this[_isErrorResponse](response))) {
>+          dart.throw(this[_exceptionOrErrorFromResponse](response, "Creation failed"));
>+        }
>+        return this;
>+      }, dynamicTo_Directory())));
>+    }
>+  }
>+  createSync(opts) {
>+    let recursive = opts && 'recursive' in opts ? opts.recursive : false;
>+    if (dart.test(recursive)) {
>+      if (dart.test(this.existsSync())) return;
>+      if (this.path != this.parent.path) {
>+        this.parent.createSync({recursive: true});
>+      }
>+    }
>+    let result = io._Directory._create(io._Namespace._namespace, this[_rawPath$]);
>+    if (io.OSError.is(result)) {
>+      dart.throw(new io.FileSystemException.new("Creation failed", this.path, result));
>+    }
>+  }
>+  static get systemTemp() {
>+    return io.Directory.new(io._Directory._systemTemp(io._Namespace._namespace));
>+  }
>+  createTemp(prefix) {
>+    if (prefix === void 0) prefix = null;
>+    let t = prefix;
>+    t == null ? prefix = "" : t;
>+    if (this.path === "") {
>+      dart.throw(new core.ArgumentError.new("Directory.createTemp called with an empty path. " + "To use the system temp directory, use Directory.systemTemp"));
>+    }
>+    let fullPrefix = null;
>+    if (this.path[$endsWith]("/") || dart.test(io.Platform.isWindows) && this.path[$endsWith]("\\")) {
>+      fullPrefix = dart.str(this.path) + dart.str(prefix);
>+    } else {
>+      fullPrefix = dart.str(this.path) + dart.str(io.Platform.pathSeparator) + dart.str(prefix);
>+    }
>+    return FutureOfDirectory()._check(io._File._dispatchWithNamespace(io._IOService.directoryCreateTemp, [null, io.FileSystemEntity._toUtf8Array(fullPrefix)]).then(io.Directory, dart.fn(response => {
>+      if (dart.test(this[_isErrorResponse](response))) {
>+        dart.throw(this[_exceptionOrErrorFromResponse](response, "Creation of temporary directory failed"));
>+      }
>+      return io.Directory.new(core.String._check(response));
>+    }, dynamicToDirectory())));
>+  }
>+  createTempSync(prefix) {
>+    if (prefix === void 0) prefix = null;
>+    let t = prefix;
>+    t == null ? prefix = "" : t;
>+    if (this.path === "") {
>+      dart.throw(new core.ArgumentError.new("Directory.createTemp called with an empty path. " + "To use the system temp directory, use Directory.systemTemp"));
>+    }
>+    let fullPrefix = null;
>+    if (this.path[$endsWith]("/") || dart.test(io.Platform.isWindows) && this.path[$endsWith]("\\")) {
>+      fullPrefix = dart.str(this.path) + dart.str(prefix);
>+    } else {
>+      fullPrefix = dart.str(this.path) + dart.str(io.Platform.pathSeparator) + dart.str(prefix);
>+    }
>+    let result = io._Directory._createTemp(io._Namespace._namespace, io.FileSystemEntity._toUtf8Array(fullPrefix));
>+    if (io.OSError.is(result)) {
>+      dart.throw(new io.FileSystemException.new("Creation of temporary directory failed", fullPrefix, result));
>+    }
>+    return io.Directory.new(core.String._check(result));
>+  }
>+  [_delete](opts) {
>+    let recursive = opts && 'recursive' in opts ? opts.recursive : false;
>+    return FutureOfDirectory()._check(io._File._dispatchWithNamespace(io._IOService.directoryDelete, [null, this[_rawPath$], recursive]).then(io.Directory, dart.fn(response => {
>+      if (dart.test(this[_isErrorResponse](response))) {
>+        dart.throw(this[_exceptionOrErrorFromResponse](response, "Deletion failed"));
>+      }
>+      return this;
>+    }, dynamicTo_Directory())));
>+  }
>+  [_deleteSync](opts) {
>+    let recursive = opts && 'recursive' in opts ? opts.recursive : false;
>+    let result = io._Directory._deleteNative(io._Namespace._namespace, this[_rawPath$], recursive);
>+    if (io.OSError.is(result)) {
>+      dart.throw(new io.FileSystemException.new("Deletion failed", this.path, result));
>+    }
>+  }
>+  rename(newPath) {
>+    return FutureOfDirectory()._check(io._File._dispatchWithNamespace(io._IOService.directoryRename, [null, this[_rawPath$], newPath]).then(io.Directory, dart.fn(response => {
>+      if (dart.test(this[_isErrorResponse](response))) {
>+        dart.throw(this[_exceptionOrErrorFromResponse](response, "Rename failed"));
>+      }
>+      return io.Directory.new(newPath);
>+    }, dynamicToDirectory())));
>+  }
>+  renameSync(newPath) {
>+    if (!(typeof newPath == 'string')) {
>+      dart.throw(new core.ArgumentError.new());
>+    }
>+    let result = io._Directory._rename(io._Namespace._namespace, this[_rawPath$], newPath);
>+    if (io.OSError.is(result)) {
>+      dart.throw(new io.FileSystemException.new("Rename failed", this.path, result));
>+    }
>+    return io.Directory.new(newPath);
>+  }
>+  list(opts) {
>+    let recursive = opts && 'recursive' in opts ? opts.recursive : false;
>+    let followLinks = opts && 'followLinks' in opts ? opts.followLinks : true;
>+    return new io._AsyncDirectoryLister.new(io.FileSystemEntity._toUtf8Array(io.FileSystemEntity._ensureTrailingPathSeparators(this.path)), recursive, followLinks).stream;
>+  }
>+  listSync(opts) {
>+    let recursive = opts && 'recursive' in opts ? opts.recursive : false;
>+    let followLinks = opts && 'followLinks' in opts ? opts.followLinks : true;
>+    if (!(typeof recursive == 'boolean') || !(typeof followLinks == 'boolean')) {
>+      dart.throw(new core.ArgumentError.new());
>+    }
>+    let result = JSArrayOfFileSystemEntity().of([]);
>+    io._Directory._fillWithDirectoryListing(io._Namespace._namespace, result, io.FileSystemEntity._toUtf8Array(io.FileSystemEntity._ensureTrailingPathSeparators(this.path)), recursive, followLinks);
>+    return result;
>+  }
>+  toString() {
>+    return "Directory: '" + dart.str(this.path) + "'";
>+  }
>+  [_isErrorResponse](response) {
>+    return core.List.is(response) && !dart.equals(response[$_get](0), 0);
>+  }
>+  [_exceptionOrErrorFromResponse](response, message) {
>+    if (!dart.test(this[_isErrorResponse](response))) dart.assertFailed(null, "dart:io/directory_impl.dart", 284, 12, "_isErrorResponse(response)");
>+    switch (dart.dindex(response, 0)) {
>+      case 1:
>+      {
>+        return new core.ArgumentError.new();
>+      }
>+      case 2:
>+      {
>+        let err = new io.OSError.new(core.String._check(dart.dindex(response, 2)), core.int._check(dart.dindex(response, 1)));
>+        return new io.FileSystemException.new(message, this.path, err);
>+      }
>+      default:
>+      {
>+        return core.Exception.new("Unknown error");
>+      }
>+    }
>+  }
>+};
>+(io._Directory.new = function(path) {
>+  this[_path$0] = null;
>+  this[_rawPath$0] = null;
>+  io._Directory.__proto__.new.call(this);
>+  core.ArgumentError.checkNotNull(path, "path");
>+  this[_path] = path;
>+  this[_rawPath$] = io.FileSystemEntity._toUtf8Array(this[_path]);
>+}).prototype = io._Directory.prototype;
>+(io._Directory.fromRawPath = function(rawPath) {
>+  this[_path$0] = null;
>+  this[_rawPath$0] = null;
>+  io._Directory.__proto__.new.call(this);
>+  if (rawPath == null) {
>+    dart.throw(new core.ArgumentError.new("rawPath cannot be null"));
>+  }
>+  this[_rawPath$] = io.FileSystemEntity._toNullTerminatedUtf8Array(rawPath);
>+  this[_path] = io.FileSystemEntity._toStringFromUtf8Array(rawPath);
>+}).prototype = io._Directory.prototype;
>+dart.addTypeTests(io._Directory);
>+const _path$0 = Symbol("_Directory._path");
>+const _rawPath$0 = Symbol("_Directory._rawPath");
>+io._Directory[dart.implements] = () => [io.Directory];
>+dart.setMethodSignature(io._Directory, () => ({
>+  __proto__: dart.getMethods(io._Directory.__proto__),
>+  exists: dart.fnType(async.Future$(core.bool), []),
>+  existsSync: dart.fnType(core.bool, []),
>+  create: dart.fnType(async.Future$(io.Directory), [], {recursive: core.bool}),
>+  createSync: dart.fnType(dart.void, [], {recursive: core.bool}),
>+  createTemp: dart.fnType(async.Future$(io.Directory), [], [core.String]),
>+  createTempSync: dart.fnType(io.Directory, [], [core.String]),
>+  [_delete]: dart.fnType(async.Future$(io.Directory), [], {recursive: core.bool}),
>+  [_deleteSync]: dart.fnType(dart.void, [], {recursive: core.bool}),
>+  rename: dart.fnType(async.Future$(io.Directory), [core.String]),
>+  renameSync: dart.fnType(io.Directory, [core.String]),
>+  list: dart.fnType(async.Stream$(io.FileSystemEntity), [], {recursive: core.bool, followLinks: core.bool}),
>+  listSync: dart.fnType(core.List$(io.FileSystemEntity), [], {recursive: core.bool, followLinks: core.bool}),
>+  [_isErrorResponse]: dart.fnType(core.bool, [dart.dynamic]),
>+  [_exceptionOrErrorFromResponse]: dart.fnType(dart.dynamic, [dart.dynamic, core.String])
>+}));
>+dart.setGetterSignature(io._Directory, () => ({
>+  __proto__: dart.getGetters(io._Directory.__proto__),
>+  path: core.String,
>+  absolute: io.Directory
>+}));
>+dart.setLibraryUri(io._Directory, "dart:io");
>+dart.setFieldSignature(io._Directory, () => ({
>+  __proto__: dart.getFields(io._Directory.__proto__),
>+  [_path]: dart.fieldType(core.String),
>+  [_rawPath$]: dart.fieldType(typed_data.Uint8List)
>+}));
>+dart.defineExtensionMethods(io._Directory, ['toString']);
>+io._AsyncDirectoryListerOps = class _AsyncDirectoryListerOps extends core.Object {
>+  static new(pointer) {
>+    dart.throw(new core.UnsupportedError.new("Directory._list"));
>+  }
>+};
>+(io._AsyncDirectoryListerOps[dart.mixinNew] = function() {
>+}).prototype = io._AsyncDirectoryListerOps.prototype;
>+dart.addTypeTests(io._AsyncDirectoryListerOps);
>+dart.setLibraryUri(io._AsyncDirectoryListerOps, "dart:io");
>+const _ops = dart.privateName(io, "_ops");
>+const _pointer = dart.privateName(io, "_pointer");
>+const _cleanup = dart.privateName(io, "_cleanup");
>+io._AsyncDirectoryLister = class _AsyncDirectoryLister extends core.Object {
>+  [_pointer]() {
>+    return this[_ops] == null ? null : this[_ops].getPointer();
>+  }
>+  get stream() {
>+    return this.controller.stream;
>+  }
>+  onListen() {
>+    FutureOfNull()._check(io._File._dispatchWithNamespace(io._IOService.directoryListStart, [null, this.rawPath, this.recursive, this.followLinks]).then(core.Null, dart.fn(response => {
>+      if (core.int.is(response)) {
>+        this[_ops] = io._AsyncDirectoryListerOps.new(response);
>+        this.next();
>+      } else if (core.Error.is(response)) {
>+        this.controller.addError(response, response[$stackTrace]);
>+        this.close();
>+      } else {
>+        this.error(response);
>+        this.close();
>+      }
>+    }, dynamicToNull())));
>+  }
>+  onResume() {
>+    if (!dart.test(this.nextRunning)) {
>+      this.next();
>+    }
>+  }
>+  onCancel() {
>+    this.canceled = true;
>+    if (!dart.test(this.nextRunning)) {
>+      this.close();
>+    }
>+    return this.closeCompleter.future;
>+  }
>+  next() {
>+    if (dart.test(this.canceled)) {
>+      this.close();
>+      return;
>+    }
>+    if (dart.test(this.controller.isPaused) || dart.test(this.nextRunning)) {
>+      return;
>+    }
>+    let pointer = this[_pointer]();
>+    if (pointer == null) {
>+      return;
>+    }
>+    this.nextRunning = true;
>+    FutureOfNull()._check(io._IOService._dispatch(io._IOService.directoryListNext, [pointer]).then(core.Null, dart.fn(result => {
>+      this.nextRunning = false;
>+      if (core.List.is(result)) {
>+        this.next();
>+        if (!(result[$length][$modulo](2) === 0)) dart.assertFailed(null, "dart:io/directory_impl.dart", 395, 16, "result.length % 2 == 0");
>+        for (let i = 0; i < dart.notNull(result[$length]); i++) {
>+          if (!(i[$modulo](2) === 0)) dart.assertFailed(null, "dart:io/directory_impl.dart", 397, 18, "i % 2 == 0");
>+          switch (result[$_get](i++)) {
>+            case 0:
>+            {
>+              this.controller.add(io.File.fromRawPath(typed_data.Uint8List._check(result[$_get](i))));
>+              break;
>+            }
>+            case 1:
>+            {
>+              this.controller.add(io.Directory.fromRawPath(typed_data.Uint8List._check(result[$_get](i))));
>+              break;
>+            }
>+            case 2:
>+            {
>+              this.controller.add(io.Link.fromRawPath(typed_data.Uint8List._check(result[$_get](i))));
>+              break;
>+            }
>+            case 3:
>+            {
>+              this.error(result[$_get](i));
>+              break;
>+            }
>+            case 4:
>+            {
>+              this.canceled = true;
>+              return;
>+            }
>+          }
>+        }
>+      } else {
>+        this.controller.addError(new io.FileSystemException.new("Internal error"));
>+      }
>+    }, dynamicToNull())));
>+  }
>+  [_cleanup]() {
>+    this.controller.close();
>+    this.closeCompleter.complete();
>+    this[_ops] = null;
>+  }
>+  close() {
>+    if (dart.test(this.closed)) {
>+      return;
>+    }
>+    if (dart.test(this.nextRunning)) {
>+      return;
>+    }
>+    this.closed = true;
>+    let pointer = this[_pointer]();
>+    if (pointer == null) {
>+      this[_cleanup]();
>+    } else {
>+      io._IOService._dispatch(io._IOService.directoryListStop, [pointer]).whenComplete(dart.bind(this, _cleanup));
>+    }
>+  }
>+  error(message) {
>+    let errorType = dart.dindex(dart.dindex(message, 2), 0);
>+    if (dart.equals(errorType, 1)) {
>+      this.controller.addError(new core.ArgumentError.new());
>+    } else if (dart.equals(errorType, 2)) {
>+      let responseErrorInfo = dart.dindex(message, 2);
>+      let err = new io.OSError.new(core.String._check(dart.dindex(responseErrorInfo, 2)), core.int._check(dart.dindex(responseErrorInfo, 1)));
>+      let errorPath = dart.dindex(message, 1);
>+      if (errorPath == null) {
>+        errorPath = convert.utf8.decode(this.rawPath, {allowMalformed: true});
>+      } else if (typed_data.Uint8List.is(errorPath)) {
>+        errorPath = convert.utf8.decode(ListOfint()._check(dart.dindex(message, 1)), {allowMalformed: true});
>+      }
>+      this.controller.addError(new io.FileSystemException.new("Directory listing failed", core.String._check(errorPath), err));
>+    } else {
>+      this.controller.addError(new io.FileSystemException.new("Internal error"));
>+    }
>+  }
>+};
>+(io._AsyncDirectoryLister.new = function(rawPath, recursive, followLinks) {
>+  this.controller = null;
>+  this.canceled = false;
>+  this.nextRunning = false;
>+  this.closed = false;
>+  this[_ops] = null;
>+  this.closeCompleter = async.Completer.new();
>+  this.rawPath = rawPath;
>+  this.recursive = recursive;
>+  this.followLinks = followLinks;
>+  this.controller = StreamControllerOfFileSystemEntity().new({onListen: dart.bind(this, 'onListen'), onResume: dart.bind(this, 'onResume'), onCancel: dart.bind(this, 'onCancel'), sync: true});
>+}).prototype = io._AsyncDirectoryLister.prototype;
>+dart.addTypeTests(io._AsyncDirectoryLister);
>+dart.setMethodSignature(io._AsyncDirectoryLister, () => ({
>+  __proto__: dart.getMethods(io._AsyncDirectoryLister.__proto__),
>+  [_pointer]: dart.fnType(core.int, []),
>+  onListen: dart.fnType(dart.void, []),
>+  onResume: dart.fnType(dart.void, []),
>+  onCancel: dart.fnType(async.Future, []),
>+  next: dart.fnType(dart.void, []),
>+  [_cleanup]: dart.fnType(dart.void, []),
>+  close: dart.fnType(dart.void, []),
>+  error: dart.fnType(dart.void, [dart.dynamic])
>+}));
>+dart.setGetterSignature(io._AsyncDirectoryLister, () => ({
>+  __proto__: dart.getGetters(io._AsyncDirectoryLister.__proto__),
>+  stream: async.Stream$(io.FileSystemEntity)
>+}));
>+dart.setLibraryUri(io._AsyncDirectoryLister, "dart:io");
>+dart.setFieldSignature(io._AsyncDirectoryLister, () => ({
>+  __proto__: dart.getFields(io._AsyncDirectoryLister.__proto__),
>+  rawPath: dart.finalFieldType(typed_data.Uint8List),
>+  recursive: dart.finalFieldType(core.bool),
>+  followLinks: dart.finalFieldType(core.bool),
>+  controller: dart.fieldType(StreamControllerOfFileSystemEntity()),
>+  canceled: dart.fieldType(core.bool),
>+  nextRunning: dart.fieldType(core.bool),
>+  closed: dart.fieldType(core.bool),
>+  [_ops]: dart.fieldType(io._AsyncDirectoryListerOps),
>+  closeCompleter: dart.fieldType(async.Completer)
>+}));
>+dart.defineLazy(io._AsyncDirectoryLister, {
>+  /*io._AsyncDirectoryLister.listFile*/get listFile() {
>+    return 0;
>+  },
>+  /*io._AsyncDirectoryLister.listDirectory*/get listDirectory() {
>+    return 1;
>+  },
>+  /*io._AsyncDirectoryLister.listLink*/get listLink() {
>+    return 2;
>+  },
>+  /*io._AsyncDirectoryLister.listError*/get listError() {
>+    return 3;
>+  },
>+  /*io._AsyncDirectoryLister.listDone*/get listDone() {
>+    return 4;
>+  },
>+  /*io._AsyncDirectoryLister.responseType*/get responseType() {
>+    return 0;
>+  },
>+  /*io._AsyncDirectoryLister.responsePath*/get responsePath() {
>+    return 1;
>+  },
>+  /*io._AsyncDirectoryLister.responseComplete*/get responseComplete() {
>+    return 1;
>+  },
>+  /*io._AsyncDirectoryLister.responseError*/get responseError() {
>+    return 2;
>+  }
>+});
>+io._EmbedderConfig = class _EmbedderConfig extends core.Object {};
>+(io._EmbedderConfig.new = function() {
>+}).prototype = io._EmbedderConfig.prototype;
>+dart.addTypeTests(io._EmbedderConfig);
>+dart.setLibraryUri(io._EmbedderConfig, "dart:io");
>+dart.defineLazy(io._EmbedderConfig, {
>+  /*io._EmbedderConfig._mayChdir*/get _mayChdir() {
>+    return true;
>+  },
>+  set _mayChdir(_) {},
>+  /*io._EmbedderConfig._mayExit*/get _mayExit() {
>+    return true;
>+  },
>+  set _mayExit(_) {},
>+  /*io._EmbedderConfig._maySetEchoMode*/get _maySetEchoMode() {
>+    return true;
>+  },
>+  set _maySetEchoMode(_) {},
>+  /*io._EmbedderConfig._maySetLineMode*/get _maySetLineMode() {
>+    return true;
>+  },
>+  set _maySetLineMode(_) {},
>+  /*io._EmbedderConfig._maySleep*/get _maySleep() {
>+    return true;
>+  },
>+  set _maySleep(_) {}
>+});
>+io._EventHandler = class _EventHandler extends core.Object {
>+  static _sendData(sender, sendPort, data) {
>+    dart.throw(new core.UnsupportedError.new("EventHandler._sendData"));
>+  }
>+};
>+(io._EventHandler.new = function() {
>+}).prototype = io._EventHandler.prototype;
>+dart.addTypeTests(io._EventHandler);
>+dart.setLibraryUri(io._EventHandler, "dart:io");
>+const _mode = dart.privateName(io, "_mode");
>+io.FileMode = class FileMode extends core.Object {};
>+(io.FileMode._internal = function(mode) {
>+  this[_mode] = mode;
>+}).prototype = io.FileMode.prototype;
>+dart.addTypeTests(io.FileMode);
>+dart.setLibraryUri(io.FileMode, "dart:io");
>+dart.setFieldSignature(io.FileMode, () => ({
>+  __proto__: dart.getFields(io.FileMode.__proto__),
>+  [_mode]: dart.finalFieldType(core.int)
>+}));
>+dart.defineLazy(io.FileMode, {
>+  /*io.FileMode.read*/get read() {
>+    return dart.const(new io.FileMode._internal(0));
>+  },
>+  /*io.FileMode.READ*/get READ() {
>+    return io.FileMode.read;
>+  },
>+  /*io.FileMode.write*/get write() {
>+    return dart.const(new io.FileMode._internal(1));
>+  },
>+  /*io.FileMode.WRITE*/get WRITE() {
>+    return io.FileMode.write;
>+  },
>+  /*io.FileMode.append*/get append() {
>+    return dart.const(new io.FileMode._internal(2));
>+  },
>+  /*io.FileMode.APPEND*/get APPEND() {
>+    return io.FileMode.append;
>+  },
>+  /*io.FileMode.writeOnly*/get writeOnly() {
>+    return dart.const(new io.FileMode._internal(3));
>+  },
>+  /*io.FileMode.WRITE_ONLY*/get WRITE_ONLY() {
>+    return io.FileMode.writeOnly;
>+  },
>+  /*io.FileMode.writeOnlyAppend*/get writeOnlyAppend() {
>+    return dart.const(new io.FileMode._internal(4));
>+  },
>+  /*io.FileMode.WRITE_ONLY_APPEND*/get WRITE_ONLY_APPEND() {
>+    return io.FileMode.writeOnlyAppend;
>+  }
>+});
>+dart.defineLazy(io, {
>+  /*io.READ*/get READ() {
>+    return io.FileMode.read;
>+  },
>+  /*io.WRITE*/get WRITE() {
>+    return io.FileMode.write;
>+  },
>+  /*io.APPEND*/get APPEND() {
>+    return io.FileMode.append;
>+  },
>+  /*io.WRITE_ONLY*/get WRITE_ONLY() {
>+    return io.FileMode.writeOnly;
>+  },
>+  /*io.WRITE_ONLY_APPEND*/get WRITE_ONLY_APPEND() {
>+    return io.FileMode.writeOnlyAppend;
>+  }
>+});
>+const _type$0 = dart.privateName(io, "_type");
>+io.FileLock = class FileLock extends core.Object {};
>+(io.FileLock._internal = function(type) {
>+  this[_type$0] = type;
>+}).prototype = io.FileLock.prototype;
>+dart.addTypeTests(io.FileLock);
>+dart.setLibraryUri(io.FileLock, "dart:io");
>+dart.setFieldSignature(io.FileLock, () => ({
>+  __proto__: dart.getFields(io.FileLock.__proto__),
>+  [_type$0]: dart.finalFieldType(core.int)
>+}));
>+dart.defineLazy(io.FileLock, {
>+  /*io.FileLock.shared*/get shared() {
>+    return dart.const(new io.FileLock._internal(1));
>+  },
>+  /*io.FileLock.SHARED*/get SHARED() {
>+    return io.FileLock.shared;
>+  },
>+  /*io.FileLock.exclusive*/get exclusive() {
>+    return dart.const(new io.FileLock._internal(2));
>+  },
>+  /*io.FileLock.EXCLUSIVE*/get EXCLUSIVE() {
>+    return io.FileLock.exclusive;
>+  },
>+  /*io.FileLock.blockingShared*/get blockingShared() {
>+    return dart.const(new io.FileLock._internal(3));
>+  },
>+  /*io.FileLock.BLOCKING_SHARED*/get BLOCKING_SHARED() {
>+    return io.FileLock.blockingShared;
>+  },
>+  /*io.FileLock.blockingExclusive*/get blockingExclusive() {
>+    return dart.const(new io.FileLock._internal(4));
>+  },
>+  /*io.FileLock.BLOCKING_EXCLUSIVE*/get BLOCKING_EXCLUSIVE() {
>+    return io.FileLock.blockingExclusive;
>+  }
>+});
>+io.File = class File extends core.Object {
>+  static new(path) {
>+    let overrides = io.IOOverrides.current;
>+    if (overrides == null) {
>+      return new io._File.new(path);
>+    }
>+    return overrides.createFile(path);
>+  }
>+  static fromUri(uri) {
>+    return io.File.new(uri.toFilePath());
>+  }
>+  static fromRawPath(rawPath) {
>+    return new io._File.fromRawPath(rawPath);
>+  }
>+};
>+(io.File[dart.mixinNew] = function() {
>+}).prototype = io.File.prototype;
>+dart.addTypeTests(io.File);
>+io.File[dart.implements] = () => [io.FileSystemEntity];
>+dart.setLibraryUri(io.File, "dart:io");
>+io.RandomAccessFile = class RandomAccessFile extends core.Object {};
>+(io.RandomAccessFile.new = function() {
>+}).prototype = io.RandomAccessFile.prototype;
>+dart.addTypeTests(io.RandomAccessFile);
>+dart.setLibraryUri(io.RandomAccessFile, "dart:io");
>+io.FileSystemException = class FileSystemException extends core.Object {
>+  get message() {
>+    return this[message$8];
>+  }
>+  set message(value) {
>+    super.message = value;
>+  }
>+  get path() {
>+    return this[path$];
>+  }
>+  set path(value) {
>+    super.path = value;
>+  }
>+  get osError() {
>+    return this[osError$];
>+  }
>+  set osError(value) {
>+    super.osError = value;
>+  }
>+  toString() {
>+    let sb = new core.StringBuffer.new();
>+    sb.write("FileSystemException");
>+    if (this.message[$isNotEmpty]) {
>+      sb.write(": " + dart.str(this.message));
>+      if (this.path != null) {
>+        sb.write(", path = '" + dart.str(this.path) + "'");
>+      }
>+      if (this.osError != null) {
>+        sb.write(" (" + dart.str(this.osError) + ")");
>+      }
>+    } else if (this.osError != null) {
>+      sb.write(": " + dart.str(this.osError));
>+      if (this.path != null) {
>+        sb.write(", path = '" + dart.str(this.path) + "'");
>+      }
>+    } else if (this.path != null) {
>+      sb.write(": " + dart.str(this.path));
>+    }
>+    return sb.toString();
>+  }
>+};
>+(io.FileSystemException.new = function(message, path, osError) {
>+  if (message === void 0) message = "";
>+  if (path === void 0) path = "";
>+  if (osError === void 0) osError = null;
>+  this[message$8] = message;
>+  this[path$] = path;
>+  this[osError$] = osError;
>+}).prototype = io.FileSystemException.prototype;
>+dart.addTypeTests(io.FileSystemException);
>+const message$8 = Symbol("FileSystemException.message");
>+const path$ = Symbol("FileSystemException.path");
>+const osError$ = Symbol("FileSystemException.osError");
>+io.FileSystemException[dart.implements] = () => [io.IOException];
>+dart.setLibraryUri(io.FileSystemException, "dart:io");
>+dart.setFieldSignature(io.FileSystemException, () => ({
>+  __proto__: dart.getFields(io.FileSystemException.__proto__),
>+  message: dart.finalFieldType(core.String),
>+  path: dart.finalFieldType(core.String),
>+  osError: dart.finalFieldType(io.OSError)
>+}));
>+dart.defineExtensionMethods(io.FileSystemException, ['toString']);
>+dart.defineLazy(io, {
>+  /*io._blockSize*/get _blockSize() {
>+    return 64 * 1024;
>+  }
>+});
>+const _position$0 = dart.privateName(io, "_position");
>+const _end$ = dart.privateName(io, "_end");
>+const _controller$ = dart.privateName(io, "_controller");
>+const _openedFile = dart.privateName(io, "_openedFile");
>+const _closeCompleter = dart.privateName(io, "_closeCompleter");
>+const _unsubscribed = dart.privateName(io, "_unsubscribed");
>+const _readInProgress = dart.privateName(io, "_readInProgress");
>+const _atEnd = dart.privateName(io, "_atEnd");
>+const _setupController = dart.privateName(io, "_setupController");
>+const _start$2 = dart.privateName(io, "_start");
>+const _readBlock = dart.privateName(io, "_readBlock");
>+const _closeFile = dart.privateName(io, "_closeFile");
>+io._FileStream = class _FileStream extends async.Stream$(core.List$(core.int)) {
>+  listen(onData, opts) {
>+    let onError = opts && 'onError' in opts ? opts.onError : null;
>+    let onDone = opts && 'onDone' in opts ? opts.onDone : null;
>+    let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
>+    this[_setupController]();
>+    return this[_controller$].stream.listen(onData, {onError: onError, onDone: onDone, cancelOnError: cancelOnError});
>+  }
>+  [_setupController]() {
>+    this[_controller$] = StreamControllerOfListOfint().new({sync: true, onListen: dart.bind(this, _start$2), onResume: dart.bind(this, _readBlock), onCancel: dart.fn(() => {
>+        this[_unsubscribed] = true;
>+        return this[_closeFile]();
>+      }, VoidToFuture())});
>+  }
>+  [_closeFile]() {
>+    if (dart.test(this[_readInProgress]) || dart.test(this[_closed])) {
>+      return this[_closeCompleter].future;
>+    }
>+    this[_closed] = true;
>+    const done = () => {
>+      this[_closeCompleter].complete();
>+      this[_controller$].close();
>+    };
>+    dart.fn(done, VoidTovoid());
>+    this[_openedFile].close().catchError(dart.bind(this[_controller$], 'addError')).whenComplete(done);
>+    return this[_closeCompleter].future;
>+  }
>+  [_readBlock]() {
>+    if (dart.test(this[_readInProgress])) return;
>+    if (dart.test(this[_atEnd])) {
>+      this[_closeFile]();
>+      return;
>+    }
>+    this[_readInProgress] = true;
>+    let readBytes = 65536;
>+    if (this[_end$] != null) {
>+      readBytes = math.min(core.int, readBytes, dart.notNull(this[_end$]) - dart.notNull(this[_position$0]));
>+      if (readBytes < 0) {
>+        this[_readInProgress] = false;
>+        if (!dart.test(this[_unsubscribed])) {
>+          this[_controller$].addError(new core.RangeError.new("Bad end position: " + dart.str(this[_end$])));
>+          this[_closeFile]();
>+          this[_unsubscribed] = true;
>+        }
>+        return;
>+      }
>+    }
>+    FutureOfNull()._check(this[_openedFile].read(readBytes).then(core.Null, dart.fn(block => {
>+      this[_readInProgress] = false;
>+      if (dart.test(this[_unsubscribed])) {
>+        this[_closeFile]();
>+        return;
>+      }
>+      this[_position$0] = dart.notNull(this[_position$0]) + dart.notNull(block[$length]);
>+      if (dart.notNull(block[$length]) < readBytes || this[_end$] != null && this[_position$0] == this[_end$]) {
>+        this[_atEnd] = true;
>+      }
>+      if (!dart.test(this[_atEnd]) && !dart.test(this[_controller$].isPaused)) {
>+        this[_readBlock]();
>+      }
>+      this[_controller$].add(block);
>+      if (dart.test(this[_atEnd])) {
>+        this[_closeFile]();
>+      }
>+    }, ListOfintToNull()))).catchError(dart.fn((e, s) => {
>+      if (!dart.test(this[_unsubscribed])) {
>+        this[_controller$].addError(e, core.StackTrace._check(s));
>+        this[_closeFile]();
>+        this[_unsubscribed] = true;
>+      }
>+    }, dynamicAnddynamicToNull()));
>+  }
>+  [_start$2]() {
>+    if (dart.notNull(this[_position$0]) < 0) {
>+      this[_controller$].addError(new core.RangeError.new("Bad start position: " + dart.str(this[_position$0])));
>+      this[_controller$].close();
>+      this[_closeCompleter].complete();
>+      return;
>+    }
>+    const onReady = file => {
>+      this[_openedFile] = file;
>+      this[_readInProgress] = false;
>+      this[_readBlock]();
>+    };
>+    dart.fn(onReady, RandomAccessFileTovoid());
>+    const onOpenFile = file => {
>+      if (dart.notNull(this[_position$0]) > 0) {
>+        file.setPosition(this[_position$0]).then(dart.void, onReady, {onError: dart.fn((e, s) => {
>+            this[_controller$].addError(e, core.StackTrace._check(s));
>+            this[_readInProgress] = false;
>+            this[_closeFile]();
>+          }, dynamicAnddynamicToNull())});
>+      } else {
>+        onReady(file);
>+      }
>+    };
>+    dart.fn(onOpenFile, RandomAccessFileTovoid());
>+    const openFailed = (error, stackTrace) => {
>+      this[_controller$].addError(error, core.StackTrace._check(stackTrace));
>+      this[_controller$].close();
>+      this[_closeCompleter].complete();
>+    };
>+    dart.fn(openFailed, dynamicAnddynamicTovoid());
>+    if (this[_path] != null) {
>+      io.File.new(this[_path]).open({mode: io.FileMode.read}).then(dart.void, onOpenFile, {onError: openFailed});
>+    } else {
>+      try {
>+        onOpenFile(io._File._openStdioSync(0));
>+      } catch (e$) {
>+        let e = dart.getThrown(e$);
>+        let s = dart.stackTrace(e$);
>+        openFailed(e, s);
>+      }
>+    }
>+  }
>+};
>+(io._FileStream.new = function(path, position, end) {
>+  this[_controller$] = null;
>+  this[_openedFile] = null;
>+  this[_closeCompleter] = async.Completer.new();
>+  this[_unsubscribed] = false;
>+  this[_readInProgress] = true;
>+  this[_closed] = false;
>+  this[_atEnd] = false;
>+  this[_path] = path;
>+  this[_position$0] = position;
>+  this[_end$] = end;
>+  io._FileStream.__proto__.new.call(this);
>+  let t = this[_position$0];
>+  t == null ? this[_position$0] = 0 : t;
>+}).prototype = io._FileStream.prototype;
>+(io._FileStream.forStdin = function() {
>+  this[_controller$] = null;
>+  this[_path] = null;
>+  this[_openedFile] = null;
>+  this[_end$] = null;
>+  this[_closeCompleter] = async.Completer.new();
>+  this[_unsubscribed] = false;
>+  this[_readInProgress] = true;
>+  this[_closed] = false;
>+  this[_atEnd] = false;
>+  this[_position$0] = 0;
>+  io._FileStream.__proto__.new.call(this);
>+}).prototype = io._FileStream.prototype;
>+dart.addTypeTests(io._FileStream);
>+dart.setMethodSignature(io._FileStream, () => ({
>+  __proto__: dart.getMethods(io._FileStream.__proto__),
>+  listen: dart.fnType(async.StreamSubscription$(core.List$(core.int)), [dart.fnType(dart.void, [core.List$(core.int)])], {onError: core.Function, onDone: dart.fnType(dart.void, []), cancelOnError: core.bool}),
>+  [_setupController]: dart.fnType(dart.void, []),
>+  [_closeFile]: dart.fnType(async.Future, []),
>+  [_readBlock]: dart.fnType(dart.void, []),
>+  [_start$2]: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(io._FileStream, "dart:io");
>+dart.setFieldSignature(io._FileStream, () => ({
>+  __proto__: dart.getFields(io._FileStream.__proto__),
>+  [_controller$]: dart.fieldType(StreamControllerOfListOfint()),
>+  [_path]: dart.fieldType(core.String),
>+  [_openedFile]: dart.fieldType(io.RandomAccessFile),
>+  [_position$0]: dart.fieldType(core.int),
>+  [_end$]: dart.fieldType(core.int),
>+  [_closeCompleter]: dart.finalFieldType(async.Completer),
>+  [_unsubscribed]: dart.fieldType(core.bool),
>+  [_readInProgress]: dart.fieldType(core.bool),
>+  [_closed]: dart.fieldType(core.bool),
>+  [_atEnd]: dart.fieldType(core.bool)
>+}));
>+const _file = dart.privateName(io, "_file");
>+const _openFuture = dart.privateName(io, "_openFuture");
>+io._FileStreamConsumer = class _FileStreamConsumer extends async.StreamConsumer$(core.List$(core.int)) {
>+  addStream(stream) {
>+    StreamOfListOfint()._check(stream);
>+    let completer = CompleterOfFile().sync();
>+    FutureOfNull()._check(this[_openFuture].then(core.Null, dart.fn(openedFile => {
>+      let _subscription = null;
>+      function error(e, stackTrace) {
>+        if (stackTrace === void 0) stackTrace = null;
>+        dart.dsend(_subscription, 'cancel', []);
>+        openedFile.close();
>+        completer.completeError(e, stackTrace);
>+      }
>+      dart.fn(error, dynamic__Tovoid());
>+      _subscription = stream.listen(dart.fn(d => {
>+        dart.dsend(_subscription, 'pause', []);
>+        try {
>+          openedFile.writeFrom(d, 0, d[$length]).then(dart.dynamic, dart.fn(_ => dart.dsend(_subscription, 'resume', []), RandomAccessFileTodynamic()), {onError: error});
>+        } catch (e$) {
>+          let e = dart.getThrown(e$);
>+          let stackTrace = dart.stackTrace(e$);
>+          error(e, stackTrace);
>+        }
>+      }, ListOfintToNull()), {onDone: dart.fn(() => {
>+          completer.complete(this[_file]);
>+        }, VoidToNull()), onError: error, cancelOnError: true});
>+    }, RandomAccessFileToNull()))).catchError(dart.bind(completer, 'completeError'));
>+    return completer.future;
>+  }
>+  close() {
>+    return FutureOfFile()._check(this[_openFuture].then(dart.void, dart.fn(openedFile => openedFile.close(), RandomAccessFileToFutureOfvoid())).then(io.File, dart.fn(_ => this[_file], voidToFile())));
>+  }
>+};
>+(io._FileStreamConsumer.new = function(file, mode) {
>+  this[_openFuture] = null;
>+  this[_file] = file;
>+  this[_openFuture] = this[_file].open({mode: mode});
>+}).prototype = io._FileStreamConsumer.prototype;
>+(io._FileStreamConsumer.fromStdio = function(fd) {
>+  this[_file] = null;
>+  this[_openFuture] = null;
>+  this[_openFuture] = FutureOfRandomAccessFile().value(io._File._openStdioSync(fd));
>+}).prototype = io._FileStreamConsumer.prototype;
>+dart.addTypeTests(io._FileStreamConsumer);
>+dart.setMethodSignature(io._FileStreamConsumer, () => ({
>+  __proto__: dart.getMethods(io._FileStreamConsumer.__proto__),
>+  addStream: dart.fnType(async.Future$(io.File), [core.Object]),
>+  close: dart.fnType(async.Future$(io.File), [])
>+}));
>+dart.setLibraryUri(io._FileStreamConsumer, "dart:io");
>+dart.setFieldSignature(io._FileStreamConsumer, () => ({
>+  __proto__: dart.getFields(io._FileStreamConsumer.__proto__),
>+  [_file]: dart.fieldType(io.File),
>+  [_openFuture]: dart.fieldType(FutureOfRandomAccessFile())
>+}));
>+const _tryDecode = dart.privateName(io, "_tryDecode");
>+let const$66;
>+let const$67;
>+io._File = class _File extends io.FileSystemEntity {
>+  get [_path]() {
>+    return this[_path$1];
>+  }
>+  set [_path](value) {
>+    this[_path$1] = value;
>+  }
>+  get [_rawPath$]() {
>+    return this[_rawPath$1];
>+  }
>+  set [_rawPath$](value) {
>+    this[_rawPath$1] = value;
>+  }
>+  get path() {
>+    return this[_path];
>+  }
>+  static _namespacePointer() {
>+    return io._Namespace._namespacePointer;
>+  }
>+  static _dispatchWithNamespace(request, data) {
>+    data[$_set](0, io._File._namespacePointer());
>+    return io._IOService._dispatch(request, data);
>+  }
>+  exists() {
>+    return FutureOfbool()._check(io._File._dispatchWithNamespace(io._IOService.fileExists, [null, this[_rawPath$]]).then(core.bool, dart.fn(response => {
>+      if (dart.test(io._isErrorResponse(response))) {
>+        dart.throw(io._exceptionFromResponse(response, "Cannot check existence", this.path));
>+      }
>+      return FutureOrOfbool()._check(response);
>+    }, dynamicToFutureOrOfbool())));
>+  }
>+  static _exists(namespace, rawPath) {
>+    dart.throw(new core.UnsupportedError.new("File._exists"));
>+  }
>+  existsSync() {
>+    let result = io._File._exists(io._Namespace._namespace, this[_rawPath$]);
>+    io._File.throwIfError(result, "Cannot check existence of file", this.path);
>+    return core.bool._check(result);
>+  }
>+  get absolute() {
>+    return io.File.new(this[_absolutePath]);
>+  }
>+  create(opts) {
>+    let recursive = opts && 'recursive' in opts ? opts.recursive : false;
>+    let result = dart.test(recursive) ? this.parent.create({recursive: true}) : FutureOfNull().value(null);
>+    return FutureOfFile()._check(result.then(dart.dynamic, dart.fn(_ => io._File._dispatchWithNamespace(io._IOService.fileCreate, [null, this[_rawPath$]]), DirectoryToFuture())).then(io.File, dart.fn(response => {
>+      if (dart.test(io._isErrorResponse(response))) {
>+        dart.throw(io._exceptionFromResponse(response, "Cannot create file", this.path));
>+      }
>+      return this;
>+    }, dynamicTo_File())));
>+  }
>+  static _create(namespace, rawPath) {
>+    dart.throw(new core.UnsupportedError.new("File._create"));
>+  }
>+  static _createLink(namespace, rawPath, target) {
>+    dart.throw(new core.UnsupportedError.new("File._createLink"));
>+  }
>+  static _linkTarget(namespace, rawPath) {
>+    dart.throw(new core.UnsupportedError.new("File._linkTarget"));
>+  }
>+  createSync(opts) {
>+    let recursive = opts && 'recursive' in opts ? opts.recursive : false;
>+    if (dart.test(recursive)) {
>+      this.parent.createSync({recursive: true});
>+    }
>+    let result = io._File._create(io._Namespace._namespace, this[_rawPath$]);
>+    io._File.throwIfError(result, "Cannot create file", this.path);
>+  }
>+  [_delete](opts) {
>+    let recursive = opts && 'recursive' in opts ? opts.recursive : false;
>+    if (dart.test(recursive)) {
>+      return FutureOfFile()._check(io.Directory.new(this.path).delete({recursive: true}).then(io.File, dart.fn(_ => this, FileSystemEntityTo_File())));
>+    }
>+    return FutureOfFile()._check(io._File._dispatchWithNamespace(io._IOService.fileDelete, [null, this[_rawPath$]]).then(io.File, dart.fn(response => {
>+      if (dart.test(io._isErrorResponse(response))) {
>+        dart.throw(io._exceptionFromResponse(response, "Cannot delete file", this.path));
>+      }
>+      return this;
>+    }, dynamicTo_File())));
>+  }
>+  static _deleteNative(namespace, rawPath) {
>+    dart.throw(new core.UnsupportedError.new("File._deleteNative"));
>+  }
>+  static _deleteLinkNative(namespace, rawPath) {
>+    dart.throw(new core.UnsupportedError.new("File._deleteLinkNative"));
>+  }
>+  [_deleteSync](opts) {
>+    let recursive = opts && 'recursive' in opts ? opts.recursive : false;
>+    if (dart.test(recursive)) {
>+      return io.Directory.fromRawPath(this[_rawPath$]).deleteSync({recursive: true});
>+    }
>+    let result = io._File._deleteNative(io._Namespace._namespace, this[_rawPath$]);
>+    io._File.throwIfError(result, "Cannot delete file", this.path);
>+  }
>+  rename(newPath) {
>+    return FutureOfFile()._check(io._File._dispatchWithNamespace(io._IOService.fileRename, [null, this[_rawPath$], newPath]).then(io.File, dart.fn(response => {
>+      if (dart.test(io._isErrorResponse(response))) {
>+        dart.throw(io._exceptionFromResponse(response, "Cannot rename file to '" + dart.str(newPath) + "'", this.path));
>+      }
>+      return io.File.new(newPath);
>+    }, dynamicToFile())));
>+  }
>+  static _rename(namespace, oldPath, newPath) {
>+    dart.throw(new core.UnsupportedError.new("File._rename"));
>+  }
>+  static _renameLink(namespace, oldPath, newPath) {
>+    dart.throw(new core.UnsupportedError.new("File._renameLink"));
>+  }
>+  renameSync(newPath) {
>+    let result = io._File._rename(io._Namespace._namespace, this[_rawPath$], newPath);
>+    io._File.throwIfError(result, "Cannot rename file to '" + dart.str(newPath) + "'", this.path);
>+    return io.File.new(newPath);
>+  }
>+  copy(newPath) {
>+    return FutureOfFile()._check(io._File._dispatchWithNamespace(io._IOService.fileCopy, [null, this[_rawPath$], newPath]).then(io.File, dart.fn(response => {
>+      if (dart.test(io._isErrorResponse(response))) {
>+        dart.throw(io._exceptionFromResponse(response, "Cannot copy file to '" + dart.str(newPath) + "'", this.path));
>+      }
>+      return io.File.new(newPath);
>+    }, dynamicToFile())));
>+  }
>+  static _copy(namespace, oldPath, newPath) {
>+    dart.throw(new core.UnsupportedError.new("File._copy"));
>+  }
>+  copySync(newPath) {
>+    let result = io._File._copy(io._Namespace._namespace, this[_rawPath$], newPath);
>+    io._File.throwIfError(result, "Cannot copy file to '" + dart.str(newPath) + "'", this.path);
>+    return io.File.new(newPath);
>+  }
>+  open(opts) {
>+    let mode = opts && 'mode' in opts ? opts.mode : io.FileMode.read;
>+    if (!dart.equals(mode, io.FileMode.read) && !dart.equals(mode, io.FileMode.write) && !dart.equals(mode, io.FileMode.append) && !dart.equals(mode, io.FileMode.writeOnly) && !dart.equals(mode, io.FileMode.writeOnlyAppend)) {
>+      return FutureOfRandomAccessFile().error(new core.ArgumentError.new("Invalid file mode for this operation"));
>+    }
>+    return FutureOfRandomAccessFile()._check(io._File._dispatchWithNamespace(io._IOService.fileOpen, [null, this[_rawPath$], mode[_mode]]).then(io.RandomAccessFile, dart.fn(response => {
>+      if (dart.test(io._isErrorResponse(response))) {
>+        dart.throw(io._exceptionFromResponse(response, "Cannot open file", this.path));
>+      }
>+      return new io._RandomAccessFile.new(core.int._check(response), this.path);
>+    }, dynamicTo_RandomAccessFile())));
>+  }
>+  length() {
>+    return FutureOfint()._check(io._File._dispatchWithNamespace(io._IOService.fileLengthFromPath, [null, this[_rawPath$]]).then(core.int, dart.fn(response => {
>+      if (dart.test(io._isErrorResponse(response))) {
>+        dart.throw(io._exceptionFromResponse(response, "Cannot retrieve length of file", this.path));
>+      }
>+      return FutureOrOfint()._check(response);
>+    }, dynamicToFutureOrOfint())));
>+  }
>+  static _lengthFromPath(namespace, rawPath) {
>+    dart.throw(new core.UnsupportedError.new("File._lengthFromPath"));
>+  }
>+  lengthSync() {
>+    let result = io._File._lengthFromPath(io._Namespace._namespace, this[_rawPath$]);
>+    io._File.throwIfError(result, "Cannot retrieve length of file", this.path);
>+    return core.int._check(result);
>+  }
>+  lastAccessed() {
>+    return FutureOfDateTime()._check(io._File._dispatchWithNamespace(io._IOService.fileLastAccessed, [null, this[_rawPath$]]).then(core.DateTime, dart.fn(response => {
>+      if (dart.test(io._isErrorResponse(response))) {
>+        dart.throw(io._exceptionFromResponse(response, "Cannot retrieve access time", this.path));
>+      }
>+      return new core.DateTime.fromMillisecondsSinceEpoch(core.int._check(response));
>+    }, dynamicToDateTime())));
>+  }
>+  static _lastAccessed(namespace, rawPath) {
>+    dart.throw(new core.UnsupportedError.new("File._lastAccessed"));
>+  }
>+  lastAccessedSync() {
>+    let ms = io._File._lastAccessed(io._Namespace._namespace, this[_rawPath$]);
>+    io._File.throwIfError(ms, "Cannot retrieve access time", this.path);
>+    return new core.DateTime.fromMillisecondsSinceEpoch(core.int._check(ms));
>+  }
>+  setLastAccessed(time) {
>+    let millis = time.millisecondsSinceEpoch;
>+    return io._File._dispatchWithNamespace(io._IOService.fileSetLastAccessed, [null, this[_rawPath$], millis]).then(dart.dynamic, dart.fn(response => {
>+      if (dart.test(io._isErrorResponse(response))) {
>+        dart.throw(io._exceptionFromResponse(response, "Cannot set access time", this.path));
>+      }
>+      return null;
>+    }, dynamicToNull()));
>+  }
>+  static _setLastAccessed(namespace, rawPath, millis) {
>+    dart.throw(new core.UnsupportedError.new("File._setLastAccessed"));
>+  }
>+  setLastAccessedSync(time) {
>+    let millis = time.millisecondsSinceEpoch;
>+    let result = io._File._setLastAccessed(io._Namespace._namespace, this[_rawPath$], millis);
>+    if (io.OSError.is(result)) {
>+      dart.throw(new io.FileSystemException.new("Failed to set file access time", this.path, result));
>+    }
>+  }
>+  lastModified() {
>+    return FutureOfDateTime()._check(io._File._dispatchWithNamespace(io._IOService.fileLastModified, [null, this[_rawPath$]]).then(core.DateTime, dart.fn(response => {
>+      if (dart.test(io._isErrorResponse(response))) {
>+        dart.throw(io._exceptionFromResponse(response, "Cannot retrieve modification time", this.path));
>+      }
>+      return new core.DateTime.fromMillisecondsSinceEpoch(core.int._check(response));
>+    }, dynamicToDateTime())));
>+  }
>+  static _lastModified(namespace, rawPath) {
>+    dart.throw(new core.UnsupportedError.new("File._lastModified"));
>+  }
>+  lastModifiedSync() {
>+    let ms = io._File._lastModified(io._Namespace._namespace, this[_rawPath$]);
>+    io._File.throwIfError(ms, "Cannot retrieve modification time", this.path);
>+    return new core.DateTime.fromMillisecondsSinceEpoch(core.int._check(ms));
>+  }
>+  setLastModified(time) {
>+    let millis = time.millisecondsSinceEpoch;
>+    return io._File._dispatchWithNamespace(io._IOService.fileSetLastModified, [null, this[_rawPath$], millis]).then(dart.dynamic, dart.fn(response => {
>+      if (dart.test(io._isErrorResponse(response))) {
>+        dart.throw(io._exceptionFromResponse(response, "Cannot set modification time", this.path));
>+      }
>+      return null;
>+    }, dynamicToNull()));
>+  }
>+  static _setLastModified(namespace, rawPath, millis) {
>+    dart.throw(new core.UnsupportedError.new("File._setLastModified"));
>+  }
>+  setLastModifiedSync(time) {
>+    let millis = time.millisecondsSinceEpoch;
>+    let result = io._File._setLastModified(io._Namespace._namespace, this[_rawPath$], millis);
>+    if (io.OSError.is(result)) {
>+      dart.throw(new io.FileSystemException.new("Failed to set file modification time", this.path, result));
>+    }
>+  }
>+  static _open(namespace, rawPath, mode) {
>+    dart.throw(new core.UnsupportedError.new("File._open"));
>+  }
>+  openSync(opts) {
>+    let mode = opts && 'mode' in opts ? opts.mode : io.FileMode.read;
>+    if (!dart.equals(mode, io.FileMode.read) && !dart.equals(mode, io.FileMode.write) && !dart.equals(mode, io.FileMode.append) && !dart.equals(mode, io.FileMode.writeOnly) && !dart.equals(mode, io.FileMode.writeOnlyAppend)) {
>+      dart.throw(new core.ArgumentError.new("Invalid file mode for this operation"));
>+    }
>+    let id = io._File._open(io._Namespace._namespace, this[_rawPath$], mode[_mode]);
>+    io._File.throwIfError(id, "Cannot open file", this.path);
>+    return new io._RandomAccessFile.new(core.int._check(id), this[_path]);
>+  }
>+  static _openStdio(fd) {
>+    dart.throw(new core.UnsupportedError.new("File._openStdio"));
>+  }
>+  static _openStdioSync(fd) {
>+    let id = io._File._openStdio(fd);
>+    if (id === 0) {
>+      dart.throw(new io.FileSystemException.new("Cannot open stdio file for: " + dart.str(fd)));
>+    }
>+    return new io._RandomAccessFile.new(id, "");
>+  }
>+  openRead(start, end) {
>+    if (start === void 0) start = null;
>+    if (end === void 0) end = null;
>+    return new io._FileStream.new(this.path, start, end);
>+  }
>+  openWrite(opts) {
>+    let mode = opts && 'mode' in opts ? opts.mode : io.FileMode.write;
>+    let encoding = opts && 'encoding' in opts ? opts.encoding : convert.utf8;
>+    if (!dart.equals(mode, io.FileMode.write) && !dart.equals(mode, io.FileMode.append) && !dart.equals(mode, io.FileMode.writeOnly) && !dart.equals(mode, io.FileMode.writeOnlyAppend)) {
>+      dart.throw(new core.ArgumentError.new("Invalid file mode for this operation"));
>+    }
>+    let consumer = new io._FileStreamConsumer.new(this, mode);
>+    return io.IOSink.new(consumer, {encoding: encoding});
>+  }
>+  readAsBytes() {
>+    function readDataChunked(file) {
>+      let builder = io.BytesBuilder.new({copy: false});
>+      let completer = CompleterOfListOfint().new();
>+      function read() {
>+        FutureOfNull()._check(file.read(65536).then(core.Null, dart.fn(data => {
>+          if (dart.notNull(data[$length]) > 0) {
>+            builder.add(data);
>+            read();
>+          } else {
>+            completer.complete(builder.takeBytes());
>+          }
>+        }, ListOfintToNull()), {onError: dart.bind(completer, 'completeError')}));
>+      }
>+      dart.fn(read, VoidTovoid());
>+      read();
>+      return completer.future;
>+    }
>+    dart.fn(readDataChunked, RandomAccessFileToFutureOfListOfint());
>+    return FutureOfListOfint()._check(this.open().then(ListOfint(), dart.fn(file => FutureOfListOfint()._check(file.length().then(ListOfint(), dart.fn(length => {
>+      if (length === 0) {
>+        return readDataChunked(file);
>+      }
>+      return file.read(length);
>+    }, intToFutureOfListOfint()))).whenComplete(dart.bind(file, 'close')), RandomAccessFileToFutureOfListOfint())));
>+  }
>+  readAsBytesSync() {
>+    let opened = this.openSync();
>+    try {
>+      let data = null;
>+      let length = opened.lengthSync();
>+      if (length === 0) {
>+        let builder = io.BytesBuilder.new({copy: false});
>+        do {
>+          data = opened.readSync(65536);
>+          if (dart.notNull(data[$length]) > 0) builder.add(data);
>+        } while (dart.notNull(data[$length]) > 0);
>+        data = builder.takeBytes();
>+      } else {
>+        data = opened.readSync(length);
>+      }
>+      return data;
>+    } finally {
>+      opened.closeSync();
>+    }
>+  }
>+  [_tryDecode](bytes, encoding) {
>+    try {
>+      return encoding.decode(bytes);
>+    } catch (e) {
>+      let _ = dart.getThrown(e);
>+      dart.throw(new io.FileSystemException.new("Failed to decode data using encoding '" + dart.str(encoding.name) + "'", this.path));
>+    }
>+  }
>+  readAsString(opts) {
>+    let encoding = opts && 'encoding' in opts ? opts.encoding : convert.utf8;
>+    let stack = core.StackTrace.current;
>+    return FutureOfString()._check(this.readAsBytes().then(core.String, dart.fn(bytes => {
>+      try {
>+        return this[_tryDecode](bytes, encoding);
>+      } catch (e$) {
>+        let e = dart.getThrown(e$);
>+        return FutureOfString().error(e, stack);
>+      }
>+    }, ListOfintToFutureOrOfString())));
>+  }
>+  readAsStringSync(opts) {
>+    let encoding = opts && 'encoding' in opts ? opts.encoding : convert.utf8;
>+    return this[_tryDecode](this.readAsBytesSync(), encoding);
>+  }
>+  readAsLines(opts) {
>+    let encoding = opts && 'encoding' in opts ? opts.encoding : convert.utf8;
>+    return FutureOfListOfString()._check(this.readAsString({encoding: encoding}).then(ListOfString(), dart.bind(const$66 || (const$66 = dart.const(new convert.LineSplitter.new())), 'convert')));
>+  }
>+  readAsLinesSync(opts) {
>+    let encoding = opts && 'encoding' in opts ? opts.encoding : convert.utf8;
>+    return (const$67 || (const$67 = dart.const(new convert.LineSplitter.new()))).convert(this.readAsStringSync({encoding: encoding}));
>+  }
>+  writeAsBytes(bytes, opts) {
>+    let mode = opts && 'mode' in opts ? opts.mode : io.FileMode.write;
>+    let flush = opts && 'flush' in opts ? opts.flush : false;
>+    return FutureOfFile()._check(this.open({mode: mode}).then(io.File, dart.fn(file => FutureOfFile()._check(file.writeFrom(bytes, 0, bytes[$length]).then(io.File, dart.fn(_ => {
>+      if (dart.test(flush)) return FutureOfFile()._check(file.flush().then(io.File, dart.fn(_ => this, RandomAccessFileTo_File())));
>+      return this;
>+    }, RandomAccessFileToFutureOrOfFile()))).whenComplete(dart.bind(file, 'close')), RandomAccessFileToFutureOfFile())));
>+  }
>+  writeAsBytesSync(bytes, opts) {
>+    let mode = opts && 'mode' in opts ? opts.mode : io.FileMode.write;
>+    let flush = opts && 'flush' in opts ? opts.flush : false;
>+    let opened = this.openSync({mode: mode});
>+    try {
>+      opened.writeFromSync(bytes, 0, bytes[$length]);
>+      if (dart.test(flush)) opened.flushSync();
>+    } finally {
>+      opened.closeSync();
>+    }
>+  }
>+  writeAsString(contents, opts) {
>+    let mode = opts && 'mode' in opts ? opts.mode : io.FileMode.write;
>+    let encoding = opts && 'encoding' in opts ? opts.encoding : convert.utf8;
>+    let flush = opts && 'flush' in opts ? opts.flush : false;
>+    try {
>+      return this.writeAsBytes(encoding.encode(contents), {mode: mode, flush: flush});
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      return FutureOfFile().error(e);
>+    }
>+  }
>+  writeAsStringSync(contents, opts) {
>+    let mode = opts && 'mode' in opts ? opts.mode : io.FileMode.write;
>+    let encoding = opts && 'encoding' in opts ? opts.encoding : convert.utf8;
>+    let flush = opts && 'flush' in opts ? opts.flush : false;
>+    this.writeAsBytesSync(encoding.encode(contents), {mode: mode, flush: flush});
>+  }
>+  toString() {
>+    return "File: '" + dart.str(this.path) + "'";
>+  }
>+  static throwIfError(result, msg, path) {
>+    if (io.OSError.is(result)) {
>+      dart.throw(new io.FileSystemException.new(msg, path, result));
>+    }
>+  }
>+};
>+(io._File.new = function(path) {
>+  this[_path$1] = null;
>+  this[_rawPath$1] = null;
>+  io._File.__proto__.new.call(this);
>+  core.ArgumentError.checkNotNull(path, "path");
>+  this[_path] = path;
>+  this[_rawPath$] = io.FileSystemEntity._toUtf8Array(path);
>+}).prototype = io._File.prototype;
>+(io._File.fromRawPath = function(rawPath) {
>+  this[_path$1] = null;
>+  this[_rawPath$1] = null;
>+  io._File.__proto__.new.call(this);
>+  core.ArgumentError.checkNotNull(rawPath, "rawPath");
>+  this[_rawPath$] = io.FileSystemEntity._toNullTerminatedUtf8Array(rawPath);
>+  this[_path] = io.FileSystemEntity._toStringFromUtf8Array(rawPath);
>+}).prototype = io._File.prototype;
>+dart.addTypeTests(io._File);
>+const _path$1 = Symbol("_File._path");
>+const _rawPath$1 = Symbol("_File._rawPath");
>+io._File[dart.implements] = () => [io.File];
>+dart.setMethodSignature(io._File, () => ({
>+  __proto__: dart.getMethods(io._File.__proto__),
>+  exists: dart.fnType(async.Future$(core.bool), []),
>+  existsSync: dart.fnType(core.bool, []),
>+  create: dart.fnType(async.Future$(io.File), [], {recursive: core.bool}),
>+  createSync: dart.fnType(dart.void, [], {recursive: core.bool}),
>+  [_delete]: dart.fnType(async.Future$(io.File), [], {recursive: core.bool}),
>+  [_deleteSync]: dart.fnType(dart.void, [], {recursive: core.bool}),
>+  rename: dart.fnType(async.Future$(io.File), [core.String]),
>+  renameSync: dart.fnType(io.File, [core.String]),
>+  copy: dart.fnType(async.Future$(io.File), [core.String]),
>+  copySync: dart.fnType(io.File, [core.String]),
>+  open: dart.fnType(async.Future$(io.RandomAccessFile), [], {mode: io.FileMode}),
>+  length: dart.fnType(async.Future$(core.int), []),
>+  lengthSync: dart.fnType(core.int, []),
>+  lastAccessed: dart.fnType(async.Future$(core.DateTime), []),
>+  lastAccessedSync: dart.fnType(core.DateTime, []),
>+  setLastAccessed: dart.fnType(async.Future, [core.DateTime]),
>+  setLastAccessedSync: dart.fnType(dart.void, [core.DateTime]),
>+  lastModified: dart.fnType(async.Future$(core.DateTime), []),
>+  lastModifiedSync: dart.fnType(core.DateTime, []),
>+  setLastModified: dart.fnType(async.Future, [core.DateTime]),
>+  setLastModifiedSync: dart.fnType(dart.void, [core.DateTime]),
>+  openSync: dart.fnType(io.RandomAccessFile, [], {mode: io.FileMode}),
>+  openRead: dart.fnType(async.Stream$(core.List$(core.int)), [], [core.int, core.int]),
>+  openWrite: dart.fnType(io.IOSink, [], {mode: io.FileMode, encoding: convert.Encoding}),
>+  readAsBytes: dart.fnType(async.Future$(core.List$(core.int)), []),
>+  readAsBytesSync: dart.fnType(core.List$(core.int), []),
>+  [_tryDecode]: dart.fnType(core.String, [core.List$(core.int), convert.Encoding]),
>+  readAsString: dart.fnType(async.Future$(core.String), [], {encoding: convert.Encoding}),
>+  readAsStringSync: dart.fnType(core.String, [], {encoding: convert.Encoding}),
>+  readAsLines: dart.fnType(async.Future$(core.List$(core.String)), [], {encoding: convert.Encoding}),
>+  readAsLinesSync: dart.fnType(core.List$(core.String), [], {encoding: convert.Encoding}),
>+  writeAsBytes: dart.fnType(async.Future$(io.File), [core.List$(core.int)], {mode: io.FileMode, flush: core.bool}),
>+  writeAsBytesSync: dart.fnType(dart.void, [core.List$(core.int)], {mode: io.FileMode, flush: core.bool}),
>+  writeAsString: dart.fnType(async.Future$(io.File), [core.String], {mode: io.FileMode, encoding: convert.Encoding, flush: core.bool}),
>+  writeAsStringSync: dart.fnType(dart.void, [core.String], {mode: io.FileMode, encoding: convert.Encoding, flush: core.bool})
>+}));
>+dart.setGetterSignature(io._File, () => ({
>+  __proto__: dart.getGetters(io._File.__proto__),
>+  path: core.String,
>+  absolute: io.File
>+}));
>+dart.setLibraryUri(io._File, "dart:io");
>+dart.setFieldSignature(io._File, () => ({
>+  __proto__: dart.getFields(io._File.__proto__),
>+  [_path]: dart.fieldType(core.String),
>+  [_rawPath$]: dart.fieldType(typed_data.Uint8List)
>+}));
>+dart.defineExtensionMethods(io._File, ['toString']);
>+io._RandomAccessFileOps = class _RandomAccessFileOps extends core.Object {
>+  static new(pointer) {
>+    dart.throw(new core.UnsupportedError.new("RandomAccessFile"));
>+  }
>+};
>+(io._RandomAccessFileOps[dart.mixinNew] = function() {
>+}).prototype = io._RandomAccessFileOps.prototype;
>+dart.addTypeTests(io._RandomAccessFileOps);
>+dart.setLibraryUri(io._RandomAccessFileOps, "dart:io");
>+const _asyncDispatched = dart.privateName(io, "_asyncDispatched");
>+const _fileService = dart.privateName(io, "_fileService");
>+const _resourceInfo = dart.privateName(io, "_resourceInfo");
>+const _maybeConnectHandler = dart.privateName(io, "_maybeConnectHandler");
>+const _maybePerformCleanup = dart.privateName(io, "_maybePerformCleanup");
>+const _dispatch = dart.privateName(io, "_dispatch");
>+const _checkAvailable = dart.privateName(io, "_checkAvailable");
>+const _fileLockValue = dart.privateName(io, "_fileLockValue");
>+io._RandomAccessFile = class _RandomAccessFile extends core.Object {
>+  [_maybePerformCleanup]() {
>+    if (dart.test(this.closed)) {
>+      io._FileResourceInfo.FileClosed(this[_resourceInfo]);
>+    }
>+  }
>+  [_maybeConnectHandler]() {
>+    if (!dart.test(io._RandomAccessFile._connectedResourceHandler)) {
>+      developer.registerExtension("ext.dart.io.getOpenFiles", dart.fn(io._FileResourceInfo.getOpenFiles, dynamicAnddynamicToFutureOfServiceExtensionResponse()));
>+      developer.registerExtension("ext.dart.io.getFileByID", dart.fn(io._FileResourceInfo.getFileInfoMapByID, dynamicAnddynamicToFutureOfServiceExtensionResponse()));
>+      io._RandomAccessFile._connectedResourceHandler = true;
>+    }
>+  }
>+  close() {
>+    return this[_dispatch](io._IOService.fileClose, [null], {markClosed: true}).then(dart.void, dart.fn(result => {
>+      if (dart.equals(result, -1)) {
>+        dart.throw(new io.FileSystemException.new("Cannot close file", this.path));
>+      }
>+      this.closed = dart.test(this.closed) || dart.equals(result, 0);
>+      this[_maybePerformCleanup]();
>+    }, dynamicToNull()));
>+  }
>+  closeSync() {
>+    this[_checkAvailable]();
>+    let id = this[_ops].close();
>+    if (id === -1) {
>+      dart.throw(new io.FileSystemException.new("Cannot close file", this.path));
>+    }
>+    this.closed = dart.test(this.closed) || id === 0;
>+    this[_maybePerformCleanup]();
>+  }
>+  readByte() {
>+    return FutureOfint()._check(this[_dispatch](io._IOService.fileReadByte, [null]).then(core.int, dart.fn(response => {
>+      if (dart.test(io._isErrorResponse(response))) {
>+        dart.throw(io._exceptionFromResponse(response, "readByte failed", this.path));
>+      }
>+      this[_resourceInfo].addRead(1);
>+      return FutureOrOfint()._check(response);
>+    }, dynamicToFutureOrOfint())));
>+  }
>+  readByteSync() {
>+    this[_checkAvailable]();
>+    let result = this[_ops].readByte();
>+    if (io.OSError.is(result)) {
>+      dart.throw(new io.FileSystemException.new("readByte failed", this.path, result));
>+    }
>+    this[_resourceInfo].addRead(1);
>+    return core.int._check(result);
>+  }
>+  read(bytes) {
>+    core.ArgumentError.checkNotNull(bytes, "bytes");
>+    return FutureOfListOfint()._check(this[_dispatch](io._IOService.fileRead, [null, bytes]).then(ListOfint(), dart.fn(response => {
>+      if (dart.test(io._isErrorResponse(response))) {
>+        dart.throw(io._exceptionFromResponse(response, "read failed", this.path));
>+      }
>+      this[_resourceInfo].addRead(core.int._check(dart.dload(dart.dindex(response, 1), 'length')));
>+      let result = ListOfint()._check(dart.dindex(response, 1));
>+      return result;
>+    }, dynamicToListOfint())));
>+  }
>+  readSync(bytes) {
>+    this[_checkAvailable]();
>+    core.ArgumentError.checkNotNull(bytes, "bytes");
>+    let result = this[_ops].read(bytes);
>+    if (io.OSError.is(result)) {
>+      dart.throw(new io.FileSystemException.new("readSync failed", this.path, result));
>+    }
>+    this[_resourceInfo].addRead(core.int._check(dart.dload(result, 'length')));
>+    return ListOfint()._check(result);
>+  }
>+  readInto(buffer, start, end) {
>+    if (start === void 0) start = 0;
>+    if (end === void 0) end = null;
>+    if (!core.List.is(buffer) || start != null && !core.int.is(start) || end != null && !core.int.is(end)) {
>+      dart.throw(new core.ArgumentError.new());
>+    }
>+    end = core.RangeError.checkValidRange(start, end, buffer[$length]);
>+    if (end == start) {
>+      return FutureOfint().value(0);
>+    }
>+    let length = dart.notNull(end) - dart.notNull(start);
>+    return FutureOfint()._check(this[_dispatch](io._IOService.fileReadInto, [null, length]).then(core.int, dart.fn(response => {
>+      if (dart.test(io._isErrorResponse(response))) {
>+        dart.throw(io._exceptionFromResponse(response, "readInto failed", this.path));
>+      }
>+      let read = core.int._check(dart.dindex(response, 1));
>+      let data = ListOfint()._check(dart.dindex(response, 2));
>+      buffer[$setRange](start, dart.notNull(start) + dart.notNull(read), data);
>+      this[_resourceInfo].addRead(read);
>+      return read;
>+    }, dynamicToint())));
>+  }
>+  readIntoSync(buffer, start, end) {
>+    if (start === void 0) start = 0;
>+    if (end === void 0) end = null;
>+    this[_checkAvailable]();
>+    if (!core.List.is(buffer) || start != null && !core.int.is(start) || end != null && !core.int.is(end)) {
>+      dart.throw(new core.ArgumentError.new());
>+    }
>+    end = core.RangeError.checkValidRange(start, end, buffer[$length]);
>+    if (end == start) {
>+      return 0;
>+    }
>+    let result = this[_ops].readInto(buffer, start, end);
>+    if (io.OSError.is(result)) {
>+      dart.throw(new io.FileSystemException.new("readInto failed", this.path, result));
>+    }
>+    this[_resourceInfo].addRead(core.int._check(result));
>+    return core.int._check(result);
>+  }
>+  writeByte(value) {
>+    core.ArgumentError.checkNotNull(value, "value");
>+    return FutureOfRandomAccessFile()._check(this[_dispatch](io._IOService.fileWriteByte, [null, value]).then(io.RandomAccessFile, dart.fn(response => {
>+      if (dart.test(io._isErrorResponse(response))) {
>+        dart.throw(io._exceptionFromResponse(response, "writeByte failed", this.path));
>+      }
>+      this[_resourceInfo].addWrite(1);
>+      return this;
>+    }, dynamicTo_RandomAccessFile())));
>+  }
>+  writeByteSync(value) {
>+    this[_checkAvailable]();
>+    core.ArgumentError.checkNotNull(value, "value");
>+    let result = this[_ops].writeByte(value);
>+    if (io.OSError.is(result)) {
>+      dart.throw(new io.FileSystemException.new("writeByte failed", this.path, result));
>+    }
>+    this[_resourceInfo].addWrite(1);
>+    return core.int._check(result);
>+  }
>+  writeFrom(buffer, start, end) {
>+    if (start === void 0) start = 0;
>+    if (end === void 0) end = null;
>+    if (!core.List.is(buffer) || start != null && !core.int.is(start) || end != null && !core.int.is(end)) {
>+      dart.throw(new core.ArgumentError.new("Invalid arguments to writeFrom"));
>+    }
>+    end = core.RangeError.checkValidRange(start, end, buffer[$length]);
>+    if (end == start) {
>+      return FutureOfRandomAccessFile().value(this);
>+    }
>+    let result = null;
>+    try {
>+      result = io._ensureFastAndSerializableByteData(buffer, start, end);
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      return FutureOfRandomAccessFile().error(e);
>+    }
>+    let request = core.List.new(4);
>+    request[$_set](0, null);
>+    request[$_set](1, result.buffer);
>+    request[$_set](2, result.start);
>+    request[$_set](3, dart.notNull(end) - (dart.notNull(start) - dart.notNull(result.start)));
>+    return FutureOfRandomAccessFile()._check(this[_dispatch](io._IOService.fileWriteFrom, request).then(io.RandomAccessFile, dart.fn(response => {
>+      if (dart.test(io._isErrorResponse(response))) {
>+        dart.throw(io._exceptionFromResponse(response, "writeFrom failed", this.path));
>+      }
>+      this[_resourceInfo].addWrite(dart.notNull(end) - (dart.notNull(start) - dart.notNull(result.start)));
>+      return this;
>+    }, dynamicTo_RandomAccessFile())));
>+  }
>+  writeFromSync(buffer, start, end) {
>+    if (start === void 0) start = 0;
>+    if (end === void 0) end = null;
>+    this[_checkAvailable]();
>+    if (!core.List.is(buffer) || start != null && !core.int.is(start) || end != null && !core.int.is(end)) {
>+      dart.throw(new core.ArgumentError.new("Invalid arguments to writeFromSync"));
>+    }
>+    end = core.RangeError.checkValidRange(start, end, buffer[$length]);
>+    if (end == start) {
>+      return;
>+    }
>+    let bufferAndStart = io._ensureFastAndSerializableByteData(buffer, start, end);
>+    let result = this[_ops].writeFrom(bufferAndStart.buffer, bufferAndStart.start, dart.notNull(end) - (dart.notNull(start) - dart.notNull(bufferAndStart.start)));
>+    if (io.OSError.is(result)) {
>+      dart.throw(new io.FileSystemException.new("writeFrom failed", this.path, result));
>+    }
>+    this[_resourceInfo].addWrite(dart.notNull(end) - (dart.notNull(start) - dart.notNull(bufferAndStart.start)));
>+  }
>+  writeString(string, opts) {
>+    let encoding = opts && 'encoding' in opts ? opts.encoding : convert.utf8;
>+    core.ArgumentError.checkNotNull(encoding, "encoding");
>+    let data = encoding.encode(string);
>+    return this.writeFrom(data, 0, data[$length]);
>+  }
>+  writeStringSync(string, opts) {
>+    let encoding = opts && 'encoding' in opts ? opts.encoding : convert.utf8;
>+    core.ArgumentError.checkNotNull(encoding, "encoding");
>+    let data = encoding.encode(string);
>+    this.writeFromSync(data, 0, data[$length]);
>+  }
>+  position() {
>+    return FutureOfint()._check(this[_dispatch](io._IOService.filePosition, [null]).then(core.int, dart.fn(response => {
>+      if (dart.test(io._isErrorResponse(response))) {
>+        dart.throw(io._exceptionFromResponse(response, "position failed", this.path));
>+      }
>+      return FutureOrOfint()._check(response);
>+    }, dynamicToFutureOrOfint())));
>+  }
>+  positionSync() {
>+    this[_checkAvailable]();
>+    let result = this[_ops].position();
>+    if (io.OSError.is(result)) {
>+      dart.throw(new io.FileSystemException.new("position failed", this.path, result));
>+    }
>+    return core.int._check(result);
>+  }
>+  setPosition(position) {
>+    return FutureOfRandomAccessFile()._check(this[_dispatch](io._IOService.fileSetPosition, [null, position]).then(io.RandomAccessFile, dart.fn(response => {
>+      if (dart.test(io._isErrorResponse(response))) {
>+        dart.throw(io._exceptionFromResponse(response, "setPosition failed", this.path));
>+      }
>+      return this;
>+    }, dynamicTo_RandomAccessFile())));
>+  }
>+  setPositionSync(position) {
>+    this[_checkAvailable]();
>+    let result = this[_ops].setPosition(position);
>+    if (io.OSError.is(result)) {
>+      dart.throw(new io.FileSystemException.new("setPosition failed", this.path, result));
>+    }
>+  }
>+  truncate(length) {
>+    return FutureOfRandomAccessFile()._check(this[_dispatch](io._IOService.fileTruncate, [null, length]).then(io.RandomAccessFile, dart.fn(response => {
>+      if (dart.test(io._isErrorResponse(response))) {
>+        dart.throw(io._exceptionFromResponse(response, "truncate failed", this.path));
>+      }
>+      return this;
>+    }, dynamicTo_RandomAccessFile())));
>+  }
>+  truncateSync(length) {
>+    this[_checkAvailable]();
>+    let result = this[_ops].truncate(length);
>+    if (io.OSError.is(result)) {
>+      dart.throw(new io.FileSystemException.new("truncate failed", this.path, result));
>+    }
>+  }
>+  length() {
>+    return FutureOfint()._check(this[_dispatch](io._IOService.fileLength, [null]).then(core.int, dart.fn(response => {
>+      if (dart.test(io._isErrorResponse(response))) {
>+        dart.throw(io._exceptionFromResponse(response, "length failed", this.path));
>+      }
>+      return FutureOrOfint()._check(response);
>+    }, dynamicToFutureOrOfint())));
>+  }
>+  lengthSync() {
>+    this[_checkAvailable]();
>+    let result = this[_ops].length();
>+    if (io.OSError.is(result)) {
>+      dart.throw(new io.FileSystemException.new("length failed", this.path, result));
>+    }
>+    return core.int._check(result);
>+  }
>+  flush() {
>+    return FutureOfRandomAccessFile()._check(this[_dispatch](io._IOService.fileFlush, [null]).then(io.RandomAccessFile, dart.fn(response => {
>+      if (dart.test(io._isErrorResponse(response))) {
>+        dart.throw(io._exceptionFromResponse(response, "flush failed", this.path));
>+      }
>+      return this;
>+    }, dynamicTo_RandomAccessFile())));
>+  }
>+  flushSync() {
>+    this[_checkAvailable]();
>+    let result = this[_ops].flush();
>+    if (io.OSError.is(result)) {
>+      dart.throw(new io.FileSystemException.new("flush failed", this.path, result));
>+    }
>+  }
>+  [_fileLockValue](fl) {
>+    return fl[_type$0];
>+  }
>+  lock(mode, start, end) {
>+    if (mode === void 0) mode = io.FileLock.exclusive;
>+    if (start === void 0) start = 0;
>+    if (end === void 0) end = -1;
>+    if (!io.FileLock.is(mode) || !core.int.is(start) || !core.int.is(end)) {
>+      dart.throw(new core.ArgumentError.new());
>+    }
>+    if (dart.notNull(start) < 0 || dart.notNull(end) < -1 || end !== -1 && dart.notNull(start) >= dart.notNull(end)) {
>+      dart.throw(new core.ArgumentError.new());
>+    }
>+    let lock = this[_fileLockValue](mode);
>+    return FutureOfRandomAccessFile()._check(this[_dispatch](io._IOService.fileLock, [null, lock, start, end]).then(io.RandomAccessFile, dart.fn(response => {
>+      if (dart.test(io._isErrorResponse(response))) {
>+        dart.throw(io._exceptionFromResponse(response, "lock failed", this.path));
>+      }
>+      return this;
>+    }, dynamicTo_RandomAccessFile())));
>+  }
>+  unlock(start, end) {
>+    if (start === void 0) start = 0;
>+    if (end === void 0) end = -1;
>+    if (!core.int.is(start) || !core.int.is(end)) {
>+      dart.throw(new core.ArgumentError.new());
>+    }
>+    if (start == end) {
>+      dart.throw(new core.ArgumentError.new());
>+    }
>+    return FutureOfRandomAccessFile()._check(this[_dispatch](io._IOService.fileLock, [null, 0, start, end]).then(io.RandomAccessFile, dart.fn(response => {
>+      if (dart.test(io._isErrorResponse(response))) {
>+        dart.throw(io._exceptionFromResponse(response, "unlock failed", this.path));
>+      }
>+      return this;
>+    }, dynamicTo_RandomAccessFile())));
>+  }
>+  lockSync(mode, start, end) {
>+    if (mode === void 0) mode = io.FileLock.exclusive;
>+    if (start === void 0) start = 0;
>+    if (end === void 0) end = -1;
>+    this[_checkAvailable]();
>+    if (!io.FileLock.is(mode) || !core.int.is(start) || !core.int.is(end)) {
>+      dart.throw(new core.ArgumentError.new());
>+    }
>+    if (dart.notNull(start) < 0 || dart.notNull(end) < -1 || end !== -1 && dart.notNull(start) >= dart.notNull(end)) {
>+      dart.throw(new core.ArgumentError.new());
>+    }
>+    let lock = this[_fileLockValue](mode);
>+    let result = this[_ops].lock(lock, start, end);
>+    if (io.OSError.is(result)) {
>+      dart.throw(new io.FileSystemException.new("lock failed", this.path, result));
>+    }
>+  }
>+  unlockSync(start, end) {
>+    if (start === void 0) start = 0;
>+    if (end === void 0) end = -1;
>+    this[_checkAvailable]();
>+    if (!core.int.is(start) || !core.int.is(end)) {
>+      dart.throw(new core.ArgumentError.new());
>+    }
>+    if (start == end) {
>+      dart.throw(new core.ArgumentError.new());
>+    }
>+    let result = this[_ops].lock(0, start, end);
>+    if (io.OSError.is(result)) {
>+      dart.throw(new io.FileSystemException.new("unlock failed", this.path, result));
>+    }
>+  }
>+  [_pointer]() {
>+    return this[_ops].getPointer();
>+  }
>+  [_dispatch](request, data, opts) {
>+    let markClosed = opts && 'markClosed' in opts ? opts.markClosed : false;
>+    if (dart.test(this.closed)) {
>+      return async.Future.error(new io.FileSystemException.new("File closed", this.path));
>+    }
>+    if (dart.test(this[_asyncDispatched])) {
>+      let msg = "An async operation is currently pending";
>+      return async.Future.error(new io.FileSystemException.new(msg, this.path));
>+    }
>+    if (dart.test(markClosed)) {
>+      this.closed = true;
>+    }
>+    this[_asyncDispatched] = true;
>+    data[$_set](0, this[_pointer]());
>+    return io._IOService._dispatch(request, data).whenComplete(dart.fn(() => {
>+      this[_asyncDispatched] = false;
>+    }, VoidToNull()));
>+  }
>+  [_checkAvailable]() {
>+    if (dart.test(this[_asyncDispatched])) {
>+      dart.throw(new io.FileSystemException.new("An async operation is currently pending", this.path));
>+    }
>+    if (dart.test(this.closed)) {
>+      dart.throw(new io.FileSystemException.new("File closed", this.path));
>+    }
>+  }
>+};
>+(io._RandomAccessFile.new = function(pointer, path) {
>+  this[_asyncDispatched] = false;
>+  this[_fileService] = null;
>+  this[_resourceInfo] = null;
>+  this[_ops] = null;
>+  this.closed = false;
>+  this.path = path;
>+  this[_ops] = io._RandomAccessFileOps.new(pointer);
>+  this[_resourceInfo] = new io._FileResourceInfo.new(this);
>+  this[_maybeConnectHandler]();
>+}).prototype = io._RandomAccessFile.prototype;
>+dart.addTypeTests(io._RandomAccessFile);
>+io._RandomAccessFile[dart.implements] = () => [io.RandomAccessFile];
>+dart.setMethodSignature(io._RandomAccessFile, () => ({
>+  __proto__: dart.getMethods(io._RandomAccessFile.__proto__),
>+  [_maybePerformCleanup]: dart.fnType(dart.void, []),
>+  [_maybeConnectHandler]: dart.fnType(dart.dynamic, []),
>+  close: dart.fnType(async.Future$(dart.void), []),
>+  closeSync: dart.fnType(dart.void, []),
>+  readByte: dart.fnType(async.Future$(core.int), []),
>+  readByteSync: dart.fnType(core.int, []),
>+  read: dart.fnType(async.Future$(core.List$(core.int)), [core.int]),
>+  readSync: dart.fnType(core.List$(core.int), [core.int]),
>+  readInto: dart.fnType(async.Future$(core.int), [core.List$(core.int)], [core.int, core.int]),
>+  readIntoSync: dart.fnType(core.int, [core.List$(core.int)], [core.int, core.int]),
>+  writeByte: dart.fnType(async.Future$(io.RandomAccessFile), [core.int]),
>+  writeByteSync: dart.fnType(core.int, [core.int]),
>+  writeFrom: dart.fnType(async.Future$(io.RandomAccessFile), [core.List$(core.int)], [core.int, core.int]),
>+  writeFromSync: dart.fnType(dart.void, [core.List$(core.int)], [core.int, core.int]),
>+  writeString: dart.fnType(async.Future$(io.RandomAccessFile), [core.String], {encoding: convert.Encoding}),
>+  writeStringSync: dart.fnType(dart.void, [core.String], {encoding: convert.Encoding}),
>+  position: dart.fnType(async.Future$(core.int), []),
>+  positionSync: dart.fnType(core.int, []),
>+  setPosition: dart.fnType(async.Future$(io.RandomAccessFile), [core.int]),
>+  setPositionSync: dart.fnType(dart.void, [core.int]),
>+  truncate: dart.fnType(async.Future$(io.RandomAccessFile), [core.int]),
>+  truncateSync: dart.fnType(dart.void, [core.int]),
>+  length: dart.fnType(async.Future$(core.int), []),
>+  lengthSync: dart.fnType(core.int, []),
>+  flush: dart.fnType(async.Future$(io.RandomAccessFile), []),
>+  flushSync: dart.fnType(dart.void, []),
>+  [_fileLockValue]: dart.fnType(core.int, [io.FileLock]),
>+  lock: dart.fnType(async.Future$(io.RandomAccessFile), [], [io.FileLock, core.int, core.int]),
>+  unlock: dart.fnType(async.Future$(io.RandomAccessFile), [], [core.int, core.int]),
>+  lockSync: dart.fnType(dart.void, [], [io.FileLock, core.int, core.int]),
>+  unlockSync: dart.fnType(dart.void, [], [core.int, core.int]),
>+  [_pointer]: dart.fnType(core.int, []),
>+  [_dispatch]: dart.fnType(async.Future, [core.int, core.List], {markClosed: core.bool}),
>+  [_checkAvailable]: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(io._RandomAccessFile, "dart:io");
>+dart.setFieldSignature(io._RandomAccessFile, () => ({
>+  __proto__: dart.getFields(io._RandomAccessFile.__proto__),
>+  path: dart.finalFieldType(core.String),
>+  [_asyncDispatched]: dart.fieldType(core.bool),
>+  [_fileService]: dart.fieldType(isolate.SendPort),
>+  [_resourceInfo]: dart.fieldType(io._FileResourceInfo),
>+  [_ops]: dart.fieldType(io._RandomAccessFileOps),
>+  closed: dart.fieldType(core.bool)
>+}));
>+dart.defineLazy(io._RandomAccessFile, {
>+  /*io._RandomAccessFile._connectedResourceHandler*/get _connectedResourceHandler() {
>+    return false;
>+  },
>+  set _connectedResourceHandler(_) {},
>+  /*io._RandomAccessFile.lockUnlock*/get lockUnlock() {
>+    return 0;
>+  }
>+});
>+let const$68;
>+io.FileSystemEntityType = class FileSystemEntityType extends core.Object {
>+  static _lookup(type) {
>+    return io.FileSystemEntityType._typeList[$_get](type);
>+  }
>+  toString() {
>+    return (const$68 || (const$68 = dart.constList(["file", "directory", "link", "notFound"], core.String)))[$_get](this[_type$0]);
>+  }
>+};
>+(io.FileSystemEntityType._internal = function(type) {
>+  this[_type$0] = type;
>+}).prototype = io.FileSystemEntityType.prototype;
>+dart.addTypeTests(io.FileSystemEntityType);
>+dart.setLibraryUri(io.FileSystemEntityType, "dart:io");
>+dart.setFieldSignature(io.FileSystemEntityType, () => ({
>+  __proto__: dart.getFields(io.FileSystemEntityType.__proto__),
>+  [_type$0]: dart.finalFieldType(core.int)
>+}));
>+dart.defineExtensionMethods(io.FileSystemEntityType, ['toString']);
>+dart.defineLazy(io.FileSystemEntityType, {
>+  /*io.FileSystemEntityType.file*/get file() {
>+    return dart.const(new io.FileSystemEntityType._internal(0));
>+  },
>+  /*io.FileSystemEntityType.FILE*/get FILE() {
>+    return io.FileSystemEntityType.file;
>+  },
>+  /*io.FileSystemEntityType.directory*/get directory() {
>+    return dart.const(new io.FileSystemEntityType._internal(1));
>+  },
>+  /*io.FileSystemEntityType.DIRECTORY*/get DIRECTORY() {
>+    return io.FileSystemEntityType.directory;
>+  },
>+  /*io.FileSystemEntityType.link*/get link() {
>+    return dart.const(new io.FileSystemEntityType._internal(2));
>+  },
>+  /*io.FileSystemEntityType.LINK*/get LINK() {
>+    return io.FileSystemEntityType.link;
>+  },
>+  /*io.FileSystemEntityType.notFound*/get notFound() {
>+    return dart.const(new io.FileSystemEntityType._internal(3));
>+  },
>+  /*io.FileSystemEntityType.NOT_FOUND*/get NOT_FOUND() {
>+    return io.FileSystemEntityType.notFound;
>+  },
>+  /*io.FileSystemEntityType._typeList*/get _typeList() {
>+    return dart.constList([io.FileSystemEntityType.file, io.FileSystemEntityType.directory, io.FileSystemEntityType.link, io.FileSystemEntityType.notFound], io.FileSystemEntityType);
>+  }
>+});
>+let const$69;
>+io.FileStat = class FileStat extends core.Object {
>+  get changed() {
>+    return this[changed$];
>+  }
>+  set changed(value) {
>+    super.changed = value;
>+  }
>+  get modified() {
>+    return this[modified$];
>+  }
>+  set modified(value) {
>+    super.modified = value;
>+  }
>+  get accessed() {
>+    return this[accessed$];
>+  }
>+  set accessed(value) {
>+    super.accessed = value;
>+  }
>+  get type() {
>+    return this[type$];
>+  }
>+  set type(value) {
>+    super.type = value;
>+  }
>+  get mode() {
>+    return this[mode$0];
>+  }
>+  set mode(value) {
>+    super.mode = value;
>+  }
>+  get size() {
>+    return this[size$];
>+  }
>+  set size(value) {
>+    super.size = value;
>+  }
>+  static _statSync(namespace, path) {
>+    dart.throw(new core.UnsupportedError.new("FileStat.stat"));
>+  }
>+  static statSync(path) {
>+    let overrides = io.IOOverrides.current;
>+    if (overrides == null) {
>+      return io.FileStat._statSyncInternal(path);
>+    }
>+    return overrides.statSync(path);
>+  }
>+  static _statSyncInternal(path) {
>+    if (dart.test(io.Platform.isWindows)) {
>+      path = io.FileSystemEntity._trimTrailingPathSeparators(path);
>+    }
>+    let data = io.FileStat._statSync(io._Namespace._namespace, path);
>+    if (io.OSError.is(data)) return io.FileStat._notFound;
>+    return new io.FileStat._internal(new core.DateTime.fromMillisecondsSinceEpoch(core.int._check(dart.dindex(data, 1))), new core.DateTime.fromMillisecondsSinceEpoch(core.int._check(dart.dindex(data, 2))), new core.DateTime.fromMillisecondsSinceEpoch(core.int._check(dart.dindex(data, 3))), io.FileSystemEntityType._lookup(core.int._check(dart.dindex(data, 0))), core.int._check(dart.dindex(data, 4)), core.int._check(dart.dindex(data, 5)));
>+  }
>+  static stat(path) {
>+    let overrides = io.IOOverrides.current;
>+    if (overrides == null) {
>+      return io.FileStat._stat(path);
>+    }
>+    return overrides.stat(path);
>+  }
>+  static _stat(path) {
>+    if (dart.test(io.Platform.isWindows)) {
>+      path = io.FileSystemEntity._trimTrailingPathSeparators(path);
>+    }
>+    return FutureOfFileStat()._check(io._File._dispatchWithNamespace(io._IOService.fileStat, [null, path]).then(io.FileStat, dart.fn(response => {
>+      if (dart.test(io._isErrorResponse(response))) {
>+        return io.FileStat._notFound;
>+      }
>+      let data = core.List._check(dart.dindex(response, 1));
>+      return new io.FileStat._internal(new core.DateTime.fromMillisecondsSinceEpoch(core.int._check(data[$_get](1))), new core.DateTime.fromMillisecondsSinceEpoch(core.int._check(data[$_get](2))), new core.DateTime.fromMillisecondsSinceEpoch(core.int._check(data[$_get](3))), io.FileSystemEntityType._lookup(core.int._check(data[$_get](0))), core.int._check(data[$_get](4)), core.int._check(data[$_get](5)));
>+    }, dynamicToFileStat())));
>+  }
>+  toString() {
>+    return "FileStat: type " + dart.str(this.type) + "\n          changed " + dart.str(this.changed) + "\n          modified " + dart.str(this.modified) + "\n          accessed " + dart.str(this.accessed) + "\n          mode " + dart.str(this.modeString()) + "\n          size " + dart.str(this.size);
>+  }
>+  modeString() {
>+    let permissions = dart.notNull(this.mode) & 4095;
>+    let codes = const$69 || (const$69 = dart.constList(["---", "--x", "-w-", "-wx", "r--", "r-x", "rw-", "rwx"], core.String));
>+    let result = [];
>+    if ((permissions & 2048) !== 0) result[$add]("(suid) ");
>+    if ((permissions & 1024) !== 0) result[$add]("(guid) ");
>+    if ((permissions & 512) !== 0) result[$add]("(sticky) ");
>+    result[$add](codes[$_get](permissions >> 6 & 7));
>+    result[$add](codes[$_get](permissions >> 3 & 7));
>+    result[$add](codes[$_get](permissions & 7));
>+    return result[$join]();
>+  }
>+};
>+(io.FileStat._internal = function(changed, modified, accessed, type, mode, size) {
>+  this[changed$] = changed;
>+  this[modified$] = modified;
>+  this[accessed$] = accessed;
>+  this[type$] = type;
>+  this[mode$0] = mode;
>+  this[size$] = size;
>+}).prototype = io.FileStat.prototype;
>+(io.FileStat._internalNotFound = function() {
>+  this[changed$] = null;
>+  this[modified$] = null;
>+  this[accessed$] = null;
>+  this[type$] = io.FileSystemEntityType.notFound;
>+  this[mode$0] = 0;
>+  this[size$] = -1;
>+}).prototype = io.FileStat.prototype;
>+dart.addTypeTests(io.FileStat);
>+const changed$ = Symbol("FileStat.changed");
>+const modified$ = Symbol("FileStat.modified");
>+const accessed$ = Symbol("FileStat.accessed");
>+const type$ = Symbol("FileStat.type");
>+const mode$0 = Symbol("FileStat.mode");
>+const size$ = Symbol("FileStat.size");
>+dart.setMethodSignature(io.FileStat, () => ({
>+  __proto__: dart.getMethods(io.FileStat.__proto__),
>+  modeString: dart.fnType(core.String, [])
>+}));
>+dart.setLibraryUri(io.FileStat, "dart:io");
>+dart.setFieldSignature(io.FileStat, () => ({
>+  __proto__: dart.getFields(io.FileStat.__proto__),
>+  changed: dart.finalFieldType(core.DateTime),
>+  modified: dart.finalFieldType(core.DateTime),
>+  accessed: dart.finalFieldType(core.DateTime),
>+  type: dart.finalFieldType(io.FileSystemEntityType),
>+  mode: dart.finalFieldType(core.int),
>+  size: dart.finalFieldType(core.int)
>+}));
>+dart.defineExtensionMethods(io.FileStat, ['toString']);
>+dart.defineLazy(io.FileStat, {
>+  /*io.FileStat._type*/get _type() {
>+    return 0;
>+  },
>+  /*io.FileStat._changedTime*/get _changedTime() {
>+    return 1;
>+  },
>+  /*io.FileStat._modifiedTime*/get _modifiedTime() {
>+    return 2;
>+  },
>+  /*io.FileStat._accessedTime*/get _accessedTime() {
>+    return 3;
>+  },
>+  /*io.FileStat._mode*/get _mode() {
>+    return 4;
>+  },
>+  /*io.FileStat._size*/get _size() {
>+    return 5;
>+  },
>+  /*io.FileStat._notFound*/get _notFound() {
>+    return dart.const(new io.FileStat._internalNotFound());
>+  }
>+});
>+io.FileSystemEvent = class FileSystemEvent extends core.Object {
>+  get type() {
>+    return this[type$0];
>+  }
>+  set type(value) {
>+    super.type = value;
>+  }
>+  get path() {
>+    return this[path$0];
>+  }
>+  set path(value) {
>+    super.path = value;
>+  }
>+  get isDirectory() {
>+    return this[isDirectory$];
>+  }
>+  set isDirectory(value) {
>+    super.isDirectory = value;
>+  }
>+};
>+(io.FileSystemEvent.__ = function(type, path, isDirectory) {
>+  this[type$0] = type;
>+  this[path$0] = path;
>+  this[isDirectory$] = isDirectory;
>+}).prototype = io.FileSystemEvent.prototype;
>+dart.addTypeTests(io.FileSystemEvent);
>+const type$0 = Symbol("FileSystemEvent.type");
>+const path$0 = Symbol("FileSystemEvent.path");
>+const isDirectory$ = Symbol("FileSystemEvent.isDirectory");
>+dart.setLibraryUri(io.FileSystemEvent, "dart:io");
>+dart.setFieldSignature(io.FileSystemEvent, () => ({
>+  __proto__: dart.getFields(io.FileSystemEvent.__proto__),
>+  type: dart.finalFieldType(core.int),
>+  path: dart.finalFieldType(core.String),
>+  isDirectory: dart.finalFieldType(core.bool)
>+}));
>+dart.defineLazy(io.FileSystemEvent, {
>+  /*io.FileSystemEvent.create*/get create() {
>+    return 1 << 0;
>+  },
>+  /*io.FileSystemEvent.CREATE*/get CREATE() {
>+    return 1 << 0;
>+  },
>+  /*io.FileSystemEvent.modify*/get modify() {
>+    return 1 << 1;
>+  },
>+  /*io.FileSystemEvent.MODIFY*/get MODIFY() {
>+    return 1 << 1;
>+  },
>+  /*io.FileSystemEvent.delete*/get delete() {
>+    return 1 << 2;
>+  },
>+  /*io.FileSystemEvent.DELETE*/get DELETE() {
>+    return 1 << 2;
>+  },
>+  /*io.FileSystemEvent.move*/get move() {
>+    return 1 << 3;
>+  },
>+  /*io.FileSystemEvent.MOVE*/get MOVE() {
>+    return 1 << 3;
>+  },
>+  /*io.FileSystemEvent.all*/get all() {
>+    return 1 | 2 | 4 | 8;
>+  },
>+  /*io.FileSystemEvent.ALL*/get ALL() {
>+    return 1 | 2 | 4 | 8;
>+  },
>+  /*io.FileSystemEvent._modifyAttributes*/get _modifyAttributes() {
>+    return 1 << 4;
>+  },
>+  /*io.FileSystemEvent._deleteSelf*/get _deleteSelf() {
>+    return 1 << 5;
>+  },
>+  /*io.FileSystemEvent._isDir*/get _isDir() {
>+    return 1 << 6;
>+  }
>+});
>+io.FileSystemCreateEvent = class FileSystemCreateEvent extends io.FileSystemEvent {
>+  toString() {
>+    return "FileSystemCreateEvent('" + dart.str(this.path) + "')";
>+  }
>+};
>+(io.FileSystemCreateEvent.__ = function(path, isDirectory) {
>+  io.FileSystemCreateEvent.__proto__.__.call(this, io.FileSystemEvent.create, core.String._check(path), core.bool._check(isDirectory));
>+}).prototype = io.FileSystemCreateEvent.prototype;
>+dart.addTypeTests(io.FileSystemCreateEvent);
>+dart.setLibraryUri(io.FileSystemCreateEvent, "dart:io");
>+dart.defineExtensionMethods(io.FileSystemCreateEvent, ['toString']);
>+io.FileSystemModifyEvent = class FileSystemModifyEvent extends io.FileSystemEvent {
>+  get contentChanged() {
>+    return this[contentChanged$];
>+  }
>+  set contentChanged(value) {
>+    super.contentChanged = value;
>+  }
>+  toString() {
>+    return "FileSystemModifyEvent('" + dart.str(this.path) + "', contentChanged=" + dart.str(this.contentChanged) + ")";
>+  }
>+};
>+(io.FileSystemModifyEvent.__ = function(path, isDirectory, contentChanged) {
>+  this[contentChanged$] = contentChanged;
>+  io.FileSystemModifyEvent.__proto__.__.call(this, io.FileSystemEvent.modify, core.String._check(path), core.bool._check(isDirectory));
>+}).prototype = io.FileSystemModifyEvent.prototype;
>+dart.addTypeTests(io.FileSystemModifyEvent);
>+const contentChanged$ = Symbol("FileSystemModifyEvent.contentChanged");
>+dart.setLibraryUri(io.FileSystemModifyEvent, "dart:io");
>+dart.setFieldSignature(io.FileSystemModifyEvent, () => ({
>+  __proto__: dart.getFields(io.FileSystemModifyEvent.__proto__),
>+  contentChanged: dart.finalFieldType(core.bool)
>+}));
>+dart.defineExtensionMethods(io.FileSystemModifyEvent, ['toString']);
>+io.FileSystemDeleteEvent = class FileSystemDeleteEvent extends io.FileSystemEvent {
>+  toString() {
>+    return "FileSystemDeleteEvent('" + dart.str(this.path) + "')";
>+  }
>+};
>+(io.FileSystemDeleteEvent.__ = function(path, isDirectory) {
>+  io.FileSystemDeleteEvent.__proto__.__.call(this, io.FileSystemEvent.delete, core.String._check(path), core.bool._check(isDirectory));
>+}).prototype = io.FileSystemDeleteEvent.prototype;
>+dart.addTypeTests(io.FileSystemDeleteEvent);
>+dart.setLibraryUri(io.FileSystemDeleteEvent, "dart:io");
>+dart.defineExtensionMethods(io.FileSystemDeleteEvent, ['toString']);
>+io.FileSystemMoveEvent = class FileSystemMoveEvent extends io.FileSystemEvent {
>+  get destination() {
>+    return this[destination$];
>+  }
>+  set destination(value) {
>+    super.destination = value;
>+  }
>+  toString() {
>+    let buffer = new core.StringBuffer.new();
>+    buffer.write("FileSystemMoveEvent('" + dart.str(this.path) + "'");
>+    if (this.destination != null) buffer.write(", '" + dart.str(this.destination) + "'");
>+    buffer.write(")");
>+    return buffer.toString();
>+  }
>+};
>+(io.FileSystemMoveEvent.__ = function(path, isDirectory, destination) {
>+  this[destination$] = destination;
>+  io.FileSystemMoveEvent.__proto__.__.call(this, io.FileSystemEvent.move, core.String._check(path), core.bool._check(isDirectory));
>+}).prototype = io.FileSystemMoveEvent.prototype;
>+dart.addTypeTests(io.FileSystemMoveEvent);
>+const destination$ = Symbol("FileSystemMoveEvent.destination");
>+dart.setLibraryUri(io.FileSystemMoveEvent, "dart:io");
>+dart.setFieldSignature(io.FileSystemMoveEvent, () => ({
>+  __proto__: dart.getFields(io.FileSystemMoveEvent.__proto__),
>+  destination: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionMethods(io.FileSystemMoveEvent, ['toString']);
>+io._FileSystemWatcher = class _FileSystemWatcher extends core.Object {
>+  static _watch(path, events, recursive) {
>+    dart.throw(new core.UnsupportedError.new("_FileSystemWatcher.watch"));
>+  }
>+  static get isSupported() {
>+    dart.throw(new core.UnsupportedError.new("_FileSystemWatcher.isSupported"));
>+  }
>+};
>+(io._FileSystemWatcher.new = function() {
>+}).prototype = io._FileSystemWatcher.prototype;
>+dart.addTypeTests(io._FileSystemWatcher);
>+dart.setLibraryUri(io._FileSystemWatcher, "dart:io");
>+io._IOResourceInfo = class _IOResourceInfo extends core.Object {
>+  static get timestamp() {
>+    return dart.notNull(io._IOResourceInfo._startTime) + dart.notNull(io._IOResourceInfo._sw.elapsedMicroseconds) / 1000;
>+  }
>+  get referenceValueMap() {
>+    return new (IdentityMapOfString$dynamic()).from(["type", "@" + dart.str(this.type), "id", this.id, "name", this.name]);
>+  }
>+  static getNextID() {
>+    let x = io._IOResourceInfo._count;
>+    io._IOResourceInfo._count = dart.notNull(x) + 1;
>+    return x;
>+  }
>+};
>+(io._IOResourceInfo.new = function(type) {
>+  this.type = type;
>+  this.id = io._IOResourceInfo.getNextID();
>+}).prototype = io._IOResourceInfo.prototype;
>+dart.addTypeTests(io._IOResourceInfo);
>+dart.setGetterSignature(io._IOResourceInfo, () => ({
>+  __proto__: dart.getGetters(io._IOResourceInfo.__proto__),
>+  referenceValueMap: core.Map$(core.String, dart.dynamic)
>+}));
>+dart.setLibraryUri(io._IOResourceInfo, "dart:io");
>+dart.setFieldSignature(io._IOResourceInfo, () => ({
>+  __proto__: dart.getFields(io._IOResourceInfo.__proto__),
>+  type: dart.finalFieldType(core.String),
>+  id: dart.finalFieldType(core.int)
>+}));
>+dart.defineLazy(io._IOResourceInfo, {
>+  /*io._IOResourceInfo._count*/get _count() {
>+    return 0;
>+  },
>+  set _count(_) {},
>+  /*io._IOResourceInfo._sw*/get _sw() {
>+    let _ = new core.Stopwatch.new();
>+    _.start();
>+    return _;
>+  },
>+  /*io._IOResourceInfo._startTime*/get _startTime() {
>+    return new core.DateTime.now().millisecondsSinceEpoch;
>+  }
>+});
>+io._ReadWriteResourceInfo = class _ReadWriteResourceInfo extends io._IOResourceInfo {
>+  addRead(bytes) {
>+    this.totalRead = dart.notNull(this.totalRead) + dart.notNull(bytes);
>+    this.readCount = dart.notNull(this.readCount) + 1;
>+    this.lastRead = io._IOResourceInfo.timestamp;
>+  }
>+  didRead() {
>+    this.addRead(0);
>+  }
>+  addWrite(bytes) {
>+    this.totalWritten = dart.notNull(this.totalWritten) + dart.notNull(bytes);
>+    this.writeCount = dart.notNull(this.writeCount) + 1;
>+    this.lastWrite = io._IOResourceInfo.timestamp;
>+  }
>+  get fullValueMap() {
>+    return new (IdentityMapOfString$dynamic()).from(["type", this.type, "id", this.id, "name", this.name, "totalRead", this.totalRead, "totalWritten", this.totalWritten, "readCount", this.readCount, "writeCount", this.writeCount, "lastRead", this.lastRead, "lastWrite", this.lastWrite]);
>+  }
>+};
>+(io._ReadWriteResourceInfo.new = function(type) {
>+  this.totalRead = 0;
>+  this.totalWritten = 0;
>+  this.readCount = 0;
>+  this.writeCount = 0;
>+  this.lastRead = 0.0;
>+  this.lastWrite = 0.0;
>+  io._ReadWriteResourceInfo.__proto__.new.call(this, type);
>+}).prototype = io._ReadWriteResourceInfo.prototype;
>+dart.addTypeTests(io._ReadWriteResourceInfo);
>+dart.setMethodSignature(io._ReadWriteResourceInfo, () => ({
>+  __proto__: dart.getMethods(io._ReadWriteResourceInfo.__proto__),
>+  addRead: dart.fnType(dart.void, [core.int]),
>+  didRead: dart.fnType(dart.void, []),
>+  addWrite: dart.fnType(dart.void, [core.int])
>+}));
>+dart.setGetterSignature(io._ReadWriteResourceInfo, () => ({
>+  __proto__: dart.getGetters(io._ReadWriteResourceInfo.__proto__),
>+  fullValueMap: core.Map$(core.String, dart.dynamic)
>+}));
>+dart.setLibraryUri(io._ReadWriteResourceInfo, "dart:io");
>+dart.setFieldSignature(io._ReadWriteResourceInfo, () => ({
>+  __proto__: dart.getFields(io._ReadWriteResourceInfo.__proto__),
>+  totalRead: dart.fieldType(core.int),
>+  totalWritten: dart.fieldType(core.int),
>+  readCount: dart.fieldType(core.int),
>+  writeCount: dart.fieldType(core.int),
>+  lastRead: dart.fieldType(core.double),
>+  lastWrite: dart.fieldType(core.double)
>+}));
>+io._FileResourceInfo = class _FileResourceInfo extends io._ReadWriteResourceInfo {
>+  static FileOpened(info) {
>+    if (!!dart.test(io._FileResourceInfo.openFiles[$containsKey](info.id))) dart.assertFailed(null, "dart:io/io_resource_info.dart", 101, 12, "!openFiles.containsKey(info.id)");
>+    io._FileResourceInfo.openFiles[$_set](info.id, info);
>+  }
>+  static FileClosed(info) {
>+    if (!dart.test(io._FileResourceInfo.openFiles[$containsKey](info.id))) dart.assertFailed(null, "dart:io/io_resource_info.dart", 106, 12, "openFiles.containsKey(info.id)");
>+    io._FileResourceInfo.openFiles[$remove](info.id);
>+  }
>+  static getOpenFilesList() {
>+    return ListOfMapOfString$dynamic().from(io._FileResourceInfo.openFiles[$values][$map](dart.dynamic, dart.fn(e => e.referenceValueMap, _FileResourceInfoToMapOfString$dynamic())));
>+  }
>+  static getOpenFiles(func, params) {
>+    if (!dart.equals(func, "ext.dart.io.getOpenFiles")) dart.assertFailed(null, "dart:io/io_resource_info.dart", 115, 12, "function == 'ext.dart.io.getOpenFiles'");
>+    let data = new (IdentityMapOfString$Object()).from(["type", "_openfiles", "data", io._FileResourceInfo.getOpenFilesList()]);
>+    let jsonValue = convert.json.encode(data);
>+    return FutureOfServiceExtensionResponse().value(new developer.ServiceExtensionResponse.result(jsonValue));
>+  }
>+  getFileInfoMap() {
>+    return this.fullValueMap;
>+  }
>+  static getFileInfoMapByID(func, params) {
>+    if (!dart.dassert(dart.dsend(params, 'containsKey', ["id"]))) dart.assertFailed(null, "dart:io/io_resource_info.dart", 126, 12, "params.containsKey('id')");
>+    let id = core.int.parse(core.String._check(dart.dindex(params, "id")));
>+    let result = dart.test(io._FileResourceInfo.openFiles[$containsKey](id)) ? io._FileResourceInfo.openFiles[$_get](id).getFileInfoMap() : new _js_helper.LinkedMap.new();
>+    let jsonValue = convert.json.encode(result);
>+    return FutureOfServiceExtensionResponse().value(new developer.ServiceExtensionResponse.result(jsonValue));
>+  }
>+  get name() {
>+    return dart.str(dart.dload(this.file, 'path'));
>+  }
>+};
>+(io._FileResourceInfo.new = function(file) {
>+  this.file = file;
>+  io._FileResourceInfo.__proto__.new.call(this, "_file");
>+  io._FileResourceInfo.FileOpened(this);
>+}).prototype = io._FileResourceInfo.prototype;
>+dart.addTypeTests(io._FileResourceInfo);
>+dart.setMethodSignature(io._FileResourceInfo, () => ({
>+  __proto__: dart.getMethods(io._FileResourceInfo.__proto__),
>+  getFileInfoMap: dart.fnType(core.Map$(core.String, dart.dynamic), [])
>+}));
>+dart.setGetterSignature(io._FileResourceInfo, () => ({
>+  __proto__: dart.getGetters(io._FileResourceInfo.__proto__),
>+  name: core.String
>+}));
>+dart.setLibraryUri(io._FileResourceInfo, "dart:io");
>+dart.setFieldSignature(io._FileResourceInfo, () => ({
>+  __proto__: dart.getFields(io._FileResourceInfo.__proto__),
>+  file: dart.finalFieldType(dart.dynamic)
>+}));
>+dart.defineLazy(io._FileResourceInfo, {
>+  /*io._FileResourceInfo._type*/get _type() {
>+    return "_file";
>+  },
>+  /*io._FileResourceInfo.openFiles*/get openFiles() {
>+    return new (IdentityMapOfint$_FileResourceInfo()).new();
>+  },
>+  set openFiles(_) {}
>+});
>+const _arguments$0 = dart.privateName(io, "_arguments");
>+const _workingDirectory = dart.privateName(io, "_workingDirectory");
>+io._ProcessResourceInfo = class _ProcessResourceInfo extends io._IOResourceInfo {
>+  get name() {
>+    return core.String._check(dart.dload(this.process, _path));
>+  }
>+  stopped() {
>+    io._ProcessResourceInfo.ProcessStopped(this);
>+  }
>+  get fullValueMap() {
>+    return new (IdentityMapOfString$dynamic()).from(["type", this.type, "id", this.id, "name", this.name, "pid", dart.dload(this.process, 'pid'), "startedAt", this.startedAt, "arguments", dart.dload(this.process, _arguments$0), "workingDirectory", dart.dload(this.process, _workingDirectory) == null ? "." : dart.dload(this.process, _workingDirectory)]);
>+  }
>+  static ProcessStarted(info) {
>+    if (!!dart.test(io._ProcessResourceInfo.startedProcesses[$containsKey](info.id))) dart.assertFailed(null, "dart:io/io_resource_info.dart", 171, 12, "!startedProcesses.containsKey(info.id)");
>+    io._ProcessResourceInfo.startedProcesses[$_set](info.id, info);
>+  }
>+  static ProcessStopped(info) {
>+    if (!dart.test(io._ProcessResourceInfo.startedProcesses[$containsKey](info.id))) dart.assertFailed(null, "dart:io/io_resource_info.dart", 176, 12, "startedProcesses.containsKey(info.id)");
>+    io._ProcessResourceInfo.startedProcesses[$remove](info.id);
>+  }
>+  static getStartedProcessesList() {
>+    return ListOfMapOfString$dynamic().from(io._ProcessResourceInfo.startedProcesses[$values][$map](dart.dynamic, dart.fn(e => e.referenceValueMap, _ProcessResourceInfoToMapOfString$dynamic())));
>+  }
>+  static getStartedProcesses(func, params) {
>+    if (!(func === "ext.dart.io.getProcesses")) dart.assertFailed(null, "dart:io/io_resource_info.dart", 185, 12, "function == 'ext.dart.io.getProcesses'");
>+    let data = new (IdentityMapOfString$Object()).from(["type", "_startedprocesses", "data", io._ProcessResourceInfo.getStartedProcessesList()]);
>+    let jsonValue = convert.json.encode(data);
>+    return FutureOfServiceExtensionResponse().value(new developer.ServiceExtensionResponse.result(jsonValue));
>+  }
>+  static getProcessInfoMapById(func, params) {
>+    let id = core.int.parse(params[$_get]("id"));
>+    let result = dart.test(io._ProcessResourceInfo.startedProcesses[$containsKey](id)) ? io._ProcessResourceInfo.startedProcesses[$_get](id).fullValueMap : new _js_helper.LinkedMap.new();
>+    let jsonValue = convert.json.encode(result);
>+    return FutureOfServiceExtensionResponse().value(new developer.ServiceExtensionResponse.result(jsonValue));
>+  }
>+};
>+(io._ProcessResourceInfo.new = function(process) {
>+  this.process = process;
>+  this.startedAt = io._IOResourceInfo.timestamp;
>+  io._ProcessResourceInfo.__proto__.new.call(this, "_process");
>+  io._ProcessResourceInfo.ProcessStarted(this);
>+}).prototype = io._ProcessResourceInfo.prototype;
>+dart.addTypeTests(io._ProcessResourceInfo);
>+dart.setMethodSignature(io._ProcessResourceInfo, () => ({
>+  __proto__: dart.getMethods(io._ProcessResourceInfo.__proto__),
>+  stopped: dart.fnType(dart.void, [])
>+}));
>+dart.setGetterSignature(io._ProcessResourceInfo, () => ({
>+  __proto__: dart.getGetters(io._ProcessResourceInfo.__proto__),
>+  name: core.String,
>+  fullValueMap: core.Map$(core.String, dart.dynamic)
>+}));
>+dart.setLibraryUri(io._ProcessResourceInfo, "dart:io");
>+dart.setFieldSignature(io._ProcessResourceInfo, () => ({
>+  __proto__: dart.getFields(io._ProcessResourceInfo.__proto__),
>+  process: dart.finalFieldType(dart.dynamic),
>+  startedAt: dart.finalFieldType(core.double)
>+}));
>+dart.defineLazy(io._ProcessResourceInfo, {
>+  /*io._ProcessResourceInfo._type*/get _type() {
>+    return "_process";
>+  },
>+  /*io._ProcessResourceInfo.startedProcesses*/get startedProcesses() {
>+    return new (IdentityMapOfint$_ProcessResourceInfo()).new();
>+  },
>+  set startedProcesses(_) {}
>+});
>+io._SocketResourceInfo = class _SocketResourceInfo extends io._ReadWriteResourceInfo {
>+  get name() {
>+    if (dart.dtest(dart.dload(this.socket, 'isListening'))) {
>+      return "listening:" + dart.str(dart.dload(dart.dload(this.socket, 'address'), 'host')) + ":" + dart.str(dart.dload(this.socket, 'port'));
>+    }
>+    let remote = "";
>+    try {
>+      let remoteHost = dart.dload(dart.dload(this.socket, 'remoteAddress'), 'host');
>+      let remotePort = dart.dload(this.socket, 'remotePort');
>+      remote = " -> " + dart.str(remoteHost) + ":" + dart.str(remotePort);
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+    }
>+    return dart.str(dart.dload(dart.dload(this.socket, 'address'), 'host')) + ":" + dart.str(dart.dload(this.socket, 'port')) + remote;
>+  }
>+  static getOpenSocketsList() {
>+    return ListOfMapOfString$dynamic().from(io._SocketResourceInfo.openSockets[$values][$map](dart.dynamic, dart.fn(e => e.referenceValueMap, _SocketResourceInfoToMapOfString$dynamic())));
>+  }
>+  getSocketInfoMap() {
>+    let result = this.fullValueMap;
>+    result[$_set]("socketType", dart.dtest(dart.dload(this.socket, 'isTcp')) ? "TCP" : "UDP");
>+    result[$_set]("listening", dart.dload(this.socket, 'isListening'));
>+    result[$_set]("host", dart.dload(dart.dload(this.socket, 'address'), 'host'));
>+    result[$_set]("port", dart.dload(this.socket, 'port'));
>+    if (!dart.dtest(dart.dload(this.socket, 'isListening'))) {
>+      try {
>+        result[$_set]("remoteHost", dart.dload(dart.dload(this.socket, 'remoteAddress'), 'host'));
>+        result[$_set]("remotePort", dart.dload(this.socket, 'remotePort'));
>+      } catch (e$) {
>+        let e = dart.getThrown(e$);
>+        result[$_set]("remotePort", "NA");
>+        result[$_set]("remoteHost", "NA");
>+      }
>+    } else {
>+      result[$_set]("remotePort", "NA");
>+      result[$_set]("remoteHost", "NA");
>+    }
>+    result[$_set]("addressType", dart.dload(dart.dload(dart.dload(this.socket, 'address'), 'type'), 'name'));
>+    return result;
>+  }
>+  static getSocketInfoMapByID(func, params) {
>+    if (!dart.test(params[$containsKey]("id"))) dart.assertFailed(null, "dart:io/io_resource_info.dart", 258, 12, "params.containsKey('id')");
>+    let id = core.int.parse(params[$_get]("id"));
>+    let result = dart.test(io._SocketResourceInfo.openSockets[$containsKey](id)) ? io._SocketResourceInfo.openSockets[$_get](id).getSocketInfoMap() : new _js_helper.LinkedMap.new();
>+    let jsonValue = convert.json.encode(result);
>+    return FutureOfServiceExtensionResponse().value(new developer.ServiceExtensionResponse.result(jsonValue));
>+  }
>+  static getOpenSockets(func, params) {
>+    if (!dart.equals(func, "ext.dart.io.getOpenSockets")) dart.assertFailed(null, "dart:io/io_resource_info.dart", 267, 12, "function == 'ext.dart.io.getOpenSockets'");
>+    let data = new (IdentityMapOfString$Object()).from(["type", "_opensockets", "data", io._SocketResourceInfo.getOpenSocketsList()]);
>+    let jsonValue = convert.json.encode(data);
>+    return FutureOfServiceExtensionResponse().value(new developer.ServiceExtensionResponse.result(jsonValue));
>+  }
>+  static SocketOpened(info) {
>+    if (!!dart.test(io._SocketResourceInfo.openSockets[$containsKey](info.id))) dart.assertFailed(null, "dart:io/io_resource_info.dart", 274, 12, "!openSockets.containsKey(info.id)");
>+    io._SocketResourceInfo.openSockets[$_set](info.id, info);
>+  }
>+  static SocketClosed(info) {
>+    if (!dart.test(io._SocketResourceInfo.openSockets[$containsKey](info.id))) dart.assertFailed(null, "dart:io/io_resource_info.dart", 279, 12, "openSockets.containsKey(info.id)");
>+    io._SocketResourceInfo.openSockets[$remove](info.id);
>+  }
>+};
>+(io._SocketResourceInfo.new = function(socket) {
>+  this.socket = socket;
>+  io._SocketResourceInfo.__proto__.new.call(this, "_socket");
>+  io._SocketResourceInfo.SocketOpened(this);
>+}).prototype = io._SocketResourceInfo.prototype;
>+dart.addTypeTests(io._SocketResourceInfo);
>+dart.setMethodSignature(io._SocketResourceInfo, () => ({
>+  __proto__: dart.getMethods(io._SocketResourceInfo.__proto__),
>+  getSocketInfoMap: dart.fnType(core.Map$(core.String, dart.dynamic), [])
>+}));
>+dart.setGetterSignature(io._SocketResourceInfo, () => ({
>+  __proto__: dart.getGetters(io._SocketResourceInfo.__proto__),
>+  name: core.String
>+}));
>+dart.setLibraryUri(io._SocketResourceInfo, "dart:io");
>+dart.setFieldSignature(io._SocketResourceInfo, () => ({
>+  __proto__: dart.getFields(io._SocketResourceInfo.__proto__),
>+  socket: dart.finalFieldType(dart.dynamic)
>+}));
>+dart.defineLazy(io._SocketResourceInfo, {
>+  /*io._SocketResourceInfo._tcpString*/get _tcpString() {
>+    return "TCP";
>+  },
>+  /*io._SocketResourceInfo._udpString*/get _udpString() {
>+    return "UDP";
>+  },
>+  /*io._SocketResourceInfo._type*/get _type() {
>+    return "_socket";
>+  },
>+  /*io._SocketResourceInfo.openSockets*/get openSockets() {
>+    return new (IdentityMapOfint$_SocketResourceInfo()).new();
>+  },
>+  set openSockets(_) {}
>+});
>+io.IOSink = class IOSink extends core.Object {
>+  static new(target, opts) {
>+    let encoding = opts && 'encoding' in opts ? opts.encoding : convert.utf8;
>+    return new io._IOSinkImpl.new(target, encoding);
>+  }
>+  get encoding() {
>+    return this[encoding];
>+  }
>+  set encoding(value) {
>+    this[encoding] = value;
>+  }
>+};
>+(io.IOSink[dart.mixinNew] = function() {
>+  this[encoding] = null;
>+}).prototype = io.IOSink.prototype;
>+dart.addTypeTests(io.IOSink);
>+const encoding = Symbol("IOSink.encoding");
>+io.IOSink[dart.implements] = () => [StreamSinkOfListOfint(), core.StringSink];
>+dart.setLibraryUri(io.IOSink, "dart:io");
>+dart.setFieldSignature(io.IOSink, () => ({
>+  __proto__: dart.getFields(io.IOSink.__proto__),
>+  encoding: dart.fieldType(convert.Encoding)
>+}));
>+const _target$ = dart.privateName(io, "_target");
>+const _doneCompleter = dart.privateName(io, "_doneCompleter");
>+const _controllerInstance = dart.privateName(io, "_controllerInstance");
>+const _controllerCompleter = dart.privateName(io, "_controllerCompleter");
>+const _isClosed$ = dart.privateName(io, "_isClosed");
>+const _isBound = dart.privateName(io, "_isBound");
>+const _hasError$ = dart.privateName(io, "_hasError");
>+const _closeTarget = dart.privateName(io, "_closeTarget");
>+const _completeDoneValue = dart.privateName(io, "_completeDoneValue");
>+const _completeDoneError = dart.privateName(io, "_completeDoneError");
>+const _is__StreamSinkImpl_default = Symbol('_is__StreamSinkImpl_default');
>+io._StreamSinkImpl$ = dart.generic(T => {
>+  let StreamOfT = () => (StreamOfT = dart.constFn(async.Stream$(T)))();
>+  let StreamControllerOfT = () => (StreamControllerOfT = dart.constFn(async.StreamController$(T)))();
>+  let StreamSinkOfT = () => (StreamSinkOfT = dart.constFn(async.StreamSink$(T)))();
>+  let StreamConsumerOfT = () => (StreamConsumerOfT = dart.constFn(async.StreamConsumer$(T)))();
>+  class _StreamSinkImpl extends core.Object {
>+    add(data) {
>+      T._check(data);
>+      if (dart.test(this[_isClosed$])) {
>+        dart.throw(new core.StateError.new("StreamSink is closed"));
>+      }
>+      this[_controller$].add(data);
>+    }
>+    addError(error, stackTrace) {
>+      if (stackTrace === void 0) stackTrace = null;
>+      if (dart.test(this[_isClosed$])) {
>+        dart.throw(new core.StateError.new("StreamSink is closed"));
>+      }
>+      this[_controller$].addError(error, stackTrace);
>+    }
>+    addStream(stream) {
>+      StreamOfT()._check(stream);
>+      if (dart.test(this[_isBound])) {
>+        dart.throw(new core.StateError.new("StreamSink is already bound to a stream"));
>+      }
>+      if (dart.test(this[_hasError$])) return this.done;
>+      this[_isBound] = true;
>+      let future = this[_controllerCompleter] == null ? this[_target$].addStream(stream) : this[_controllerCompleter].future.then(dart.dynamic, dart.fn(_ => this[_target$].addStream(stream), dynamicToFuture()));
>+      let t = this[_controllerInstance];
>+      t == null ? null : t.close();
>+      return future.whenComplete(dart.fn(() => {
>+        this[_isBound] = false;
>+      }, VoidToNull()));
>+    }
>+    flush() {
>+      if (dart.test(this[_isBound])) {
>+        dart.throw(new core.StateError.new("StreamSink is bound to a stream"));
>+      }
>+      if (this[_controllerInstance] == null) return async.Future.value(this);
>+      this[_isBound] = true;
>+      let future = this[_controllerCompleter].future;
>+      this[_controllerInstance].close();
>+      return future.whenComplete(dart.fn(() => {
>+        this[_isBound] = false;
>+      }, VoidToNull()));
>+    }
>+    close() {
>+      if (dart.test(this[_isBound])) {
>+        dart.throw(new core.StateError.new("StreamSink is bound to a stream"));
>+      }
>+      if (!dart.test(this[_isClosed$])) {
>+        this[_isClosed$] = true;
>+        if (this[_controllerInstance] != null) {
>+          this[_controllerInstance].close();
>+        } else {
>+          this[_closeTarget]();
>+        }
>+      }
>+      return this.done;
>+    }
>+    [_closeTarget]() {
>+      this[_target$].close().then(dart.void, dart.bind(this, _completeDoneValue), {onError: dart.bind(this, _completeDoneError)});
>+    }
>+    get done() {
>+      return this[_doneCompleter].future;
>+    }
>+    [_completeDoneValue](value) {
>+      if (!dart.test(this[_doneCompleter].isCompleted)) {
>+        this[_doneCompleter].complete(value);
>+      }
>+    }
>+    [_completeDoneError](error, stackTrace) {
>+      if (!dart.test(this[_doneCompleter].isCompleted)) {
>+        this[_hasError$] = true;
>+        this[_doneCompleter].completeError(error, stackTrace);
>+      }
>+    }
>+    get [_controller$]() {
>+      if (dart.test(this[_isBound])) {
>+        dart.throw(new core.StateError.new("StreamSink is bound to a stream"));
>+      }
>+      if (dart.test(this[_isClosed$])) {
>+        dart.throw(new core.StateError.new("StreamSink is closed"));
>+      }
>+      if (this[_controllerInstance] == null) {
>+        this[_controllerInstance] = StreamControllerOfT().new({sync: true});
>+        this[_controllerCompleter] = async.Completer.new();
>+        FutureOfNull()._check(this[_target$].addStream(this[_controller$].stream).then(core.Null, dart.fn(_ => {
>+          if (dart.test(this[_isBound])) {
>+            this[_controllerCompleter].complete(this);
>+            this[_controllerCompleter] = null;
>+            this[_controllerInstance] = null;
>+          } else {
>+            this[_closeTarget]();
>+          }
>+        }, dynamicToNull()), {onError: dart.fn((error, stackTrace) => {
>+            if (dart.test(this[_isBound])) {
>+              this[_controllerCompleter].completeError(error, core.StackTrace._check(stackTrace));
>+              this[_controllerCompleter] = null;
>+              this[_controllerInstance] = null;
>+            } else {
>+              this[_completeDoneError](error, core.StackTrace._check(stackTrace));
>+            }
>+          }, dynamicAnddynamicToNull())}));
>+      }
>+      return this[_controllerInstance];
>+    }
>+  }
>+  (_StreamSinkImpl.new = function(target) {
>+    this[_doneCompleter] = async.Completer.new();
>+    this[_controllerInstance] = null;
>+    this[_controllerCompleter] = null;
>+    this[_isClosed$] = false;
>+    this[_isBound] = false;
>+    this[_hasError$] = false;
>+    this[_target$] = target;
>+  }).prototype = _StreamSinkImpl.prototype;
>+  dart.addTypeTests(_StreamSinkImpl);
>+  _StreamSinkImpl.prototype[_is__StreamSinkImpl_default] = true;
>+  _StreamSinkImpl[dart.implements] = () => [StreamSinkOfT()];
>+  dart.setMethodSignature(_StreamSinkImpl, () => ({
>+    __proto__: dart.getMethods(_StreamSinkImpl.__proto__),
>+    add: dart.fnType(dart.void, [core.Object]),
>+    addError: dart.fnType(dart.void, [core.Object], [core.StackTrace]),
>+    addStream: dart.fnType(async.Future, [core.Object]),
>+    flush: dart.fnType(async.Future, []),
>+    close: dart.fnType(async.Future, []),
>+    [_closeTarget]: dart.fnType(dart.void, []),
>+    [_completeDoneValue]: dart.fnType(dart.void, [dart.dynamic]),
>+    [_completeDoneError]: dart.fnType(dart.void, [dart.dynamic, core.StackTrace])
>+  }));
>+  dart.setGetterSignature(_StreamSinkImpl, () => ({
>+    __proto__: dart.getGetters(_StreamSinkImpl.__proto__),
>+    done: async.Future,
>+    [_controller$]: async.StreamController$(T)
>+  }));
>+  dart.setLibraryUri(_StreamSinkImpl, "dart:io");
>+  dart.setFieldSignature(_StreamSinkImpl, () => ({
>+    __proto__: dart.getFields(_StreamSinkImpl.__proto__),
>+    [_target$]: dart.finalFieldType(StreamConsumerOfT()),
>+    [_doneCompleter]: dart.finalFieldType(async.Completer),
>+    [_controllerInstance]: dart.fieldType(StreamControllerOfT()),
>+    [_controllerCompleter]: dart.fieldType(async.Completer),
>+    [_isClosed$]: dart.fieldType(core.bool),
>+    [_isBound]: dart.fieldType(core.bool),
>+    [_hasError$]: dart.fieldType(core.bool)
>+  }));
>+  return _StreamSinkImpl;
>+});
>+io._StreamSinkImpl = io._StreamSinkImpl$();
>+dart.addTypeTests(io._StreamSinkImpl, _is__StreamSinkImpl_default);
>+const _encoding = dart.privateName(io, "_encoding");
>+const _encodingMutable = dart.privateName(io, "_encodingMutable");
>+io._IOSinkImpl = class _IOSinkImpl extends io._StreamSinkImpl$(core.List$(core.int)) {
>+  get encoding() {
>+    return this[_encoding];
>+  }
>+  set encoding(value) {
>+    if (!dart.test(this[_encodingMutable])) {
>+      dart.throw(new core.StateError.new("IOSink encoding is not mutable"));
>+    }
>+    this[_encoding] = value;
>+  }
>+  write(obj) {
>+    let string = dart.str(obj);
>+    if (string[$isEmpty]) return;
>+    this.add(this[_encoding].encode(string));
>+  }
>+  writeAll(objects, separator) {
>+    if (separator === void 0) separator = "";
>+    let iterator = objects[$iterator];
>+    if (!dart.test(iterator.moveNext())) return;
>+    if (separator[$isEmpty]) {
>+      do {
>+        this.write(iterator.current);
>+      } while (dart.test(iterator.moveNext()));
>+    } else {
>+      this.write(iterator.current);
>+      while (dart.test(iterator.moveNext())) {
>+        this.write(separator);
>+        this.write(iterator.current);
>+      }
>+    }
>+  }
>+  writeln(object) {
>+    if (object === void 0) object = "";
>+    this.write(object);
>+    this.write("\n");
>+  }
>+  writeCharCode(charCode) {
>+    this.write(core.String.fromCharCode(charCode));
>+  }
>+};
>+(io._IOSinkImpl.new = function(target, encoding) {
>+  this[_encodingMutable] = true;
>+  this[_encoding] = encoding;
>+  io._IOSinkImpl.__proto__.new.call(this, target);
>+}).prototype = io._IOSinkImpl.prototype;
>+dart.addTypeTests(io._IOSinkImpl);
>+io._IOSinkImpl[dart.implements] = () => [io.IOSink];
>+dart.setMethodSignature(io._IOSinkImpl, () => ({
>+  __proto__: dart.getMethods(io._IOSinkImpl.__proto__),
>+  write: dart.fnType(dart.void, [core.Object]),
>+  writeAll: dart.fnType(dart.void, [core.Iterable], [core.String]),
>+  writeln: dart.fnType(dart.void, [], [core.Object]),
>+  writeCharCode: dart.fnType(dart.void, [core.int])
>+}));
>+dart.setGetterSignature(io._IOSinkImpl, () => ({
>+  __proto__: dart.getGetters(io._IOSinkImpl.__proto__),
>+  encoding: convert.Encoding
>+}));
>+dart.setSetterSignature(io._IOSinkImpl, () => ({
>+  __proto__: dart.getSetters(io._IOSinkImpl.__proto__),
>+  encoding: convert.Encoding
>+}));
>+dart.setLibraryUri(io._IOSinkImpl, "dart:io");
>+dart.setFieldSignature(io._IOSinkImpl, () => ({
>+  __proto__: dart.getFields(io._IOSinkImpl.__proto__),
>+  [_encoding]: dart.fieldType(convert.Encoding),
>+  [_encodingMutable]: dart.fieldType(core.bool)
>+}));
>+io._IOService = class _IOService extends core.Object {
>+  static _dispatch(request, data) {
>+    dart.throw(new core.UnsupportedError.new("_IOService._dispatch"));
>+  }
>+};
>+(io._IOService.new = function() {
>+}).prototype = io._IOService.prototype;
>+dart.addTypeTests(io._IOService);
>+dart.setLibraryUri(io._IOService, "dart:io");
>+dart.defineLazy(io._IOService, {
>+  /*io._IOService.fileExists*/get fileExists() {
>+    return 0;
>+  },
>+  /*io._IOService.fileCreate*/get fileCreate() {
>+    return 1;
>+  },
>+  /*io._IOService.fileDelete*/get fileDelete() {
>+    return 2;
>+  },
>+  /*io._IOService.fileRename*/get fileRename() {
>+    return 3;
>+  },
>+  /*io._IOService.fileCopy*/get fileCopy() {
>+    return 4;
>+  },
>+  /*io._IOService.fileOpen*/get fileOpen() {
>+    return 5;
>+  },
>+  /*io._IOService.fileResolveSymbolicLinks*/get fileResolveSymbolicLinks() {
>+    return 6;
>+  },
>+  /*io._IOService.fileClose*/get fileClose() {
>+    return 7;
>+  },
>+  /*io._IOService.filePosition*/get filePosition() {
>+    return 8;
>+  },
>+  /*io._IOService.fileSetPosition*/get fileSetPosition() {
>+    return 9;
>+  },
>+  /*io._IOService.fileTruncate*/get fileTruncate() {
>+    return 10;
>+  },
>+  /*io._IOService.fileLength*/get fileLength() {
>+    return 11;
>+  },
>+  /*io._IOService.fileLengthFromPath*/get fileLengthFromPath() {
>+    return 12;
>+  },
>+  /*io._IOService.fileLastAccessed*/get fileLastAccessed() {
>+    return 13;
>+  },
>+  /*io._IOService.fileSetLastAccessed*/get fileSetLastAccessed() {
>+    return 14;
>+  },
>+  /*io._IOService.fileLastModified*/get fileLastModified() {
>+    return 15;
>+  },
>+  /*io._IOService.fileSetLastModified*/get fileSetLastModified() {
>+    return 16;
>+  },
>+  /*io._IOService.fileFlush*/get fileFlush() {
>+    return 17;
>+  },
>+  /*io._IOService.fileReadByte*/get fileReadByte() {
>+    return 18;
>+  },
>+  /*io._IOService.fileWriteByte*/get fileWriteByte() {
>+    return 19;
>+  },
>+  /*io._IOService.fileRead*/get fileRead() {
>+    return 20;
>+  },
>+  /*io._IOService.fileReadInto*/get fileReadInto() {
>+    return 21;
>+  },
>+  /*io._IOService.fileWriteFrom*/get fileWriteFrom() {
>+    return 22;
>+  },
>+  /*io._IOService.fileCreateLink*/get fileCreateLink() {
>+    return 23;
>+  },
>+  /*io._IOService.fileDeleteLink*/get fileDeleteLink() {
>+    return 24;
>+  },
>+  /*io._IOService.fileRenameLink*/get fileRenameLink() {
>+    return 25;
>+  },
>+  /*io._IOService.fileLinkTarget*/get fileLinkTarget() {
>+    return 26;
>+  },
>+  /*io._IOService.fileType*/get fileType() {
>+    return 27;
>+  },
>+  /*io._IOService.fileIdentical*/get fileIdentical() {
>+    return 28;
>+  },
>+  /*io._IOService.fileStat*/get fileStat() {
>+    return 29;
>+  },
>+  /*io._IOService.fileLock*/get fileLock() {
>+    return 30;
>+  },
>+  /*io._IOService.socketLookup*/get socketLookup() {
>+    return 31;
>+  },
>+  /*io._IOService.socketListInterfaces*/get socketListInterfaces() {
>+    return 32;
>+  },
>+  /*io._IOService.socketReverseLookup*/get socketReverseLookup() {
>+    return 33;
>+  },
>+  /*io._IOService.directoryCreate*/get directoryCreate() {
>+    return 34;
>+  },
>+  /*io._IOService.directoryDelete*/get directoryDelete() {
>+    return 35;
>+  },
>+  /*io._IOService.directoryExists*/get directoryExists() {
>+    return 36;
>+  },
>+  /*io._IOService.directoryCreateTemp*/get directoryCreateTemp() {
>+    return 37;
>+  },
>+  /*io._IOService.directoryListStart*/get directoryListStart() {
>+    return 38;
>+  },
>+  /*io._IOService.directoryListNext*/get directoryListNext() {
>+    return 39;
>+  },
>+  /*io._IOService.directoryListStop*/get directoryListStop() {
>+    return 40;
>+  },
>+  /*io._IOService.directoryRename*/get directoryRename() {
>+    return 41;
>+  },
>+  /*io._IOService.sslProcessFilter*/get sslProcessFilter() {
>+    return 42;
>+  }
>+});
>+io.Link = class Link extends core.Object {
>+  static new(path) {
>+    let overrides = io.IOOverrides.current;
>+    if (overrides == null) {
>+      return new io._Link.new(path);
>+    }
>+    return overrides.createLink(path);
>+  }
>+  static fromRawPath(rawPath) {
>+    return new io._Link.fromRawPath(rawPath);
>+  }
>+  static fromUri(uri) {
>+    return io.Link.new(uri.toFilePath());
>+  }
>+};
>+(io.Link[dart.mixinNew] = function() {
>+}).prototype = io.Link.prototype;
>+dart.addTypeTests(io.Link);
>+io.Link[dart.implements] = () => [io.FileSystemEntity];
>+dart.setLibraryUri(io.Link, "dart:io");
>+const _exceptionFromResponse = dart.privateName(io, "_exceptionFromResponse");
>+io._Link = class _Link extends io.FileSystemEntity {
>+  get [_path]() {
>+    return this[_path$2];
>+  }
>+  set [_path](value) {
>+    this[_path$2] = value;
>+  }
>+  get [_rawPath$]() {
>+    return this[_rawPath$2];
>+  }
>+  set [_rawPath$](value) {
>+    this[_rawPath$2] = value;
>+  }
>+  get path() {
>+    return this[_path];
>+  }
>+  toString() {
>+    return "Link: '" + dart.str(this.path) + "'";
>+  }
>+  exists() {
>+    return io.FileSystemEntity._isLinkRaw(this[_rawPath$]);
>+  }
>+  existsSync() {
>+    return io.FileSystemEntity._isLinkRawSync(this[_rawPath$]);
>+  }
>+  get absolute() {
>+    return io.Link.fromRawPath(this[_rawAbsolutePath]);
>+  }
>+  create(target, opts) {
>+    let recursive = opts && 'recursive' in opts ? opts.recursive : false;
>+    let result = dart.test(recursive) ? this.parent.create({recursive: true}) : FutureOfNull().value(null);
>+    return FutureOfLink()._check(result.then(dart.dynamic, dart.fn(_ => io._File._dispatchWithNamespace(io._IOService.fileCreateLink, [null, this[_rawPath$], target]), DirectoryToFuture())).then(io.Link, dart.fn(response => {
>+      if (dart.test(this[_isErrorResponse](response))) {
>+        dart.throw(this[_exceptionFromResponse](response, "Cannot create link to target '" + dart.str(target) + "'", this.path));
>+      }
>+      return this;
>+    }, dynamicTo_Link())));
>+  }
>+  createSync(target, opts) {
>+    let recursive = opts && 'recursive' in opts ? opts.recursive : false;
>+    if (dart.test(recursive)) {
>+      this.parent.createSync({recursive: true});
>+    }
>+    let result = io._File._createLink(io._Namespace._namespace, this[_rawPath$], target);
>+    io._Link.throwIfError(result, "Cannot create link", this.path);
>+  }
>+  updateSync(target) {
>+    this.deleteSync();
>+    this.createSync(target);
>+  }
>+  update(target) {
>+    return FutureOfLink()._check(this.delete().then(io.Link, dart.fn(_ => this.create(target), FileSystemEntityToFutureOfLink())));
>+  }
>+  [_delete](opts) {
>+    let recursive = opts && 'recursive' in opts ? opts.recursive : false;
>+    if (dart.test(recursive)) {
>+      return FutureOfLink()._check(io.Directory.fromRawPath(this[_rawPath$]).delete({recursive: true}).then(io.Link, dart.fn(_ => this, FileSystemEntityTo_Link())));
>+    }
>+    return FutureOfLink()._check(io._File._dispatchWithNamespace(io._IOService.fileDeleteLink, [null, this[_rawPath$]]).then(io.Link, dart.fn(response => {
>+      if (dart.test(this[_isErrorResponse](response))) {
>+        dart.throw(this[_exceptionFromResponse](response, "Cannot delete link", this.path));
>+      }
>+      return this;
>+    }, dynamicTo_Link())));
>+  }
>+  [_deleteSync](opts) {
>+    let recursive = opts && 'recursive' in opts ? opts.recursive : false;
>+    if (dart.test(recursive)) {
>+      return io.Directory.fromRawPath(this[_rawPath$]).deleteSync({recursive: true});
>+    }
>+    let result = io._File._deleteLinkNative(io._Namespace._namespace, this[_rawPath$]);
>+    io._Link.throwIfError(result, "Cannot delete link", this.path);
>+  }
>+  rename(newPath) {
>+    return FutureOfLink()._check(io._File._dispatchWithNamespace(io._IOService.fileRenameLink, [null, this[_rawPath$], newPath]).then(io.Link, dart.fn(response => {
>+      if (dart.test(this[_isErrorResponse](response))) {
>+        dart.throw(this[_exceptionFromResponse](response, "Cannot rename link to '" + dart.str(newPath) + "'", this.path));
>+      }
>+      return io.Link.new(newPath);
>+    }, dynamicToLink())));
>+  }
>+  renameSync(newPath) {
>+    let result = io._File._renameLink(io._Namespace._namespace, this[_rawPath$], newPath);
>+    io._Link.throwIfError(result, "Cannot rename link '" + dart.str(this.path) + "' to '" + dart.str(newPath) + "'");
>+    return io.Link.new(newPath);
>+  }
>+  target() {
>+    return FutureOfString()._check(io._File._dispatchWithNamespace(io._IOService.fileLinkTarget, [null, this[_rawPath$]]).then(core.String, dart.fn(response => {
>+      if (dart.test(this[_isErrorResponse](response))) {
>+        dart.throw(this[_exceptionFromResponse](response, "Cannot get target of link", this.path));
>+      }
>+      return FutureOrOfString()._check(response);
>+    }, dynamicToFutureOrOfString())));
>+  }
>+  targetSync() {
>+    let result = io._File._linkTarget(io._Namespace._namespace, this[_rawPath$]);
>+    io._Link.throwIfError(result, "Cannot read link", this.path);
>+    return core.String._check(result);
>+  }
>+  static throwIfError(result, msg, path) {
>+    if (path === void 0) path = "";
>+    if (io.OSError.is(result)) {
>+      dart.throw(new io.FileSystemException.new(msg, path, result));
>+    }
>+  }
>+  [_isErrorResponse](response) {
>+    return core.List.is(response) && !dart.equals(response[$_get](0), 0);
>+  }
>+  [_exceptionFromResponse](response, message, path) {
>+    if (!dart.test(this[_isErrorResponse](response))) dart.assertFailed(null, "dart:io/link.dart", 288, 12, "_isErrorResponse(response)");
>+    switch (dart.dindex(response, 0)) {
>+      case 1:
>+      {
>+        return new core.ArgumentError.new();
>+      }
>+      case 2:
>+      {
>+        let err = new io.OSError.new(core.String._check(dart.dindex(response, 2)), core.int._check(dart.dindex(response, 1)));
>+        return new io.FileSystemException.new(message, path, err);
>+      }
>+      default:
>+      {
>+        return core.Exception.new("Unknown error");
>+      }
>+    }
>+  }
>+};
>+(io._Link.new = function(path) {
>+  this[_path$2] = null;
>+  this[_rawPath$2] = null;
>+  io._Link.__proto__.new.call(this);
>+  core.ArgumentError.checkNotNull(path, "path");
>+  this[_path] = path;
>+  this[_rawPath$] = io.FileSystemEntity._toUtf8Array(path);
>+}).prototype = io._Link.prototype;
>+(io._Link.fromRawPath = function(rawPath) {
>+  this[_path$2] = null;
>+  this[_rawPath$2] = null;
>+  io._Link.__proto__.new.call(this);
>+  this[_rawPath$] = io.FileSystemEntity._toNullTerminatedUtf8Array(rawPath);
>+  this[_path] = io.FileSystemEntity._toStringFromUtf8Array(rawPath);
>+}).prototype = io._Link.prototype;
>+dart.addTypeTests(io._Link);
>+const _path$2 = Symbol("_Link._path");
>+const _rawPath$2 = Symbol("_Link._rawPath");
>+io._Link[dart.implements] = () => [io.Link];
>+dart.setMethodSignature(io._Link, () => ({
>+  __proto__: dart.getMethods(io._Link.__proto__),
>+  exists: dart.fnType(async.Future$(core.bool), []),
>+  existsSync: dart.fnType(core.bool, []),
>+  create: dart.fnType(async.Future$(io.Link), [core.String], {recursive: core.bool}),
>+  createSync: dart.fnType(dart.void, [core.String], {recursive: core.bool}),
>+  updateSync: dart.fnType(dart.void, [core.String]),
>+  update: dart.fnType(async.Future$(io.Link), [core.String]),
>+  [_delete]: dart.fnType(async.Future$(io.Link), [], {recursive: core.bool}),
>+  [_deleteSync]: dart.fnType(dart.void, [], {recursive: core.bool}),
>+  rename: dart.fnType(async.Future$(io.Link), [core.String]),
>+  renameSync: dart.fnType(io.Link, [core.String]),
>+  target: dart.fnType(async.Future$(core.String), []),
>+  targetSync: dart.fnType(core.String, []),
>+  [_isErrorResponse]: dart.fnType(core.bool, [dart.dynamic]),
>+  [_exceptionFromResponse]: dart.fnType(dart.dynamic, [dart.dynamic, core.String, core.String])
>+}));
>+dart.setGetterSignature(io._Link, () => ({
>+  __proto__: dart.getGetters(io._Link.__proto__),
>+  path: core.String,
>+  absolute: io.Link
>+}));
>+dart.setLibraryUri(io._Link, "dart:io");
>+dart.setFieldSignature(io._Link, () => ({
>+  __proto__: dart.getFields(io._Link.__proto__),
>+  [_path]: dart.fieldType(core.String),
>+  [_rawPath$]: dart.fieldType(typed_data.Uint8List)
>+}));
>+dart.defineExtensionMethods(io._Link, ['toString']);
>+io._Namespace = class _Namespace extends core.Object {
>+  static get _namespace() {
>+    dart.throw(new core.UnsupportedError.new("_Namespace"));
>+  }
>+  static get _namespacePointer() {
>+    dart.throw(new core.UnsupportedError.new("_Namespace"));
>+  }
>+  static _setupNamespace(namespace) {
>+    dart.throw(new core.UnsupportedError.new("_Namespace"));
>+  }
>+};
>+(io._Namespace.new = function() {
>+}).prototype = io._Namespace.prototype;
>+dart.addTypeTests(io._Namespace);
>+dart.setLibraryUri(io._Namespace, "dart:io");
>+dart.defineLazy(io, {
>+  /*io._ioOverridesToken*/get _ioOverridesToken() {
>+    return new core.Object.new();
>+  },
>+  /*io._asyncRunZoned*/get _asyncRunZoned() {
>+    return dart.fn(async.runZoned, Fn__ToR());
>+  }
>+});
>+io.IOOverrides = class IOOverrides extends core.Object {
>+  static get current() {
>+    return io.IOOverrides._check((() => {
>+      let l = async.Zone.current._get(io._ioOverridesToken);
>+      return l != null ? l : io.IOOverrides._global;
>+    })());
>+  }
>+  static set global(overrides) {
>+    io.IOOverrides._global = overrides;
>+  }
>+  static runZoned(R, body, opts) {
>+    let createDirectory = opts && 'createDirectory' in opts ? opts.createDirectory : null;
>+    let getCurrentDirectory = opts && 'getCurrentDirectory' in opts ? opts.getCurrentDirectory : null;
>+    let setCurrentDirectory = opts && 'setCurrentDirectory' in opts ? opts.setCurrentDirectory : null;
>+    let getSystemTempDirectory = opts && 'getSystemTempDirectory' in opts ? opts.getSystemTempDirectory : null;
>+    let createFile = opts && 'createFile' in opts ? opts.createFile : null;
>+    let stat = opts && 'stat' in opts ? opts.stat : null;
>+    let statSync = opts && 'statSync' in opts ? opts.statSync : null;
>+    let fseIdentical = opts && 'fseIdentical' in opts ? opts.fseIdentical : null;
>+    let fseIdenticalSync = opts && 'fseIdenticalSync' in opts ? opts.fseIdenticalSync : null;
>+    let fseGetType = opts && 'fseGetType' in opts ? opts.fseGetType : null;
>+    let fseGetTypeSync = opts && 'fseGetTypeSync' in opts ? opts.fseGetTypeSync : null;
>+    let fsWatch = opts && 'fsWatch' in opts ? opts.fsWatch : null;
>+    let fsWatchIsSupported = opts && 'fsWatchIsSupported' in opts ? opts.fsWatchIsSupported : null;
>+    let createLink = opts && 'createLink' in opts ? opts.createLink : null;
>+    let socketConnect = opts && 'socketConnect' in opts ? opts.socketConnect : null;
>+    let socketStartConnect = opts && 'socketStartConnect' in opts ? opts.socketStartConnect : null;
>+    let zoneSpecification = opts && 'zoneSpecification' in opts ? opts.zoneSpecification : null;
>+    let onError = opts && 'onError' in opts ? opts.onError : null;
>+    let overrides = new io._IOOverridesScope.new(createDirectory, getCurrentDirectory, setCurrentDirectory, getSystemTempDirectory, createFile, stat, statSync, fseIdentical, fseIdenticalSync, fseGetType, fseGetTypeSync, fsWatch, fsWatchIsSupported, createLink, socketConnect, socketStartConnect);
>+    return io._asyncRunZoned(R, body, {zoneValues: new _js_helper.LinkedMap.from([io._ioOverridesToken, overrides]), zoneSpecification: zoneSpecification, onError: onError});
>+  }
>+  static runWithIOOverrides(R, body, overrides, opts) {
>+    let zoneSpecification = opts && 'zoneSpecification' in opts ? opts.zoneSpecification : null;
>+    let onError = opts && 'onError' in opts ? opts.onError : null;
>+    return io._asyncRunZoned(R, body, {zoneValues: new _js_helper.LinkedMap.from([io._ioOverridesToken, overrides]), zoneSpecification: zoneSpecification, onError: onError});
>+  }
>+  createDirectory(path) {
>+    return new io._Directory.new(path);
>+  }
>+  getCurrentDirectory() {
>+    return io._Directory.current;
>+  }
>+  setCurrentDirectory(path) {
>+    io._Directory.current = path;
>+  }
>+  getSystemTempDirectory() {
>+    return io._Directory.systemTemp;
>+  }
>+  createFile(path) {
>+    return new io._File.new(path);
>+  }
>+  stat(path) {
>+    return io.FileStat._stat(path);
>+  }
>+  statSync(path) {
>+    return io.FileStat._statSyncInternal(path);
>+  }
>+  fseIdentical(path1, path2) {
>+    return io.FileSystemEntity._identical(path1, path2);
>+  }
>+  fseIdenticalSync(path1, path2) {
>+    return io.FileSystemEntity._identicalSync(path1, path2);
>+  }
>+  fseGetType(path, followLinks) {
>+    return io.FileSystemEntity._getTypeRequest(typed_data.Uint8List._check(convert.utf8.encode(path)), followLinks);
>+  }
>+  fseGetTypeSync(path, followLinks) {
>+    return io.FileSystemEntity._getTypeSyncHelper(typed_data.Uint8List._check(convert.utf8.encode(path)), followLinks);
>+  }
>+  fsWatch(path, events, recursive) {
>+    return io._FileSystemWatcher._watch(path, events, recursive);
>+  }
>+  fsWatchIsSupported() {
>+    return io._FileSystemWatcher.isSupported;
>+  }
>+  createLink(path) {
>+    return new io._Link.new(path);
>+  }
>+  socketConnect(host, port, opts) {
>+    let sourceAddress = opts && 'sourceAddress' in opts ? opts.sourceAddress : null;
>+    let timeout = opts && 'timeout' in opts ? opts.timeout : null;
>+    return io.Socket._connect(host, port, {sourceAddress: sourceAddress, timeout: timeout});
>+  }
>+  socketStartConnect(host, port, opts) {
>+    let sourceAddress = opts && 'sourceAddress' in opts ? opts.sourceAddress : null;
>+    return io.Socket._startConnect(host, port, {sourceAddress: sourceAddress});
>+  }
>+};
>+(io.IOOverrides.new = function() {
>+}).prototype = io.IOOverrides.prototype;
>+dart.addTypeTests(io.IOOverrides);
>+dart.setMethodSignature(io.IOOverrides, () => ({
>+  __proto__: dart.getMethods(io.IOOverrides.__proto__),
>+  createDirectory: dart.fnType(io.Directory, [core.String]),
>+  getCurrentDirectory: dart.fnType(io.Directory, []),
>+  setCurrentDirectory: dart.fnType(dart.void, [core.String]),
>+  getSystemTempDirectory: dart.fnType(io.Directory, []),
>+  createFile: dart.fnType(io.File, [core.String]),
>+  stat: dart.fnType(async.Future$(io.FileStat), [core.String]),
>+  statSync: dart.fnType(io.FileStat, [core.String]),
>+  fseIdentical: dart.fnType(async.Future$(core.bool), [core.String, core.String]),
>+  fseIdenticalSync: dart.fnType(core.bool, [core.String, core.String]),
>+  fseGetType: dart.fnType(async.Future$(io.FileSystemEntityType), [core.String, core.bool]),
>+  fseGetTypeSync: dart.fnType(io.FileSystemEntityType, [core.String, core.bool]),
>+  fsWatch: dart.fnType(async.Stream$(io.FileSystemEvent), [core.String, core.int, core.bool]),
>+  fsWatchIsSupported: dart.fnType(core.bool, []),
>+  createLink: dart.fnType(io.Link, [core.String]),
>+  socketConnect: dart.fnType(async.Future$(io.Socket), [dart.dynamic, core.int], {sourceAddress: dart.dynamic, timeout: core.Duration}),
>+  socketStartConnect: dart.fnType(async.Future$(io.ConnectionTask$(io.Socket)), [dart.dynamic, core.int], {sourceAddress: dart.dynamic})
>+}));
>+dart.setLibraryUri(io.IOOverrides, "dart:io");
>+dart.defineLazy(io.IOOverrides, {
>+  /*io.IOOverrides._global*/get _global() {
>+    return null;
>+  },
>+  set _global(_) {}
>+});
>+const _createDirectory = dart.privateName(io, "_createDirectory");
>+const _getCurrentDirectory = dart.privateName(io, "_getCurrentDirectory");
>+const _setCurrentDirectory = dart.privateName(io, "_setCurrentDirectory");
>+const _getSystemTempDirectory = dart.privateName(io, "_getSystemTempDirectory");
>+const _createFile = dart.privateName(io, "_createFile");
>+const _stat = dart.privateName(io, "_stat");
>+const _statSync = dart.privateName(io, "_statSync");
>+const _fseIdentical = dart.privateName(io, "_fseIdentical");
>+const _fseIdenticalSync = dart.privateName(io, "_fseIdenticalSync");
>+const _fseGetType = dart.privateName(io, "_fseGetType");
>+const _fseGetTypeSync = dart.privateName(io, "_fseGetTypeSync");
>+const _fsWatch = dart.privateName(io, "_fsWatch");
>+const _fsWatchIsSupported = dart.privateName(io, "_fsWatchIsSupported");
>+const _createLink = dart.privateName(io, "_createLink");
>+const _socketConnect = dart.privateName(io, "_socketConnect");
>+const _socketStartConnect = dart.privateName(io, "_socketStartConnect");
>+const _previous$1 = dart.privateName(io, "_previous");
>+io._IOOverridesScope = class _IOOverridesScope extends io.IOOverrides {
>+  createDirectory(path) {
>+    if (this[_createDirectory] != null) return this[_createDirectory](path);
>+    if (this[_previous$1] != null) return this[_previous$1].createDirectory(path);
>+    return super.createDirectory(path);
>+  }
>+  getCurrentDirectory() {
>+    if (this[_getCurrentDirectory] != null) return this[_getCurrentDirectory]();
>+    if (this[_previous$1] != null) return this[_previous$1].getCurrentDirectory();
>+    return super.getCurrentDirectory();
>+  }
>+  setCurrentDirectory(path) {
>+    if (this[_setCurrentDirectory] != null)
>+      this[_setCurrentDirectory](path);
>+    else if (this[_previous$1] != null)
>+      this[_previous$1].setCurrentDirectory(path);
>+    else
>+      super.setCurrentDirectory(path);
>+  }
>+  getSystemTempDirectory() {
>+    if (this[_getSystemTempDirectory] != null) return this[_getSystemTempDirectory]();
>+    if (this[_previous$1] != null) return this[_previous$1].getSystemTempDirectory();
>+    return super.getSystemTempDirectory();
>+  }
>+  createFile(path) {
>+    if (this[_createFile] != null) return this[_createFile](path);
>+    if (this[_previous$1] != null) return this[_previous$1].createFile(path);
>+    return super.createFile(path);
>+  }
>+  stat(path) {
>+    if (this[_stat] != null) return this[_stat](path);
>+    if (this[_previous$1] != null) return this[_previous$1].stat(path);
>+    return super.stat(path);
>+  }
>+  statSync(path) {
>+    if (this[_stat] != null) return this[_statSync](path);
>+    if (this[_previous$1] != null) return this[_previous$1].statSync(path);
>+    return super.statSync(path);
>+  }
>+  fseIdentical(path1, path2) {
>+    if (this[_fseIdentical] != null) return this[_fseIdentical](path1, path2);
>+    if (this[_previous$1] != null) return this[_previous$1].fseIdentical(path1, path2);
>+    return super.fseIdentical(path1, path2);
>+  }
>+  fseIdenticalSync(path1, path2) {
>+    if (this[_fseIdenticalSync] != null) return this[_fseIdenticalSync](path1, path2);
>+    if (this[_previous$1] != null) return this[_previous$1].fseIdenticalSync(path1, path2);
>+    return super.fseIdenticalSync(path1, path2);
>+  }
>+  fseGetType(path, followLinks) {
>+    if (this[_fseGetType] != null) return this[_fseGetType](path, followLinks);
>+    if (this[_previous$1] != null) return this[_previous$1].fseGetType(path, followLinks);
>+    return super.fseGetType(path, followLinks);
>+  }
>+  fseGetTypeSync(path, followLinks) {
>+    if (this[_fseGetTypeSync] != null) return this[_fseGetTypeSync](path, followLinks);
>+    if (this[_previous$1] != null) return this[_previous$1].fseGetTypeSync(path, followLinks);
>+    return super.fseGetTypeSync(path, followLinks);
>+  }
>+  fsWatch(path, events, recursive) {
>+    if (this[_fsWatch] != null) return this[_fsWatch](path, events, recursive);
>+    if (this[_previous$1] != null) return this[_previous$1].fsWatch(path, events, recursive);
>+    return super.fsWatch(path, events, recursive);
>+  }
>+  fsWatchIsSupported() {
>+    if (this[_fsWatchIsSupported] != null) return this[_fsWatchIsSupported]();
>+    if (this[_previous$1] != null) return this[_previous$1].fsWatchIsSupported();
>+    return super.fsWatchIsSupported();
>+  }
>+  createLink(path) {
>+    if (this[_createLink] != null) return this[_createLink](path);
>+    if (this[_previous$1] != null) return this[_previous$1].createLink(path);
>+    return super.createLink(path);
>+  }
>+  socketConnect(host, port, opts) {
>+    let sourceAddress = opts && 'sourceAddress' in opts ? opts.sourceAddress : null;
>+    let timeout = opts && 'timeout' in opts ? opts.timeout : null;
>+    if (this[_socketConnect] != null) {
>+      return this[_socketConnect](host, port, {sourceAddress: sourceAddress, timeout: timeout});
>+    }
>+    if (this[_previous$1] != null) {
>+      return this[_previous$1].socketConnect(host, port, {sourceAddress: sourceAddress, timeout: timeout});
>+    }
>+    return super.socketConnect(host, port, {sourceAddress: sourceAddress, timeout: timeout});
>+  }
>+  socketStartConnect(host, port, opts) {
>+    let sourceAddress = opts && 'sourceAddress' in opts ? opts.sourceAddress : null;
>+    if (this[_socketStartConnect] != null) {
>+      return this[_socketStartConnect](host, port, {sourceAddress: sourceAddress});
>+    }
>+    if (this[_previous$1] != null) {
>+      return this[_previous$1].socketStartConnect(host, port, {sourceAddress: sourceAddress});
>+    }
>+    return super.socketStartConnect(host, port, {sourceAddress: sourceAddress});
>+  }
>+};
>+(io._IOOverridesScope.new = function(createDirectory, getCurrentDirectory, setCurrentDirectory, getSystemTempDirectory, createFile, stat, statSync, fseIdentical, fseIdenticalSync, fseGetType, fseGetTypeSync, fsWatch, fsWatchIsSupported, createLink, socketConnect, socketStartConnect) {
>+  this[_previous$1] = io.IOOverrides.current;
>+  this[_createDirectory] = createDirectory;
>+  this[_getCurrentDirectory] = getCurrentDirectory;
>+  this[_setCurrentDirectory] = setCurrentDirectory;
>+  this[_getSystemTempDirectory] = getSystemTempDirectory;
>+  this[_createFile] = createFile;
>+  this[_stat] = stat;
>+  this[_statSync] = statSync;
>+  this[_fseIdentical] = fseIdentical;
>+  this[_fseIdenticalSync] = fseIdenticalSync;
>+  this[_fseGetType] = fseGetType;
>+  this[_fseGetTypeSync] = fseGetTypeSync;
>+  this[_fsWatch] = fsWatch;
>+  this[_fsWatchIsSupported] = fsWatchIsSupported;
>+  this[_createLink] = createLink;
>+  this[_socketConnect] = socketConnect;
>+  this[_socketStartConnect] = socketStartConnect;
>+}).prototype = io._IOOverridesScope.prototype;
>+dart.addTypeTests(io._IOOverridesScope);
>+dart.setLibraryUri(io._IOOverridesScope, "dart:io");
>+dart.setFieldSignature(io._IOOverridesScope, () => ({
>+  __proto__: dart.getFields(io._IOOverridesScope.__proto__),
>+  [_previous$1]: dart.finalFieldType(io.IOOverrides),
>+  [_createDirectory]: dart.fieldType(StringToDirectory()),
>+  [_getCurrentDirectory]: dart.fieldType(VoidToDirectory()),
>+  [_setCurrentDirectory]: dart.fieldType(StringTovoid()),
>+  [_getSystemTempDirectory]: dart.fieldType(VoidToDirectory()),
>+  [_createFile]: dart.fieldType(StringToFile()),
>+  [_stat]: dart.fieldType(StringToFutureOfFileStat()),
>+  [_statSync]: dart.fieldType(StringToFileStat()),
>+  [_fseIdentical]: dart.fieldType(StringAndStringToFutureOfbool()),
>+  [_fseIdenticalSync]: dart.fieldType(StringAndStringTobool()),
>+  [_fseGetType]: dart.fieldType(StringAndboolToFutureOfFileSystemEntityType()),
>+  [_fseGetTypeSync]: dart.fieldType(StringAndboolToFileSystemEntityType()),
>+  [_fsWatch]: dart.fieldType(StringAndintAndboolToStreamOfFileSystemEvent()),
>+  [_fsWatchIsSupported]: dart.fieldType(VoidTobool()),
>+  [_createLink]: dart.fieldType(StringToLink()),
>+  [_socketConnect]: dart.fieldType(dynamicAndint__ToFutureOfSocket()),
>+  [_socketStartConnect]: dart.fieldType(dynamicAndint__ToFutureOfConnectionTaskOfSocket())
>+}));
>+io.Platform = class Platform extends core.Object {
>+  static get numberOfProcessors() {
>+    return io.Platform._numberOfProcessors;
>+  }
>+  static get pathSeparator() {
>+    return io.Platform._pathSeparator;
>+  }
>+  static get localeName() {
>+    return io._Platform.localeName();
>+  }
>+  static get operatingSystem() {
>+    return io.Platform._operatingSystem;
>+  }
>+  static get operatingSystemVersion() {
>+    return io.Platform._operatingSystemVersion;
>+  }
>+  static get localHostname() {
>+    return io.Platform._localHostname;
>+  }
>+  static get environment() {
>+    return io._Platform.environment;
>+  }
>+  static get executable() {
>+    return io._Platform.executable;
>+  }
>+  static get resolvedExecutable() {
>+    return io._Platform.resolvedExecutable;
>+  }
>+  static get script() {
>+    return io._Platform.script;
>+  }
>+  static get executableArguments() {
>+    return io._Platform.executableArguments;
>+  }
>+  static get packageRoot() {
>+    return null;
>+  }
>+  static get packageConfig() {
>+    return io._Platform.packageConfig;
>+  }
>+  static get version() {
>+    return io.Platform._version;
>+  }
>+};
>+(io.Platform.new = function() {
>+}).prototype = io.Platform.prototype;
>+dart.addTypeTests(io.Platform);
>+dart.setLibraryUri(io.Platform, "dart:io");
>+dart.defineLazy(io.Platform, {
>+  /*io.Platform._numberOfProcessors*/get _numberOfProcessors() {
>+    return io._Platform.numberOfProcessors;
>+  },
>+  /*io.Platform._pathSeparator*/get _pathSeparator() {
>+    return io._Platform.pathSeparator;
>+  },
>+  /*io.Platform._operatingSystem*/get _operatingSystem() {
>+    return io._Platform.operatingSystem;
>+  },
>+  /*io.Platform._operatingSystemVersion*/get _operatingSystemVersion() {
>+    return io._Platform.operatingSystemVersion;
>+  },
>+  /*io.Platform._localHostname*/get _localHostname() {
>+    return io._Platform.localHostname;
>+  },
>+  /*io.Platform._version*/get _version() {
>+    return io._Platform.version;
>+  },
>+  /*io.Platform.isLinux*/get isLinux() {
>+    return io.Platform._operatingSystem === "linux";
>+  },
>+  /*io.Platform.isMacOS*/get isMacOS() {
>+    return io.Platform._operatingSystem === "macos";
>+  },
>+  /*io.Platform.isWindows*/get isWindows() {
>+    return io.Platform._operatingSystem === "windows";
>+  },
>+  /*io.Platform.isAndroid*/get isAndroid() {
>+    return io.Platform._operatingSystem === "android";
>+  },
>+  /*io.Platform.isIOS*/get isIOS() {
>+    return io.Platform._operatingSystem === "ios";
>+  },
>+  /*io.Platform.isFuchsia*/get isFuchsia() {
>+    return io.Platform._operatingSystem === "fuchsia";
>+  }
>+});
>+io._Platform = class _Platform extends core.Object {
>+  static _numberOfProcessors() {
>+    dart.throw(new core.UnsupportedError.new("Platform._numberOfProcessors"));
>+  }
>+  static _pathSeparator() {
>+    dart.throw(new core.UnsupportedError.new("Platform._pathSeparator"));
>+  }
>+  static _operatingSystem() {
>+    dart.throw(new core.UnsupportedError.new("Platform._operatingSystem"));
>+  }
>+  static _operatingSystemVersion() {
>+    dart.throw(new core.UnsupportedError.new("Platform._operatingSystemVersion"));
>+  }
>+  static _localHostname() {
>+    dart.throw(new core.UnsupportedError.new("Platform._localHostname"));
>+  }
>+  static _executable() {
>+    dart.throw(new core.UnsupportedError.new("Platform._executable"));
>+  }
>+  static _resolvedExecutable() {
>+    dart.throw(new core.UnsupportedError.new("Platform._resolvedExecutable"));
>+  }
>+  static _environment() {
>+    dart.throw(new core.UnsupportedError.new("Platform._environment"));
>+  }
>+  static _executableArguments() {
>+    dart.throw(new core.UnsupportedError.new("Platform._executableArguments"));
>+  }
>+  static _packageRoot() {
>+    dart.throw(new core.UnsupportedError.new("Platform._packageRoot"));
>+  }
>+  static _packageConfig() {
>+    dart.throw(new core.UnsupportedError.new("Platform._packageConfig"));
>+  }
>+  static _version() {
>+    dart.throw(new core.UnsupportedError.new("Platform._version"));
>+  }
>+  static _localeName() {
>+    dart.throw(new core.UnsupportedError.new("Platform._localeName"));
>+  }
>+  static _script() {
>+    dart.throw(new core.UnsupportedError.new("Platform._script"));
>+  }
>+  static localeName() {
>+    let result = io._Platform._localeClosure == null ? io._Platform._localeName() : io._Platform._localeClosure();
>+    if (io.OSError.is(result)) {
>+      dart.throw(result);
>+    }
>+    return result;
>+  }
>+  static get numberOfProcessors() {
>+    return io._Platform._numberOfProcessors();
>+  }
>+  static get pathSeparator() {
>+    return io._Platform._pathSeparator();
>+  }
>+  static get operatingSystem() {
>+    return io._Platform._operatingSystem();
>+  }
>+  static get script() {
>+    return io._Platform._script();
>+  }
>+  static get operatingSystemVersion() {
>+    if (io._Platform._cachedOSVersion == null) {
>+      let result = io._Platform._operatingSystemVersion();
>+      if (io.OSError.is(result)) {
>+        dart.throw(result);
>+      }
>+      io._Platform._cachedOSVersion = core.String._check(result);
>+    }
>+    return io._Platform._cachedOSVersion;
>+  }
>+  static get localHostname() {
>+    let result = io._Platform._localHostname();
>+    if (io.OSError.is(result)) {
>+      dart.throw(result);
>+    }
>+    return core.String._check(result);
>+  }
>+  static get executableArguments() {
>+    return io._Platform._executableArguments();
>+  }
>+  static get environment() {
>+    if (io._Platform._environmentCache == null) {
>+      let env = io._Platform._environment();
>+      if (!io.OSError.is(env)) {
>+        let isWindows = io._Platform.operatingSystem === "windows";
>+        let result = isWindows ? new (_CaseInsensitiveStringMapOfString()).new() : new (IdentityMapOfString$String()).new();
>+        for (let str of core.Iterable._check(env)) {
>+          if (str == null) {
>+            continue;
>+          }
>+          let equalsIndex = dart.dsend(str, 'indexOf', ["="]);
>+          if (dart.dtest(dart.dsend(equalsIndex, '>', [0]))) {
>+            result[$_set](core.String._check(dart.dsend(str, 'substring', [0, equalsIndex])), core.String._check(dart.dsend(str, 'substring', [dart.dsend(equalsIndex, '+', [1])])));
>+          }
>+        }
>+        io._Platform._environmentCache = new (UnmodifiableMapViewOfString$String()).new(result);
>+      } else {
>+        io._Platform._environmentCache = env;
>+      }
>+    }
>+    if (io.OSError.is(io._Platform._environmentCache)) {
>+      dart.throw(io._Platform._environmentCache);
>+    } else {
>+      return MapOfString$String()._check(io._Platform._environmentCache);
>+    }
>+  }
>+  static get version() {
>+    return io._Platform._version();
>+  }
>+};
>+(io._Platform.new = function() {
>+}).prototype = io._Platform.prototype;
>+dart.addTypeTests(io._Platform);
>+dart.setLibraryUri(io._Platform, "dart:io");
>+dart.defineLazy(io._Platform, {
>+  /*io._Platform.executable*/get executable() {
>+    return core.String._check(io._Platform._executable());
>+  },
>+  set executable(_) {},
>+  /*io._Platform.resolvedExecutable*/get resolvedExecutable() {
>+    return core.String._check(io._Platform._resolvedExecutable());
>+  },
>+  set resolvedExecutable(_) {},
>+  /*io._Platform.packageRoot*/get packageRoot() {
>+    return null;
>+  },
>+  set packageRoot(_) {},
>+  /*io._Platform.packageConfig*/get packageConfig() {
>+    return io._Platform._packageConfig();
>+  },
>+  set packageConfig(_) {},
>+  /*io._Platform._localeClosure*/get _localeClosure() {
>+    return null;
>+  },
>+  set _localeClosure(_) {},
>+  /*io._Platform._environmentCache*/get _environmentCache() {
>+    return null;
>+  },
>+  set _environmentCache(_) {},
>+  /*io._Platform._cachedOSVersion*/get _cachedOSVersion() {
>+    return null;
>+  },
>+  set _cachedOSVersion(_) {}
>+});
>+const _map$1 = dart.privateName(io, "_map");
>+const _is__CaseInsensitiveStringMap_default = Symbol('_is__CaseInsensitiveStringMap_default');
>+io._CaseInsensitiveStringMap$ = dart.generic(V => {
>+  let IdentityMapOfString$V = () => (IdentityMapOfString$V = dart.constFn(_js_helper.IdentityMap$(core.String, V)))();
>+  let VoidToV = () => (VoidToV = dart.constFn(dart.fnType(V, [])))();
>+  let MapOfString$V = () => (MapOfString$V = dart.constFn(core.Map$(core.String, V)))();
>+  let StringAndVToV = () => (StringAndVToV = dart.constFn(dart.fnType(V, [core.String, V])))();
>+  let VToV = () => (VToV = dart.constFn(dart.fnType(V, [V])))();
>+  class _CaseInsensitiveStringMap extends collection.MapBase$(core.String, V) {
>+    containsKey(key) {
>+      return typeof key == 'string' && dart.test(this[_map$1][$containsKey](key[$toUpperCase]()));
>+    }
>+    containsValue(value) {
>+      return this[_map$1][$containsValue](value);
>+    }
>+    _get(key) {
>+      return typeof key == 'string' ? this[_map$1][$_get](key[$toUpperCase]()) : null;
>+    }
>+    _set(key, value) {
>+      core.String._check(key);
>+      V._check(value);
>+      this[_map$1][$_set](key[$toUpperCase](), value);
>+      return value;
>+    }
>+    putIfAbsent(key, ifAbsent) {
>+      core.String._check(key);
>+      VoidToV()._check(ifAbsent);
>+      return this[_map$1][$putIfAbsent](key[$toUpperCase](), ifAbsent);
>+    }
>+    addAll(other) {
>+      MapOfString$V()._check(other);
>+      other[$forEach](dart.fn((key, value) => this._set(key[$toUpperCase](), value), StringAndVToV()));
>+    }
>+    remove(key) {
>+      return typeof key == 'string' ? this[_map$1][$remove](key[$toUpperCase]()) : null;
>+    }
>+    clear() {
>+      this[_map$1][$clear]();
>+    }
>+    forEach(f) {
>+      this[_map$1][$forEach](f);
>+    }
>+    get keys() {
>+      return this[_map$1][$keys];
>+    }
>+    get values() {
>+      return this[_map$1][$values];
>+    }
>+    get length() {
>+      return this[_map$1][$length];
>+    }
>+    get isEmpty() {
>+      return this[_map$1][$isEmpty];
>+    }
>+    get isNotEmpty() {
>+      return this[_map$1][$isNotEmpty];
>+    }
>+    get entries() {
>+      return this[_map$1][$entries];
>+    }
>+    map(K2, V2, transform) {
>+      return core.Map$(K2, V2)._check(this[_map$1][$map](K2, V2, transform));
>+    }
>+    update(key, update, opts) {
>+      core.String._check(key);
>+      VToV()._check(update);
>+      let ifAbsent = opts && 'ifAbsent' in opts ? opts.ifAbsent : null;
>+      VoidToV()._check(ifAbsent);
>+      return this[_map$1][$update](key[$toUpperCase](), update, {ifAbsent: ifAbsent});
>+    }
>+    updateAll(update) {
>+      StringAndVToV()._check(update);
>+      this[_map$1][$updateAll](update);
>+    }
>+    removeWhere(test) {
>+      this[_map$1][$removeWhere](test);
>+    }
>+    toString() {
>+      return dart.toString(this[_map$1]);
>+    }
>+  }
>+  (_CaseInsensitiveStringMap.new = function() {
>+    this[_map$1] = new (IdentityMapOfString$V()).new();
>+  }).prototype = _CaseInsensitiveStringMap.prototype;
>+  dart.addTypeTests(_CaseInsensitiveStringMap);
>+  _CaseInsensitiveStringMap.prototype[_is__CaseInsensitiveStringMap_default] = true;
>+  dart.setMethodSignature(_CaseInsensitiveStringMap, () => ({
>+    __proto__: dart.getMethods(_CaseInsensitiveStringMap.__proto__),
>+    containsKey: dart.fnType(core.bool, [core.Object]),
>+    [$containsKey]: dart.fnType(core.bool, [core.Object]),
>+    containsValue: dart.fnType(core.bool, [core.Object]),
>+    [$containsValue]: dart.fnType(core.bool, [core.Object]),
>+    _get: dart.fnType(V, [core.Object]),
>+    [$_get]: dart.fnType(V, [core.Object]),
>+    _set: dart.fnType(dart.void, [core.Object, core.Object]),
>+    [$_set]: dart.fnType(dart.void, [core.Object, core.Object]),
>+    putIfAbsent: dart.fnType(V, [core.Object, core.Object]),
>+    [$putIfAbsent]: dart.fnType(V, [core.Object, core.Object]),
>+    addAll: dart.fnType(dart.void, [core.Object]),
>+    [$addAll]: dart.fnType(dart.void, [core.Object]),
>+    remove: dart.fnType(V, [core.Object]),
>+    [$remove]: dart.fnType(V, [core.Object]),
>+    clear: dart.fnType(dart.void, []),
>+    [$clear]: dart.fnType(dart.void, []),
>+    forEach: dart.fnType(dart.void, [dart.fnType(dart.void, [core.String, V])]),
>+    [$forEach]: dart.fnType(dart.void, [dart.fnType(dart.void, [core.String, V])]),
>+    map: dart.gFnType((K2, V2) => [core.Map$(K2, V2), [dart.fnType(core.MapEntry$(K2, V2), [core.String, V])]]),
>+    [$map]: dart.gFnType((K2, V2) => [core.Map$(K2, V2), [dart.fnType(core.MapEntry$(K2, V2), [core.String, V])]]),
>+    update: dart.fnType(V, [core.Object, core.Object], {ifAbsent: core.Object}),
>+    [$update]: dart.fnType(V, [core.Object, core.Object], {ifAbsent: core.Object}),
>+    updateAll: dart.fnType(dart.void, [core.Object]),
>+    [$updateAll]: dart.fnType(dart.void, [core.Object]),
>+    removeWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [core.String, V])]),
>+    [$removeWhere]: dart.fnType(dart.void, [dart.fnType(core.bool, [core.String, V])]),
>+    toString: dart.fnType(core.String, []),
>+    [$toString]: dart.fnType(core.String, [])
>+  }));
>+  dart.setGetterSignature(_CaseInsensitiveStringMap, () => ({
>+    __proto__: dart.getGetters(_CaseInsensitiveStringMap.__proto__),
>+    keys: core.Iterable$(core.String),
>+    [$keys]: core.Iterable$(core.String),
>+    values: core.Iterable$(V),
>+    [$values]: core.Iterable$(V),
>+    length: core.int,
>+    [$length]: core.int,
>+    isEmpty: core.bool,
>+    [$isEmpty]: core.bool,
>+    isNotEmpty: core.bool,
>+    [$isNotEmpty]: core.bool,
>+    entries: core.Iterable$(core.MapEntry$(core.String, V)),
>+    [$entries]: core.Iterable$(core.MapEntry$(core.String, V))
>+  }));
>+  dart.setLibraryUri(_CaseInsensitiveStringMap, "dart:io");
>+  dart.setFieldSignature(_CaseInsensitiveStringMap, () => ({
>+    __proto__: dart.getFields(_CaseInsensitiveStringMap.__proto__),
>+    [_map$1]: dart.finalFieldType(MapOfString$V())
>+  }));
>+  dart.defineExtensionMethods(_CaseInsensitiveStringMap, [
>+    'containsKey',
>+    'containsValue',
>+    '_get',
>+    '_set',
>+    'putIfAbsent',
>+    'addAll',
>+    'remove',
>+    'clear',
>+    'forEach',
>+    'map',
>+    'update',
>+    'updateAll',
>+    'removeWhere',
>+    'toString'
>+  ]);
>+  dart.defineExtensionAccessors(_CaseInsensitiveStringMap, [
>+    'keys',
>+    'values',
>+    'length',
>+    'isEmpty',
>+    'isNotEmpty',
>+    'entries'
>+  ]);
>+  return _CaseInsensitiveStringMap;
>+});
>+io._CaseInsensitiveStringMap = io._CaseInsensitiveStringMap$();
>+dart.addTypeTests(io._CaseInsensitiveStringMap, _is__CaseInsensitiveStringMap_default);
>+io._ProcessUtils = class _ProcessUtils extends core.Object {
>+  static _exit(status) {
>+    dart.throw(new core.UnsupportedError.new("ProcessUtils._exit"));
>+  }
>+  static _setExitCode(status) {
>+    dart.throw(new core.UnsupportedError.new("ProcessUtils._setExitCode"));
>+  }
>+  static _getExitCode() {
>+    dart.throw(new core.UnsupportedError.new("ProcessUtils._getExitCode"));
>+  }
>+  static _sleep(millis) {
>+    dart.throw(new core.UnsupportedError.new("ProcessUtils._sleep"));
>+  }
>+  static _pid(process) {
>+    dart.throw(new core.UnsupportedError.new("ProcessUtils._pid"));
>+  }
>+  static _watchSignal(signal) {
>+    dart.throw(new core.UnsupportedError.new("ProcessUtils._watchSignal"));
>+  }
>+};
>+(io._ProcessUtils.new = function() {
>+}).prototype = io._ProcessUtils.prototype;
>+dart.addTypeTests(io._ProcessUtils);
>+dart.setLibraryUri(io._ProcessUtils, "dart:io");
>+io.exit = function(code) {
>+  core.ArgumentError.checkNotNull(code, "code");
>+  if (!dart.test(io._EmbedderConfig._mayExit)) {
>+    dart.throw(new core.UnsupportedError.new("This embedder disallows calling dart:io's exit()"));
>+  }
>+  io._ProcessUtils._exit(code);
>+};
>+dart.copyProperties(io, {
>+  get exitCode() {
>+    return io._ProcessUtils._getExitCode();
>+  },
>+  set exitCode(code) {
>+    core.ArgumentError.checkNotNull(code, "code");
>+    io._ProcessUtils._setExitCode(code);
>+  }
>+});
>+io.sleep = function(duration) {
>+  let milliseconds = duration.inMilliseconds;
>+  if (dart.notNull(milliseconds) < 0) {
>+    dart.throw(new core.ArgumentError.new("sleep: duration cannot be negative"));
>+  }
>+  if (!dart.test(io._EmbedderConfig._maySleep)) {
>+    dart.throw(new core.UnsupportedError.new("This embedder disallows calling dart:io's sleep()"));
>+  }
>+  io._ProcessUtils._sleep(milliseconds);
>+};
>+dart.copyProperties(io, {
>+  get pid() {
>+    return io._ProcessUtils._pid(null);
>+  }
>+});
>+io.ProcessInfo = class ProcessInfo extends core.Object {
>+  static get currentRss() {
>+    dart.throw(new core.UnsupportedError.new("ProcessInfo.currentRss"));
>+  }
>+  static get maxRss() {
>+    dart.throw(new core.UnsupportedError.new("ProcessInfo.maxRss"));
>+  }
>+};
>+(io.ProcessInfo.new = function() {
>+}).prototype = io.ProcessInfo.prototype;
>+dart.addTypeTests(io.ProcessInfo);
>+dart.setLibraryUri(io.ProcessInfo, "dart:io");
>+let const$70;
>+let const$71;
>+io.ProcessStartMode = class ProcessStartMode extends core.Object {
>+  static get values() {
>+    return const$70 || (const$70 = dart.constList([io.ProcessStartMode.normal, io.ProcessStartMode.inheritStdio, io.ProcessStartMode.detached, io.ProcessStartMode.detachedWithStdio], io.ProcessStartMode));
>+  }
>+  toString() {
>+    return (const$71 || (const$71 = dart.constList(["normal", "inheritStdio", "detached", "detachedWithStdio"], core.String)))[$_get](this[_mode]);
>+  }
>+};
>+(io.ProcessStartMode._internal = function(mode) {
>+  this[_mode] = mode;
>+}).prototype = io.ProcessStartMode.prototype;
>+dart.addTypeTests(io.ProcessStartMode);
>+dart.setLibraryUri(io.ProcessStartMode, "dart:io");
>+dart.setFieldSignature(io.ProcessStartMode, () => ({
>+  __proto__: dart.getFields(io.ProcessStartMode.__proto__),
>+  [_mode]: dart.finalFieldType(core.int)
>+}));
>+dart.defineExtensionMethods(io.ProcessStartMode, ['toString']);
>+dart.defineLazy(io.ProcessStartMode, {
>+  /*io.ProcessStartMode.normal*/get normal() {
>+    return dart.const(new io.ProcessStartMode._internal(0));
>+  },
>+  /*io.ProcessStartMode.NORMAL*/get NORMAL() {
>+    return io.ProcessStartMode.normal;
>+  },
>+  /*io.ProcessStartMode.inheritStdio*/get inheritStdio() {
>+    return dart.const(new io.ProcessStartMode._internal(1));
>+  },
>+  /*io.ProcessStartMode.INHERIT_STDIO*/get INHERIT_STDIO() {
>+    return io.ProcessStartMode.inheritStdio;
>+  },
>+  /*io.ProcessStartMode.detached*/get detached() {
>+    return dart.const(new io.ProcessStartMode._internal(2));
>+  },
>+  /*io.ProcessStartMode.DETACHED*/get DETACHED() {
>+    return io.ProcessStartMode.detached;
>+  },
>+  /*io.ProcessStartMode.detachedWithStdio*/get detachedWithStdio() {
>+    return dart.const(new io.ProcessStartMode._internal(3));
>+  },
>+  /*io.ProcessStartMode.DETACHED_WITH_STDIO*/get DETACHED_WITH_STDIO() {
>+    return io.ProcessStartMode.detachedWithStdio;
>+  }
>+});
>+io.Process = class Process extends core.Object {
>+  static start(executable, arguments$0, opts) {
>+    let workingDirectory = opts && 'workingDirectory' in opts ? opts.workingDirectory : null;
>+    let environment = opts && 'environment' in opts ? opts.environment : null;
>+    let includeParentEnvironment = opts && 'includeParentEnvironment' in opts ? opts.includeParentEnvironment : true;
>+    let runInShell = opts && 'runInShell' in opts ? opts.runInShell : false;
>+    let mode = opts && 'mode' in opts ? opts.mode : io.ProcessStartMode.normal;
>+    dart.throw(new core.UnsupportedError.new("Process.start"));
>+  }
>+  static run(executable, arguments$0, opts) {
>+    let workingDirectory = opts && 'workingDirectory' in opts ? opts.workingDirectory : null;
>+    let environment = opts && 'environment' in opts ? opts.environment : null;
>+    let includeParentEnvironment = opts && 'includeParentEnvironment' in opts ? opts.includeParentEnvironment : true;
>+    let runInShell = opts && 'runInShell' in opts ? opts.runInShell : false;
>+    let stdoutEncoding = opts && 'stdoutEncoding' in opts ? opts.stdoutEncoding : io.systemEncoding;
>+    let stderrEncoding = opts && 'stderrEncoding' in opts ? opts.stderrEncoding : io.systemEncoding;
>+    dart.throw(new core.UnsupportedError.new("Process.run"));
>+  }
>+  static runSync(executable, arguments$0, opts) {
>+    let workingDirectory = opts && 'workingDirectory' in opts ? opts.workingDirectory : null;
>+    let environment = opts && 'environment' in opts ? opts.environment : null;
>+    let includeParentEnvironment = opts && 'includeParentEnvironment' in opts ? opts.includeParentEnvironment : true;
>+    let runInShell = opts && 'runInShell' in opts ? opts.runInShell : false;
>+    let stdoutEncoding = opts && 'stdoutEncoding' in opts ? opts.stdoutEncoding : io.systemEncoding;
>+    let stderrEncoding = opts && 'stderrEncoding' in opts ? opts.stderrEncoding : io.systemEncoding;
>+    dart.throw(new core.UnsupportedError.new("Process.runSync"));
>+  }
>+  static killPid(pid, signal) {
>+    if (signal === void 0) signal = io.ProcessSignal.sigterm;
>+    dart.throw(new core.UnsupportedError.new("Process.killPid"));
>+  }
>+};
>+(io.Process.new = function() {
>+}).prototype = io.Process.prototype;
>+dart.addTypeTests(io.Process);
>+dart.setLibraryUri(io.Process, "dart:io");
>+io.ProcessResult = class ProcessResult extends core.Object {
>+  get exitCode() {
>+    return this[exitCode$];
>+  }
>+  set exitCode(value) {
>+    super.exitCode = value;
>+  }
>+  get stdout() {
>+    return this[stdout$];
>+  }
>+  set stdout(value) {
>+    super.stdout = value;
>+  }
>+  get stderr() {
>+    return this[stderr$];
>+  }
>+  set stderr(value) {
>+    super.stderr = value;
>+  }
>+  get pid() {
>+    return this[pid$];
>+  }
>+  set pid(value) {
>+    super.pid = value;
>+  }
>+};
>+(io.ProcessResult.new = function(pid, exitCode, stdout, stderr) {
>+  this[pid$] = pid;
>+  this[exitCode$] = exitCode;
>+  this[stdout$] = stdout;
>+  this[stderr$] = stderr;
>+}).prototype = io.ProcessResult.prototype;
>+dart.addTypeTests(io.ProcessResult);
>+const exitCode$ = Symbol("ProcessResult.exitCode");
>+const stdout$ = Symbol("ProcessResult.stdout");
>+const stderr$ = Symbol("ProcessResult.stderr");
>+const pid$ = Symbol("ProcessResult.pid");
>+dart.setLibraryUri(io.ProcessResult, "dart:io");
>+dart.setFieldSignature(io.ProcessResult, () => ({
>+  __proto__: dart.getFields(io.ProcessResult.__proto__),
>+  exitCode: dart.finalFieldType(core.int),
>+  stdout: dart.finalFieldType(dart.dynamic),
>+  stderr: dart.finalFieldType(dart.dynamic),
>+  pid: dart.finalFieldType(core.int)
>+}));
>+const _signalNumber = dart.privateName(io, "_signalNumber");
>+const _name$3 = dart.privateName(io, "_name");
>+io.ProcessSignal = class ProcessSignal extends core.Object {
>+  toString() {
>+    return this[_name$3];
>+  }
>+  watch() {
>+    return io._ProcessUtils._watchSignal(this);
>+  }
>+};
>+(io.ProcessSignal.__ = function(signalNumber, name) {
>+  this[_signalNumber] = signalNumber;
>+  this[_name$3] = name;
>+}).prototype = io.ProcessSignal.prototype;
>+dart.addTypeTests(io.ProcessSignal);
>+dart.setMethodSignature(io.ProcessSignal, () => ({
>+  __proto__: dart.getMethods(io.ProcessSignal.__proto__),
>+  watch: dart.fnType(async.Stream$(io.ProcessSignal), [])
>+}));
>+dart.setLibraryUri(io.ProcessSignal, "dart:io");
>+dart.setFieldSignature(io.ProcessSignal, () => ({
>+  __proto__: dart.getFields(io.ProcessSignal.__proto__),
>+  [_signalNumber]: dart.finalFieldType(core.int),
>+  [_name$3]: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionMethods(io.ProcessSignal, ['toString']);
>+dart.defineLazy(io.ProcessSignal, {
>+  /*io.ProcessSignal.sighup*/get sighup() {
>+    return dart.const(new io.ProcessSignal.__(1, "SIGHUP"));
>+  },
>+  /*io.ProcessSignal.sigint*/get sigint() {
>+    return dart.const(new io.ProcessSignal.__(2, "SIGINT"));
>+  },
>+  /*io.ProcessSignal.sigquit*/get sigquit() {
>+    return dart.const(new io.ProcessSignal.__(3, "SIGQUIT"));
>+  },
>+  /*io.ProcessSignal.sigill*/get sigill() {
>+    return dart.const(new io.ProcessSignal.__(4, "SIGILL"));
>+  },
>+  /*io.ProcessSignal.sigtrap*/get sigtrap() {
>+    return dart.const(new io.ProcessSignal.__(5, "SIGTRAP"));
>+  },
>+  /*io.ProcessSignal.sigabrt*/get sigabrt() {
>+    return dart.const(new io.ProcessSignal.__(6, "SIGABRT"));
>+  },
>+  /*io.ProcessSignal.sigbus*/get sigbus() {
>+    return dart.const(new io.ProcessSignal.__(7, "SIGBUS"));
>+  },
>+  /*io.ProcessSignal.sigfpe*/get sigfpe() {
>+    return dart.const(new io.ProcessSignal.__(8, "SIGFPE"));
>+  },
>+  /*io.ProcessSignal.sigkill*/get sigkill() {
>+    return dart.const(new io.ProcessSignal.__(9, "SIGKILL"));
>+  },
>+  /*io.ProcessSignal.sigusr1*/get sigusr1() {
>+    return dart.const(new io.ProcessSignal.__(10, "SIGUSR1"));
>+  },
>+  /*io.ProcessSignal.sigsegv*/get sigsegv() {
>+    return dart.const(new io.ProcessSignal.__(11, "SIGSEGV"));
>+  },
>+  /*io.ProcessSignal.sigusr2*/get sigusr2() {
>+    return dart.const(new io.ProcessSignal.__(12, "SIGUSR2"));
>+  },
>+  /*io.ProcessSignal.sigpipe*/get sigpipe() {
>+    return dart.const(new io.ProcessSignal.__(13, "SIGPIPE"));
>+  },
>+  /*io.ProcessSignal.sigalrm*/get sigalrm() {
>+    return dart.const(new io.ProcessSignal.__(14, "SIGALRM"));
>+  },
>+  /*io.ProcessSignal.sigterm*/get sigterm() {
>+    return dart.const(new io.ProcessSignal.__(15, "SIGTERM"));
>+  },
>+  /*io.ProcessSignal.sigchld*/get sigchld() {
>+    return dart.const(new io.ProcessSignal.__(17, "SIGCHLD"));
>+  },
>+  /*io.ProcessSignal.sigcont*/get sigcont() {
>+    return dart.const(new io.ProcessSignal.__(18, "SIGCONT"));
>+  },
>+  /*io.ProcessSignal.sigstop*/get sigstop() {
>+    return dart.const(new io.ProcessSignal.__(19, "SIGSTOP"));
>+  },
>+  /*io.ProcessSignal.sigtstp*/get sigtstp() {
>+    return dart.const(new io.ProcessSignal.__(20, "SIGTSTP"));
>+  },
>+  /*io.ProcessSignal.sigttin*/get sigttin() {
>+    return dart.const(new io.ProcessSignal.__(21, "SIGTTIN"));
>+  },
>+  /*io.ProcessSignal.sigttou*/get sigttou() {
>+    return dart.const(new io.ProcessSignal.__(22, "SIGTTOU"));
>+  },
>+  /*io.ProcessSignal.sigurg*/get sigurg() {
>+    return dart.const(new io.ProcessSignal.__(23, "SIGURG"));
>+  },
>+  /*io.ProcessSignal.sigxcpu*/get sigxcpu() {
>+    return dart.const(new io.ProcessSignal.__(24, "SIGXCPU"));
>+  },
>+  /*io.ProcessSignal.sigxfsz*/get sigxfsz() {
>+    return dart.const(new io.ProcessSignal.__(25, "SIGXFSZ"));
>+  },
>+  /*io.ProcessSignal.sigvtalrm*/get sigvtalrm() {
>+    return dart.const(new io.ProcessSignal.__(26, "SIGVTALRM"));
>+  },
>+  /*io.ProcessSignal.sigprof*/get sigprof() {
>+    return dart.const(new io.ProcessSignal.__(27, "SIGPROF"));
>+  },
>+  /*io.ProcessSignal.sigwinch*/get sigwinch() {
>+    return dart.const(new io.ProcessSignal.__(28, "SIGWINCH"));
>+  },
>+  /*io.ProcessSignal.sigpoll*/get sigpoll() {
>+    return dart.const(new io.ProcessSignal.__(29, "SIGPOLL"));
>+  },
>+  /*io.ProcessSignal.sigsys*/get sigsys() {
>+    return dart.const(new io.ProcessSignal.__(31, "SIGSYS"));
>+  },
>+  /*io.ProcessSignal.SIGHUP*/get SIGHUP() {
>+    return io.ProcessSignal.sighup;
>+  },
>+  /*io.ProcessSignal.SIGINT*/get SIGINT() {
>+    return io.ProcessSignal.sigint;
>+  },
>+  /*io.ProcessSignal.SIGQUIT*/get SIGQUIT() {
>+    return io.ProcessSignal.sigquit;
>+  },
>+  /*io.ProcessSignal.SIGILL*/get SIGILL() {
>+    return io.ProcessSignal.sigill;
>+  },
>+  /*io.ProcessSignal.SIGTRAP*/get SIGTRAP() {
>+    return io.ProcessSignal.sigtrap;
>+  },
>+  /*io.ProcessSignal.SIGABRT*/get SIGABRT() {
>+    return io.ProcessSignal.sigabrt;
>+  },
>+  /*io.ProcessSignal.SIGBUS*/get SIGBUS() {
>+    return io.ProcessSignal.sigbus;
>+  },
>+  /*io.ProcessSignal.SIGFPE*/get SIGFPE() {
>+    return io.ProcessSignal.sigfpe;
>+  },
>+  /*io.ProcessSignal.SIGKILL*/get SIGKILL() {
>+    return io.ProcessSignal.sigkill;
>+  },
>+  /*io.ProcessSignal.SIGUSR1*/get SIGUSR1() {
>+    return io.ProcessSignal.sigusr1;
>+  },
>+  /*io.ProcessSignal.SIGSEGV*/get SIGSEGV() {
>+    return io.ProcessSignal.sigsegv;
>+  },
>+  /*io.ProcessSignal.SIGUSR2*/get SIGUSR2() {
>+    return io.ProcessSignal.sigusr2;
>+  },
>+  /*io.ProcessSignal.SIGPIPE*/get SIGPIPE() {
>+    return io.ProcessSignal.sigpipe;
>+  },
>+  /*io.ProcessSignal.SIGALRM*/get SIGALRM() {
>+    return io.ProcessSignal.sigalrm;
>+  },
>+  /*io.ProcessSignal.SIGTERM*/get SIGTERM() {
>+    return io.ProcessSignal.sigterm;
>+  },
>+  /*io.ProcessSignal.SIGCHLD*/get SIGCHLD() {
>+    return io.ProcessSignal.sigchld;
>+  },
>+  /*io.ProcessSignal.SIGCONT*/get SIGCONT() {
>+    return io.ProcessSignal.sigcont;
>+  },
>+  /*io.ProcessSignal.SIGSTOP*/get SIGSTOP() {
>+    return io.ProcessSignal.sigstop;
>+  },
>+  /*io.ProcessSignal.SIGTSTP*/get SIGTSTP() {
>+    return io.ProcessSignal.sigtstp;
>+  },
>+  /*io.ProcessSignal.SIGTTIN*/get SIGTTIN() {
>+    return io.ProcessSignal.sigttin;
>+  },
>+  /*io.ProcessSignal.SIGTTOU*/get SIGTTOU() {
>+    return io.ProcessSignal.sigttou;
>+  },
>+  /*io.ProcessSignal.SIGURG*/get SIGURG() {
>+    return io.ProcessSignal.sigurg;
>+  },
>+  /*io.ProcessSignal.SIGXCPU*/get SIGXCPU() {
>+    return io.ProcessSignal.sigxcpu;
>+  },
>+  /*io.ProcessSignal.SIGXFSZ*/get SIGXFSZ() {
>+    return io.ProcessSignal.sigxfsz;
>+  },
>+  /*io.ProcessSignal.SIGVTALRM*/get SIGVTALRM() {
>+    return io.ProcessSignal.sigvtalrm;
>+  },
>+  /*io.ProcessSignal.SIGPROF*/get SIGPROF() {
>+    return io.ProcessSignal.sigprof;
>+  },
>+  /*io.ProcessSignal.SIGWINCH*/get SIGWINCH() {
>+    return io.ProcessSignal.sigwinch;
>+  },
>+  /*io.ProcessSignal.SIGPOLL*/get SIGPOLL() {
>+    return io.ProcessSignal.sigpoll;
>+  },
>+  /*io.ProcessSignal.SIGSYS*/get SIGSYS() {
>+    return io.ProcessSignal.sigsys;
>+  }
>+});
>+io.SignalException = class SignalException extends core.Object {
>+  get message() {
>+    return this[message$9];
>+  }
>+  set message(value) {
>+    super.message = value;
>+  }
>+  get osError() {
>+    return this[osError$0];
>+  }
>+  set osError(value) {
>+    super.osError = value;
>+  }
>+  toString() {
>+    let msg = "";
>+    if (this.osError != null) {
>+      msg = ", osError: " + dart.str(this.osError);
>+    }
>+    return "SignalException: " + dart.str(this.message) + msg;
>+  }
>+};
>+(io.SignalException.new = function(message, osError) {
>+  if (osError === void 0) osError = null;
>+  this[message$9] = message;
>+  this[osError$0] = osError;
>+}).prototype = io.SignalException.prototype;
>+dart.addTypeTests(io.SignalException);
>+const message$9 = Symbol("SignalException.message");
>+const osError$0 = Symbol("SignalException.osError");
>+io.SignalException[dart.implements] = () => [io.IOException];
>+dart.setLibraryUri(io.SignalException, "dart:io");
>+dart.setFieldSignature(io.SignalException, () => ({
>+  __proto__: dart.getFields(io.SignalException.__proto__),
>+  message: dart.finalFieldType(core.String),
>+  osError: dart.finalFieldType(dart.dynamic)
>+}));
>+dart.defineExtensionMethods(io.SignalException, ['toString']);
>+io.ProcessException = class ProcessException extends core.Object {
>+  get executable() {
>+    return this[executable$];
>+  }
>+  set executable(value) {
>+    super.executable = value;
>+  }
>+  get arguments() {
>+    return this[arguments$];
>+  }
>+  set arguments(value) {
>+    super.arguments = value;
>+  }
>+  get message() {
>+    return this[message$10];
>+  }
>+  set message(value) {
>+    super.message = value;
>+  }
>+  get errorCode() {
>+    return this[errorCode$1];
>+  }
>+  set errorCode(value) {
>+    super.errorCode = value;
>+  }
>+  toString() {
>+    let msg = this.message == null ? "OS error code: " + dart.str(this.errorCode) : this.message;
>+    let args = this.arguments[$join](" ");
>+    return "ProcessException: " + dart.str(msg) + "\n  Command: " + dart.str(this.executable) + " " + dart.str(args);
>+  }
>+};
>+(io.ProcessException.new = function(executable, arguments$0, message, errorCode) {
>+  if (message === void 0) message = "";
>+  if (errorCode === void 0) errorCode = 0;
>+  this[executable$] = executable;
>+  this[arguments$] = arguments$0;
>+  this[message$10] = message;
>+  this[errorCode$1] = errorCode;
>+}).prototype = io.ProcessException.prototype;
>+dart.addTypeTests(io.ProcessException);
>+const executable$ = Symbol("ProcessException.executable");
>+const arguments$ = Symbol("ProcessException.arguments");
>+const message$10 = Symbol("ProcessException.message");
>+const errorCode$1 = Symbol("ProcessException.errorCode");
>+io.ProcessException[dart.implements] = () => [io.IOException];
>+dart.setLibraryUri(io.ProcessException, "dart:io");
>+dart.setFieldSignature(io.ProcessException, () => ({
>+  __proto__: dart.getFields(io.ProcessException.__proto__),
>+  executable: dart.finalFieldType(core.String),
>+  arguments: dart.finalFieldType(ListOfString()),
>+  message: dart.finalFieldType(core.String),
>+  errorCode: dart.finalFieldType(core.int)
>+}));
>+dart.defineExtensionMethods(io.ProcessException, ['toString']);
>+const _socket = dart.privateName(io, "_socket");
>+const _owner = dart.privateName(io, "_owner");
>+const _onCancel$ = dart.privateName(io, "_onCancel");
>+const _detachRaw = dart.privateName(io, "_detachRaw");
>+io.SecureSocket = class SecureSocket extends core.Object {
>+  static connect(host, port, opts) {
>+    let context = opts && 'context' in opts ? opts.context : null;
>+    let onBadCertificate = opts && 'onBadCertificate' in opts ? opts.onBadCertificate : null;
>+    let supportedProtocols = opts && 'supportedProtocols' in opts ? opts.supportedProtocols : null;
>+    let timeout = opts && 'timeout' in opts ? opts.timeout : null;
>+    return FutureOfSecureSocket()._check(io.RawSecureSocket.connect(host, port, {context: context, onBadCertificate: onBadCertificate, supportedProtocols: supportedProtocols, timeout: timeout}).then(io.SecureSocket, dart.fn(rawSocket => io.SecureSocket.__(rawSocket), RawSecureSocketToSecureSocket())));
>+  }
>+  static startConnect(host, port, opts) {
>+    let context = opts && 'context' in opts ? opts.context : null;
>+    let onBadCertificate = opts && 'onBadCertificate' in opts ? opts.onBadCertificate : null;
>+    let supportedProtocols = opts && 'supportedProtocols' in opts ? opts.supportedProtocols : null;
>+    return FutureOfConnectionTaskOfSecureSocket()._check(io.RawSecureSocket.startConnect(host, port, {context: context, onBadCertificate: onBadCertificate, supportedProtocols: supportedProtocols}).then(ConnectionTaskOfSecureSocket(), dart.fn(rawState => {
>+      let socket = FutureOfSecureSocket()._check(rawState.socket.then(io.SecureSocket, dart.fn(rawSocket => io.SecureSocket.__(rawSocket), RawSecureSocketToSecureSocket())));
>+      return new (ConnectionTaskOfSecureSocket()).__({socket: socket, onCancel: rawState[_onCancel$]});
>+    }, ConnectionTaskOfRawSecureSocketToConnectionTaskOfSecureSocket())));
>+  }
>+  static secure(socket, opts) {
>+    let host = opts && 'host' in opts ? opts.host : null;
>+    let context = opts && 'context' in opts ? opts.context : null;
>+    let onBadCertificate = opts && 'onBadCertificate' in opts ? opts.onBadCertificate : null;
>+    return FutureOfSecureSocket()._check(FutureOfRawSecureSocket()._check(async.Future.as(dart.dsend(socket, _detachRaw, [])).then(io.RawSecureSocket, dart.fn(detachedRaw => io.RawSecureSocket.secure(io.RawSocket.as(dart.dindex(detachedRaw, 0)), {subscription: StreamSubscriptionOfRawSocketEvent().as(dart.dindex(detachedRaw, 1)), host: host, context: context, onBadCertificate: onBadCertificate}), dynamicToFutureOfRawSecureSocket()))).then(io.SecureSocket, dart.fn(raw => io.SecureSocket.__(raw), RawSecureSocketToSecureSocket())));
>+  }
>+  static secureServer(socket, context, opts) {
>+    let bufferedData = opts && 'bufferedData' in opts ? opts.bufferedData : null;
>+    let requestClientCertificate = opts && 'requestClientCertificate' in opts ? opts.requestClientCertificate : false;
>+    let requireClientCertificate = opts && 'requireClientCertificate' in opts ? opts.requireClientCertificate : false;
>+    let supportedProtocols = opts && 'supportedProtocols' in opts ? opts.supportedProtocols : null;
>+    return FutureOfSecureSocket()._check(FutureOfRawSecureSocket()._check(async.Future.as(dart.dsend(socket, _detachRaw, [])).then(io.RawSecureSocket, dart.fn(detachedRaw => io.RawSecureSocket.secureServer(io.RawSocket.as(dart.dindex(detachedRaw, 0)), context, {subscription: StreamSubscriptionOfRawSocketEvent().as(dart.dindex(detachedRaw, 1)), bufferedData: bufferedData, requestClientCertificate: requestClientCertificate, requireClientCertificate: requireClientCertificate, supportedProtocols: supportedProtocols}), dynamicToFutureOfRawSecureSocket()))).then(io.SecureSocket, dart.fn(raw => io.SecureSocket.__(raw), RawSecureSocketToSecureSocket())));
>+  }
>+};
>+(io.SecureSocket[dart.mixinNew] = function() {
>+}).prototype = io.SecureSocket.prototype;
>+dart.addTypeTests(io.SecureSocket);
>+io.SecureSocket[dart.implements] = () => [io.Socket];
>+dart.setLibraryUri(io.SecureSocket, "dart:io");
>+io.SecureServerSocket = class SecureServerSocket extends async.Stream$(io.SecureSocket) {
>+  static bind(address, port, context, opts) {
>+    let backlog = opts && 'backlog' in opts ? opts.backlog : 0;
>+    let v6Only = opts && 'v6Only' in opts ? opts.v6Only : false;
>+    let requestClientCertificate = opts && 'requestClientCertificate' in opts ? opts.requestClientCertificate : false;
>+    let requireClientCertificate = opts && 'requireClientCertificate' in opts ? opts.requireClientCertificate : false;
>+    let supportedProtocols = opts && 'supportedProtocols' in opts ? opts.supportedProtocols : null;
>+    let shared = opts && 'shared' in opts ? opts.shared : false;
>+    return FutureOfSecureServerSocket()._check(io.RawSecureServerSocket.bind(address, port, context, {backlog: backlog, v6Only: v6Only, requestClientCertificate: requestClientCertificate, requireClientCertificate: requireClientCertificate, supportedProtocols: supportedProtocols, shared: shared}).then(io.SecureServerSocket, dart.fn(serverSocket => new io.SecureServerSocket.__(serverSocket), RawSecureServerSocketToSecureServerSocket())));
>+  }
>+  listen(onData, opts) {
>+    let onError = opts && 'onError' in opts ? opts.onError : null;
>+    let onDone = opts && 'onDone' in opts ? opts.onDone : null;
>+    let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
>+    return this[_socket].map(io.SecureSocket, dart.fn(rawSocket => io.SecureSocket.__(rawSocket), RawSecureSocketToSecureSocket())).listen(onData, {onError: onError, onDone: onDone, cancelOnError: cancelOnError});
>+  }
>+  get port() {
>+    return this[_socket].port;
>+  }
>+  get address() {
>+    return this[_socket].address;
>+  }
>+  close() {
>+    return FutureOfSecureServerSocket()._check(this[_socket].close().then(io.SecureServerSocket, dart.fn(_ => this, RawSecureServerSocketToSecureServerSocket())));
>+  }
>+  set [_owner](owner) {
>+    this[_socket][_owner] = owner;
>+  }
>+};
>+(io.SecureServerSocket.__ = function(socket) {
>+  this[_socket] = socket;
>+  io.SecureServerSocket.__proto__.new.call(this);
>+}).prototype = io.SecureServerSocket.prototype;
>+dart.addTypeTests(io.SecureServerSocket);
>+dart.setMethodSignature(io.SecureServerSocket, () => ({
>+  __proto__: dart.getMethods(io.SecureServerSocket.__proto__),
>+  listen: dart.fnType(async.StreamSubscription$(io.SecureSocket), [dart.fnType(dart.void, [io.SecureSocket])], {onError: core.Function, onDone: dart.fnType(dart.void, []), cancelOnError: core.bool}),
>+  close: dart.fnType(async.Future$(io.SecureServerSocket), [])
>+}));
>+dart.setGetterSignature(io.SecureServerSocket, () => ({
>+  __proto__: dart.getGetters(io.SecureServerSocket.__proto__),
>+  port: core.int,
>+  address: io.InternetAddress
>+}));
>+dart.setSetterSignature(io.SecureServerSocket, () => ({
>+  __proto__: dart.getSetters(io.SecureServerSocket.__proto__),
>+  [_owner]: dart.dynamic
>+}));
>+dart.setLibraryUri(io.SecureServerSocket, "dart:io");
>+dart.setFieldSignature(io.SecureServerSocket, () => ({
>+  __proto__: dart.getFields(io.SecureServerSocket.__proto__),
>+  [_socket]: dart.finalFieldType(io.RawSecureServerSocket)
>+}));
>+const _context = dart.privateName(io, "_context");
>+const _subscription$ = dart.privateName(io, "_subscription");
>+const _onSubscriptionStateChange = dart.privateName(io, "_onSubscriptionStateChange");
>+const _onPauseStateChange = dart.privateName(io, "_onPauseStateChange");
>+const _onData$0 = dart.privateName(io, "_onData");
>+io.RawSecureSocket = class RawSecureSocket extends core.Object {
>+  static connect(host, port, opts) {
>+    let context = opts && 'context' in opts ? opts.context : null;
>+    let onBadCertificate = opts && 'onBadCertificate' in opts ? opts.onBadCertificate : null;
>+    let supportedProtocols = opts && 'supportedProtocols' in opts ? opts.supportedProtocols : null;
>+    let timeout = opts && 'timeout' in opts ? opts.timeout : null;
>+    io._RawSecureSocket._verifyFields(host, port, false, false, false, onBadCertificate);
>+    return FutureOfRawSecureSocket()._check(io.RawSocket.connect(host, port, {timeout: timeout}).then(io.RawSecureSocket, dart.fn(socket => io.RawSecureSocket.secure(socket, {context: context, onBadCertificate: onBadCertificate, supportedProtocols: supportedProtocols}), RawSocketToFutureOfRawSecureSocket())));
>+  }
>+  static startConnect(host, port, opts) {
>+    let context = opts && 'context' in opts ? opts.context : null;
>+    let onBadCertificate = opts && 'onBadCertificate' in opts ? opts.onBadCertificate : null;
>+    let supportedProtocols = opts && 'supportedProtocols' in opts ? opts.supportedProtocols : null;
>+    return FutureOfConnectionTaskOfRawSecureSocket()._check(io.RawSocket.startConnect(host, port).then(ConnectionTaskOfRawSecureSocket(), dart.fn(rawState => {
>+      let socket = FutureOfRawSecureSocket()._check(rawState.socket.then(io.RawSecureSocket, dart.fn(rawSocket => io.RawSecureSocket.secure(rawSocket, {context: context, onBadCertificate: onBadCertificate, supportedProtocols: supportedProtocols}), RawSocketToFutureOfRawSecureSocket())));
>+      return new (ConnectionTaskOfRawSecureSocket()).__({socket: socket, onCancel: rawState[_onCancel$]});
>+    }, ConnectionTaskOfRawSocketToConnectionTaskOfRawSecureSocket())));
>+  }
>+  static secure(socket, opts) {
>+    let subscription = opts && 'subscription' in opts ? opts.subscription : null;
>+    let host = opts && 'host' in opts ? opts.host : null;
>+    let context = opts && 'context' in opts ? opts.context : null;
>+    let onBadCertificate = opts && 'onBadCertificate' in opts ? opts.onBadCertificate : null;
>+    let supportedProtocols = opts && 'supportedProtocols' in opts ? opts.supportedProtocols : null;
>+    socket.readEventsEnabled = false;
>+    socket.writeEventsEnabled = false;
>+    return io._RawSecureSocket.connect(host != null ? host : socket.address.host, socket.port, {is_server: false, socket: socket, subscription: subscription, context: context, onBadCertificate: onBadCertificate, supportedProtocols: supportedProtocols});
>+  }
>+  static secureServer(socket, context, opts) {
>+    let subscription = opts && 'subscription' in opts ? opts.subscription : null;
>+    let bufferedData = opts && 'bufferedData' in opts ? opts.bufferedData : null;
>+    let requestClientCertificate = opts && 'requestClientCertificate' in opts ? opts.requestClientCertificate : false;
>+    let requireClientCertificate = opts && 'requireClientCertificate' in opts ? opts.requireClientCertificate : false;
>+    let supportedProtocols = opts && 'supportedProtocols' in opts ? opts.supportedProtocols : null;
>+    socket.readEventsEnabled = false;
>+    socket.writeEventsEnabled = false;
>+    return io._RawSecureSocket.connect(socket.address, socket.remotePort, {context: context, is_server: true, socket: socket, subscription: subscription, bufferedData: bufferedData, requestClientCertificate: requestClientCertificate, requireClientCertificate: requireClientCertificate, supportedProtocols: supportedProtocols});
>+  }
>+};
>+(io.RawSecureSocket.new = function() {
>+}).prototype = io.RawSecureSocket.prototype;
>+dart.addTypeTests(io.RawSecureSocket);
>+io.RawSecureSocket[dart.implements] = () => [io.RawSocket];
>+dart.setLibraryUri(io.RawSecureSocket, "dart:io");
>+io.RawSecureServerSocket = class RawSecureServerSocket extends async.Stream$(io.RawSecureSocket) {
>+  get requestClientCertificate() {
>+    return this[requestClientCertificate$];
>+  }
>+  set requestClientCertificate(value) {
>+    super.requestClientCertificate = value;
>+  }
>+  get requireClientCertificate() {
>+    return this[requireClientCertificate$];
>+  }
>+  set requireClientCertificate(value) {
>+    super.requireClientCertificate = value;
>+  }
>+  get supportedProtocols() {
>+    return this[supportedProtocols$];
>+  }
>+  set supportedProtocols(value) {
>+    super.supportedProtocols = value;
>+  }
>+  static bind(address, port, context, opts) {
>+    let backlog = opts && 'backlog' in opts ? opts.backlog : 0;
>+    let v6Only = opts && 'v6Only' in opts ? opts.v6Only : false;
>+    let requestClientCertificate = opts && 'requestClientCertificate' in opts ? opts.requestClientCertificate : false;
>+    let requireClientCertificate = opts && 'requireClientCertificate' in opts ? opts.requireClientCertificate : false;
>+    let supportedProtocols = opts && 'supportedProtocols' in opts ? opts.supportedProtocols : null;
>+    let shared = opts && 'shared' in opts ? opts.shared : false;
>+    return FutureOfRawSecureServerSocket()._check(io.RawServerSocket.bind(address, port, {backlog: backlog, v6Only: v6Only, shared: shared}).then(io.RawSecureServerSocket, dart.fn(serverSocket => new io.RawSecureServerSocket.__(serverSocket, context, requestClientCertificate, requireClientCertificate, supportedProtocols), RawServerSocketToRawSecureServerSocket())));
>+  }
>+  listen(onData, opts) {
>+    let onError = opts && 'onError' in opts ? opts.onError : null;
>+    let onDone = opts && 'onDone' in opts ? opts.onDone : null;
>+    let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
>+    return this[_controller$].stream.listen(onData, {onError: onError, onDone: onDone, cancelOnError: cancelOnError});
>+  }
>+  get port() {
>+    return this[_socket].port;
>+  }
>+  get address() {
>+    return this[_socket].address;
>+  }
>+  close() {
>+    this[_closed] = true;
>+    return FutureOfRawSecureServerSocket()._check(this[_socket].close().then(io.RawSecureServerSocket, dart.fn(_ => this, RawServerSocketToRawSecureServerSocket())));
>+  }
>+  [_onData$0](connection) {
>+    let remotePort = null;
>+    try {
>+      remotePort = connection.remotePort;
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      return;
>+    }
>+    FutureOfNull()._check(io._RawSecureSocket.connect(connection.address, core.int._check(remotePort), {context: this[_context], is_server: true, socket: connection, requestClientCertificate: this.requestClientCertificate, requireClientCertificate: this.requireClientCertificate, supportedProtocols: this.supportedProtocols}).then(core.Null, dart.fn(secureConnection => {
>+      if (dart.test(this[_closed])) {
>+        secureConnection.close();
>+      } else {
>+        this[_controller$].add(secureConnection);
>+      }
>+    }, RawSecureSocketToNull()))).catchError(dart.fn((e, s) => {
>+      if (!dart.test(this[_closed])) {
>+        this[_controller$].addError(e, core.StackTrace._check(s));
>+      }
>+    }, dynamicAnddynamicToNull()));
>+  }
>+  [_onPauseStateChange]() {
>+    if (dart.test(this[_controller$].isPaused)) {
>+      this[_subscription$].pause();
>+    } else {
>+      this[_subscription$].resume();
>+    }
>+  }
>+  [_onSubscriptionStateChange]() {
>+    if (dart.test(this[_controller$].hasListener)) {
>+      this[_subscription$] = this[_socket].listen(dart.bind(this, _onData$0), {onError: dart.bind(this[_controller$], 'addError'), onDone: dart.bind(this[_controller$], 'close')});
>+    } else {
>+      this.close();
>+    }
>+  }
>+  set [_owner](owner) {
>+    dart.dput(this[_socket], _owner, owner);
>+  }
>+};
>+(io.RawSecureServerSocket.__ = function(socket, context, requestClientCertificate, requireClientCertificate, supportedProtocols) {
>+  this[_controller$] = null;
>+  this[_subscription$] = null;
>+  this[_closed] = false;
>+  this[_socket] = socket;
>+  this[_context] = context;
>+  this[requestClientCertificate$] = requestClientCertificate;
>+  this[requireClientCertificate$] = requireClientCertificate;
>+  this[supportedProtocols$] = supportedProtocols;
>+  io.RawSecureServerSocket.__proto__.new.call(this);
>+  this[_controller$] = StreamControllerOfRawSecureSocket().new({sync: true, onListen: dart.bind(this, _onSubscriptionStateChange), onPause: dart.bind(this, _onPauseStateChange), onResume: dart.bind(this, _onPauseStateChange), onCancel: dart.bind(this, _onSubscriptionStateChange)});
>+}).prototype = io.RawSecureServerSocket.prototype;
>+dart.addTypeTests(io.RawSecureServerSocket);
>+const requestClientCertificate$ = Symbol("RawSecureServerSocket.requestClientCertificate");
>+const requireClientCertificate$ = Symbol("RawSecureServerSocket.requireClientCertificate");
>+const supportedProtocols$ = Symbol("RawSecureServerSocket.supportedProtocols");
>+dart.setMethodSignature(io.RawSecureServerSocket, () => ({
>+  __proto__: dart.getMethods(io.RawSecureServerSocket.__proto__),
>+  listen: dart.fnType(async.StreamSubscription$(io.RawSecureSocket), [dart.fnType(dart.void, [io.RawSecureSocket])], {onError: core.Function, onDone: dart.fnType(dart.void, []), cancelOnError: core.bool}),
>+  close: dart.fnType(async.Future$(io.RawSecureServerSocket), []),
>+  [_onData$0]: dart.fnType(dart.void, [io.RawSocket]),
>+  [_onPauseStateChange]: dart.fnType(dart.void, []),
>+  [_onSubscriptionStateChange]: dart.fnType(dart.void, [])
>+}));
>+dart.setGetterSignature(io.RawSecureServerSocket, () => ({
>+  __proto__: dart.getGetters(io.RawSecureServerSocket.__proto__),
>+  port: core.int,
>+  address: io.InternetAddress
>+}));
>+dart.setSetterSignature(io.RawSecureServerSocket, () => ({
>+  __proto__: dart.getSetters(io.RawSecureServerSocket.__proto__),
>+  [_owner]: dart.dynamic
>+}));
>+dart.setLibraryUri(io.RawSecureServerSocket, "dart:io");
>+dart.setFieldSignature(io.RawSecureServerSocket, () => ({
>+  __proto__: dart.getFields(io.RawSecureServerSocket.__proto__),
>+  [_socket]: dart.finalFieldType(io.RawServerSocket),
>+  [_controller$]: dart.fieldType(StreamControllerOfRawSecureSocket()),
>+  [_subscription$]: dart.fieldType(StreamSubscriptionOfRawSocket()),
>+  [_context]: dart.finalFieldType(io.SecurityContext),
>+  requestClientCertificate: dart.finalFieldType(core.bool),
>+  requireClientCertificate: dart.finalFieldType(core.bool),
>+  supportedProtocols: dart.finalFieldType(ListOfString()),
>+  [_closed]: dart.fieldType(core.bool)
>+}));
>+io.X509Certificate = class X509Certificate extends core.Object {};
>+(io.X509Certificate[dart.mixinNew] = function() {
>+}).prototype = io.X509Certificate.prototype;
>+dart.addTypeTests(io.X509Certificate);
>+dart.setLibraryUri(io.X509Certificate, "dart:io");
>+io._FilterStatus = class _FilterStatus extends core.Object {};
>+(io._FilterStatus.new = function() {
>+  this.progress = false;
>+  this.readEmpty = true;
>+  this.writeEmpty = true;
>+  this.readPlaintextNoLongerEmpty = false;
>+  this.writePlaintextNoLongerFull = false;
>+  this.readEncryptedNoLongerFull = false;
>+  this.writeEncryptedNoLongerEmpty = false;
>+}).prototype = io._FilterStatus.prototype;
>+dart.addTypeTests(io._FilterStatus);
>+dart.setLibraryUri(io._FilterStatus, "dart:io");
>+dart.setFieldSignature(io._FilterStatus, () => ({
>+  __proto__: dart.getFields(io._FilterStatus.__proto__),
>+  progress: dart.fieldType(core.bool),
>+  readEmpty: dart.fieldType(core.bool),
>+  writeEmpty: dart.fieldType(core.bool),
>+  readPlaintextNoLongerEmpty: dart.fieldType(core.bool),
>+  writePlaintextNoLongerFull: dart.fieldType(core.bool),
>+  readEncryptedNoLongerFull: dart.fieldType(core.bool),
>+  writeEncryptedNoLongerEmpty: dart.fieldType(core.bool)
>+}));
>+const _socketSubscription = dart.privateName(io, "_socketSubscription");
>+const _bufferedData = dart.privateName(io, "_bufferedData");
>+const _handshakeComplete = dart.privateName(io, "_handshakeComplete");
>+const _stream$ = dart.privateName(io, "_stream");
>+const _bufferedDataIndex = dart.privateName(io, "_bufferedDataIndex");
>+const _status = dart.privateName(io, "_status");
>+const _writeEventsEnabled = dart.privateName(io, "_writeEventsEnabled");
>+const _readEventsEnabled = dart.privateName(io, "_readEventsEnabled");
>+const _pauseCount = dart.privateName(io, "_pauseCount");
>+const _pendingReadEvent = dart.privateName(io, "_pendingReadEvent");
>+const _socketClosedRead = dart.privateName(io, "_socketClosedRead");
>+const _socketClosedWrite = dart.privateName(io, "_socketClosedWrite");
>+const _closedRead = dart.privateName(io, "_closedRead");
>+const _closedWrite = dart.privateName(io, "_closedWrite");
>+const _filterStatus = dart.privateName(io, "_filterStatus");
>+const _connectPending = dart.privateName(io, "_connectPending");
>+const _filterPending = dart.privateName(io, "_filterPending");
>+const _filterActive = dart.privateName(io, "_filterActive");
>+const _secureFilter = dart.privateName(io, "_secureFilter");
>+const _selectedProtocol = dart.privateName(io, "_selectedProtocol");
>+const _secureHandshakeCompleteHandler = dart.privateName(io, "_secureHandshakeCompleteHandler");
>+const _onBadCertificateWrapper = dart.privateName(io, "_onBadCertificateWrapper");
>+const _eventDispatcher = dart.privateName(io, "_eventDispatcher");
>+const _reportError = dart.privateName(io, "_reportError");
>+const _doneHandler = dart.privateName(io, "_doneHandler");
>+const _secureHandshake = dart.privateName(io, "_secureHandshake");
>+const _sendWriteEvent = dart.privateName(io, "_sendWriteEvent");
>+const _completeCloseCompleter = dart.privateName(io, "_completeCloseCompleter");
>+const _close$ = dart.privateName(io, "_close");
>+const _scheduleReadEvent = dart.privateName(io, "_scheduleReadEvent");
>+const _scheduleFilter = dart.privateName(io, "_scheduleFilter");
>+const _readHandler = dart.privateName(io, "_readHandler");
>+const _writeHandler = dart.privateName(io, "_writeHandler");
>+const _closeHandler = dart.privateName(io, "_closeHandler");
>+const _readSocket = dart.privateName(io, "_readSocket");
>+const _writeSocket = dart.privateName(io, "_writeSocket");
>+const _tryFilter = dart.privateName(io, "_tryFilter");
>+const _pushAllFilterStages = dart.privateName(io, "_pushAllFilterStages");
>+const _readSocketOrBufferedData = dart.privateName(io, "_readSocketOrBufferedData");
>+const _sendReadEvent = dart.privateName(io, "_sendReadEvent");
>+const _value$2 = dart.privateName(io, "_value");
>+let const$72;
>+io.RawSocketEvent = class RawSocketEvent extends core.Object {
>+  toString() {
>+    return (const$72 || (const$72 = dart.constList(["RawSocketEvent.read", "RawSocketEvent.write", "RawSocketEvent.readClosed", "RawSocketEvent.closed"], core.String)))[$_get](this[_value$2]);
>+  }
>+};
>+(io.RawSocketEvent.__ = function(value) {
>+  this[_value$2] = value;
>+}).prototype = io.RawSocketEvent.prototype;
>+dart.addTypeTests(io.RawSocketEvent);
>+dart.setLibraryUri(io.RawSocketEvent, "dart:io");
>+dart.setFieldSignature(io.RawSocketEvent, () => ({
>+  __proto__: dart.getFields(io.RawSocketEvent.__proto__),
>+  [_value$2]: dart.finalFieldType(core.int)
>+}));
>+dart.defineExtensionMethods(io.RawSocketEvent, ['toString']);
>+dart.defineLazy(io.RawSocketEvent, {
>+  /*io.RawSocketEvent.read*/get read() {
>+    return dart.const(new io.RawSocketEvent.__(0));
>+  },
>+  /*io.RawSocketEvent.write*/get write() {
>+    return dart.const(new io.RawSocketEvent.__(1));
>+  },
>+  /*io.RawSocketEvent.readClosed*/get readClosed() {
>+    return dart.const(new io.RawSocketEvent.__(2));
>+  },
>+  /*io.RawSocketEvent.closed*/get closed() {
>+    return dart.const(new io.RawSocketEvent.__(3));
>+  },
>+  /*io.RawSocketEvent.READ*/get READ() {
>+    return io.RawSocketEvent.read;
>+  },
>+  /*io.RawSocketEvent.WRITE*/get WRITE() {
>+    return io.RawSocketEvent.write;
>+  },
>+  /*io.RawSocketEvent.READ_CLOSED*/get READ_CLOSED() {
>+    return io.RawSocketEvent.readClosed;
>+  },
>+  /*io.RawSocketEvent.CLOSED*/get CLOSED() {
>+    return io.RawSocketEvent.closed;
>+  }
>+});
>+io._RawSecureSocket = class _RawSecureSocket extends async.Stream$(io.RawSocketEvent) {
>+  static _isBufferEncrypted(identifier) {
>+    return dart.notNull(identifier) >= 2;
>+  }
>+  static connect(host, requestedPort, opts) {
>+    let is_server = opts && 'is_server' in opts ? opts.is_server : null;
>+    let context = opts && 'context' in opts ? opts.context : null;
>+    let socket = opts && 'socket' in opts ? opts.socket : null;
>+    let subscription = opts && 'subscription' in opts ? opts.subscription : null;
>+    let bufferedData = opts && 'bufferedData' in opts ? opts.bufferedData : null;
>+    let requestClientCertificate = opts && 'requestClientCertificate' in opts ? opts.requestClientCertificate : false;
>+    let requireClientCertificate = opts && 'requireClientCertificate' in opts ? opts.requireClientCertificate : false;
>+    let onBadCertificate = opts && 'onBadCertificate' in opts ? opts.onBadCertificate : null;
>+    let supportedProtocols = opts && 'supportedProtocols' in opts ? opts.supportedProtocols : null;
>+    io._RawSecureSocket._verifyFields(host, requestedPort, is_server, requestClientCertificate, requireClientCertificate, onBadCertificate);
>+    if (io.InternetAddress.is(host)) host = dart.dload(host, 'host');
>+    let address = socket.address;
>+    if (host != null) {
>+      address = io.InternetAddress._cloneWithNewHost(address, core.String._check(host));
>+    }
>+    return new io._RawSecureSocket.new(address, requestedPort, is_server, context, socket, subscription, bufferedData, requestClientCertificate, requireClientCertificate, onBadCertificate, supportedProtocols)[_handshakeComplete].future;
>+  }
>+  listen(onData, opts) {
>+    let onError = opts && 'onError' in opts ? opts.onError : null;
>+    let onDone = opts && 'onDone' in opts ? opts.onDone : null;
>+    let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
>+    this[_sendWriteEvent]();
>+    return this[_stream$].listen(onData, {onError: onError, onDone: onDone, cancelOnError: cancelOnError});
>+  }
>+  static _verifyFields(host, requestedPort, is_server, requestClientCertificate, requireClientCertificate, onBadCertificate) {
>+    if (!(typeof host == 'string') && !io.InternetAddress.is(host)) {
>+      dart.throw(new core.ArgumentError.new("host is not a String or an InternetAddress"));
>+    }
>+    core.ArgumentError.checkNotNull(requestedPort, "requestedPort");
>+    if (dart.notNull(requestedPort) < 0 || dart.notNull(requestedPort) > 65535) {
>+      dart.throw(new core.ArgumentError.new("requestedPort is not in the range 0..65535"));
>+    }
>+    core.ArgumentError.checkNotNull(requestClientCertificate, "requestClientCertificate");
>+    core.ArgumentError.checkNotNull(requireClientCertificate, "requireClientCertificate");
>+  }
>+  get port() {
>+    return this[_socket].port;
>+  }
>+  get remoteAddress() {
>+    return this[_socket].remoteAddress;
>+  }
>+  get remotePort() {
>+    return this[_socket].remotePort;
>+  }
>+  set [_owner](owner) {
>+    dart.dput(this[_socket], _owner, owner);
>+  }
>+  available() {
>+    return this[_status] !== 202 ? 0 : this[_secureFilter].buffers[$_get](0).length;
>+  }
>+  close() {
>+    this.shutdown(io.SocketDirection.both);
>+    return this[_closeCompleter].future;
>+  }
>+  [_completeCloseCompleter](dummy) {
>+    if (dummy === void 0) dummy = null;
>+    if (!dart.test(this[_closeCompleter].isCompleted)) this[_closeCompleter].complete(this);
>+  }
>+  [_close$]() {
>+    this[_closedWrite] = true;
>+    this[_closedRead] = true;
>+    if (this[_socket] != null) {
>+      this[_socket].close().then(dart.void, dart.bind(this, _completeCloseCompleter));
>+    } else {
>+      this[_completeCloseCompleter]();
>+    }
>+    this[_socketClosedWrite] = true;
>+    this[_socketClosedRead] = true;
>+    if (!dart.test(this[_filterActive]) && this[_secureFilter] != null) {
>+      this[_secureFilter].destroy();
>+      this[_secureFilter] = null;
>+    }
>+    if (this[_socketSubscription] != null) {
>+      this[_socketSubscription].cancel();
>+    }
>+    this[_controller$].close();
>+    this[_status] = 203;
>+  }
>+  shutdown(direction) {
>+    if (dart.equals(direction, io.SocketDirection.send) || dart.equals(direction, io.SocketDirection.both)) {
>+      this[_closedWrite] = true;
>+      if (dart.test(this[_filterStatus].writeEmpty)) {
>+        this[_socket].shutdown(io.SocketDirection.send);
>+        this[_socketClosedWrite] = true;
>+        if (dart.test(this[_closedRead])) {
>+          this[_close$]();
>+        }
>+      }
>+    }
>+    if (dart.equals(direction, io.SocketDirection.receive) || dart.equals(direction, io.SocketDirection.both)) {
>+      this[_closedRead] = true;
>+      this[_socketClosedRead] = true;
>+      this[_socket].shutdown(io.SocketDirection.receive);
>+      if (dart.test(this[_socketClosedWrite])) {
>+        this[_close$]();
>+      }
>+    }
>+  }
>+  get writeEventsEnabled() {
>+    return this[_writeEventsEnabled];
>+  }
>+  set writeEventsEnabled(value) {
>+    this[_writeEventsEnabled] = value;
>+    if (dart.test(value)) {
>+      async.Timer.run(dart.fn(() => this[_sendWriteEvent](), VoidTodynamic()));
>+    }
>+  }
>+  get readEventsEnabled() {
>+    return this[_readEventsEnabled];
>+  }
>+  set readEventsEnabled(value) {
>+    this[_readEventsEnabled] = value;
>+    this[_scheduleReadEvent]();
>+  }
>+  read(length) {
>+    if (length === void 0) length = null;
>+    if (length != null && (!core.int.is(length) || dart.notNull(length) < 0)) {
>+      dart.throw(new core.ArgumentError.new("Invalid length parameter in SecureSocket.read (length: " + dart.str(length) + ")"));
>+    }
>+    if (dart.test(this[_closedRead])) {
>+      dart.throw(new io.SocketException.new("Reading from a closed socket"));
>+    }
>+    if (this[_status] !== 202) {
>+      return null;
>+    }
>+    let result = this[_secureFilter].buffers[$_get](0).read(length);
>+    this[_scheduleFilter]();
>+    return result;
>+  }
>+  write(data, offset, bytes) {
>+    if (offset === void 0) offset = null;
>+    if (bytes === void 0) bytes = null;
>+    if (bytes != null && (!core.int.is(bytes) || dart.notNull(bytes) < 0)) {
>+      dart.throw(new core.ArgumentError.new("Invalid bytes parameter in SecureSocket.read (bytes: " + dart.str(bytes) + ")"));
>+    }
>+    if (offset != null && (!core.int.is(offset) || dart.notNull(offset) < 0)) {
>+      dart.throw(new core.ArgumentError.new("Invalid offset parameter in SecureSocket.read (offset: " + dart.str(offset) + ")"));
>+    }
>+    if (dart.test(this[_closedWrite])) {
>+      this[_controller$].addError(new io.SocketException.new("Writing to a closed socket"));
>+      return 0;
>+    }
>+    if (this[_status] !== 202) return 0;
>+    let t = offset;
>+    t == null ? offset = 0 : t;
>+    let t$ = bytes;
>+    t$ == null ? bytes = dart.notNull(data[$length]) - dart.notNull(offset) : t$;
>+    let written = this[_secureFilter].buffers[$_get](1).write(data, offset, bytes);
>+    if (dart.notNull(written) > 0) {
>+      this[_filterStatus].writeEmpty = false;
>+    }
>+    this[_scheduleFilter]();
>+    return written;
>+  }
>+  get peerCertificate() {
>+    return this[_secureFilter].peerCertificate;
>+  }
>+  get selectedProtocol() {
>+    return this[_selectedProtocol];
>+  }
>+  [_onBadCertificateWrapper](certificate) {
>+    if (this.onBadCertificate == null) return false;
>+    let result = dart.dcall(this.onBadCertificate, [certificate]);
>+    if (typeof result == 'boolean') return result;
>+    dart.throw(new io.HandshakeException.new("onBadCertificate callback returned non-boolean " + dart.str(result)));
>+  }
>+  setOption(option, enabled) {
>+    if (this[_socket] == null) return false;
>+    return this[_socket].setOption(option, enabled);
>+  }
>+  getRawOption(option) {
>+    let t = this[_socket];
>+    return t == null ? null : t.getRawOption(option);
>+  }
>+  setRawOption(option) {
>+    let t = this[_socket];
>+    t == null ? null : t.setRawOption(option);
>+  }
>+  [_eventDispatcher](event) {
>+    try {
>+      if (dart.equals(event, io.RawSocketEvent.read)) {
>+        this[_readHandler]();
>+      } else if (dart.equals(event, io.RawSocketEvent.write)) {
>+        this[_writeHandler]();
>+      } else if (dart.equals(event, io.RawSocketEvent.readClosed)) {
>+        this[_closeHandler]();
>+      }
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      let stackTrace = dart.stackTrace(e$);
>+      this[_reportError](e, stackTrace);
>+    }
>+  }
>+  [_readHandler]() {
>+    this[_readSocket]();
>+    this[_scheduleFilter]();
>+  }
>+  [_writeHandler]() {
>+    this[_writeSocket]();
>+    this[_scheduleFilter]();
>+  }
>+  [_doneHandler]() {
>+    if (dart.test(this[_filterStatus].readEmpty)) {
>+      this[_close$]();
>+    }
>+  }
>+  [_reportError](e, stackTrace) {
>+    if (stackTrace === void 0) stackTrace = null;
>+    if (this[_status] === 203) {
>+      return;
>+    } else if (dart.test(this[_connectPending])) {
>+      this[_handshakeComplete].completeError(e, stackTrace);
>+    } else {
>+      this[_controller$].addError(e, stackTrace);
>+    }
>+    this[_close$]();
>+  }
>+  [_closeHandler]() {
>+    if (this[_status] === 202) {
>+      if (dart.test(this[_closedRead])) return;
>+      this[_socketClosedRead] = true;
>+      if (dart.test(this[_filterStatus].readEmpty)) {
>+        this[_closedRead] = true;
>+        this[_controller$].add(io.RawSocketEvent.readClosed);
>+        if (dart.test(this[_socketClosedWrite])) {
>+          this[_close$]();
>+        }
>+      } else {
>+        this[_scheduleFilter]();
>+      }
>+    } else if (this[_status] === 201) {
>+      this[_socketClosedRead] = true;
>+      if (dart.test(this[_filterStatus].readEmpty)) {
>+        this[_reportError](new io.HandshakeException.new("Connection terminated during handshake"), null);
>+      } else {
>+        this[_secureHandshake]();
>+      }
>+    }
>+  }
>+  [_secureHandshake]() {
>+    try {
>+      this[_secureFilter].handshake();
>+      this[_filterStatus].writeEmpty = false;
>+      this[_readSocket]();
>+      this[_writeSocket]();
>+      this[_scheduleFilter]();
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      let stackTrace = dart.stackTrace(e$);
>+      this[_reportError](e, stackTrace);
>+    }
>+  }
>+  renegotiate(opts) {
>+    let useSessionCache = opts && 'useSessionCache' in opts ? opts.useSessionCache : true;
>+    let requestClientCertificate = opts && 'requestClientCertificate' in opts ? opts.requestClientCertificate : false;
>+    let requireClientCertificate = opts && 'requireClientCertificate' in opts ? opts.requireClientCertificate : false;
>+    if (this[_status] !== 202) {
>+      dart.throw(new io.HandshakeException.new("Called renegotiate on a non-connected socket"));
>+    }
>+    this[_secureFilter].renegotiate(useSessionCache, requestClientCertificate, requireClientCertificate);
>+    this[_status] = 201;
>+    this[_filterStatus].writeEmpty = false;
>+    this[_scheduleFilter]();
>+  }
>+  [_secureHandshakeCompleteHandler]() {
>+    this[_status] = 202;
>+    if (dart.test(this[_connectPending])) {
>+      this[_connectPending] = false;
>+      try {
>+        this[_selectedProtocol] = this[_secureFilter].selectedProtocol();
>+        async.Timer.run(dart.fn(() => this[_handshakeComplete].complete(this), VoidTovoid()));
>+      } catch (e) {
>+        let error = dart.getThrown(e);
>+        let stack = dart.stackTrace(e);
>+        this[_handshakeComplete].completeError(error, stack);
>+      }
>+    }
>+  }
>+  [_onPauseStateChange]() {
>+    if (dart.test(this[_controller$].isPaused)) {
>+      this[_pauseCount] = dart.notNull(this[_pauseCount]) + 1;
>+    } else {
>+      this[_pauseCount] = dart.notNull(this[_pauseCount]) - 1;
>+      if (this[_pauseCount] === 0) {
>+        this[_scheduleReadEvent]();
>+        this[_sendWriteEvent]();
>+      }
>+    }
>+    if (!dart.test(this[_socketClosedRead]) || !dart.test(this[_socketClosedWrite])) {
>+      if (dart.test(this[_controller$].isPaused)) {
>+        this[_socketSubscription].pause();
>+      } else {
>+        this[_socketSubscription].resume();
>+      }
>+    }
>+  }
>+  [_onSubscriptionStateChange]() {
>+    if (dart.test(this[_controller$].hasListener)) {
>+    }
>+  }
>+  [_scheduleFilter]() {
>+    this[_filterPending] = true;
>+    this[_tryFilter]();
>+  }
>+  [_tryFilter]() {
>+    if (this[_status] === 203) {
>+      return;
>+    }
>+    if (dart.test(this[_filterPending]) && !dart.test(this[_filterActive])) {
>+      this[_filterActive] = true;
>+      this[_filterPending] = false;
>+      FutureOfNull()._check(this[_pushAllFilterStages]().then(core.Null, dart.fn(status => {
>+        this[_filterStatus] = status;
>+        this[_filterActive] = false;
>+        if (this[_status] === 203) {
>+          this[_secureFilter].destroy();
>+          this[_secureFilter] = null;
>+          return;
>+        }
>+        this[_socket].readEventsEnabled = true;
>+        if (dart.test(this[_filterStatus].writeEmpty) && dart.test(this[_closedWrite]) && !dart.test(this[_socketClosedWrite])) {
>+          this.shutdown(io.SocketDirection.send);
>+          if (this[_status] === 203) {
>+            return;
>+          }
>+        }
>+        if (dart.test(this[_filterStatus].readEmpty) && dart.test(this[_socketClosedRead]) && !dart.test(this[_closedRead])) {
>+          if (this[_status] === 201) {
>+            this[_secureFilter].handshake();
>+            if (this[_status] === 201) {
>+              dart.throw(new io.HandshakeException.new("Connection terminated during handshake"));
>+            }
>+          }
>+          this[_closeHandler]();
>+        }
>+        if (this[_status] === 203) {
>+          return;
>+        }
>+        if (dart.test(this[_filterStatus].progress)) {
>+          this[_filterPending] = true;
>+          if (dart.test(this[_filterStatus].writeEncryptedNoLongerEmpty)) {
>+            this[_writeSocket]();
>+          }
>+          if (dart.test(this[_filterStatus].writePlaintextNoLongerFull)) {
>+            this[_sendWriteEvent]();
>+          }
>+          if (dart.test(this[_filterStatus].readEncryptedNoLongerFull)) {
>+            this[_readSocket]();
>+          }
>+          if (dart.test(this[_filterStatus].readPlaintextNoLongerEmpty)) {
>+            this[_scheduleReadEvent]();
>+          }
>+          if (this[_status] === 201) {
>+            this[_secureHandshake]();
>+          }
>+        }
>+        this[_tryFilter]();
>+      }, _FilterStatusToNull()))).catchError(dart.bind(this, _reportError));
>+    }
>+  }
>+  [_readSocketOrBufferedData](bytes) {
>+    if (this[_bufferedData] != null) {
>+      if (dart.notNull(bytes) > dart.notNull(this[_bufferedData][$length]) - dart.notNull(this[_bufferedDataIndex])) {
>+        bytes = dart.notNull(this[_bufferedData][$length]) - dart.notNull(this[_bufferedDataIndex]);
>+      }
>+      let result = this[_bufferedData][$sublist](this[_bufferedDataIndex], dart.notNull(this[_bufferedDataIndex]) + dart.notNull(bytes));
>+      this[_bufferedDataIndex] = dart.notNull(this[_bufferedDataIndex]) + dart.notNull(bytes);
>+      if (this[_bufferedData][$length] == this[_bufferedDataIndex]) {
>+        this[_bufferedData] = null;
>+      }
>+      return result;
>+    } else if (!dart.test(this[_socketClosedRead])) {
>+      return this[_socket].read(bytes);
>+    } else {
>+      return null;
>+    }
>+  }
>+  [_readSocket]() {
>+    if (this[_status] === 203) return;
>+    let buffer = this[_secureFilter].buffers[$_get](2);
>+    if (dart.notNull(buffer.writeFromSource(dart.bind(this, _readSocketOrBufferedData))) > 0) {
>+      this[_filterStatus].readEmpty = false;
>+    } else {
>+      this[_socket].readEventsEnabled = false;
>+    }
>+  }
>+  [_writeSocket]() {
>+    if (dart.test(this[_socketClosedWrite])) return;
>+    let buffer = this[_secureFilter].buffers[$_get](3);
>+    if (dart.test(buffer.readToSocket(this[_socket]))) {
>+      this[_socket].writeEventsEnabled = true;
>+    }
>+  }
>+  [_scheduleReadEvent]() {
>+    if (!dart.test(this[_pendingReadEvent]) && dart.test(this[_readEventsEnabled]) && this[_pauseCount] === 0 && this[_secureFilter] != null && !dart.test(this[_secureFilter].buffers[$_get](0).isEmpty)) {
>+      this[_pendingReadEvent] = true;
>+      async.Timer.run(dart.bind(this, _sendReadEvent));
>+    }
>+  }
>+  [_sendReadEvent]() {
>+    this[_pendingReadEvent] = false;
>+    if (this[_status] !== 203 && dart.test(this[_readEventsEnabled]) && this[_pauseCount] === 0 && this[_secureFilter] != null && !dart.test(this[_secureFilter].buffers[$_get](0).isEmpty)) {
>+      this[_controller$].add(io.RawSocketEvent.read);
>+      this[_scheduleReadEvent]();
>+    }
>+  }
>+  [_sendWriteEvent]() {
>+    if (!dart.test(this[_closedWrite]) && dart.test(this[_writeEventsEnabled]) && this[_pauseCount] === 0 && this[_secureFilter] != null && dart.notNull(this[_secureFilter].buffers[$_get](1).free) > 0) {
>+      this[_writeEventsEnabled] = false;
>+      this[_controller$].add(io.RawSocketEvent.write);
>+    }
>+  }
>+  [_pushAllFilterStages]() {
>+    let wasInHandshake = this[_status] !== 202;
>+    let args = core.List.new(2 + 4 * 2);
>+    args[$_set](0, this[_secureFilter][_pointer]());
>+    args[$_set](1, wasInHandshake);
>+    let bufs = this[_secureFilter].buffers;
>+    for (let i = 0; i < 4; ++i) {
>+      args[$_set](2 * i + 2, bufs[$_get](i).start);
>+      args[$_set](2 * i + 3, bufs[$_get](i).end);
>+    }
>+    return FutureOf_FilterStatus()._check(io._IOService._dispatch(io._IOService.sslProcessFilter, args).then(io._FilterStatus, dart.fn(response => {
>+      if (dart.equals(dart.dload(response, 'length'), 2)) {
>+        if (wasInHandshake) {
>+          this[_reportError](new io.HandshakeException.new(dart.str(dart.dindex(response, 1)) + " error " + dart.str(dart.dindex(response, 0))), null);
>+        } else {
>+          this[_reportError](new io.TlsException.new(dart.str(dart.dindex(response, 1)) + " error " + dart.str(dart.dindex(response, 0))), null);
>+        }
>+      }
>+      function start(index) {
>+        return core.int._check(dart.dindex(response, 2 * dart.notNull(index)));
>+      }
>+      dart.fn(start, intToint());
>+      function end(index) {
>+        return core.int._check(dart.dindex(response, 2 * dart.notNull(index) + 1));
>+      }
>+      dart.fn(end, intToint());
>+      let status = new io._FilterStatus.new();
>+      status.writeEmpty = dart.test(bufs[$_get](1).isEmpty) && start(3) == end(3);
>+      if (wasInHandshake) status.writeEmpty = false;
>+      status.readEmpty = dart.test(bufs[$_get](2).isEmpty) && start(0) == end(0);
>+      let buffer = bufs[$_get](1);
>+      let new_start = start(1);
>+      if (new_start != buffer.start) {
>+        status.progress = true;
>+        if (buffer.free === 0) {
>+          status.writePlaintextNoLongerFull = true;
>+        }
>+        buffer.start = new_start;
>+      }
>+      buffer = bufs[$_get](2);
>+      new_start = start(2);
>+      if (new_start != buffer.start) {
>+        status.progress = true;
>+        if (buffer.free === 0) {
>+          status.readEncryptedNoLongerFull = true;
>+        }
>+        buffer.start = new_start;
>+      }
>+      buffer = bufs[$_get](3);
>+      let new_end = end(3);
>+      if (new_end != buffer.end) {
>+        status.progress = true;
>+        if (buffer.length === 0) {
>+          status.writeEncryptedNoLongerEmpty = true;
>+        }
>+        buffer.end = new_end;
>+      }
>+      buffer = bufs[$_get](0);
>+      new_end = end(0);
>+      if (new_end != buffer.end) {
>+        status.progress = true;
>+        if (buffer.length === 0) {
>+          status.readPlaintextNoLongerEmpty = true;
>+        }
>+        buffer.end = new_end;
>+      }
>+      return status;
>+    }, dynamicTo_FilterStatus())));
>+  }
>+};
>+(io._RawSecureSocket.new = function(address, requestedPort, is_server, context, socket, socketSubscription, bufferedData, requestClientCertificate, requireClientCertificate, onBadCertificate, supportedProtocols) {
>+  this[_handshakeComplete] = CompleterOf_RawSecureSocket().new();
>+  this[_controller$] = null;
>+  this[_stream$] = null;
>+  this[_bufferedDataIndex] = 0;
>+  this[_status] = 201;
>+  this[_writeEventsEnabled] = true;
>+  this[_readEventsEnabled] = true;
>+  this[_pauseCount] = 0;
>+  this[_pendingReadEvent] = false;
>+  this[_socketClosedRead] = false;
>+  this[_socketClosedWrite] = false;
>+  this[_closedRead] = false;
>+  this[_closedWrite] = false;
>+  this[_closeCompleter] = CompleterOfRawSecureSocket().new();
>+  this[_filterStatus] = new io._FilterStatus.new();
>+  this[_connectPending] = true;
>+  this[_filterPending] = false;
>+  this[_filterActive] = false;
>+  this[_secureFilter] = io._SecureFilter.new();
>+  this[_selectedProtocol] = null;
>+  this.address = address;
>+  this.is_server = is_server;
>+  this.context = context;
>+  this[_socket] = socket;
>+  this[_socketSubscription] = socketSubscription;
>+  this[_bufferedData] = bufferedData;
>+  this.requestClientCertificate = requestClientCertificate;
>+  this.requireClientCertificate = requireClientCertificate;
>+  this.onBadCertificate = onBadCertificate;
>+  io._RawSecureSocket.__proto__.new.call(this);
>+  let t = this.context;
>+  t == null ? this.context = io.SecurityContext.defaultContext : t;
>+  this[_controller$] = StreamControllerOfRawSocketEvent().new({sync: true, onListen: dart.bind(this, _onSubscriptionStateChange), onPause: dart.bind(this, _onPauseStateChange), onResume: dart.bind(this, _onPauseStateChange), onCancel: dart.bind(this, _onSubscriptionStateChange)});
>+  this[_stream$] = this[_controller$].stream;
>+  this[_secureFilter].init();
>+  this[_secureFilter].registerHandshakeCompleteCallback(dart.bind(this, _secureHandshakeCompleteHandler));
>+  if (this.onBadCertificate != null) {
>+    this[_secureFilter].registerBadCertificateCallback(dart.bind(this, _onBadCertificateWrapper));
>+  }
>+  this[_socket].readEventsEnabled = true;
>+  this[_socket].writeEventsEnabled = false;
>+  if (this[_socketSubscription] == null) {
>+    this[_socketSubscription] = this[_socket].listen(dart.bind(this, _eventDispatcher), {onError: dart.bind(this, _reportError), onDone: dart.bind(this, _doneHandler)});
>+  } else {
>+    if (dart.test(this[_socketSubscription].isPaused)) {
>+      this[_socket].close();
>+      dart.throw(new core.ArgumentError.new("Subscription passed to TLS upgrade is paused"));
>+    }
>+    let s = this[_socket];
>+    if (dart.dtest(dart.dload(dart.dload(s, _socket), 'closedReadEventSent'))) {
>+      this[_eventDispatcher](io.RawSocketEvent.readClosed);
>+    }
>+    let _ = this[_socketSubscription];
>+    _.onData(dart.bind(this, _eventDispatcher));
>+    _.onError(dart.bind(this, _reportError));
>+    _.onDone(dart.bind(this, _doneHandler));
>+  }
>+  try {
>+    let encodedProtocols = io.SecurityContext._protocolsToLengthEncoding(supportedProtocols);
>+    this[_secureFilter].connect(this.address.host, this.context, this.is_server, dart.test(this.requestClientCertificate) || dart.test(this.requireClientCertificate), this.requireClientCertificate, encodedProtocols);
>+    this[_secureHandshake]();
>+  } catch (e$) {
>+    let e = dart.getThrown(e$);
>+    let s = dart.stackTrace(e$);
>+    this[_reportError](e, s);
>+  }
>+}).prototype = io._RawSecureSocket.prototype;
>+dart.addTypeTests(io._RawSecureSocket);
>+io._RawSecureSocket[dart.implements] = () => [io.RawSecureSocket];
>+dart.setMethodSignature(io._RawSecureSocket, () => ({
>+  __proto__: dart.getMethods(io._RawSecureSocket.__proto__),
>+  listen: dart.fnType(async.StreamSubscription$(io.RawSocketEvent), [dart.fnType(dart.void, [io.RawSocketEvent])], {onError: core.Function, onDone: dart.fnType(dart.void, []), cancelOnError: core.bool}),
>+  available: dart.fnType(core.int, []),
>+  close: dart.fnType(async.Future$(io.RawSecureSocket), []),
>+  [_completeCloseCompleter]: dart.fnType(dart.void, [], [io.RawSocket]),
>+  [_close$]: dart.fnType(dart.void, []),
>+  shutdown: dart.fnType(dart.void, [io.SocketDirection]),
>+  read: dart.fnType(core.List$(core.int), [], [core.int]),
>+  write: dart.fnType(core.int, [core.List$(core.int)], [core.int, core.int]),
>+  [_onBadCertificateWrapper]: dart.fnType(core.bool, [io.X509Certificate]),
>+  setOption: dart.fnType(core.bool, [io.SocketOption, core.bool]),
>+  getRawOption: dart.fnType(typed_data.Uint8List, [io.RawSocketOption]),
>+  setRawOption: dart.fnType(dart.void, [io.RawSocketOption]),
>+  [_eventDispatcher]: dart.fnType(dart.void, [io.RawSocketEvent]),
>+  [_readHandler]: dart.fnType(dart.void, []),
>+  [_writeHandler]: dart.fnType(dart.void, []),
>+  [_doneHandler]: dart.fnType(dart.void, []),
>+  [_reportError]: dart.fnType(dart.void, [dart.dynamic], [core.StackTrace]),
>+  [_closeHandler]: dart.fnType(dart.void, []),
>+  [_secureHandshake]: dart.fnType(dart.void, []),
>+  renegotiate: dart.fnType(dart.void, [], {useSessionCache: core.bool, requestClientCertificate: core.bool, requireClientCertificate: core.bool}),
>+  [_secureHandshakeCompleteHandler]: dart.fnType(dart.void, []),
>+  [_onPauseStateChange]: dart.fnType(dart.void, []),
>+  [_onSubscriptionStateChange]: dart.fnType(dart.void, []),
>+  [_scheduleFilter]: dart.fnType(dart.void, []),
>+  [_tryFilter]: dart.fnType(dart.void, []),
>+  [_readSocketOrBufferedData]: dart.fnType(core.List$(core.int), [core.int]),
>+  [_readSocket]: dart.fnType(dart.void, []),
>+  [_writeSocket]: dart.fnType(dart.void, []),
>+  [_scheduleReadEvent]: dart.fnType(dart.dynamic, []),
>+  [_sendReadEvent]: dart.fnType(dart.dynamic, []),
>+  [_sendWriteEvent]: dart.fnType(dart.dynamic, []),
>+  [_pushAllFilterStages]: dart.fnType(async.Future$(io._FilterStatus), [])
>+}));
>+dart.setGetterSignature(io._RawSecureSocket, () => ({
>+  __proto__: dart.getGetters(io._RawSecureSocket.__proto__),
>+  port: core.int,
>+  remoteAddress: io.InternetAddress,
>+  remotePort: core.int,
>+  writeEventsEnabled: core.bool,
>+  readEventsEnabled: core.bool,
>+  peerCertificate: io.X509Certificate,
>+  selectedProtocol: core.String
>+}));
>+dart.setSetterSignature(io._RawSecureSocket, () => ({
>+  __proto__: dart.getSetters(io._RawSecureSocket.__proto__),
>+  [_owner]: dart.dynamic,
>+  writeEventsEnabled: core.bool,
>+  readEventsEnabled: core.bool
>+}));
>+dart.setLibraryUri(io._RawSecureSocket, "dart:io");
>+dart.setFieldSignature(io._RawSecureSocket, () => ({
>+  __proto__: dart.getFields(io._RawSecureSocket.__proto__),
>+  [_socket]: dart.fieldType(io.RawSocket),
>+  [_handshakeComplete]: dart.finalFieldType(CompleterOf_RawSecureSocket()),
>+  [_controller$]: dart.fieldType(StreamControllerOfRawSocketEvent()),
>+  [_stream$]: dart.fieldType(StreamOfRawSocketEvent()),
>+  [_socketSubscription]: dart.fieldType(StreamSubscriptionOfRawSocketEvent()),
>+  [_bufferedData]: dart.fieldType(ListOfint()),
>+  [_bufferedDataIndex]: dart.fieldType(core.int),
>+  address: dart.finalFieldType(io.InternetAddress),
>+  is_server: dart.finalFieldType(core.bool),
>+  context: dart.fieldType(io.SecurityContext),
>+  requestClientCertificate: dart.finalFieldType(core.bool),
>+  requireClientCertificate: dart.finalFieldType(core.bool),
>+  onBadCertificate: dart.finalFieldType(core.Function),
>+  [_status]: dart.fieldType(core.int),
>+  [_writeEventsEnabled]: dart.fieldType(core.bool),
>+  [_readEventsEnabled]: dart.fieldType(core.bool),
>+  [_pauseCount]: dart.fieldType(core.int),
>+  [_pendingReadEvent]: dart.fieldType(core.bool),
>+  [_socketClosedRead]: dart.fieldType(core.bool),
>+  [_socketClosedWrite]: dart.fieldType(core.bool),
>+  [_closedRead]: dart.fieldType(core.bool),
>+  [_closedWrite]: dart.fieldType(core.bool),
>+  [_closeCompleter]: dart.fieldType(CompleterOfRawSecureSocket()),
>+  [_filterStatus]: dart.fieldType(io._FilterStatus),
>+  [_connectPending]: dart.fieldType(core.bool),
>+  [_filterPending]: dart.fieldType(core.bool),
>+  [_filterActive]: dart.fieldType(core.bool),
>+  [_secureFilter]: dart.fieldType(io._SecureFilter),
>+  [_selectedProtocol]: dart.fieldType(core.String)
>+}));
>+dart.defineLazy(io._RawSecureSocket, {
>+  /*io._RawSecureSocket.handshakeStatus*/get handshakeStatus() {
>+    return 201;
>+  },
>+  /*io._RawSecureSocket.connectedStatus*/get connectedStatus() {
>+    return 202;
>+  },
>+  /*io._RawSecureSocket.closedStatus*/get closedStatus() {
>+    return 203;
>+  },
>+  /*io._RawSecureSocket.readPlaintextId*/get readPlaintextId() {
>+    return 0;
>+  },
>+  /*io._RawSecureSocket.writePlaintextId*/get writePlaintextId() {
>+    return 1;
>+  },
>+  /*io._RawSecureSocket.readEncryptedId*/get readEncryptedId() {
>+    return 2;
>+  },
>+  /*io._RawSecureSocket.writeEncryptedId*/get writeEncryptedId() {
>+    return 3;
>+  },
>+  /*io._RawSecureSocket.bufferCount*/get bufferCount() {
>+    return 4;
>+  }
>+});
>+io._ExternalBuffer = class _ExternalBuffer extends core.Object {
>+  advanceStart(bytes) {
>+    if (!(dart.notNull(this.start) > dart.notNull(this.end) || dart.notNull(this.start) + dart.notNull(bytes) <= dart.notNull(this.end))) dart.assertFailed(null, "dart:io/secure_socket.dart", 1131, 12, "start > end || start + bytes <= end");
>+    this.start = dart.notNull(this.start) + dart.notNull(bytes);
>+    if (dart.notNull(this.start) >= dart.notNull(core.num._check(this.size))) {
>+      this.start = dart.notNull(this.start) - dart.notNull(core.num._check(this.size));
>+      if (!(dart.notNull(this.start) <= dart.notNull(this.end))) dart.assertFailed(null, "dart:io/secure_socket.dart", 1135, 14, "start <= end");
>+      if (!(dart.notNull(this.start) < dart.notNull(core.num._check(this.size)))) dart.assertFailed(null, "dart:io/secure_socket.dart", 1136, 14, "start < size as ");
>+    }
>+  }
>+  advanceEnd(bytes) {
>+    if (!(dart.notNull(this.start) <= dart.notNull(this.end) || dart.notNull(this.start) > dart.notNull(this.end) + dart.notNull(bytes))) dart.assertFailed(null, "dart:io/secure_socket.dart", 1141, 12, "start <= end || start > end + bytes");
>+    this.end = dart.notNull(this.end) + dart.notNull(bytes);
>+    if (dart.notNull(this.end) >= dart.notNull(core.num._check(this.size))) {
>+      this.end = dart.notNull(this.end) - dart.notNull(core.num._check(this.size));
>+      if (!(dart.notNull(this.end) < dart.notNull(this.start))) dart.assertFailed(null, "dart:io/secure_socket.dart", 1145, 14, "end < start");
>+      if (!(dart.notNull(this.end) < dart.notNull(core.num._check(this.size)))) dart.assertFailed(null, "dart:io/secure_socket.dart", 1146, 14, "end < size as ");
>+    }
>+  }
>+  get isEmpty() {
>+    return this.end == this.start;
>+  }
>+  get length() {
>+    return core.int._check(dart.notNull(this.start) > dart.notNull(this.end) ? dart.dsend(dart.dsend(this.size, '+', [this.end]), '-', [this.start]) : dart.notNull(this.end) - dart.notNull(this.start));
>+  }
>+  get linearLength() {
>+    return core.int._check(dart.notNull(this.start) > dart.notNull(this.end) ? dart.dsend(this.size, '-', [this.start]) : dart.notNull(this.end) - dart.notNull(this.start));
>+  }
>+  get free() {
>+    return core.int._check(dart.notNull(this.start) > dart.notNull(this.end) ? dart.notNull(this.start) - dart.notNull(this.end) - 1 : dart.dsend(dart.dsend(dart.dsend(this.size, '+', [this.start]), '-', [this.end]), '-', [1]));
>+  }
>+  get linearFree() {
>+    if (dart.notNull(this.start) > dart.notNull(this.end)) return dart.notNull(this.start) - dart.notNull(this.end) - 1;
>+    if (this.start === 0) return core.int._check(dart.dsend(dart.dsend(this.size, '-', [this.end]), '-', [1]));
>+    return core.int._check(dart.dsend(this.size, '-', [this.end]));
>+  }
>+  read(bytes) {
>+    if (bytes == null) {
>+      bytes = this.length;
>+    } else {
>+      bytes = math.min(core.int, bytes, this.length);
>+    }
>+    if (bytes === 0) return null;
>+    let result = typed_data.Uint8List.new(bytes);
>+    let bytesRead = 0;
>+    while (bytesRead < dart.notNull(bytes)) {
>+      let toRead = math.min(core.int, dart.notNull(bytes) - bytesRead, this.linearLength);
>+      result[$setRange](bytesRead, bytesRead + toRead, this.data, this.start);
>+      this.advanceStart(toRead);
>+      bytesRead = bytesRead + toRead;
>+    }
>+    return result;
>+  }
>+  write(inputData, offset, bytes) {
>+    if (dart.notNull(bytes) > dart.notNull(this.free)) {
>+      bytes = this.free;
>+    }
>+    let written = 0;
>+    let toWrite = math.min(core.int, bytes, this.linearFree);
>+    while (toWrite > 0) {
>+      this.data[$setRange](this.end, dart.notNull(this.end) + toWrite, inputData, offset);
>+      this.advanceEnd(toWrite);
>+      offset = dart.notNull(offset) + toWrite;
>+      written = written + toWrite;
>+      toWrite = math.min(core.int, dart.notNull(bytes) - written, this.linearFree);
>+    }
>+    return written;
>+  }
>+  writeFromSource(getData) {
>+    let written = 0;
>+    let toWrite = this.linearFree;
>+    while (dart.notNull(toWrite) > 0) {
>+      let inputData = getData(toWrite);
>+      if (inputData == null || inputData[$length] === 0) break;
>+      let len = inputData[$length];
>+      this.data[$setRange](this.end, dart.notNull(this.end) + dart.notNull(len), inputData);
>+      this.advanceEnd(len);
>+      written = written + dart.notNull(len);
>+      toWrite = this.linearFree;
>+    }
>+    return written;
>+  }
>+  readToSocket(socket) {
>+    while (true) {
>+      let toWrite = this.linearLength;
>+      if (toWrite === 0) return false;
>+      let bytes = socket.write(this.data, this.start, toWrite);
>+      this.advanceStart(bytes);
>+      if (dart.notNull(bytes) < dart.notNull(toWrite)) {
>+        return true;
>+      }
>+    }
>+  }
>+};
>+(io._ExternalBuffer.new = function(size) {
>+  this.data = null;
>+  this.start = null;
>+  this.end = null;
>+  this.size = size;
>+  this.start = core.int._check(this.end = core.int._check(dart.dsend(this.size, '~/', [2])));
>+}).prototype = io._ExternalBuffer.prototype;
>+dart.addTypeTests(io._ExternalBuffer);
>+dart.setMethodSignature(io._ExternalBuffer, () => ({
>+  __proto__: dart.getMethods(io._ExternalBuffer.__proto__),
>+  advanceStart: dart.fnType(dart.void, [core.int]),
>+  advanceEnd: dart.fnType(dart.void, [core.int]),
>+  read: dart.fnType(core.List$(core.int), [core.int]),
>+  write: dart.fnType(core.int, [core.List$(core.int), core.int, core.int]),
>+  writeFromSource: dart.fnType(core.int, [dart.fnType(core.List$(core.int), [core.int])]),
>+  readToSocket: dart.fnType(core.bool, [io.RawSocket])
>+}));
>+dart.setGetterSignature(io._ExternalBuffer, () => ({
>+  __proto__: dart.getGetters(io._ExternalBuffer.__proto__),
>+  isEmpty: core.bool,
>+  length: core.int,
>+  linearLength: core.int,
>+  free: core.int,
>+  linearFree: core.int
>+}));
>+dart.setLibraryUri(io._ExternalBuffer, "dart:io");
>+dart.setFieldSignature(io._ExternalBuffer, () => ({
>+  __proto__: dart.getFields(io._ExternalBuffer.__proto__),
>+  data: dart.fieldType(ListOfint()),
>+  start: dart.fieldType(core.int),
>+  end: dart.fieldType(core.int),
>+  size: dart.finalFieldType(dart.dynamic)
>+}));
>+io._SecureFilter = class _SecureFilter extends core.Object {
>+  static new() {
>+    dart.throw(new core.UnsupportedError.new("_SecureFilter._SecureFilter"));
>+  }
>+};
>+(io._SecureFilter[dart.mixinNew] = function() {
>+}).prototype = io._SecureFilter.prototype;
>+dart.addTypeTests(io._SecureFilter);
>+dart.setLibraryUri(io._SecureFilter, "dart:io");
>+io.TlsException = class TlsException extends core.Object {
>+  get type() {
>+    return this[type$1];
>+  }
>+  set type(value) {
>+    super.type = value;
>+  }
>+  get message() {
>+    return this[message$11];
>+  }
>+  set message(value) {
>+    super.message = value;
>+  }
>+  get osError() {
>+    return this[osError$1];
>+  }
>+  set osError(value) {
>+    super.osError = value;
>+  }
>+  toString() {
>+    let sb = new core.StringBuffer.new();
>+    sb.write(this.type);
>+    if (this.message[$isNotEmpty]) {
>+      sb.write(": " + dart.str(this.message));
>+      if (this.osError != null) {
>+        sb.write(" (" + dart.str(this.osError) + ")");
>+      }
>+    } else if (this.osError != null) {
>+      sb.write(": " + dart.str(this.osError));
>+    }
>+    return sb.toString();
>+  }
>+};
>+(io.TlsException.new = function(message, osError) {
>+  if (message === void 0) message = "";
>+  if (osError === void 0) osError = null;
>+  io.TlsException.__.call(this, "TlsException", message, osError);
>+}).prototype = io.TlsException.prototype;
>+(io.TlsException.__ = function(type, message, osError) {
>+  this[type$1] = type;
>+  this[message$11] = message;
>+  this[osError$1] = osError;
>+}).prototype = io.TlsException.prototype;
>+dart.addTypeTests(io.TlsException);
>+const type$1 = Symbol("TlsException.type");
>+const message$11 = Symbol("TlsException.message");
>+const osError$1 = Symbol("TlsException.osError");
>+io.TlsException[dart.implements] = () => [io.IOException];
>+dart.setLibraryUri(io.TlsException, "dart:io");
>+dart.setFieldSignature(io.TlsException, () => ({
>+  __proto__: dart.getFields(io.TlsException.__proto__),
>+  type: dart.finalFieldType(core.String),
>+  message: dart.finalFieldType(core.String),
>+  osError: dart.finalFieldType(io.OSError)
>+}));
>+dart.defineExtensionMethods(io.TlsException, ['toString']);
>+io.HandshakeException = class HandshakeException extends io.TlsException {};
>+(io.HandshakeException.new = function(message, osError) {
>+  if (message === void 0) message = "";
>+  if (osError === void 0) osError = null;
>+  io.HandshakeException.__proto__.__.call(this, "HandshakeException", message, osError);
>+}).prototype = io.HandshakeException.prototype;
>+dart.addTypeTests(io.HandshakeException);
>+dart.setLibraryUri(io.HandshakeException, "dart:io");
>+io.CertificateException = class CertificateException extends io.TlsException {};
>+(io.CertificateException.new = function(message, osError) {
>+  if (message === void 0) message = "";
>+  if (osError === void 0) osError = null;
>+  io.CertificateException.__proto__.__.call(this, "CertificateException", message, osError);
>+}).prototype = io.CertificateException.prototype;
>+dart.addTypeTests(io.CertificateException);
>+dart.setLibraryUri(io.CertificateException, "dart:io");
>+io.SecurityContext = class SecurityContext extends core.Object {
>+  static new(opts) {
>+    let withTrustedRoots = opts && 'withTrustedRoots' in opts ? opts.withTrustedRoots : false;
>+    dart.throw(new core.UnsupportedError.new("SecurityContext constructor"));
>+  }
>+  static get defaultContext() {
>+    dart.throw(new core.UnsupportedError.new("default SecurityContext getter"));
>+  }
>+  static get alpnSupported() {
>+    dart.throw(new core.UnsupportedError.new("SecurityContext alpnSupported getter"));
>+  }
>+  static _protocolsToLengthEncoding(protocols) {
>+    if (protocols == null || protocols[$length] === 0) {
>+      return typed_data.Uint8List.new(0);
>+    }
>+    let protocolsLength = protocols[$length];
>+    let expectedLength = protocolsLength;
>+    for (let i = 0; i < dart.notNull(protocolsLength); i++) {
>+      let length = protocols[$_get](i).length;
>+      if (length > 0 && length <= 255) {
>+        expectedLength = dart.notNull(expectedLength) + length;
>+      } else {
>+        dart.throw(new core.ArgumentError.new("Length of protocol must be between 1 and 255 (was: " + dart.str(length) + ")."));
>+      }
>+    }
>+    if (dart.notNull(expectedLength) >= 1 << 13) {
>+      dart.throw(new core.ArgumentError.new("The maximum message length supported is 2^13-1."));
>+    }
>+    let bytes = typed_data.Uint8List.new(expectedLength);
>+    let bytesOffset = 0;
>+    for (let i = 0; i < dart.notNull(protocolsLength); i++) {
>+      let proto = protocols[$_get](i);
>+      bytes[$_set](bytesOffset++, proto.length);
>+      let bits = 0;
>+      for (let j = 0; j < proto.length; j++) {
>+        let char = proto[$codeUnitAt](j);
>+        bits = (bits | char) >>> 0;
>+        bytes[$_set](bytesOffset++, char & 255);
>+      }
>+      if (bits > 127) {
>+        return io.SecurityContext._protocolsToLengthEncodingNonAsciiBailout(protocols);
>+      }
>+    }
>+    return bytes;
>+  }
>+  static _protocolsToLengthEncodingNonAsciiBailout(protocols) {
>+    function addProtocol(outBytes, protocol) {
>+      let protocolBytes = convert.utf8.encode(protocol);
>+      let len = protocolBytes[$length];
>+      if (dart.notNull(len) > 255) {
>+        dart.throw(new core.ArgumentError.new("Length of protocol must be between 1 and 255 (was: " + dart.str(len) + ")"));
>+      }
>+      outBytes[$add](len);
>+      outBytes[$addAll](protocolBytes);
>+    }
>+    dart.fn(addProtocol, ListOfintAndStringTovoid());
>+    let bytes = JSArrayOfint().of([]);
>+    for (let i = 0; i < dart.notNull(protocols[$length]); i++) {
>+      addProtocol(bytes, protocols[$_get](i));
>+    }
>+    if (dart.notNull(bytes[$length]) >= 1 << 13) {
>+      dart.throw(new core.ArgumentError.new("The maximum message length supported is 2^13-1."));
>+    }
>+    return typed_data.Uint8List.fromList(bytes);
>+  }
>+};
>+(io.SecurityContext[dart.mixinNew] = function() {
>+}).prototype = io.SecurityContext.prototype;
>+dart.addTypeTests(io.SecurityContext);
>+dart.setLibraryUri(io.SecurityContext, "dart:io");
>+dart.defineLazy(io, {
>+  /*io._nextServiceId*/get _nextServiceId() {
>+    return 1;
>+  },
>+  set _nextServiceId(_) {}
>+});
>+const __serviceId = dart.privateName(io, "__serviceId");
>+const _serviceId = dart.privateName(io, "_serviceId");
>+const _serviceTypePath = dart.privateName(io, "_serviceTypePath");
>+const _servicePath = dart.privateName(io, "_servicePath");
>+const _serviceTypeName = dart.privateName(io, "_serviceTypeName");
>+const _serviceType = dart.privateName(io, "_serviceType");
>+io._ServiceObject = class _ServiceObject extends core.Object {
>+  get [_serviceId]() {
>+    if (this[__serviceId] === 0) {
>+      let x = io._nextServiceId;
>+      io._nextServiceId = dart.notNull(x) + 1;
>+      this[__serviceId] = x;
>+    }
>+    return this[__serviceId];
>+  }
>+  get [_servicePath]() {
>+    return dart.str(this[_serviceTypePath]) + "/" + dart.str(this[_serviceId]);
>+  }
>+  [_serviceType](ref) {
>+    if (dart.test(ref)) return "@" + dart.str(this[_serviceTypeName]);
>+    return this[_serviceTypeName];
>+  }
>+};
>+(io._ServiceObject.new = function() {
>+  this[__serviceId] = 0;
>+}).prototype = io._ServiceObject.prototype;
>+dart.addTypeTests(io._ServiceObject);
>+dart.setMethodSignature(io._ServiceObject, () => ({
>+  __proto__: dart.getMethods(io._ServiceObject.__proto__),
>+  [_serviceType]: dart.fnType(core.String, [core.bool])
>+}));
>+dart.setGetterSignature(io._ServiceObject, () => ({
>+  __proto__: dart.getGetters(io._ServiceObject.__proto__),
>+  [_serviceId]: core.int,
>+  [_servicePath]: core.String
>+}));
>+dart.setLibraryUri(io._ServiceObject, "dart:io");
>+dart.setFieldSignature(io._ServiceObject, () => ({
>+  __proto__: dart.getFields(io._ServiceObject.__proto__),
>+  [__serviceId]: dart.fieldType(core.int)
>+}));
>+io.InternetAddressType = class InternetAddressType extends core.Object {
>+  static _from(value) {
>+    if (value === 0) return io.InternetAddressType.IPv4;
>+    if (value === 1) return io.InternetAddressType.IPv6;
>+    dart.throw(new core.ArgumentError.new("Invalid type: " + dart.str(value)));
>+  }
>+  get name() {
>+    switch (this[_value$2]) {
>+      case -1:
>+      {
>+        return "ANY";
>+      }
>+      case 0:
>+      {
>+        return "IPv4";
>+      }
>+      case 1:
>+      {
>+        return "IPv6";
>+      }
>+      default:
>+      {
>+        dart.throw(new core.ArgumentError.new("Invalid InternetAddress"));
>+      }
>+    }
>+  }
>+  toString() {
>+    return "InternetAddressType: " + dart.str(this.name);
>+  }
>+};
>+(io.InternetAddressType.__ = function(value) {
>+  this[_value$2] = value;
>+}).prototype = io.InternetAddressType.prototype;
>+dart.addTypeTests(io.InternetAddressType);
>+dart.setGetterSignature(io.InternetAddressType, () => ({
>+  __proto__: dart.getGetters(io.InternetAddressType.__proto__),
>+  name: core.String
>+}));
>+dart.setLibraryUri(io.InternetAddressType, "dart:io");
>+dart.setFieldSignature(io.InternetAddressType, () => ({
>+  __proto__: dart.getFields(io.InternetAddressType.__proto__),
>+  [_value$2]: dart.finalFieldType(core.int)
>+}));
>+dart.defineExtensionMethods(io.InternetAddressType, ['toString']);
>+dart.defineLazy(io.InternetAddressType, {
>+  /*io.InternetAddressType.IPv4*/get IPv4() {
>+    return dart.const(new io.InternetAddressType.__(0));
>+  },
>+  /*io.InternetAddressType.IPv6*/get IPv6() {
>+    return dart.const(new io.InternetAddressType.__(1));
>+  },
>+  /*io.InternetAddressType.any*/get any() {
>+    return dart.const(new io.InternetAddressType.__(-1));
>+  },
>+  /*io.InternetAddressType.IP_V4*/get IP_V4() {
>+    return io.InternetAddressType.IPv4;
>+  },
>+  /*io.InternetAddressType.IP_V6*/get IP_V6() {
>+    return io.InternetAddressType.IPv6;
>+  },
>+  /*io.InternetAddressType.ANY*/get ANY() {
>+    return io.InternetAddressType.any;
>+  }
>+});
>+io.InternetAddress = class InternetAddress extends core.Object {
>+  static get loopbackIPv4() {
>+    return io.InternetAddress.LOOPBACK_IP_V4;
>+  }
>+  static get LOOPBACK_IP_V4() {
>+    dart.throw(new core.UnsupportedError.new("InternetAddress.LOOPBACK_IP_V4"));
>+  }
>+  static get loopbackIPv6() {
>+    return io.InternetAddress.LOOPBACK_IP_V6;
>+  }
>+  static get LOOPBACK_IP_V6() {
>+    dart.throw(new core.UnsupportedError.new("InternetAddress.LOOPBACK_IP_V6"));
>+  }
>+  static get anyIPv4() {
>+    return io.InternetAddress.ANY_IP_V4;
>+  }
>+  static get ANY_IP_V4() {
>+    dart.throw(new core.UnsupportedError.new("InternetAddress.ANY_IP_V4"));
>+  }
>+  static get anyIPv6() {
>+    return io.InternetAddress.ANY_IP_V6;
>+  }
>+  static get ANY_IP_V6() {
>+    dart.throw(new core.UnsupportedError.new("InternetAddress.ANY_IP_V6"));
>+  }
>+  static new(address) {
>+    dart.throw(new core.UnsupportedError.new("InternetAddress"));
>+  }
>+  static lookup(host, opts) {
>+    let type = opts && 'type' in opts ? opts.type : io.InternetAddressType.any;
>+    dart.throw(new core.UnsupportedError.new("InternetAddress.lookup"));
>+  }
>+  static _cloneWithNewHost(address, host) {
>+    dart.throw(new core.UnsupportedError.new("InternetAddress._cloneWithNewHost"));
>+  }
>+};
>+(io.InternetAddress[dart.mixinNew] = function() {
>+}).prototype = io.InternetAddress.prototype;
>+dart.addTypeTests(io.InternetAddress);
>+dart.setLibraryUri(io.InternetAddress, "dart:io");
>+io.NetworkInterface = class NetworkInterface extends core.Object {
>+  static get listSupported() {
>+    dart.throw(new core.UnsupportedError.new("NetworkInterface.listSupported"));
>+  }
>+  static list(opts) {
>+    let includeLoopback = opts && 'includeLoopback' in opts ? opts.includeLoopback : false;
>+    let includeLinkLocal = opts && 'includeLinkLocal' in opts ? opts.includeLinkLocal : false;
>+    let type = opts && 'type' in opts ? opts.type : io.InternetAddressType.any;
>+    dart.throw(new core.UnsupportedError.new("NetworkInterface.list"));
>+  }
>+};
>+(io.NetworkInterface.new = function() {
>+}).prototype = io.NetworkInterface.prototype;
>+dart.addTypeTests(io.NetworkInterface);
>+dart.setLibraryUri(io.NetworkInterface, "dart:io");
>+io.RawServerSocket = class RawServerSocket extends core.Object {
>+  static bind(address, port, opts) {
>+    let backlog = opts && 'backlog' in opts ? opts.backlog : 0;
>+    let v6Only = opts && 'v6Only' in opts ? opts.v6Only : false;
>+    let shared = opts && 'shared' in opts ? opts.shared : false;
>+    dart.throw(new core.UnsupportedError.new("RawServerSocket.bind"));
>+  }
>+};
>+(io.RawServerSocket.new = function() {
>+}).prototype = io.RawServerSocket.prototype;
>+io.RawServerSocket.prototype[dart.isStream] = true;
>+dart.addTypeTests(io.RawServerSocket);
>+io.RawServerSocket[dart.implements] = () => [StreamOfRawSocket()];
>+dart.setLibraryUri(io.RawServerSocket, "dart:io");
>+io.ServerSocket = class ServerSocket extends core.Object {
>+  static bind(address, port, opts) {
>+    let backlog = opts && 'backlog' in opts ? opts.backlog : 0;
>+    let v6Only = opts && 'v6Only' in opts ? opts.v6Only : false;
>+    let shared = opts && 'shared' in opts ? opts.shared : false;
>+    dart.throw(new core.UnsupportedError.new("ServerSocket.bind"));
>+  }
>+};
>+(io.ServerSocket.new = function() {
>+}).prototype = io.ServerSocket.prototype;
>+io.ServerSocket.prototype[dart.isStream] = true;
>+dart.addTypeTests(io.ServerSocket);
>+io.ServerSocket[dart.implements] = () => [StreamOfSocket()];
>+dart.setLibraryUri(io.ServerSocket, "dart:io");
>+io.SocketDirection = class SocketDirection extends core.Object {};
>+(io.SocketDirection.__ = function(value) {
>+  this[_value$2] = value;
>+}).prototype = io.SocketDirection.prototype;
>+dart.addTypeTests(io.SocketDirection);
>+dart.setLibraryUri(io.SocketDirection, "dart:io");
>+dart.setFieldSignature(io.SocketDirection, () => ({
>+  __proto__: dart.getFields(io.SocketDirection.__proto__),
>+  [_value$2]: dart.finalFieldType(dart.dynamic)
>+}));
>+dart.defineLazy(io.SocketDirection, {
>+  /*io.SocketDirection.receive*/get receive() {
>+    return dart.const(new io.SocketDirection.__(0));
>+  },
>+  /*io.SocketDirection.send*/get send() {
>+    return dart.const(new io.SocketDirection.__(1));
>+  },
>+  /*io.SocketDirection.both*/get both() {
>+    return dart.const(new io.SocketDirection.__(2));
>+  },
>+  /*io.SocketDirection.RECEIVE*/get RECEIVE() {
>+    return io.SocketDirection.receive;
>+  },
>+  /*io.SocketDirection.SEND*/get SEND() {
>+    return io.SocketDirection.send;
>+  },
>+  /*io.SocketDirection.BOTH*/get BOTH() {
>+    return io.SocketDirection.both;
>+  }
>+});
>+io.SocketOption = class SocketOption extends core.Object {};
>+(io.SocketOption.__ = function(value) {
>+  this[_value$2] = value;
>+}).prototype = io.SocketOption.prototype;
>+dart.addTypeTests(io.SocketOption);
>+dart.setLibraryUri(io.SocketOption, "dart:io");
>+dart.setFieldSignature(io.SocketOption, () => ({
>+  __proto__: dart.getFields(io.SocketOption.__proto__),
>+  [_value$2]: dart.finalFieldType(dart.dynamic)
>+}));
>+dart.defineLazy(io.SocketOption, {
>+  /*io.SocketOption.tcpNoDelay*/get tcpNoDelay() {
>+    return dart.const(new io.SocketOption.__(0));
>+  },
>+  /*io.SocketOption.TCP_NODELAY*/get TCP_NODELAY() {
>+    return io.SocketOption.tcpNoDelay;
>+  },
>+  /*io.SocketOption._ipMulticastLoop*/get _ipMulticastLoop() {
>+    return dart.const(new io.SocketOption.__(1));
>+  },
>+  /*io.SocketOption._ipMulticastHops*/get _ipMulticastHops() {
>+    return dart.const(new io.SocketOption.__(2));
>+  },
>+  /*io.SocketOption._ipMulticastIf*/get _ipMulticastIf() {
>+    return dart.const(new io.SocketOption.__(3));
>+  },
>+  /*io.SocketOption._ipBroadcast*/get _ipBroadcast() {
>+    return dart.const(new io.SocketOption.__(4));
>+  }
>+});
>+io._RawSocketOptions = class _RawSocketOptions extends core.Object {
>+  toString() {
>+    return {
>+      0: "_RawSocketOptions.SOL_SOCKET",
>+      1: "_RawSocketOptions.IPPROTO_IP",
>+      2: "_RawSocketOptions.IP_MULTICAST_IF",
>+      3: "_RawSocketOptions.IPPROTO_IPV6",
>+      4: "_RawSocketOptions.IPV6_MULTICAST_IF",
>+      5: "_RawSocketOptions.IPPROTO_TCP",
>+      6: "_RawSocketOptions.IPPROTO_UDP"
>+    }[this.index];
>+  }
>+};
>+(io._RawSocketOptions.new = function(x) {
>+  this.index = x;
>+}).prototype = io._RawSocketOptions.prototype;
>+dart.addTypeTests(io._RawSocketOptions);
>+dart.setLibraryUri(io._RawSocketOptions, "dart:io");
>+dart.setFieldSignature(io._RawSocketOptions, () => ({
>+  __proto__: dart.getFields(io._RawSocketOptions.__proto__),
>+  index: dart.finalFieldType(core.int)
>+}));
>+dart.defineExtensionMethods(io._RawSocketOptions, ['toString']);
>+io._RawSocketOptions.SOL_SOCKET = dart.const(new io._RawSocketOptions.new(0));
>+io._RawSocketOptions.IPPROTO_IP = dart.const(new io._RawSocketOptions.new(1));
>+io._RawSocketOptions.IP_MULTICAST_IF = dart.const(new io._RawSocketOptions.new(2));
>+io._RawSocketOptions.IPPROTO_IPV6 = dart.const(new io._RawSocketOptions.new(3));
>+io._RawSocketOptions.IPV6_MULTICAST_IF = dart.const(new io._RawSocketOptions.new(4));
>+io._RawSocketOptions.IPPROTO_TCP = dart.const(new io._RawSocketOptions.new(5));
>+io._RawSocketOptions.IPPROTO_UDP = dart.const(new io._RawSocketOptions.new(6));
>+io._RawSocketOptions.values = dart.constList([io._RawSocketOptions.SOL_SOCKET, io._RawSocketOptions.IPPROTO_IP, io._RawSocketOptions.IP_MULTICAST_IF, io._RawSocketOptions.IPPROTO_IPV6, io._RawSocketOptions.IPV6_MULTICAST_IF, io._RawSocketOptions.IPPROTO_TCP, io._RawSocketOptions.IPPROTO_UDP], io._RawSocketOptions);
>+io.RawSocketOption = class RawSocketOption extends core.Object {
>+  static fromInt(level, option, value) {
>+    if (value == null) {
>+      value = 0;
>+    }
>+    let list = typed_data.Uint8List.new(4);
>+    let buffer = typed_data.ByteData.view(list[$buffer]);
>+    buffer[$setInt32](0, value);
>+    return new io.RawSocketOption.new(level, option, list);
>+  }
>+  static fromBool(level, option, value) {
>+    return io.RawSocketOption.fromInt(level, option, value === true ? 1 : 0);
>+  }
>+  get level() {
>+    return this[level$2];
>+  }
>+  set level(value) {
>+    super.level = value;
>+  }
>+  get option() {
>+    return this[option$];
>+  }
>+  set option(value) {
>+    super.option = value;
>+  }
>+  get value() {
>+    return this[value$];
>+  }
>+  set value(value) {
>+    super.value = value;
>+  }
>+  static get levelSocket() {
>+    return io.RawSocketOption._getOptionValue(io._RawSocketOptions.SOL_SOCKET.index);
>+  }
>+  static get levelIPv4() {
>+    return io.RawSocketOption._getOptionValue(io._RawSocketOptions.IPPROTO_IP.index);
>+  }
>+  static get IPv4MulticastInterface() {
>+    return io.RawSocketOption._getOptionValue(io._RawSocketOptions.IP_MULTICAST_IF.index);
>+  }
>+  static get levelIPv6() {
>+    return io.RawSocketOption._getOptionValue(io._RawSocketOptions.IPPROTO_IPV6.index);
>+  }
>+  static get IPv6MulticastInterface() {
>+    return io.RawSocketOption._getOptionValue(io._RawSocketOptions.IPV6_MULTICAST_IF.index);
>+  }
>+  static get levelTcp() {
>+    return io.RawSocketOption._getOptionValue(io._RawSocketOptions.IPPROTO_TCP.index);
>+  }
>+  static get levelUdp() {
>+    return io.RawSocketOption._getOptionValue(io._RawSocketOptions.IPPROTO_UDP.index);
>+  }
>+  static _getOptionValue(key) {
>+    dart.throw(new core.UnsupportedError.new("RawSocketOption._getOptionValue"));
>+  }
>+};
>+(io.RawSocketOption.new = function(level, option, value) {
>+  this[level$2] = level;
>+  this[option$] = option;
>+  this[value$] = value;
>+}).prototype = io.RawSocketOption.prototype;
>+dart.addTypeTests(io.RawSocketOption);
>+const level$2 = Symbol("RawSocketOption.level");
>+const option$ = Symbol("RawSocketOption.option");
>+const value$ = Symbol("RawSocketOption.value");
>+dart.setLibraryUri(io.RawSocketOption, "dart:io");
>+dart.setFieldSignature(io.RawSocketOption, () => ({
>+  __proto__: dart.getFields(io.RawSocketOption.__proto__),
>+  level: dart.finalFieldType(core.int),
>+  option: dart.finalFieldType(core.int),
>+  value: dart.finalFieldType(typed_data.Uint8List)
>+}));
>+const _is_ConnectionTask_default = Symbol('_is_ConnectionTask_default');
>+io.ConnectionTask$ = dart.generic(S => {
>+  let FutureOfS = () => (FutureOfS = dart.constFn(async.Future$(S)))();
>+  class ConnectionTask extends core.Object {
>+    get socket() {
>+      return this[socket$];
>+    }
>+    set socket(value) {
>+      super.socket = value;
>+    }
>+    cancel() {
>+      this[_onCancel$]();
>+    }
>+  }
>+  (ConnectionTask.__ = function(opts) {
>+    let socket = opts && 'socket' in opts ? opts.socket : null;
>+    let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
>+    if (!(socket != null)) dart.assertFailed(null, "dart:io/socket.dart", 569, 16, "socket != null");
>+    if (!(onCancel != null)) dart.assertFailed(null, "dart:io/socket.dart", 570, 16, "onCancel != null");
>+    this[socket$] = socket;
>+    this[_onCancel$] = onCancel;
>+  }).prototype = ConnectionTask.prototype;
>+  dart.addTypeTests(ConnectionTask);
>+  ConnectionTask.prototype[_is_ConnectionTask_default] = true;
>+  const socket$ = Symbol("ConnectionTask.socket");
>+  dart.setMethodSignature(ConnectionTask, () => ({
>+    __proto__: dart.getMethods(ConnectionTask.__proto__),
>+    cancel: dart.fnType(dart.void, [])
>+  }));
>+  dart.setLibraryUri(ConnectionTask, "dart:io");
>+  dart.setFieldSignature(ConnectionTask, () => ({
>+    __proto__: dart.getFields(ConnectionTask.__proto__),
>+    socket: dart.finalFieldType(FutureOfS()),
>+    [_onCancel$]: dart.finalFieldType(VoidTovoid())
>+  }));
>+  return ConnectionTask;
>+});
>+io.ConnectionTask = io.ConnectionTask$();
>+dart.addTypeTests(io.ConnectionTask, _is_ConnectionTask_default);
>+io.RawSocket = class RawSocket extends core.Object {
>+  get readEventsEnabled() {
>+    return this[readEventsEnabled];
>+  }
>+  set readEventsEnabled(value) {
>+    this[readEventsEnabled] = value;
>+  }
>+  get writeEventsEnabled() {
>+    return this[writeEventsEnabled];
>+  }
>+  set writeEventsEnabled(value) {
>+    this[writeEventsEnabled] = value;
>+  }
>+  static connect(host, port, opts) {
>+    let sourceAddress = opts && 'sourceAddress' in opts ? opts.sourceAddress : null;
>+    let timeout = opts && 'timeout' in opts ? opts.timeout : null;
>+    dart.throw(new core.UnsupportedError.new("RawSocket constructor"));
>+  }
>+  static startConnect(host, port, opts) {
>+    let sourceAddress = opts && 'sourceAddress' in opts ? opts.sourceAddress : null;
>+    dart.throw(new core.UnsupportedError.new("RawSocket constructor"));
>+  }
>+};
>+(io.RawSocket.new = function() {
>+  this[readEventsEnabled] = null;
>+  this[writeEventsEnabled] = null;
>+}).prototype = io.RawSocket.prototype;
>+io.RawSocket.prototype[dart.isStream] = true;
>+dart.addTypeTests(io.RawSocket);
>+const readEventsEnabled = Symbol("RawSocket.readEventsEnabled");
>+const writeEventsEnabled = Symbol("RawSocket.writeEventsEnabled");
>+io.RawSocket[dart.implements] = () => [StreamOfRawSocketEvent()];
>+dart.setLibraryUri(io.RawSocket, "dart:io");
>+dart.setFieldSignature(io.RawSocket, () => ({
>+  __proto__: dart.getFields(io.RawSocket.__proto__),
>+  readEventsEnabled: dart.fieldType(core.bool),
>+  writeEventsEnabled: dart.fieldType(core.bool)
>+}));
>+io.Socket = class Socket extends core.Object {
>+  static connect(host, port, opts) {
>+    let sourceAddress = opts && 'sourceAddress' in opts ? opts.sourceAddress : null;
>+    let timeout = opts && 'timeout' in opts ? opts.timeout : null;
>+    let overrides = io.IOOverrides.current;
>+    if (overrides == null) {
>+      return io.Socket._connect(host, port, {sourceAddress: sourceAddress, timeout: timeout});
>+    }
>+    return overrides.socketConnect(host, port, {sourceAddress: sourceAddress, timeout: timeout});
>+  }
>+  static startConnect(host, port, opts) {
>+    let sourceAddress = opts && 'sourceAddress' in opts ? opts.sourceAddress : null;
>+    let overrides = io.IOOverrides.current;
>+    if (overrides == null) {
>+      return io.Socket._startConnect(host, port, {sourceAddress: sourceAddress});
>+    }
>+    return overrides.socketStartConnect(host, port, {sourceAddress: sourceAddress});
>+  }
>+  static _connect(host, port, opts) {
>+    let sourceAddress = opts && 'sourceAddress' in opts ? opts.sourceAddress : null;
>+    let timeout = opts && 'timeout' in opts ? opts.timeout : null;
>+    dart.throw(new core.UnsupportedError.new("Socket constructor"));
>+  }
>+  static _startConnect(host, port, opts) {
>+    let sourceAddress = opts && 'sourceAddress' in opts ? opts.sourceAddress : null;
>+    dart.throw(new core.UnsupportedError.new("Socket constructor"));
>+  }
>+};
>+(io.Socket.new = function() {
>+}).prototype = io.Socket.prototype;
>+io.Socket.prototype[dart.isStream] = true;
>+dart.addTypeTests(io.Socket);
>+io.Socket[dart.implements] = () => [StreamOfListOfint(), io.IOSink];
>+dart.setLibraryUri(io.Socket, "dart:io");
>+io.Datagram = class Datagram extends core.Object {
>+  get data() {
>+    return this[data$];
>+  }
>+  set data(value) {
>+    this[data$] = value;
>+  }
>+  get address() {
>+    return this[address$];
>+  }
>+  set address(value) {
>+    this[address$] = value;
>+  }
>+  get port() {
>+    return this[port$];
>+  }
>+  set port(value) {
>+    this[port$] = value;
>+  }
>+};
>+(io.Datagram.new = function(data, address, port) {
>+  this[data$] = data;
>+  this[address$] = address;
>+  this[port$] = port;
>+}).prototype = io.Datagram.prototype;
>+dart.addTypeTests(io.Datagram);
>+const data$ = Symbol("Datagram.data");
>+const address$ = Symbol("Datagram.address");
>+const port$ = Symbol("Datagram.port");
>+dart.setLibraryUri(io.Datagram, "dart:io");
>+dart.setFieldSignature(io.Datagram, () => ({
>+  __proto__: dart.getFields(io.Datagram.__proto__),
>+  data: dart.fieldType(ListOfint()),
>+  address: dart.fieldType(io.InternetAddress),
>+  port: dart.fieldType(core.int)
>+}));
>+io.RawDatagramSocket = class RawDatagramSocket extends async.Stream$(io.RawSocketEvent) {
>+  get readEventsEnabled() {
>+    return this[readEventsEnabled$];
>+  }
>+  set readEventsEnabled(value) {
>+    this[readEventsEnabled$] = value;
>+  }
>+  get writeEventsEnabled() {
>+    return this[writeEventsEnabled$];
>+  }
>+  set writeEventsEnabled(value) {
>+    this[writeEventsEnabled$] = value;
>+  }
>+  get multicastLoopback() {
>+    return this[multicastLoopback];
>+  }
>+  set multicastLoopback(value) {
>+    this[multicastLoopback] = value;
>+  }
>+  get multicastHops() {
>+    return this[multicastHops];
>+  }
>+  set multicastHops(value) {
>+    this[multicastHops] = value;
>+  }
>+  get multicastInterface() {
>+    return this[multicastInterface];
>+  }
>+  set multicastInterface(value) {
>+    this[multicastInterface] = value;
>+  }
>+  get broadcastEnabled() {
>+    return this[broadcastEnabled];
>+  }
>+  set broadcastEnabled(value) {
>+    this[broadcastEnabled] = value;
>+  }
>+  static bind(host, port, opts) {
>+    let reuseAddress = opts && 'reuseAddress' in opts ? opts.reuseAddress : true;
>+    let reusePort = opts && 'reusePort' in opts ? opts.reusePort : false;
>+    let ttl = opts && 'ttl' in opts ? opts.ttl : 1;
>+    dart.throw(new core.UnsupportedError.new("RawDatagramSocket.bind"));
>+  }
>+};
>+(io.RawDatagramSocket.new = function() {
>+  this[readEventsEnabled$] = null;
>+  this[writeEventsEnabled$] = null;
>+  this[multicastLoopback] = null;
>+  this[multicastHops] = null;
>+  this[multicastInterface] = null;
>+  this[broadcastEnabled] = null;
>+  io.RawDatagramSocket.__proto__.new.call(this);
>+}).prototype = io.RawDatagramSocket.prototype;
>+dart.addTypeTests(io.RawDatagramSocket);
>+const readEventsEnabled$ = Symbol("RawDatagramSocket.readEventsEnabled");
>+const writeEventsEnabled$ = Symbol("RawDatagramSocket.writeEventsEnabled");
>+const multicastLoopback = Symbol("RawDatagramSocket.multicastLoopback");
>+const multicastHops = Symbol("RawDatagramSocket.multicastHops");
>+const multicastInterface = Symbol("RawDatagramSocket.multicastInterface");
>+const broadcastEnabled = Symbol("RawDatagramSocket.broadcastEnabled");
>+dart.setLibraryUri(io.RawDatagramSocket, "dart:io");
>+dart.setFieldSignature(io.RawDatagramSocket, () => ({
>+  __proto__: dart.getFields(io.RawDatagramSocket.__proto__),
>+  readEventsEnabled: dart.fieldType(core.bool),
>+  writeEventsEnabled: dart.fieldType(core.bool),
>+  multicastLoopback: dart.fieldType(core.bool),
>+  multicastHops: dart.fieldType(core.int),
>+  multicastInterface: dart.fieldType(io.NetworkInterface),
>+  broadcastEnabled: dart.fieldType(core.bool)
>+}));
>+io.SocketException = class SocketException extends core.Object {
>+  get message() {
>+    return this[message$12];
>+  }
>+  set message(value) {
>+    super.message = value;
>+  }
>+  get osError() {
>+    return this[osError$2];
>+  }
>+  set osError(value) {
>+    super.osError = value;
>+  }
>+  get address() {
>+    return this[address$0];
>+  }
>+  set address(value) {
>+    super.address = value;
>+  }
>+  get port() {
>+    return this[port$0];
>+  }
>+  set port(value) {
>+    super.port = value;
>+  }
>+  toString() {
>+    let sb = new core.StringBuffer.new();
>+    sb.write("SocketException");
>+    if (this.message[$isNotEmpty]) {
>+      sb.write(": " + dart.str(this.message));
>+      if (this.osError != null) {
>+        sb.write(" (" + dart.str(this.osError) + ")");
>+      }
>+    } else if (this.osError != null) {
>+      sb.write(": " + dart.str(this.osError));
>+    }
>+    if (this.address != null) {
>+      sb.write(", address = " + dart.str(this.address.host));
>+    }
>+    if (this.port != null) {
>+      sb.write(", port = " + dart.str(this.port));
>+    }
>+    return sb.toString();
>+  }
>+};
>+(io.SocketException.new = function(message, opts) {
>+  let osError = opts && 'osError' in opts ? opts.osError : null;
>+  let address = opts && 'address' in opts ? opts.address : null;
>+  let port = opts && 'port' in opts ? opts.port : null;
>+  this[message$12] = message;
>+  this[osError$2] = osError;
>+  this[address$0] = address;
>+  this[port$0] = port;
>+}).prototype = io.SocketException.prototype;
>+(io.SocketException.closed = function() {
>+  this[message$12] = "Socket has been closed";
>+  this[osError$2] = null;
>+  this[address$0] = null;
>+  this[port$0] = null;
>+}).prototype = io.SocketException.prototype;
>+dart.addTypeTests(io.SocketException);
>+const message$12 = Symbol("SocketException.message");
>+const osError$2 = Symbol("SocketException.osError");
>+const address$0 = Symbol("SocketException.address");
>+const port$0 = Symbol("SocketException.port");
>+io.SocketException[dart.implements] = () => [io.IOException];
>+dart.setLibraryUri(io.SocketException, "dart:io");
>+dart.setFieldSignature(io.SocketException, () => ({
>+  __proto__: dart.getFields(io.SocketException.__proto__),
>+  message: dart.finalFieldType(core.String),
>+  osError: dart.finalFieldType(io.OSError),
>+  address: dart.finalFieldType(io.InternetAddress),
>+  port: dart.finalFieldType(core.int)
>+}));
>+dart.defineExtensionMethods(io.SocketException, ['toString']);
>+dart.defineLazy(io, {
>+  /*io._stdioHandleTypeTerminal*/get _stdioHandleTypeTerminal() {
>+    return 0;
>+  },
>+  /*io._stdioHandleTypePipe*/get _stdioHandleTypePipe() {
>+    return 1;
>+  },
>+  /*io._stdioHandleTypeFile*/get _stdioHandleTypeFile() {
>+    return 2;
>+  },
>+  /*io._stdioHandleTypeSocket*/get _stdioHandleTypeSocket() {
>+    return 3;
>+  },
>+  /*io._stdioHandleTypeOther*/get _stdioHandleTypeOther() {
>+    return 4;
>+  }
>+});
>+io._StdStream = class _StdStream extends async.Stream$(core.List$(core.int)) {
>+  listen(onData, opts) {
>+    let onError = opts && 'onError' in opts ? opts.onError : null;
>+    let onDone = opts && 'onDone' in opts ? opts.onDone : null;
>+    let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
>+    return this[_stream$].listen(onData, {onError: onError, onDone: onDone, cancelOnError: cancelOnError});
>+  }
>+};
>+(io._StdStream.new = function(stream) {
>+  this[_stream$] = stream;
>+  io._StdStream.__proto__.new.call(this);
>+}).prototype = io._StdStream.prototype;
>+dart.addTypeTests(io._StdStream);
>+dart.setMethodSignature(io._StdStream, () => ({
>+  __proto__: dart.getMethods(io._StdStream.__proto__),
>+  listen: dart.fnType(async.StreamSubscription$(core.List$(core.int)), [dart.fnType(dart.void, [core.List$(core.int)])], {onError: core.Function, onDone: dart.fnType(dart.void, []), cancelOnError: core.bool})
>+}));
>+dart.setLibraryUri(io._StdStream, "dart:io");
>+dart.setFieldSignature(io._StdStream, () => ({
>+  __proto__: dart.getFields(io._StdStream.__proto__),
>+  [_stream$]: dart.finalFieldType(StreamOfListOfint())
>+}));
>+const _fd = dart.privateName(io, "_fd");
>+io.Stdin = class Stdin extends io._StdStream {
>+  readLineSync(opts) {
>+    let encoding = opts && 'encoding' in opts ? opts.encoding : io.systemEncoding;
>+    let retainNewlines = opts && 'retainNewlines' in opts ? opts.retainNewlines : false;
>+    let CR = 13;
>+    let LF = 10;
>+    let line = JSArrayOfint().of([]);
>+    let crIsNewline = dart.test(io.Platform.isWindows) && dart.equals(io.stdioType(io.stdin), io.StdioType.terminal) && !dart.test(this.lineMode);
>+    if (dart.test(retainNewlines)) {
>+      let byte = null;
>+      do {
>+        byte = this.readByteSync();
>+        if (dart.notNull(byte) < 0) {
>+          break;
>+        }
>+        line[$add](byte);
>+      } while (byte !== LF && !(byte === CR && crIsNewline));
>+      if (dart.test(line[$isEmpty])) {
>+        return null;
>+      }
>+    } else if (crIsNewline) {
>+      while (true) {
>+        let byte = this.readByteSync();
>+        if (dart.notNull(byte) < 0) {
>+          if (dart.test(line[$isEmpty])) return null;
>+          break;
>+        }
>+        if (byte === LF || byte === CR) break;
>+        line[$add](byte);
>+      }
>+    } else {
>+      outer:
>+        while (true) {
>+          let byte = this.readByteSync();
>+          if (byte === LF) break;
>+          if (byte === CR) {
>+            do {
>+              byte = this.readByteSync();
>+              if (byte === LF) break outer;
>+              line[$add](CR);
>+            } while (byte === CR);
>+          }
>+          if (dart.notNull(byte) < 0) {
>+            if (dart.test(line[$isEmpty])) return null;
>+            break;
>+          }
>+          line[$add](byte);
>+        }
>+    }
>+    return encoding.decode(line);
>+  }
>+  get echoMode() {
>+    dart.throw(new core.UnsupportedError.new("Stdin.echoMode"));
>+  }
>+  set echoMode(enabled) {
>+    dart.throw(new core.UnsupportedError.new("Stdin.echoMode"));
>+  }
>+  get lineMode() {
>+    dart.throw(new core.UnsupportedError.new("Stdin.lineMode"));
>+  }
>+  set lineMode(enabled) {
>+    dart.throw(new core.UnsupportedError.new("Stdin.lineMode"));
>+  }
>+  get supportsAnsiEscapes() {
>+    dart.throw(new core.UnsupportedError.new("Stdin.supportsAnsiEscapes"));
>+  }
>+  readByteSync() {
>+    dart.throw(new core.UnsupportedError.new("Stdin.readByteSync"));
>+  }
>+  get hasTerminal() {
>+    try {
>+      return dart.equals(io.stdioType(this), io.StdioType.terminal);
>+    } catch (e) {
>+      let _ = dart.getThrown(e);
>+      if (io.FileSystemException.is(_)) {
>+        return false;
>+      } else
>+        throw e;
>+    }
>+  }
>+};
>+(io.Stdin.__ = function(stream, fd) {
>+  this[_fd] = fd;
>+  io.Stdin.__proto__.new.call(this, stream);
>+}).prototype = io.Stdin.prototype;
>+io.Stdin.prototype[dart.isStream] = true;
>+dart.addTypeTests(io.Stdin);
>+io.Stdin[dart.implements] = () => [StreamOfListOfint()];
>+dart.setMethodSignature(io.Stdin, () => ({
>+  __proto__: dart.getMethods(io.Stdin.__proto__),
>+  readLineSync: dart.fnType(core.String, [], {encoding: convert.Encoding, retainNewlines: core.bool}),
>+  readByteSync: dart.fnType(core.int, [])
>+}));
>+dart.setGetterSignature(io.Stdin, () => ({
>+  __proto__: dart.getGetters(io.Stdin.__proto__),
>+  echoMode: core.bool,
>+  lineMode: core.bool,
>+  supportsAnsiEscapes: core.bool,
>+  hasTerminal: core.bool
>+}));
>+dart.setSetterSignature(io.Stdin, () => ({
>+  __proto__: dart.getSetters(io.Stdin.__proto__),
>+  echoMode: core.bool,
>+  lineMode: core.bool
>+}));
>+dart.setLibraryUri(io.Stdin, "dart:io");
>+dart.setFieldSignature(io.Stdin, () => ({
>+  __proto__: dart.getFields(io.Stdin.__proto__),
>+  [_fd]: dart.fieldType(core.int)
>+}));
>+const _nonBlocking = dart.privateName(io, "_nonBlocking");
>+const _hasTerminal = dart.privateName(io, "_hasTerminal");
>+const _terminalColumns = dart.privateName(io, "_terminalColumns");
>+const _terminalLines = dart.privateName(io, "_terminalLines");
>+io._StdSink = class _StdSink extends core.Object {
>+  get encoding() {
>+    return this[_sink$0].encoding;
>+  }
>+  set encoding(encoding) {
>+    this[_sink$0].encoding = encoding;
>+  }
>+  write(object) {
>+    this[_sink$0].write(object);
>+  }
>+  writeln(object) {
>+    if (object === void 0) object = "";
>+    this[_sink$0].writeln(object);
>+  }
>+  writeAll(objects, sep) {
>+    if (sep === void 0) sep = "";
>+    this[_sink$0].writeAll(objects, sep);
>+  }
>+  add(data) {
>+    ListOfint()._check(data);
>+    this[_sink$0].add(data);
>+  }
>+  addError(error, stackTrace) {
>+    if (stackTrace === void 0) stackTrace = null;
>+    this[_sink$0].addError(error, stackTrace);
>+  }
>+  writeCharCode(charCode) {
>+    this[_sink$0].writeCharCode(charCode);
>+  }
>+  addStream(stream) {
>+    StreamOfListOfint()._check(stream);
>+    return this[_sink$0].addStream(stream);
>+  }
>+  flush() {
>+    return this[_sink$0].flush();
>+  }
>+  close() {
>+    return this[_sink$0].close();
>+  }
>+  get done() {
>+    return this[_sink$0].done;
>+  }
>+};
>+(io._StdSink.new = function(sink) {
>+  this[_sink$0] = sink;
>+}).prototype = io._StdSink.prototype;
>+dart.addTypeTests(io._StdSink);
>+io._StdSink[dart.implements] = () => [io.IOSink];
>+dart.setMethodSignature(io._StdSink, () => ({
>+  __proto__: dart.getMethods(io._StdSink.__proto__),
>+  write: dart.fnType(dart.void, [core.Object]),
>+  writeln: dart.fnType(dart.void, [], [core.Object]),
>+  writeAll: dart.fnType(dart.void, [core.Iterable], [core.String]),
>+  add: dart.fnType(dart.void, [core.Object]),
>+  addError: dart.fnType(dart.void, [core.Object], [core.StackTrace]),
>+  writeCharCode: dart.fnType(dart.void, [core.int]),
>+  addStream: dart.fnType(async.Future, [core.Object]),
>+  flush: dart.fnType(async.Future, []),
>+  close: dart.fnType(async.Future, [])
>+}));
>+dart.setGetterSignature(io._StdSink, () => ({
>+  __proto__: dart.getGetters(io._StdSink.__proto__),
>+  encoding: convert.Encoding,
>+  done: async.Future
>+}));
>+dart.setSetterSignature(io._StdSink, () => ({
>+  __proto__: dart.getSetters(io._StdSink.__proto__),
>+  encoding: convert.Encoding
>+}));
>+dart.setLibraryUri(io._StdSink, "dart:io");
>+dart.setFieldSignature(io._StdSink, () => ({
>+  __proto__: dart.getFields(io._StdSink.__proto__),
>+  [_sink$0]: dart.finalFieldType(io.IOSink)
>+}));
>+io.Stdout = class Stdout extends io._StdSink {
>+  get hasTerminal() {
>+    return this[_hasTerminal](this[_fd]);
>+  }
>+  get terminalColumns() {
>+    return this[_terminalColumns](this[_fd]);
>+  }
>+  get terminalLines() {
>+    return this[_terminalLines](this[_fd]);
>+  }
>+  get supportsAnsiEscapes() {
>+    return io.Stdout._supportsAnsiEscapes(this[_fd]);
>+  }
>+  [_hasTerminal](fd) {
>+    dart.throw(new core.UnsupportedError.new("Stdout.hasTerminal"));
>+  }
>+  [_terminalColumns](fd) {
>+    dart.throw(new core.UnsupportedError.new("Stdout.terminalColumns"));
>+  }
>+  [_terminalLines](fd) {
>+    dart.throw(new core.UnsupportedError.new("Stdout.terminalLines"));
>+  }
>+  static _supportsAnsiEscapes(fd) {
>+    dart.throw(new core.UnsupportedError.new("Stdout.supportsAnsiEscapes"));
>+  }
>+  get nonBlocking() {
>+    let t = this[_nonBlocking];
>+    t == null ? this[_nonBlocking] = io.IOSink.new(new io._FileStreamConsumer.fromStdio(this[_fd])) : t;
>+    return this[_nonBlocking];
>+  }
>+};
>+(io.Stdout.__ = function(sink, fd) {
>+  this[_nonBlocking] = null;
>+  this[_fd] = fd;
>+  io.Stdout.__proto__.new.call(this, sink);
>+}).prototype = io.Stdout.prototype;
>+dart.addTypeTests(io.Stdout);
>+io.Stdout[dart.implements] = () => [io.IOSink];
>+dart.setMethodSignature(io.Stdout, () => ({
>+  __proto__: dart.getMethods(io.Stdout.__proto__),
>+  [_hasTerminal]: dart.fnType(core.bool, [core.int]),
>+  [_terminalColumns]: dart.fnType(core.int, [core.int]),
>+  [_terminalLines]: dart.fnType(core.int, [core.int])
>+}));
>+dart.setGetterSignature(io.Stdout, () => ({
>+  __proto__: dart.getGetters(io.Stdout.__proto__),
>+  hasTerminal: core.bool,
>+  terminalColumns: core.int,
>+  terminalLines: core.int,
>+  supportsAnsiEscapes: core.bool,
>+  nonBlocking: io.IOSink
>+}));
>+dart.setLibraryUri(io.Stdout, "dart:io");
>+dart.setFieldSignature(io.Stdout, () => ({
>+  __proto__: dart.getFields(io.Stdout.__proto__),
>+  [_fd]: dart.finalFieldType(core.int),
>+  [_nonBlocking]: dart.fieldType(io.IOSink)
>+}));
>+io.StdoutException = class StdoutException extends core.Object {
>+  get message() {
>+    return this[message$13];
>+  }
>+  set message(value) {
>+    super.message = value;
>+  }
>+  get osError() {
>+    return this[osError$3];
>+  }
>+  set osError(value) {
>+    super.osError = value;
>+  }
>+  toString() {
>+    return "StdoutException: " + dart.str(this.message) + (this.osError == null ? "" : ", " + dart.str(this.osError));
>+  }
>+};
>+(io.StdoutException.new = function(message, osError) {
>+  if (osError === void 0) osError = null;
>+  this[message$13] = message;
>+  this[osError$3] = osError;
>+}).prototype = io.StdoutException.prototype;
>+dart.addTypeTests(io.StdoutException);
>+const message$13 = Symbol("StdoutException.message");
>+const osError$3 = Symbol("StdoutException.osError");
>+io.StdoutException[dart.implements] = () => [io.IOException];
>+dart.setLibraryUri(io.StdoutException, "dart:io");
>+dart.setFieldSignature(io.StdoutException, () => ({
>+  __proto__: dart.getFields(io.StdoutException.__proto__),
>+  message: dart.finalFieldType(core.String),
>+  osError: dart.finalFieldType(io.OSError)
>+}));
>+dart.defineExtensionMethods(io.StdoutException, ['toString']);
>+io.StdinException = class StdinException extends core.Object {
>+  get message() {
>+    return this[message$14];
>+  }
>+  set message(value) {
>+    super.message = value;
>+  }
>+  get osError() {
>+    return this[osError$4];
>+  }
>+  set osError(value) {
>+    super.osError = value;
>+  }
>+  toString() {
>+    return "StdinException: " + dart.str(this.message) + (this.osError == null ? "" : ", " + dart.str(this.osError));
>+  }
>+};
>+(io.StdinException.new = function(message, osError) {
>+  if (osError === void 0) osError = null;
>+  this[message$14] = message;
>+  this[osError$4] = osError;
>+}).prototype = io.StdinException.prototype;
>+dart.addTypeTests(io.StdinException);
>+const message$14 = Symbol("StdinException.message");
>+const osError$4 = Symbol("StdinException.osError");
>+io.StdinException[dart.implements] = () => [io.IOException];
>+dart.setLibraryUri(io.StdinException, "dart:io");
>+dart.setFieldSignature(io.StdinException, () => ({
>+  __proto__: dart.getFields(io.StdinException.__proto__),
>+  message: dart.finalFieldType(core.String),
>+  osError: dart.finalFieldType(io.OSError)
>+}));
>+dart.defineExtensionMethods(io.StdinException, ['toString']);
>+io._StdConsumer = class _StdConsumer extends core.Object {
>+  addStream(stream) {
>+    StreamOfListOfint()._check(stream);
>+    let completer = async.Completer.new();
>+    let sub = null;
>+    sub = stream.listen(dart.fn(data => {
>+      try {
>+        dart.dsend(this[_file], 'writeFromSync', [data]);
>+      } catch (e$) {
>+        let e = dart.getThrown(e$);
>+        let s = dart.stackTrace(e$);
>+        dart.dsend(sub, 'cancel', []);
>+        completer.completeError(e, s);
>+      }
>+    }, ListOfintToNull()), {onError: dart.bind(completer, 'completeError'), onDone: dart.bind(completer, 'complete'), cancelOnError: true});
>+    return completer.future;
>+  }
>+  close() {
>+    dart.dsend(this[_file], 'closeSync', []);
>+    return async.Future.value();
>+  }
>+};
>+(io._StdConsumer.new = function(fd) {
>+  this[_file] = io._File._openStdioSync(fd);
>+}).prototype = io._StdConsumer.prototype;
>+dart.addTypeTests(io._StdConsumer);
>+io._StdConsumer[dart.implements] = () => [StreamConsumerOfListOfint()];
>+dart.setMethodSignature(io._StdConsumer, () => ({
>+  __proto__: dart.getMethods(io._StdConsumer.__proto__),
>+  addStream: dart.fnType(async.Future, [core.Object]),
>+  close: dart.fnType(async.Future, [])
>+}));
>+dart.setLibraryUri(io._StdConsumer, "dart:io");
>+dart.setFieldSignature(io._StdConsumer, () => ({
>+  __proto__: dart.getFields(io._StdConsumer.__proto__),
>+  [_file]: dart.finalFieldType(dart.dynamic)
>+}));
>+io.StdioType = class StdioType extends core.Object {
>+  get name() {
>+    return this[name$3];
>+  }
>+  set name(value) {
>+    super.name = value;
>+  }
>+  toString() {
>+    return "StdioType: " + dart.str(this.name);
>+  }
>+};
>+(io.StdioType.__ = function(name) {
>+  this[name$3] = name;
>+}).prototype = io.StdioType.prototype;
>+dart.addTypeTests(io.StdioType);
>+const name$3 = Symbol("StdioType.name");
>+dart.setLibraryUri(io.StdioType, "dart:io");
>+dart.setFieldSignature(io.StdioType, () => ({
>+  __proto__: dart.getFields(io.StdioType.__proto__),
>+  name: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionMethods(io.StdioType, ['toString']);
>+dart.defineLazy(io.StdioType, {
>+  /*io.StdioType.terminal*/get terminal() {
>+    return dart.const(new io.StdioType.__("terminal"));
>+  },
>+  /*io.StdioType.pipe*/get pipe() {
>+    return dart.const(new io.StdioType.__("pipe"));
>+  },
>+  /*io.StdioType.file*/get file() {
>+    return dart.const(new io.StdioType.__("file"));
>+  },
>+  /*io.StdioType.other*/get other() {
>+    return dart.const(new io.StdioType.__("other"));
>+  },
>+  /*io.StdioType.TERMINAL*/get TERMINAL() {
>+    return io.StdioType.terminal;
>+  },
>+  /*io.StdioType.PIPE*/get PIPE() {
>+    return io.StdioType.pipe;
>+  },
>+  /*io.StdioType.FILE*/get FILE() {
>+    return io.StdioType.file;
>+  },
>+  /*io.StdioType.OTHER*/get OTHER() {
>+    return io.StdioType.other;
>+  }
>+});
>+dart.defineLazy(io, {
>+  /*io._stdin*/get _stdin() {
>+    return null;
>+  },
>+  set _stdin(_) {},
>+  /*io._stdout*/get _stdout() {
>+    return null;
>+  },
>+  set _stdout(_) {},
>+  /*io._stderr*/get _stderr() {
>+    return null;
>+  },
>+  set _stderr(_) {},
>+  /*io._stdinFD*/get _stdinFD() {
>+    return 0;
>+  },
>+  set _stdinFD(_) {},
>+  /*io._stdoutFD*/get _stdoutFD() {
>+    return 1;
>+  },
>+  set _stdoutFD(_) {},
>+  /*io._stderrFD*/get _stderrFD() {
>+    return 2;
>+  },
>+  set _stderrFD(_) {}
>+});
>+io._setStdioFDs = function(stdin, stdout, stderr) {
>+  io._stdinFD = stdin;
>+  io._stdoutFD = stdout;
>+  io._stderrFD = stderr;
>+};
>+dart.copyProperties(io, {
>+  get stdin() {
>+    let t = io._stdin;
>+    t == null ? io._stdin = io._StdIOUtils._getStdioInputStream(io._stdinFD) : t;
>+    return io._stdin;
>+  }
>+});
>+dart.copyProperties(io, {
>+  get stdout() {
>+    let t = io._stdout;
>+    t == null ? io._stdout = io.Stdout._check(io._StdIOUtils._getStdioOutputStream(io._stdoutFD)) : t;
>+    return io._stdout;
>+  }
>+});
>+dart.copyProperties(io, {
>+  get stderr() {
>+    let t = io._stderr;
>+    t == null ? io._stderr = io.Stdout._check(io._StdIOUtils._getStdioOutputStream(io._stderrFD)) : t;
>+    return io._stderr;
>+  }
>+});
>+io.stdioType = function(object) {
>+  if (io._StdStream.is(object)) {
>+    object = dart.dload(object, _stream$);
>+  } else if (dart.equals(object, io.stdout) || dart.equals(object, io.stderr)) {
>+    let stdiofd = dart.equals(object, io.stdout) ? io._stdoutFD : io._stderrFD;
>+    switch (io._StdIOUtils._getStdioHandleType(stdiofd)) {
>+      case 0:
>+      {
>+        return io.StdioType.terminal;
>+      }
>+      case 1:
>+      {
>+        return io.StdioType.pipe;
>+      }
>+      case 2:
>+      {
>+        return io.StdioType.file;
>+      }
>+    }
>+  }
>+  if (io._FileStream.is(object)) {
>+    return io.StdioType.file;
>+  }
>+  if (io.Socket.is(object)) {
>+    let socketType = io._StdIOUtils._socketType(object);
>+    if (socketType == null) return io.StdioType.other;
>+    switch (socketType) {
>+      case 0:
>+      {
>+        return io.StdioType.terminal;
>+      }
>+      case 1:
>+      {
>+        return io.StdioType.pipe;
>+      }
>+      case 2:
>+      {
>+        return io.StdioType.file;
>+      }
>+    }
>+  }
>+  if (io._IOSinkImpl.is(object)) {
>+    try {
>+      if (io._FileStreamConsumer.is(object[_target$])) {
>+        return io.StdioType.file;
>+      }
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+    }
>+  }
>+  return io.StdioType.other;
>+};
>+io._StdIOUtils = class _StdIOUtils extends core.Object {
>+  static _getStdioOutputStream(fd) {
>+    dart.throw(new core.UnsupportedError.new("StdIOUtils._getStdioOutputStream"));
>+  }
>+  static _getStdioInputStream(fd) {
>+    dart.throw(new core.UnsupportedError.new("StdIOUtils._getStdioInputStream"));
>+  }
>+  static _socketType(socket) {
>+    dart.throw(new core.UnsupportedError.new("StdIOUtils._socketType"));
>+  }
>+  static _getStdioHandleType(fd) {
>+    dart.throw(new core.UnsupportedError.new("StdIOUtils._getStdioHandleType"));
>+  }
>+};
>+(io._StdIOUtils.new = function() {
>+}).prototype = io._StdIOUtils.prototype;
>+dart.addTypeTests(io._StdIOUtils);
>+dart.setLibraryUri(io._StdIOUtils, "dart:io");
>+dart.defineLazy(io, {
>+  /*io.systemEncoding*/get systemEncoding() {
>+    return dart.const(new io.SystemEncoding.new());
>+  },
>+  /*io.SYSTEM_ENCODING*/get SYSTEM_ENCODING() {
>+    return dart.const(new io.SystemEncoding.new());
>+  }
>+});
>+let const$73;
>+let const$74;
>+let const$75;
>+let const$76;
>+io.SystemEncoding = class SystemEncoding extends convert.Encoding {
>+  get name() {
>+    return "system";
>+  }
>+  encode(input) {
>+    core.String._check(input);
>+    return this.encoder.convert(input);
>+  }
>+  decode(encoded) {
>+    ListOfint()._check(encoded);
>+    return this.decoder.convert(encoded);
>+  }
>+  get encoder() {
>+    if (io.Platform.operatingSystem === "windows") {
>+      return const$73 || (const$73 = dart.const(new io._WindowsCodePageEncoder.new()));
>+    } else {
>+      return const$74 || (const$74 = dart.const(new convert.Utf8Encoder.new()));
>+    }
>+  }
>+  get decoder() {
>+    if (io.Platform.operatingSystem === "windows") {
>+      return const$75 || (const$75 = dart.const(new io._WindowsCodePageDecoder.new()));
>+    } else {
>+      return const$76 || (const$76 = dart.const(new convert.Utf8Decoder.new()));
>+    }
>+  }
>+};
>+(io.SystemEncoding.new = function() {
>+  io.SystemEncoding.__proto__.new.call(this);
>+}).prototype = io.SystemEncoding.prototype;
>+dart.addTypeTests(io.SystemEncoding);
>+dart.setMethodSignature(io.SystemEncoding, () => ({
>+  __proto__: dart.getMethods(io.SystemEncoding.__proto__),
>+  encode: dart.fnType(core.List$(core.int), [core.Object]),
>+  decode: dart.fnType(core.String, [core.Object])
>+}));
>+dart.setGetterSignature(io.SystemEncoding, () => ({
>+  __proto__: dart.getGetters(io.SystemEncoding.__proto__),
>+  name: core.String,
>+  encoder: convert.Converter$(core.String, core.List$(core.int)),
>+  decoder: convert.Converter$(core.List$(core.int), core.String)
>+}));
>+dart.setLibraryUri(io.SystemEncoding, "dart:io");
>+io._WindowsCodePageEncoder = class _WindowsCodePageEncoder extends convert.Converter$(core.String, core.List$(core.int)) {
>+  convert(input) {
>+    core.String._check(input);
>+    let encoded = io._WindowsCodePageEncoder._encodeString(input);
>+    if (encoded == null) {
>+      dart.throw(new core.FormatException.new("Invalid character for encoding"));
>+    }
>+    return encoded;
>+  }
>+  startChunkedConversion(sink) {
>+    SinkOfListOfint()._check(sink);
>+    return new io._WindowsCodePageEncoderSink.new(sink);
>+  }
>+  static _encodeString(string) {
>+    dart.throw(new core.UnsupportedError.new("_WindowsCodePageEncoder._encodeString"));
>+  }
>+};
>+(io._WindowsCodePageEncoder.new = function() {
>+  io._WindowsCodePageEncoder.__proto__.new.call(this);
>+}).prototype = io._WindowsCodePageEncoder.prototype;
>+dart.addTypeTests(io._WindowsCodePageEncoder);
>+dart.setMethodSignature(io._WindowsCodePageEncoder, () => ({
>+  __proto__: dart.getMethods(io._WindowsCodePageEncoder.__proto__),
>+  convert: dart.fnType(core.List$(core.int), [core.Object]),
>+  startChunkedConversion: dart.fnType(convert.StringConversionSink, [core.Object])
>+}));
>+dart.setLibraryUri(io._WindowsCodePageEncoder, "dart:io");
>+io._WindowsCodePageEncoderSink = class _WindowsCodePageEncoderSink extends convert.StringConversionSinkBase {
>+  close() {
>+    this[_sink$0].close();
>+  }
>+  add(string) {
>+    core.String._check(string);
>+    let encoded = io._WindowsCodePageEncoder._encodeString(string);
>+    if (encoded == null) {
>+      dart.throw(new core.FormatException.new("Invalid character for encoding"));
>+    }
>+    this[_sink$0].add(encoded);
>+  }
>+  addSlice(source, start, end, isLast) {
>+    if (start !== 0 || end !== source.length) {
>+      source = source[$substring](start, end);
>+    }
>+    this.add(source);
>+    if (dart.test(isLast)) this.close();
>+  }
>+};
>+(io._WindowsCodePageEncoderSink.new = function(sink) {
>+  this[_sink$0] = sink;
>+}).prototype = io._WindowsCodePageEncoderSink.prototype;
>+dart.addTypeTests(io._WindowsCodePageEncoderSink);
>+dart.setMethodSignature(io._WindowsCodePageEncoderSink, () => ({
>+  __proto__: dart.getMethods(io._WindowsCodePageEncoderSink.__proto__),
>+  close: dart.fnType(dart.void, []),
>+  add: dart.fnType(dart.void, [core.Object]),
>+  addSlice: dart.fnType(dart.void, [core.String, core.int, core.int, core.bool])
>+}));
>+dart.setLibraryUri(io._WindowsCodePageEncoderSink, "dart:io");
>+dart.setFieldSignature(io._WindowsCodePageEncoderSink, () => ({
>+  __proto__: dart.getFields(io._WindowsCodePageEncoderSink.__proto__),
>+  [_sink$0]: dart.finalFieldType(SinkOfListOfint())
>+}));
>+io._WindowsCodePageDecoder = class _WindowsCodePageDecoder extends convert.Converter$(core.List$(core.int), core.String) {
>+  convert(input) {
>+    ListOfint()._check(input);
>+    return io._WindowsCodePageDecoder._decodeBytes(input);
>+  }
>+  startChunkedConversion(sink) {
>+    SinkOfString()._check(sink);
>+    return new io._WindowsCodePageDecoderSink.new(sink);
>+  }
>+  static _decodeBytes(bytes) {
>+    dart.throw(new core.UnsupportedError.new("_WindowsCodePageDecoder._decodeBytes"));
>+  }
>+};
>+(io._WindowsCodePageDecoder.new = function() {
>+  io._WindowsCodePageDecoder.__proto__.new.call(this);
>+}).prototype = io._WindowsCodePageDecoder.prototype;
>+dart.addTypeTests(io._WindowsCodePageDecoder);
>+dart.setMethodSignature(io._WindowsCodePageDecoder, () => ({
>+  __proto__: dart.getMethods(io._WindowsCodePageDecoder.__proto__),
>+  convert: dart.fnType(core.String, [core.Object]),
>+  startChunkedConversion: dart.fnType(convert.ByteConversionSink, [core.Object])
>+}));
>+dart.setLibraryUri(io._WindowsCodePageDecoder, "dart:io");
>+io._WindowsCodePageDecoderSink = class _WindowsCodePageDecoderSink extends convert.ByteConversionSinkBase {
>+  close() {
>+    this[_sink$0].close();
>+  }
>+  add(bytes) {
>+    ListOfint()._check(bytes);
>+    this[_sink$0].add(io._WindowsCodePageDecoder._decodeBytes(bytes));
>+  }
>+};
>+(io._WindowsCodePageDecoderSink.new = function(sink) {
>+  this[_sink$0] = sink;
>+  io._WindowsCodePageDecoderSink.__proto__.new.call(this);
>+}).prototype = io._WindowsCodePageDecoderSink.prototype;
>+dart.addTypeTests(io._WindowsCodePageDecoderSink);
>+dart.setMethodSignature(io._WindowsCodePageDecoderSink, () => ({
>+  __proto__: dart.getMethods(io._WindowsCodePageDecoderSink.__proto__),
>+  close: dart.fnType(dart.void, []),
>+  add: dart.fnType(dart.void, [core.Object])
>+}));
>+dart.setLibraryUri(io._WindowsCodePageDecoderSink, "dart:io");
>+dart.setFieldSignature(io._WindowsCodePageDecoderSink, () => ({
>+  __proto__: dart.getFields(io._WindowsCodePageDecoderSink.__proto__),
>+  [_sink$0]: dart.finalFieldType(SinkOfString())
>+}));
>+io.RawSynchronousSocket = class RawSynchronousSocket extends core.Object {
>+  static connectSync(host, port) {
>+    dart.throw(new core.UnsupportedError.new("RawSynchronousSocket.connectSync"));
>+  }
>+};
>+(io.RawSynchronousSocket.new = function() {
>+}).prototype = io.RawSynchronousSocket.prototype;
>+dart.addTypeTests(io.RawSynchronousSocket);
>+dart.setLibraryUri(io.RawSynchronousSocket, "dart:io");
>+isolate.IsolateSpawnException = class IsolateSpawnException extends core.Object {
>+  get message() {
>+    return this[message$15];
>+  }
>+  set message(value) {
>+    super.message = value;
>+  }
>+  toString() {
>+    return "IsolateSpawnException: " + dart.str(this.message);
>+  }
>+};
>+(isolate.IsolateSpawnException.new = function(message) {
>+  this[message$15] = message;
>+}).prototype = isolate.IsolateSpawnException.prototype;
>+dart.addTypeTests(isolate.IsolateSpawnException);
>+const message$15 = Symbol("IsolateSpawnException.message");
>+isolate.IsolateSpawnException[dart.implements] = () => [core.Exception];
>+dart.setLibraryUri(isolate.IsolateSpawnException, "dart:isolate");
>+dart.setFieldSignature(isolate.IsolateSpawnException, () => ({
>+  __proto__: dart.getFields(isolate.IsolateSpawnException.__proto__),
>+  message: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionMethods(isolate.IsolateSpawnException, ['toString']);
>+const _pause = dart.privateName(isolate, "_pause");
>+isolate.Isolate = class Isolate extends core.Object {
>+  get controlPort() {
>+    return this[controlPort$];
>+  }
>+  set controlPort(value) {
>+    super.controlPort = value;
>+  }
>+  get pauseCapability() {
>+    return this[pauseCapability$];
>+  }
>+  set pauseCapability(value) {
>+    super.pauseCapability = value;
>+  }
>+  get terminateCapability() {
>+    return this[terminateCapability$];
>+  }
>+  set terminateCapability(value) {
>+    super.terminateCapability = value;
>+  }
>+  get debugName() {
>+    return isolate._unsupported();
>+  }
>+  static get current() {
>+    return isolate._unsupported();
>+  }
>+  static get packageRoot() {
>+    return isolate._unsupported();
>+  }
>+  static get packageConfig() {
>+    return isolate._unsupported();
>+  }
>+  static resolvePackageUri(packageUri) {
>+    return isolate._unsupported();
>+  }
>+  static spawn(T, entryPoint, message, opts) {
>+    let paused = opts && 'paused' in opts ? opts.paused : false;
>+    let errorsAreFatal = opts && 'errorsAreFatal' in opts ? opts.errorsAreFatal : null;
>+    let onExit = opts && 'onExit' in opts ? opts.onExit : null;
>+    let onError = opts && 'onError' in opts ? opts.onError : null;
>+    return isolate._unsupported();
>+  }
>+  static spawnUri(uri, args, message, opts) {
>+    let paused = opts && 'paused' in opts ? opts.paused : false;
>+    let onExit = opts && 'onExit' in opts ? opts.onExit : null;
>+    let onError = opts && 'onError' in opts ? opts.onError : null;
>+    let errorsAreFatal = opts && 'errorsAreFatal' in opts ? opts.errorsAreFatal : null;
>+    let checked = opts && 'checked' in opts ? opts.checked : null;
>+    let environment = opts && 'environment' in opts ? opts.environment : null;
>+    let packageRoot = opts && 'packageRoot' in opts ? opts.packageRoot : null;
>+    let packageConfig = opts && 'packageConfig' in opts ? opts.packageConfig : null;
>+    let automaticPackageResolution = opts && 'automaticPackageResolution' in opts ? opts.automaticPackageResolution : false;
>+    return isolate._unsupported();
>+  }
>+  pause(resumeCapability) {
>+    if (resumeCapability === void 0) resumeCapability = null;
>+    let t = resumeCapability;
>+    t == null ? resumeCapability = isolate.Capability.new() : t;
>+    this[_pause](resumeCapability);
>+    return resumeCapability;
>+  }
>+  [_pause](resumeCapability) {
>+    return isolate._unsupported();
>+  }
>+  resume(resumeCapability) {
>+    return isolate._unsupported();
>+  }
>+  addOnExitListener(responsePort, opts) {
>+    let response = opts && 'response' in opts ? opts.response : null;
>+    return isolate._unsupported();
>+  }
>+  removeOnExitListener(responsePort) {
>+    return isolate._unsupported();
>+  }
>+  setErrorsFatal(errorsAreFatal) {
>+    return isolate._unsupported();
>+  }
>+  kill(opts) {
>+    let priority = opts && 'priority' in opts ? opts.priority : 1;
>+    return isolate._unsupported();
>+  }
>+  ping(responsePort, opts) {
>+    let response = opts && 'response' in opts ? opts.response : null;
>+    let priority = opts && 'priority' in opts ? opts.priority : 0;
>+    return isolate._unsupported();
>+  }
>+  addErrorListener(port) {
>+    return isolate._unsupported();
>+  }
>+  removeErrorListener(port) {
>+    return isolate._unsupported();
>+  }
>+  get errors() {
>+    let controller = null;
>+    let port = null;
>+    function handleError(message) {
>+      let listMessage = core.List._check(message);
>+      let errorDescription = core.String._check(listMessage[$_get](0));
>+      let stackDescription = core.String._check(listMessage[$_get](1));
>+      let error = new isolate.RemoteError.new(errorDescription, stackDescription);
>+      controller.addError(error, error.stackTrace);
>+    }
>+    dart.fn(handleError, dynamicTovoid());
>+    controller = async.StreamController.broadcast({sync: true, onListen: dart.fn(() => {
>+        port = isolate.RawReceivePort.new(handleError);
>+        this.addErrorListener(port.sendPort);
>+      }, VoidToNull()), onCancel: dart.fn(() => {
>+        this.removeErrorListener(port.sendPort);
>+        port.close();
>+        port = null;
>+      }, VoidToNull())});
>+    return controller.stream;
>+  }
>+};
>+(isolate.Isolate.new = function(controlPort, opts) {
>+  let pauseCapability = opts && 'pauseCapability' in opts ? opts.pauseCapability : null;
>+  let terminateCapability = opts && 'terminateCapability' in opts ? opts.terminateCapability : null;
>+  this[controlPort$] = controlPort;
>+  this[pauseCapability$] = pauseCapability;
>+  this[terminateCapability$] = terminateCapability;
>+}).prototype = isolate.Isolate.prototype;
>+dart.addTypeTests(isolate.Isolate);
>+const controlPort$ = Symbol("Isolate.controlPort");
>+const pauseCapability$ = Symbol("Isolate.pauseCapability");
>+const terminateCapability$ = Symbol("Isolate.terminateCapability");
>+dart.setMethodSignature(isolate.Isolate, () => ({
>+  __proto__: dart.getMethods(isolate.Isolate.__proto__),
>+  pause: dart.fnType(isolate.Capability, [], [isolate.Capability]),
>+  [_pause]: dart.fnType(dart.void, [isolate.Capability]),
>+  resume: dart.fnType(dart.void, [isolate.Capability]),
>+  addOnExitListener: dart.fnType(dart.void, [isolate.SendPort], {response: core.Object}),
>+  removeOnExitListener: dart.fnType(dart.void, [isolate.SendPort]),
>+  setErrorsFatal: dart.fnType(dart.void, [core.bool]),
>+  kill: dart.fnType(dart.void, [], {priority: core.int}),
>+  ping: dart.fnType(dart.void, [isolate.SendPort], {response: core.Object, priority: core.int}),
>+  addErrorListener: dart.fnType(dart.void, [isolate.SendPort]),
>+  removeErrorListener: dart.fnType(dart.void, [isolate.SendPort])
>+}));
>+dart.setGetterSignature(isolate.Isolate, () => ({
>+  __proto__: dart.getGetters(isolate.Isolate.__proto__),
>+  debugName: core.String,
>+  errors: async.Stream
>+}));
>+dart.setLibraryUri(isolate.Isolate, "dart:isolate");
>+dart.setFieldSignature(isolate.Isolate, () => ({
>+  __proto__: dart.getFields(isolate.Isolate.__proto__),
>+  controlPort: dart.finalFieldType(isolate.SendPort),
>+  pauseCapability: dart.finalFieldType(isolate.Capability),
>+  terminateCapability: dart.finalFieldType(isolate.Capability)
>+}));
>+dart.defineLazy(isolate.Isolate, {
>+  /*isolate.Isolate.immediate*/get immediate() {
>+    return 0;
>+  },
>+  /*isolate.Isolate.beforeNextEvent*/get beforeNextEvent() {
>+    return 1;
>+  }
>+});
>+isolate.SendPort = class SendPort extends core.Object {};
>+(isolate.SendPort.new = function() {
>+}).prototype = isolate.SendPort.prototype;
>+dart.addTypeTests(isolate.SendPort);
>+isolate.SendPort[dart.implements] = () => [isolate.Capability];
>+dart.setLibraryUri(isolate.SendPort, "dart:isolate");
>+isolate.ReceivePort = class ReceivePort extends core.Object {
>+  static new() {
>+    return new isolate._ReceivePort.new();
>+  }
>+  static fromRawReceivePort(rawPort) {
>+    return isolate._unsupported();
>+  }
>+};
>+(isolate.ReceivePort[dart.mixinNew] = function() {
>+}).prototype = isolate.ReceivePort.prototype;
>+isolate.ReceivePort.prototype[dart.isStream] = true;
>+dart.addTypeTests(isolate.ReceivePort);
>+isolate.ReceivePort[dart.implements] = () => [async.Stream];
>+dart.setLibraryUri(isolate.ReceivePort, "dart:isolate");
>+isolate.RawReceivePort = class RawReceivePort extends core.Object {
>+  static new(handler) {
>+    if (handler === void 0) handler = null;
>+    return isolate._unsupported();
>+  }
>+};
>+(isolate.RawReceivePort[dart.mixinNew] = function() {
>+}).prototype = isolate.RawReceivePort.prototype;
>+dart.addTypeTests(isolate.RawReceivePort);
>+dart.setLibraryUri(isolate.RawReceivePort, "dart:isolate");
>+const _description = dart.privateName(isolate, "_description");
>+isolate.RemoteError = class RemoteError extends core.Object {
>+  get stackTrace() {
>+    return this[stackTrace];
>+  }
>+  set stackTrace(value) {
>+    super.stackTrace = value;
>+  }
>+  toString() {
>+    return this[_description];
>+  }
>+};
>+(isolate.RemoteError.new = function(description, stackDescription) {
>+  this[_description] = description;
>+  this[stackTrace] = core.StackTrace.fromString(stackDescription);
>+}).prototype = isolate.RemoteError.prototype;
>+dart.addTypeTests(isolate.RemoteError);
>+const stackTrace = Symbol("RemoteError.stackTrace");
>+isolate.RemoteError[dart.implements] = () => [core.Error];
>+dart.setLibraryUri(isolate.RemoteError, "dart:isolate");
>+dart.setFieldSignature(isolate.RemoteError, () => ({
>+  __proto__: dart.getFields(isolate.RemoteError.__proto__),
>+  [_description]: dart.finalFieldType(core.String),
>+  stackTrace: dart.finalFieldType(core.StackTrace)
>+}));
>+dart.defineExtensionMethods(isolate.RemoteError, ['toString']);
>+dart.defineExtensionAccessors(isolate.RemoteError, ['stackTrace']);
>+isolate.TransferableTypedData = class TransferableTypedData extends core.Object {
>+  static fromList(list) {
>+    return isolate._unsupported();
>+  }
>+};
>+(isolate.TransferableTypedData[dart.mixinNew] = function() {
>+}).prototype = isolate.TransferableTypedData.prototype;
>+dart.addTypeTests(isolate.TransferableTypedData);
>+dart.setLibraryUri(isolate.TransferableTypedData, "dart:isolate");
>+isolate._ReceivePort = class _ReceivePort extends async.Stream {
>+  close() {}
>+  get sendPort() {
>+    return isolate._unsupported();
>+  }
>+  listen(onData, opts) {
>+    let onError = opts && 'onError' in opts ? opts.onError : null;
>+    let onDone = opts && 'onDone' in opts ? opts.onDone : null;
>+    let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
>+    return isolate._unsupported();
>+  }
>+};
>+(isolate._ReceivePort.new = function() {
>+  isolate._ReceivePort.__proto__.new.call(this);
>+}).prototype = isolate._ReceivePort.prototype;
>+dart.addTypeTests(isolate._ReceivePort);
>+isolate._ReceivePort[dart.implements] = () => [isolate.ReceivePort];
>+dart.setMethodSignature(isolate._ReceivePort, () => ({
>+  __proto__: dart.getMethods(isolate._ReceivePort.__proto__),
>+  close: dart.fnType(dart.void, []),
>+  listen: dart.fnType(async.StreamSubscription, [dart.dynamic], {onError: core.Function, onDone: dart.dynamic, cancelOnError: core.bool})
>+}));
>+dart.setGetterSignature(isolate._ReceivePort, () => ({
>+  __proto__: dart.getGetters(isolate._ReceivePort.__proto__),
>+  sendPort: isolate.SendPort
>+}));
>+dart.setLibraryUri(isolate._ReceivePort, "dart:isolate");
>+isolate._unsupported = function() {
>+  dart.throw(new core.UnsupportedError.new("dart:isolate is not supported on dart4web"));
>+};
>+isolate.Capability = class Capability extends core.Object {
>+  static new() {
>+    return isolate._unsupported();
>+  }
>+};
>+(isolate.Capability[dart.mixinNew] = function() {
>+}).prototype = isolate.Capability.prototype;
>+dart.addTypeTests(isolate.Capability);
>+dart.setLibraryUri(isolate.Capability, "dart:isolate");
>+dart.defineLazy(js, {
>+  /*js.context*/get context() {
>+    return js.JsObject._check(js._wrapToDart(dart.global));
>+  }
>+});
>+const _jsObject = dart.privateName(js, "_jsObject");
>+js.JsObject = class JsObject extends core.Object {
>+  static new(constructor, arguments$0) {
>+    if (arguments$0 === void 0) arguments$0 = null;
>+    let ctor = constructor[_jsObject];
>+    if (arguments$0 == null) {
>+      return js.JsObject._check(js._wrapToDart(new ctor()));
>+    }
>+    let unwrapped = core.List.from(arguments$0[$map](dart.dynamic, dart.fn(js._convertToJS, dynamicTodynamic())));
>+    return js.JsObject._check(js._wrapToDart(new ctor(...unwrapped)));
>+  }
>+  static fromBrowserObject(object) {
>+    if (typeof object == 'number' || typeof object == 'string' || typeof object == 'boolean' || object == null) {
>+      dart.throw(new core.ArgumentError.new("object cannot be a num, string, bool, or null"));
>+    }
>+    return js.JsObject._check(js._wrapToDart(js._convertToJS(object)));
>+  }
>+  static jsify(object) {
>+    if (!core.Map.is(object) && !core.Iterable.is(object)) {
>+      dart.throw(new core.ArgumentError.new("object must be a Map or Iterable"));
>+    }
>+    return js.JsObject._check(js._wrapToDart(js.JsObject._convertDataTree(object)));
>+  }
>+  static _convertDataTree(data) {
>+    let _convertedObjects = new _js_helper.IdentityMap.new();
>+    function _convert(o) {
>+      if (dart.test(_convertedObjects.containsKey(o))) {
>+        return _convertedObjects._get(o);
>+      }
>+      if (core.Map.is(o)) {
>+        let convertedMap = {};
>+        _convertedObjects._set(o, convertedMap);
>+        for (let key of o[$keys]) {
>+          convertedMap[key] = _convert(o[$_get](key));
>+        }
>+        return convertedMap;
>+      } else if (core.Iterable.is(o)) {
>+        let convertedList = [];
>+        _convertedObjects._set(o, convertedList);
>+        convertedList[$addAll](o[$map](dart.dynamic, _convert));
>+        return convertedList;
>+      } else {
>+        return js._convertToJS(o);
>+      }
>+    }
>+    dart.fn(_convert, dynamicTodynamic());
>+    return _convert(data);
>+  }
>+  _get(property) {
>+    if (!(typeof property == 'string') && !(typeof property == 'number')) {
>+      dart.throw(new core.ArgumentError.new("property is not a String or num"));
>+    }
>+    return js._convertToDart(this[_jsObject][property]);
>+  }
>+  _set(property, value) {
>+    if (!(typeof property == 'string') && !(typeof property == 'number')) {
>+      dart.throw(new core.ArgumentError.new("property is not a String or num"));
>+    }
>+    this[_jsObject][property] = js._convertToJS(value);
>+    return value;
>+  }
>+  get hashCode() {
>+    return 0;
>+  }
>+  _equals(other) {
>+    return js.JsObject.is(other) && this[_jsObject] === other[_jsObject];
>+  }
>+  hasProperty(property) {
>+    if (!(typeof property == 'string') && !(typeof property == 'number')) {
>+      dart.throw(new core.ArgumentError.new("property is not a String or num"));
>+    }
>+    return property in this[_jsObject];
>+  }
>+  deleteProperty(property) {
>+    if (!(typeof property == 'string') && !(typeof property == 'number')) {
>+      dart.throw(new core.ArgumentError.new("property is not a String or num"));
>+    }
>+    delete this[_jsObject][property];
>+  }
>+  instanceof(type) {
>+    return this[_jsObject] instanceof js._convertToJS(type);
>+  }
>+  toString() {
>+    try {
>+      return String(this[_jsObject]);
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      return super.toString();
>+    }
>+  }
>+  callMethod(method, args) {
>+    if (args === void 0) args = null;
>+    if (!(typeof method == 'string') && !(typeof method == 'number')) {
>+      dart.throw(new core.ArgumentError.new("method is not a String or num"));
>+    }
>+    if (args != null) args = core.List.from(args[$map](dart.dynamic, dart.fn(js._convertToJS, dynamicTodynamic())));
>+    let fn = this[_jsObject][method];
>+    if (typeof fn !== "function") {
>+      dart.throw(new core.NoSuchMethodError.new(this[_jsObject], core.Symbol.new(core.String._check(method)), args, new (LinkedMapOfSymbol$dynamic()).new()));
>+    }
>+    return js._convertToDart(fn.apply(this[_jsObject], args));
>+  }
>+};
>+(js.JsObject._fromJs = function(jsObject) {
>+  this[_jsObject] = jsObject;
>+  if (!(this[_jsObject] != null)) dart.assertFailed(null, "dart:js", 110, 12, "_jsObject != null");
>+}).prototype = js.JsObject.prototype;
>+dart.addTypeTests(js.JsObject);
>+dart.setMethodSignature(js.JsObject, () => ({
>+  __proto__: dart.getMethods(js.JsObject.__proto__),
>+  _get: dart.fnType(dart.dynamic, [core.Object]),
>+  _set: dart.fnType(dart.void, [core.Object, dart.dynamic]),
>+  hasProperty: dart.fnType(core.bool, [dart.dynamic]),
>+  deleteProperty: dart.fnType(dart.void, [dart.dynamic]),
>+  instanceof: dart.fnType(core.bool, [js.JsFunction]),
>+  callMethod: dart.fnType(dart.dynamic, [dart.dynamic], [core.List])
>+}));
>+dart.setLibraryUri(js.JsObject, "dart:js");
>+dart.setFieldSignature(js.JsObject, () => ({
>+  __proto__: dart.getFields(js.JsObject.__proto__),
>+  [_jsObject]: dart.finalFieldType(dart.dynamic)
>+}));
>+dart.defineExtensionMethods(js.JsObject, ['_equals', 'toString']);
>+dart.defineExtensionAccessors(js.JsObject, ['hashCode']);
>+js.JsFunction = class JsFunction extends js.JsObject {
>+  static withThis(f) {
>+    return new js.JsFunction._fromJs(function() {
>+      let args = [js._convertToDart(this)];
>+      for (let arg of arguments) {
>+        args.push(js._convertToDart(arg));
>+      }
>+      return js._convertToJS(f(...args));
>+    });
>+  }
>+  apply(args, opts) {
>+    let thisArg = opts && 'thisArg' in opts ? opts.thisArg : null;
>+    return js._convertToDart(this[_jsObject].apply(js._convertToJS(thisArg), args == null ? null : core.List.from(args[$map](dart.dynamic, js._convertToJS))));
>+  }
>+};
>+(js.JsFunction._fromJs = function(jsObject) {
>+  js.JsFunction.__proto__._fromJs.call(this, jsObject);
>+}).prototype = js.JsFunction.prototype;
>+dart.addTypeTests(js.JsFunction);
>+dart.setMethodSignature(js.JsFunction, () => ({
>+  __proto__: dart.getMethods(js.JsFunction.__proto__),
>+  apply: dart.fnType(dart.dynamic, [core.List], {thisArg: dart.dynamic})
>+}));
>+dart.setLibraryUri(js.JsFunction, "dart:js");
>+const _checkIndex = dart.privateName(js, "_checkIndex");
>+const _checkInsertIndex = dart.privateName(js, "_checkInsertIndex");
>+const _is_JsArray_default = Symbol('_is_JsArray_default');
>+js.JsArray$ = dart.generic(E => {
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  const JsObject_ListMixin$ = class JsObject_ListMixin extends js.JsObject {};
>+  (JsObject_ListMixin$._fromJs = function(_jsObject) {
>+    JsObject_ListMixin$.__proto__._fromJs.call(this, _jsObject);
>+  }).prototype = JsObject_ListMixin$.prototype;
>+  (JsObject_ListMixin$.new = function(constructor, arguments$0) {
>+    JsObject_ListMixin$.__proto__.new.call(this, constructor, arguments$0);
>+  }).prototype = JsObject_ListMixin$.prototype;
>+  (JsObject_ListMixin$.fromBrowserObject = function(object) {
>+    JsObject_ListMixin$.__proto__.fromBrowserObject.call(this, object);
>+  }).prototype = JsObject_ListMixin$.prototype;
>+  (JsObject_ListMixin$.jsify = function(object) {
>+    JsObject_ListMixin$.__proto__.jsify.call(this, object);
>+  }).prototype = JsObject_ListMixin$.prototype;
>+  dart.applyMixin(JsObject_ListMixin$, collection.ListMixin$(E));
>+  class JsArray extends JsObject_ListMixin$ {
>+    [_checkIndex](index) {
>+      if (core.int.is(index) && (dart.notNull(index) < 0 || dart.notNull(index) >= dart.notNull(this.length))) {
>+        dart.throw(new core.RangeError.range(index, 0, this.length));
>+      }
>+    }
>+    [_checkInsertIndex](index) {
>+      if (core.int.is(index) && (dart.notNull(index) < 0 || dart.notNull(index) >= dart.notNull(this.length) + 1)) {
>+        dart.throw(new core.RangeError.range(index, 0, this.length));
>+      }
>+    }
>+    static _checkRange(start, end, length) {
>+      if (dart.notNull(start) < 0 || dart.notNull(start) > dart.notNull(length)) {
>+        dart.throw(new core.RangeError.range(start, 0, length));
>+      }
>+      if (dart.notNull(end) < dart.notNull(start) || dart.notNull(end) > dart.notNull(length)) {
>+        dart.throw(new core.RangeError.range(end, start, length));
>+      }
>+    }
>+    _get(index) {
>+      if (typeof index == 'number' && index === index[$toInt]()) {
>+        this[_checkIndex](dart.asInt(index));
>+      }
>+      return E.as(super._get(index));
>+    }
>+    _set(index, value) {
>+      if (typeof index == 'number' && index === index[$toInt]()) {
>+        this[_checkIndex](dart.asInt(index));
>+      }
>+      super._set(index, value);
>+      return value;
>+    }
>+    get length() {
>+      let len = this[_jsObject].length;
>+      if (typeof len === "number" && len >>> 0 === len) {
>+        return len;
>+      }
>+      dart.throw(new core.StateError.new("Bad JsArray length"));
>+    }
>+    set length(length) {
>+      super._set("length", length);
>+    }
>+    add(value) {
>+      E._check(value);
>+      this.callMethod("push", [value]);
>+    }
>+    addAll(iterable) {
>+      IterableOfE()._check(iterable);
>+      let list = iterable instanceof Array ? iterable : core.List.from(iterable);
>+      this.callMethod("push", core.List._check(list));
>+    }
>+    insert(index, element) {
>+      E._check(element);
>+      this[_checkInsertIndex](index);
>+      this.callMethod("splice", [index, 0, element]);
>+    }
>+    removeAt(index) {
>+      this[_checkIndex](index);
>+      return E.as(dart.dindex(this.callMethod("splice", [index, 1]), 0));
>+    }
>+    removeLast() {
>+      if (this.length === 0) dart.throw(new core.RangeError.new(-1));
>+      return E.as(this.callMethod("pop"));
>+    }
>+    removeRange(start, end) {
>+      js.JsArray._checkRange(start, end, this.length);
>+      this.callMethod("splice", [start, dart.notNull(end) - dart.notNull(start)]);
>+    }
>+    setRange(start, end, iterable, skipCount) {
>+      IterableOfE()._check(iterable);
>+      if (skipCount === void 0) skipCount = 0;
>+      js.JsArray._checkRange(start, end, this.length);
>+      let length = dart.notNull(end) - dart.notNull(start);
>+      if (length === 0) return;
>+      if (dart.notNull(skipCount) < 0) dart.throw(new core.ArgumentError.new(skipCount));
>+      let args = JSArrayOfObject().of([start, length]);
>+      args[$addAll](iterable[$skip](skipCount)[$take](length));
>+      this.callMethod("splice", args);
>+    }
>+    sort(compare) {
>+      if (compare === void 0) compare = null;
>+      this.callMethod("sort", compare == null ? [] : [compare]);
>+    }
>+  }
>+  (JsArray.new = function() {
>+    JsArray.__proto__._fromJs.call(this, []);
>+  }).prototype = JsArray.prototype;
>+  (JsArray.from = function(other) {
>+    JsArray.__proto__._fromJs.call(this, (() => {
>+      let _ = [];
>+      _[$addAll](other[$map](dart.dynamic, dart.fn(js._convertToJS, dynamicTodynamic())));
>+      return _;
>+    })());
>+  }).prototype = JsArray.prototype;
>+  (JsArray._fromJs = function(jsObject) {
>+    JsArray.__proto__._fromJs.call(this, jsObject);
>+  }).prototype = JsArray.prototype;
>+  dart.addTypeTests(JsArray);
>+  JsArray.prototype[_is_JsArray_default] = true;
>+  dart.setMethodSignature(JsArray, () => ({
>+    __proto__: dart.getMethods(JsArray.__proto__),
>+    [_checkIndex]: dart.fnType(dart.dynamic, [core.int]),
>+    [_checkInsertIndex]: dart.fnType(dart.dynamic, [core.int]),
>+    _get: dart.fnType(E, [core.Object]),
>+    [$_get]: dart.fnType(E, [core.Object]),
>+    _set: dart.fnType(dart.void, [core.Object, dart.dynamic]),
>+    [$_set]: dart.fnType(dart.void, [core.Object, dart.dynamic]),
>+    add: dart.fnType(dart.void, [core.Object]),
>+    [$add]: dart.fnType(dart.void, [core.Object]),
>+    addAll: dart.fnType(dart.void, [core.Object]),
>+    [$addAll]: dart.fnType(dart.void, [core.Object]),
>+    insert: dart.fnType(dart.void, [core.int, core.Object]),
>+    [$insert]: dart.fnType(dart.void, [core.int, core.Object]),
>+    setRange: dart.fnType(dart.void, [core.int, core.int, core.Object], [core.int]),
>+    [$setRange]: dart.fnType(dart.void, [core.int, core.int, core.Object], [core.int])
>+  }));
>+  dart.setGetterSignature(JsArray, () => ({
>+    __proto__: dart.getGetters(JsArray.__proto__),
>+    length: core.int,
>+    [$length]: core.int
>+  }));
>+  dart.setSetterSignature(JsArray, () => ({
>+    __proto__: dart.getSetters(JsArray.__proto__),
>+    length: core.int,
>+    [$length]: core.int
>+  }));
>+  dart.setLibraryUri(JsArray, "dart:js");
>+  dart.defineExtensionMethods(JsArray, [
>+    '_get',
>+    '_set',
>+    'add',
>+    'addAll',
>+    'insert',
>+    'removeAt',
>+    'removeLast',
>+    'removeRange',
>+    'setRange',
>+    'sort'
>+  ]);
>+  dart.defineExtensionAccessors(JsArray, ['length']);
>+  return JsArray;
>+});
>+js.JsArray = js.JsArray$();
>+dart.addTypeTests(js.JsArray, _is_JsArray_default);
>+js._isBrowserType = function(o) {
>+  return o instanceof Object && (o instanceof Blob || o instanceof Event || window.KeyRange && o instanceof KeyRange || window.IDBKeyRange && o instanceof IDBKeyRange || o instanceof ImageData || o instanceof Node || window.Int8Array && o instanceof Int8Array.__proto__ || o instanceof Window);
>+};
>+const _dartObj = dart.privateName(js, "_dartObj");
>+js._DartObject = class _DartObject extends core.Object {};
>+(js._DartObject.new = function(dartObj) {
>+  this[_dartObj] = dartObj;
>+}).prototype = js._DartObject.prototype;
>+dart.addTypeTests(js._DartObject);
>+dart.setLibraryUri(js._DartObject, "dart:js");
>+dart.setFieldSignature(js._DartObject, () => ({
>+  __proto__: dart.getFields(js._DartObject.__proto__),
>+  [_dartObj]: dart.finalFieldType(dart.dynamic)
>+}));
>+js._convertToJS = function(o) {
>+  if (o == null || typeof o == 'string' || typeof o == 'number' || typeof o == 'boolean' || dart.test(js._isBrowserType(o))) {
>+    return o;
>+  } else if (core.DateTime.is(o)) {
>+    return _js_helper.Primitives.lazyAsJsDate(o);
>+  } else if (js.JsObject.is(o)) {
>+    return o[_jsObject];
>+  } else if (core.Function.is(o)) {
>+    return js._putIfAbsent(js._jsProxies, o, dart.fn(js._wrapDartFunction, dynamicTodynamic()));
>+  } else {
>+    return js._putIfAbsent(js._jsProxies, o, dart.fn(o => new js._DartObject.new(o), dynamicTo_DartObject()));
>+  }
>+};
>+js._wrapDartFunction = function(f) {
>+  let wrapper = function() {
>+    let args = Array.prototype.map.call(arguments, js._convertToDart);
>+    return js._convertToJS(f(...args));
>+  };
>+  js._dartProxies.set(wrapper, f);
>+  return wrapper;
>+};
>+js._convertToDart = function(o) {
>+  if (o == null || typeof o == 'string' || typeof o == 'number' || typeof o == 'boolean' || dart.test(js._isBrowserType(o))) {
>+    return o;
>+  } else if (o instanceof Date) {
>+    let ms = o.getTime();
>+    return new core.DateTime.fromMillisecondsSinceEpoch(dart.asInt(ms));
>+  } else if (js._DartObject.is(o) && !core.identical(dart.getReifiedType(o), dart.jsobject)) {
>+    return o[_dartObj];
>+  } else {
>+    return js._wrapToDart(o);
>+  }
>+};
>+js._wrapToDart = function(o) {
>+  return js._putIfAbsent(js._dartProxies, o, dart.fn(js._wrapToDartHelper, dynamicToObject()));
>+};
>+js._wrapToDartHelper = function(o) {
>+  if (typeof o == "function") {
>+    return new js.JsFunction._fromJs(o);
>+  }
>+  if (o instanceof Array) {
>+    return new js.JsArray._fromJs(o);
>+  }
>+  return new js.JsObject._fromJs(o);
>+};
>+dart.defineLazy(js, {
>+  /*js._dartProxies*/get _dartProxies() {
>+    return new WeakMap();
>+  },
>+  /*js._jsProxies*/get _jsProxies() {
>+    return new WeakMap();
>+  }
>+});
>+js._putIfAbsent = function(weakMap, o, getValue) {
>+  let value = weakMap.get(o);
>+  if (value == null) {
>+    value = getValue(o);
>+    weakMap.set(o, value);
>+  }
>+  return value;
>+};
>+js.allowInterop = function(F, f) {
>+  return f;
>+};
>+dart.defineLazy(js, {
>+  /*js._interopCaptureThisExpando*/get _interopCaptureThisExpando() {
>+    return new (ExpandoOfFunction()).new();
>+  },
>+  set _interopCaptureThisExpando(_) {}
>+});
>+js.allowInteropCaptureThis = function(f) {
>+  let ret = js._interopCaptureThisExpando._get(f);
>+  if (ret == null) {
>+    ret = function() {
>+      let args = [this];
>+      for (let arg of arguments) {
>+        args.push(arg);
>+      }
>+      return f(...args);
>+    };
>+    js._interopCaptureThisExpando._set(f, ret);
>+  }
>+  return ret;
>+};
>+js_util.jsify = function(object) {
>+  if (!core.Map.is(object) && !core.Iterable.is(object)) {
>+    dart.throw(new core.ArgumentError.new("object must be a Map or Iterable"));
>+  }
>+  return js_util._convertDataTree(object);
>+};
>+js_util._convertDataTree = function(data) {
>+  let _convertedObjects = new _js_helper.IdentityMap.new();
>+  function _convert(o) {
>+    if (dart.test(_convertedObjects.containsKey(o))) {
>+      return _convertedObjects._get(o);
>+    }
>+    if (core.Map.is(o)) {
>+      let convertedMap = {};
>+      _convertedObjects._set(o, convertedMap);
>+      for (let key of o[$keys]) {
>+        convertedMap[key] = _convert(o[$_get](key));
>+      }
>+      return convertedMap;
>+    } else if (core.Iterable.is(o)) {
>+      let convertedList = [];
>+      _convertedObjects._set(o, convertedList);
>+      convertedList[$addAll](o[$map](dart.dynamic, _convert));
>+      return convertedList;
>+    } else {
>+      return o;
>+    }
>+  }
>+  dart.fn(_convert, dynamicTodynamic());
>+  return _convert(data);
>+};
>+js_util.newObject = function() {
>+  return {};
>+};
>+js_util.hasProperty = function(o, name) {
>+  return name in o;
>+};
>+js_util.getProperty = function(o, name) {
>+  return o[name];
>+};
>+js_util.setProperty = function(o, name, value) {
>+  return o[name] = value;
>+};
>+js_util.callMethod = function(o, method, args) {
>+  return o[method].apply(o, args);
>+};
>+js_util.instanceof = function(o, type) {
>+  return o instanceof type;
>+};
>+js_util.callConstructor = function(constr, arguments$0) {
>+  if (arguments$0 == null) {
>+    return new constr();
>+  }
>+  if (arguments$0 instanceof Array) {
>+    let argumentCount = arguments$0.length;
>+    switch (argumentCount) {
>+      case 0:
>+      {
>+        return new constr();
>+      }
>+      case 1:
>+      {
>+        let arg0 = arguments$0[0];
>+        return new constr(arg0);
>+      }
>+      case 2:
>+      {
>+        let arg0 = arguments$0[0];
>+        let arg1 = arguments$0[1];
>+        return new constr(arg0, arg1);
>+      }
>+      case 3:
>+      {
>+        let arg0 = arguments$0[0];
>+        let arg1 = arguments$0[1];
>+        let arg2 = arguments$0[2];
>+        return new constr(arg0, arg1, arg2);
>+      }
>+      case 4:
>+      {
>+        let arg0 = arguments$0[0];
>+        let arg1 = arguments$0[1];
>+        let arg2 = arguments$0[2];
>+        let arg3 = arguments$0[3];
>+        return new constr(arg0, arg1, arg2, arg3);
>+      }
>+    }
>+  }
>+  let args = [null];
>+  args[$addAll](arguments$0);
>+  let factoryFunction = constr.bind.apply(constr, args);
>+  String(factoryFunction);
>+  return new factoryFunction();
>+};
>+dart.defineLazy(math, {
>+  /*math.e*/get e() {
>+    return 2.718281828459045;
>+  },
>+  /*math.ln10*/get ln10() {
>+    return 2.302585092994046;
>+  },
>+  /*math.ln2*/get ln2() {
>+    return 0.6931471805599453;
>+  },
>+  /*math.log2e*/get log2e() {
>+    return 1.4426950408889634;
>+  },
>+  /*math.log10e*/get log10e() {
>+    return 0.4342944819032518;
>+  },
>+  /*math.pi*/get pi() {
>+    return 3.141592653589793;
>+  },
>+  /*math.sqrt1_2*/get sqrt1_2() {
>+    return 0.7071067811865476;
>+  },
>+  /*math.sqrt2*/get sqrt2() {
>+    return 1.4142135623730951;
>+  }
>+});
>+math.min = function(T, a, b) {
>+  if (a == null) dart.argumentError(a);
>+  if (b == null) dart.argumentError(b);
>+  return Math.min(a, b);
>+};
>+math.max = function(T, a, b) {
>+  if (a == null) dart.argumentError(a);
>+  if (b == null) dart.argumentError(b);
>+  return Math.max(a, b);
>+};
>+math.atan2 = function(a, b) {
>+  if (a == null) dart.argumentError(a);
>+  if (b == null) dart.argumentError(b);
>+  return Math.atan2(a, b);
>+};
>+math.pow = function(x, exponent) {
>+  if (x == null) dart.argumentError(x);
>+  if (exponent == null) dart.argumentError(exponent);
>+  return Math.pow(x, exponent);
>+};
>+math.sin = function(radians) {
>+  if (radians == null) dart.argumentError(radians);
>+  return Math.sin(radians);
>+};
>+math.cos = function(radians) {
>+  if (radians == null) dart.argumentError(radians);
>+  return Math.cos(radians);
>+};
>+math.tan = function(radians) {
>+  if (radians == null) dart.argumentError(radians);
>+  return Math.tan(radians);
>+};
>+math.acos = function(x) {
>+  if (x == null) dart.argumentError(x);
>+  return Math.acos(x);
>+};
>+math.asin = function(x) {
>+  if (x == null) dart.argumentError(x);
>+  return Math.asin(x);
>+};
>+math.atan = function(x) {
>+  if (x == null) dart.argumentError(x);
>+  return Math.atan(x);
>+};
>+math.sqrt = function(x) {
>+  if (x == null) dart.argumentError(x);
>+  return Math.sqrt(x);
>+};
>+math.exp = function(x) {
>+  if (x == null) dart.argumentError(x);
>+  return Math.exp(x);
>+};
>+math.log = function(x) {
>+  if (x == null) dart.argumentError(x);
>+  return Math.log(x);
>+};
>+dart.defineLazy(math, {
>+  /*math._POW2_32*/get _POW2_32() {
>+    return 4294967296;
>+  }
>+});
>+math._JSRandom = class _JSRandom extends core.Object {
>+  nextInt(max) {
>+    if (dart.notNull(max) <= 0 || dart.notNull(max) > 4294967296) {
>+      dart.throw(new core.RangeError.new("max must be in range 0 < max â¤ 2^32, was " + dart.str(max)));
>+    }
>+    return Math.random() * max >>> 0;
>+  }
>+  nextDouble() {
>+    return Math.random();
>+  }
>+  nextBool() {
>+    return Math.random() < 0.5;
>+  }
>+};
>+(math._JSRandom.new = function() {
>+}).prototype = math._JSRandom.prototype;
>+dart.addTypeTests(math._JSRandom);
>+math._JSRandom[dart.implements] = () => [math.Random];
>+dart.setMethodSignature(math._JSRandom, () => ({
>+  __proto__: dart.getMethods(math._JSRandom.__proto__),
>+  nextInt: dart.fnType(core.int, [core.int]),
>+  nextDouble: dart.fnType(core.double, []),
>+  nextBool: dart.fnType(core.bool, [])
>+}));
>+dart.setLibraryUri(math._JSRandom, "dart:math");
>+const _lo = dart.privateName(math, "_lo");
>+const _hi = dart.privateName(math, "_hi");
>+const _nextState = dart.privateName(math, "_nextState");
>+math._Random = class _Random extends core.Object {
>+  [_nextState]() {
>+    let tmpHi = 4294901760 * this[_lo];
>+    let tmpHiLo = (tmpHi & 4294967295) >>> 0;
>+    let tmpHiHi = tmpHi - tmpHiLo;
>+    let tmpLo = 55905 * this[_lo];
>+    let tmpLoLo = (tmpLo & 4294967295) >>> 0;
>+    let tmpLoHi = tmpLo - tmpLoLo;
>+    let newLo = tmpLoLo + tmpHiLo + this[_hi];
>+    this[_lo] = (newLo & 4294967295) >>> 0;
>+    let newLoHi = newLo - this[_lo];
>+    this[_hi] = (((tmpLoHi + tmpHiHi + newLoHi) / 4294967296)[$truncate]() & 4294967295) >>> 0;
>+    if (!(this[_lo] < 4294967296)) dart.assertFailed(null, "dart:math", 342, 12, "_lo < _POW2_32");
>+    if (!(this[_hi] < 4294967296)) dart.assertFailed(null, "dart:math", 343, 12, "_hi < _POW2_32");
>+  }
>+  nextInt(max) {
>+    if (max == null) dart.argumentError(max);
>+    if (max <= 0 || max > 4294967296) {
>+      dart.throw(new core.RangeError.new("max must be in range 0 < max â¤ 2^32, was " + dart.str(max)));
>+    }
>+    if ((max & max - 1) === 0) {
>+      this[_nextState]();
>+      return (this[_lo] & max - 1) >>> 0;
>+    }
>+    let rnd32 = null;
>+    let result = null;
>+    do {
>+      this[_nextState]();
>+      rnd32 = this[_lo];
>+      result = dart.asInt(rnd32[$remainder](max));
>+    } while (dart.notNull(rnd32) - dart.notNull(result) + max >= 4294967296);
>+    return result;
>+  }
>+  nextDouble() {
>+    this[_nextState]();
>+    let bits26 = (this[_lo] & (1 << 26) - 1) >>> 0;
>+    this[_nextState]();
>+    let bits27 = (this[_lo] & (1 << 27) - 1) >>> 0;
>+    return (bits26 * 134217728.0 + bits27) / 9007199254740992.0;
>+  }
>+  nextBool() {
>+    this[_nextState]();
>+    return (this[_lo] & 1) === 0;
>+  }
>+};
>+(math._Random.new = function(seed) {
>+  this[_lo] = 0;
>+  this[_hi] = 0;
>+  let empty_seed = 0;
>+  if (dart.notNull(seed) < 0) {
>+    empty_seed = -1;
>+  }
>+  do {
>+    let low = (dart.notNull(seed) & 4294967295) >>> 0;
>+    seed = ((dart.notNull(seed) - low) / 4294967296)[$truncate]();
>+    let high = (dart.notNull(seed) & 4294967295) >>> 0;
>+    seed = ((dart.notNull(seed) - high) / 4294967296)[$truncate]();
>+    let tmplow = low << 21 >>> 0;
>+    let tmphigh = (high << 21 | low[$rightShift](11)) >>> 0;
>+    tmplow = ((~low & 4294967295) >>> 0) + tmplow;
>+    low = (tmplow & 4294967295) >>> 0;
>+    high = ((~high >>> 0) + tmphigh + ((tmplow - low) / 4294967296)[$truncate]() & 4294967295) >>> 0;
>+    tmphigh = high[$rightShift](24);
>+    tmplow = (low[$rightShift](24) | high << 8) >>> 0;
>+    low = (low ^ tmplow) >>> 0;
>+    high = (high ^ tmphigh) >>> 0;
>+    tmplow = low * 265;
>+    low = (tmplow & 4294967295) >>> 0;
>+    high = (high * 265 + ((tmplow - low) / 4294967296)[$truncate]() & 4294967295) >>> 0;
>+    tmphigh = high[$rightShift](14);
>+    tmplow = (low[$rightShift](14) | high << 18) >>> 0;
>+    low = (low ^ tmplow) >>> 0;
>+    high = (high ^ tmphigh) >>> 0;
>+    tmplow = low * 21;
>+    low = (tmplow & 4294967295) >>> 0;
>+    high = (high * 21 + ((tmplow - low) / 4294967296)[$truncate]() & 4294967295) >>> 0;
>+    tmphigh = high[$rightShift](28);
>+    tmplow = (low[$rightShift](28) | high << 4) >>> 0;
>+    low = (low ^ tmplow) >>> 0;
>+    high = (high ^ tmphigh) >>> 0;
>+    tmplow = low << 31 >>> 0;
>+    tmphigh = (high << 31 | low[$rightShift](1)) >>> 0;
>+    tmplow = tmplow + low;
>+    low = (tmplow & 4294967295) >>> 0;
>+    high = (high + tmphigh + ((tmplow - low) / 4294967296)[$truncate]() & 4294967295) >>> 0;
>+    tmplow = this[_lo] * 1037;
>+    this[_lo] = (tmplow & 4294967295) >>> 0;
>+    this[_hi] = (this[_hi] * 1037 + ((tmplow - this[_lo]) / 4294967296)[$truncate]() & 4294967295) >>> 0;
>+    this[_lo] = (this[_lo] ^ low) >>> 0;
>+    this[_hi] = (this[_hi] ^ high) >>> 0;
>+  } while (seed !== empty_seed);
>+  if (this[_hi] === 0 && this[_lo] === 0) {
>+    this[_lo] = 23063;
>+  }
>+  this[_nextState]();
>+  this[_nextState]();
>+  this[_nextState]();
>+  this[_nextState]();
>+}).prototype = math._Random.prototype;
>+dart.addTypeTests(math._Random);
>+math._Random[dart.implements] = () => [math.Random];
>+dart.setMethodSignature(math._Random, () => ({
>+  __proto__: dart.getMethods(math._Random.__proto__),
>+  [_nextState]: dart.fnType(dart.void, []),
>+  nextInt: dart.fnType(core.int, [core.int]),
>+  nextDouble: dart.fnType(core.double, []),
>+  nextBool: dart.fnType(core.bool, [])
>+}));
>+dart.setLibraryUri(math._Random, "dart:math");
>+dart.setFieldSignature(math._Random, () => ({
>+  __proto__: dart.getFields(math._Random.__proto__),
>+  [_lo]: dart.fieldType(core.int),
>+  [_hi]: dart.fieldType(core.int)
>+}));
>+dart.defineLazy(math._Random, {
>+  /*math._Random._POW2_53_D*/get _POW2_53_D() {
>+    return 1.0 * 9007199254740992;
>+  },
>+  /*math._Random._POW2_27_D*/get _POW2_27_D() {
>+    return 1.0 * (1 << 27);
>+  },
>+  /*math._Random._MASK32*/get _MASK32() {
>+    return 4294967295;
>+  }
>+});
>+const _buffer$0 = dart.privateName(math, "_buffer");
>+const _getRandomBytes = dart.privateName(math, "_getRandomBytes");
>+math._JSSecureRandom = class _JSSecureRandom extends core.Object {
>+  [_getRandomBytes](start, length) {
>+    crypto.getRandomValues(this[_buffer$0][$buffer][$asUint8List](start, length));
>+  }
>+  nextBool() {
>+    this[_getRandomBytes](0, 1);
>+    return this[_buffer$0][$getUint8](0)[$isOdd];
>+  }
>+  nextDouble() {
>+    this[_getRandomBytes](1, 7);
>+    this[_buffer$0][$setUint8](0, 63);
>+    let highByte = this[_buffer$0][$getUint8](1);
>+    this[_buffer$0][$setUint8](1, (dart.notNull(highByte) | 240) >>> 0);
>+    let result = dart.notNull(this[_buffer$0][$getFloat64](0)) - 1.0;
>+    if ((dart.notNull(highByte) & 16) !== 0) {
>+      result = result + 1.1102230246251565e-16;
>+    }
>+    return result;
>+  }
>+  nextInt(max) {
>+    if (max == null) dart.argumentError(max);
>+    if (max <= 0 || max > 4294967296) {
>+      dart.throw(new core.RangeError.new("max must be in range 0 < max â¤ 2^32, was " + dart.str(max)));
>+    }
>+    let byteCount = 1;
>+    if (max > 255) {
>+      byteCount++;
>+      if (max > 65535) {
>+        byteCount++;
>+        if (max > 16777215) {
>+          byteCount++;
>+        }
>+      }
>+    }
>+    this[_buffer$0][$setUint32](0, 0);
>+    let start = 4 - byteCount;
>+    let randomLimit = dart.asInt(math.pow(256, byteCount));
>+    while (true) {
>+      this[_getRandomBytes](start, byteCount);
>+      let random = this[_buffer$0][$getUint32](0);
>+      if ((max & max - 1) === 0) {
>+        return (dart.notNull(random) & max - 1) >>> 0;
>+      }
>+      let result = dart.asInt(random[$remainder](max));
>+      if (dart.notNull(random) - dart.notNull(result) + max < dart.notNull(randomLimit)) {
>+        return result;
>+      }
>+    }
>+  }
>+};
>+(math._JSSecureRandom.new = function() {
>+  this[_buffer$0] = typed_data.ByteData.new(8);
>+  let crypto = self.crypto;
>+  if (crypto != null) {
>+    let getRandomValues = crypto.getRandomValues;
>+    if (getRandomValues != null) {
>+      return;
>+    }
>+  }
>+  dart.throw(new core.UnsupportedError.new("No source of cryptographically secure random numbers available."));
>+}).prototype = math._JSSecureRandom.prototype;
>+dart.addTypeTests(math._JSSecureRandom);
>+math._JSSecureRandom[dart.implements] = () => [math.Random];
>+dart.setMethodSignature(math._JSSecureRandom, () => ({
>+  __proto__: dart.getMethods(math._JSSecureRandom.__proto__),
>+  [_getRandomBytes]: dart.fnType(dart.void, [core.int, core.int]),
>+  nextBool: dart.fnType(core.bool, []),
>+  nextDouble: dart.fnType(core.double, []),
>+  nextInt: dart.fnType(core.int, [core.int])
>+}));
>+dart.setLibraryUri(math._JSSecureRandom, "dart:math");
>+dart.setFieldSignature(math._JSSecureRandom, () => ({
>+  __proto__: dart.getFields(math._JSSecureRandom.__proto__),
>+  [_buffer$0]: dart.finalFieldType(typed_data.ByteData)
>+}));
>+math._JenkinsSmiHash = class _JenkinsSmiHash extends core.Object {
>+  static combine(hash, value) {
>+    hash = 536870911 & dart.notNull(hash) + dart.notNull(value);
>+    hash = 536870911 & dart.notNull(hash) + ((524287 & dart.notNull(hash)) << 10);
>+    return (dart.notNull(hash) ^ hash[$rightShift](6)) >>> 0;
>+  }
>+  static finish(hash) {
>+    hash = 536870911 & dart.notNull(hash) + ((67108863 & dart.notNull(hash)) << 3);
>+    hash = (dart.notNull(hash) ^ hash[$rightShift](11)) >>> 0;
>+    return 536870911 & dart.notNull(hash) + ((16383 & dart.notNull(hash)) << 15);
>+  }
>+  static hash2(a, b) {
>+    return math._JenkinsSmiHash.finish(math._JenkinsSmiHash.combine(math._JenkinsSmiHash.combine(0, core.int._check(a)), core.int._check(b)));
>+  }
>+  static hash4(a, b, c, d) {
>+    return math._JenkinsSmiHash.finish(math._JenkinsSmiHash.combine(math._JenkinsSmiHash.combine(math._JenkinsSmiHash.combine(math._JenkinsSmiHash.combine(0, core.int._check(a)), core.int._check(b)), core.int._check(c)), core.int._check(d)));
>+  }
>+};
>+(math._JenkinsSmiHash.new = function() {
>+}).prototype = math._JenkinsSmiHash.prototype;
>+dart.addTypeTests(math._JenkinsSmiHash);
>+dart.setLibraryUri(math._JenkinsSmiHash, "dart:math");
>+const _is_Point_default = Symbol('_is_Point_default');
>+math.Point$ = dart.generic(T => {
>+  let PointOfT = () => (PointOfT = dart.constFn(math.Point$(T)))();
>+  class Point extends core.Object {
>+    get x() {
>+      return this[x$];
>+    }
>+    set x(value) {
>+      super.x = value;
>+    }
>+    get y() {
>+      return this[y$];
>+    }
>+    set y(value) {
>+      super.y = value;
>+    }
>+    toString() {
>+      return "Point(" + dart.str(this.x) + ", " + dart.str(this.y) + ")";
>+    }
>+    _equals(other) {
>+      return PointOfnum().is(other) && this.x == other.x && this.y == other.y;
>+    }
>+    get hashCode() {
>+      return math._JenkinsSmiHash.hash2(dart.hashCode(this.x), dart.hashCode(this.y));
>+    }
>+    ['+'](other) {
>+      PointOfT()._check(other);
>+      return new (PointOfT()).new(dart.notNull(this.x) + dart.notNull(other.x), dart.notNull(this.y) + dart.notNull(other.y));
>+    }
>+    ['-'](other) {
>+      PointOfT()._check(other);
>+      return new (PointOfT()).new(dart.notNull(this.x) - dart.notNull(other.x), dart.notNull(this.y) - dart.notNull(other.y));
>+    }
>+    ['*'](factor) {
>+      return new (PointOfT()).new(dart.notNull(this.x) * dart.notNull(factor), dart.notNull(this.y) * dart.notNull(factor));
>+    }
>+    get magnitude() {
>+      return math.sqrt(dart.notNull(this.x) * dart.notNull(this.x) + dart.notNull(this.y) * dart.notNull(this.y));
>+    }
>+    distanceTo(other) {
>+      PointOfT()._check(other);
>+      let dx = dart.notNull(this.x) - dart.notNull(other.x);
>+      let dy = dart.notNull(this.y) - dart.notNull(other.y);
>+      return math.sqrt(dx * dx + dy * dy);
>+    }
>+    squaredDistanceTo(other) {
>+      PointOfT()._check(other);
>+      let dx = dart.notNull(this.x) - dart.notNull(other.x);
>+      let dy = dart.notNull(this.y) - dart.notNull(other.y);
>+      return dx * dx + dy * dy;
>+    }
>+  }
>+  (Point.new = function(x, y) {
>+    this[x$] = x;
>+    this[y$] = y;
>+  }).prototype = Point.prototype;
>+  dart.addTypeTests(Point);
>+  Point.prototype[_is_Point_default] = true;
>+  const x$ = Symbol("Point.x");
>+  const y$ = Symbol("Point.y");
>+  dart.setMethodSignature(Point, () => ({
>+    __proto__: dart.getMethods(Point.__proto__),
>+    toString: dart.fnType(core.String, []),
>+    [$toString]: dart.fnType(core.String, []),
>+    _equals: dart.fnType(core.bool, [dart.dynamic]),
>+    [$_equals]: dart.fnType(core.bool, [dart.dynamic]),
>+    '+': dart.fnType(math.Point$(T), [core.Object]),
>+    '-': dart.fnType(math.Point$(T), [core.Object]),
>+    '*': dart.fnType(math.Point$(T), [core.num]),
>+    distanceTo: dart.fnType(core.double, [core.Object]),
>+    squaredDistanceTo: dart.fnType(T, [core.Object])
>+  }));
>+  dart.setGetterSignature(Point, () => ({
>+    __proto__: dart.getGetters(Point.__proto__),
>+    hashCode: core.int,
>+    [$hashCode]: core.int,
>+    magnitude: core.double
>+  }));
>+  dart.setLibraryUri(Point, "dart:math");
>+  dart.setFieldSignature(Point, () => ({
>+    __proto__: dart.getFields(Point.__proto__),
>+    x: dart.finalFieldType(T),
>+    y: dart.finalFieldType(T)
>+  }));
>+  dart.defineExtensionMethods(Point, ['toString', '_equals']);
>+  dart.defineExtensionAccessors(Point, ['hashCode']);
>+  return Point;
>+});
>+math.Point = math.Point$();
>+dart.addTypeTests(math.Point, _is_Point_default);
>+let const$77;
>+math.Random = class Random extends core.Object {
>+  static new(seed) {
>+    if (seed === void 0) seed = null;
>+    return seed == null ? const$77 || (const$77 = dart.const(new math._JSRandom.new())) : new math._Random.new(seed);
>+  }
>+  static secure() {
>+    let t = math.Random._secureRandom;
>+    return t == null ? math.Random._secureRandom = new math._JSSecureRandom.new() : t;
>+  }
>+};
>+(math.Random[dart.mixinNew] = function() {
>+}).prototype = math.Random.prototype;
>+dart.addTypeTests(math.Random);
>+dart.setLibraryUri(math.Random, "dart:math");
>+dart.defineLazy(math.Random, {
>+  /*math.Random._secureRandom*/get _secureRandom() {
>+    return null;
>+  },
>+  set _secureRandom(_) {}
>+});
>+const _is__RectangleBase_default = Symbol('_is__RectangleBase_default');
>+math._RectangleBase$ = dart.generic(T => {
>+  let RectangleOfT = () => (RectangleOfT = dart.constFn(math.Rectangle$(T)))();
>+  let PointOfT = () => (PointOfT = dart.constFn(math.Point$(T)))();
>+  class _RectangleBase extends core.Object {
>+    get right() {
>+      return dart.notNull(this[$left]) + dart.notNull(this[$width]);
>+    }
>+    get bottom() {
>+      return dart.notNull(this[$top]) + dart.notNull(this[$height]);
>+    }
>+    toString() {
>+      return "Rectangle (" + dart.str(this[$left]) + ", " + dart.str(this[$top]) + ") " + dart.str(this[$width]) + " x " + dart.str(this[$height]);
>+    }
>+    _equals(other) {
>+      return RectangleOfnum().is(other) && this[$left] == other[$left] && this[$top] == other[$top] && this[$right] == other[$right] && this[$bottom] == other[$bottom];
>+    }
>+    get hashCode() {
>+      return math._JenkinsSmiHash.hash4(dart.hashCode(this[$left]), dart.hashCode(this[$top]), dart.hashCode(this[$right]), dart.hashCode(this[$bottom]));
>+    }
>+    intersection(other) {
>+      RectangleOfT()._check(other);
>+      let x0 = math.max(T, this[$left], other[$left]);
>+      let x1 = math.min(T, dart.notNull(this[$left]) + dart.notNull(this[$width]), dart.notNull(other[$left]) + dart.notNull(other[$width]));
>+      if (x0 <= x1) {
>+        let y0 = math.max(T, this[$top], other[$top]);
>+        let y1 = math.min(T, dart.notNull(this[$top]) + dart.notNull(this[$height]), dart.notNull(other[$top]) + dart.notNull(other[$height]));
>+        if (y0 <= y1) {
>+          return new (RectangleOfT()).new(x0, y0, x1 - x0, y1 - y0);
>+        }
>+      }
>+      return null;
>+    }
>+    intersects(other) {
>+      return dart.notNull(this[$left]) <= dart.notNull(other[$left]) + dart.notNull(other[$width]) && dart.notNull(other[$left]) <= dart.notNull(this[$left]) + dart.notNull(this[$width]) && dart.notNull(this[$top]) <= dart.notNull(other[$top]) + dart.notNull(other[$height]) && dart.notNull(other[$top]) <= dart.notNull(this[$top]) + dart.notNull(this[$height]);
>+    }
>+    boundingBox(other) {
>+      RectangleOfT()._check(other);
>+      let right = math.max(T, dart.notNull(this[$left]) + dart.notNull(this[$width]), dart.notNull(other[$left]) + dart.notNull(other[$width]));
>+      let bottom = math.max(T, dart.notNull(this[$top]) + dart.notNull(this[$height]), dart.notNull(other[$top]) + dart.notNull(other[$height]));
>+      let left = math.min(T, this[$left], other[$left]);
>+      let top = math.min(T, this[$top], other[$top]);
>+      return new (RectangleOfT()).new(left, top, right - left, bottom - top);
>+    }
>+    containsRectangle(another) {
>+      return dart.notNull(this[$left]) <= dart.notNull(another[$left]) && dart.notNull(this[$left]) + dart.notNull(this[$width]) >= dart.notNull(another[$left]) + dart.notNull(another[$width]) && dart.notNull(this[$top]) <= dart.notNull(another[$top]) && dart.notNull(this[$top]) + dart.notNull(this[$height]) >= dart.notNull(another[$top]) + dart.notNull(another[$height]);
>+    }
>+    containsPoint(another) {
>+      return dart.notNull(another.x) >= dart.notNull(this[$left]) && dart.notNull(another.x) <= dart.notNull(this[$left]) + dart.notNull(this[$width]) && dart.notNull(another.y) >= dart.notNull(this[$top]) && dart.notNull(another.y) <= dart.notNull(this[$top]) + dart.notNull(this[$height]);
>+    }
>+    get topLeft() {
>+      return new (PointOfT()).new(this[$left], this[$top]);
>+    }
>+    get topRight() {
>+      return new (PointOfT()).new(dart.notNull(this[$left]) + dart.notNull(this[$width]), this[$top]);
>+    }
>+    get bottomRight() {
>+      return new (PointOfT()).new(dart.notNull(this[$left]) + dart.notNull(this[$width]), dart.notNull(this[$top]) + dart.notNull(this[$height]));
>+    }
>+    get bottomLeft() {
>+      return new (PointOfT()).new(this[$left], dart.notNull(this[$top]) + dart.notNull(this[$height]));
>+    }
>+  }
>+  (_RectangleBase.new = function() {
>+  }).prototype = _RectangleBase.prototype;
>+  dart.addTypeTests(_RectangleBase);
>+  _RectangleBase.prototype[_is__RectangleBase_default] = true;
>+  dart.setMethodSignature(_RectangleBase, () => ({
>+    __proto__: dart.getMethods(_RectangleBase.__proto__),
>+    toString: dart.fnType(core.String, []),
>+    [$toString]: dart.fnType(core.String, []),
>+    _equals: dart.fnType(core.bool, [dart.dynamic]),
>+    [$_equals]: dart.fnType(core.bool, [dart.dynamic]),
>+    intersection: dart.fnType(math.Rectangle$(T), [core.Object]),
>+    [$intersection]: dart.fnType(math.Rectangle$(T), [core.Object]),
>+    intersects: dart.fnType(core.bool, [math.Rectangle$(core.num)]),
>+    [$intersects]: dart.fnType(core.bool, [math.Rectangle$(core.num)]),
>+    boundingBox: dart.fnType(math.Rectangle$(T), [core.Object]),
>+    [$boundingBox]: dart.fnType(math.Rectangle$(T), [core.Object]),
>+    containsRectangle: dart.fnType(core.bool, [math.Rectangle$(core.num)]),
>+    [$containsRectangle]: dart.fnType(core.bool, [math.Rectangle$(core.num)]),
>+    containsPoint: dart.fnType(core.bool, [math.Point$(core.num)]),
>+    [$containsPoint]: dart.fnType(core.bool, [math.Point$(core.num)])
>+  }));
>+  dart.setGetterSignature(_RectangleBase, () => ({
>+    __proto__: dart.getGetters(_RectangleBase.__proto__),
>+    right: T,
>+    [$right]: T,
>+    bottom: T,
>+    [$bottom]: T,
>+    hashCode: core.int,
>+    [$hashCode]: core.int,
>+    topLeft: math.Point$(T),
>+    [$topLeft]: math.Point$(T),
>+    topRight: math.Point$(T),
>+    [$topRight]: math.Point$(T),
>+    bottomRight: math.Point$(T),
>+    [$bottomRight]: math.Point$(T),
>+    bottomLeft: math.Point$(T),
>+    [$bottomLeft]: math.Point$(T)
>+  }));
>+  dart.setLibraryUri(_RectangleBase, "dart:math");
>+  dart.defineExtensionMethods(_RectangleBase, [
>+    'toString',
>+    '_equals',
>+    'intersection',
>+    'intersects',
>+    'boundingBox',
>+    'containsRectangle',
>+    'containsPoint'
>+  ]);
>+  dart.defineExtensionAccessors(_RectangleBase, [
>+    'right',
>+    'bottom',
>+    'hashCode',
>+    'topLeft',
>+    'topRight',
>+    'bottomRight',
>+    'bottomLeft'
>+  ]);
>+  return _RectangleBase;
>+});
>+math._RectangleBase = math._RectangleBase$();
>+dart.addTypeTests(math._RectangleBase, _is__RectangleBase_default);
>+const _is_Rectangle_default = Symbol('_is_Rectangle_default');
>+math.Rectangle$ = dart.generic(T => {
>+  let RectangleOfT = () => (RectangleOfT = dart.constFn(math.Rectangle$(T)))();
>+  class Rectangle extends math._RectangleBase$(T) {
>+    get left() {
>+      return this[left$];
>+    }
>+    set left(value) {
>+      super.left = value;
>+    }
>+    get top() {
>+      return this[top$];
>+    }
>+    set top(value) {
>+      super.top = value;
>+    }
>+    get width() {
>+      return this[width$];
>+    }
>+    set width(value) {
>+      super.width = value;
>+    }
>+    get height() {
>+      return this[height$];
>+    }
>+    set height(value) {
>+      super.height = value;
>+    }
>+    static fromPoints(a, b) {
>+      let left = math.min(T, a.x, b.x);
>+      let width = math.max(T, a.x, b.x) - left;
>+      let top = math.min(T, a.y, b.y);
>+      let height = math.max(T, a.y, b.y) - top;
>+      return new (RectangleOfT()).new(left, top, width, height);
>+    }
>+  }
>+  (Rectangle.new = function(left, top, width, height) {
>+    this[left$] = left;
>+    this[top$] = top;
>+    this[width$] = dart.notNull(width) < 0 ? -dart.notNull(width) * 0 : width;
>+    this[height$] = dart.notNull(height) < 0 ? -dart.notNull(height) * 0 : height;
>+    Rectangle.__proto__.new.call(this);
>+  }).prototype = Rectangle.prototype;
>+  dart.addTypeTests(Rectangle);
>+  Rectangle.prototype[_is_Rectangle_default] = true;
>+  const left$ = Symbol("Rectangle.left");
>+  const top$ = Symbol("Rectangle.top");
>+  const width$ = Symbol("Rectangle.width");
>+  const height$ = Symbol("Rectangle.height");
>+  dart.setLibraryUri(Rectangle, "dart:math");
>+  dart.setFieldSignature(Rectangle, () => ({
>+    __proto__: dart.getFields(Rectangle.__proto__),
>+    left: dart.finalFieldType(T),
>+    top: dart.finalFieldType(T),
>+    width: dart.finalFieldType(T),
>+    height: dart.finalFieldType(T)
>+  }));
>+  dart.defineExtensionAccessors(Rectangle, ['left', 'top', 'width', 'height']);
>+  return Rectangle;
>+});
>+math.Rectangle = math.Rectangle$();
>+dart.addTypeTests(math.Rectangle, _is_Rectangle_default);
>+const _width = dart.privateName(math, "_width");
>+const _height = dart.privateName(math, "_height");
>+const _is_MutableRectangle_default = Symbol('_is_MutableRectangle_default');
>+math.MutableRectangle$ = dart.generic(T => {
>+  let MutableRectangleOfT = () => (MutableRectangleOfT = dart.constFn(math.MutableRectangle$(T)))();
>+  let RectangleOfT = () => (RectangleOfT = dart.constFn(math.Rectangle$(T)))();
>+  class MutableRectangle extends math._RectangleBase$(T) {
>+    get left() {
>+      return this[left$];
>+    }
>+    set left(value) {
>+      this[left$] = T._check(value);
>+    }
>+    get top() {
>+      return this[top$];
>+    }
>+    set top(value) {
>+      this[top$] = T._check(value);
>+    }
>+    static fromPoints(a, b) {
>+      let left = math.min(T, a.x, b.x);
>+      let width = math.max(T, a.x, b.x) - left;
>+      let top = math.min(T, a.y, b.y);
>+      let height = math.max(T, a.y, b.y) - top;
>+      return new (MutableRectangleOfT()).new(left, top, width, height);
>+    }
>+    get width() {
>+      return this[_width];
>+    }
>+    set width(width) {
>+      T._check(width);
>+      if (dart.notNull(width) < 0) width = math._clampToZero(T, width);
>+      this[_width] = width;
>+    }
>+    get height() {
>+      return this[_height];
>+    }
>+    set height(height) {
>+      T._check(height);
>+      if (dart.notNull(height) < 0) height = math._clampToZero(T, height);
>+      this[_height] = height;
>+    }
>+  }
>+  (MutableRectangle.new = function(left, top, width, height) {
>+    this[left$] = left;
>+    this[top$] = top;
>+    this[_width] = dart.notNull(width) < 0 ? math._clampToZero(T, width) : width;
>+    this[_height] = dart.notNull(height) < 0 ? math._clampToZero(T, height) : height;
>+    MutableRectangle.__proto__.new.call(this);
>+  }).prototype = MutableRectangle.prototype;
>+  dart.addTypeTests(MutableRectangle);
>+  MutableRectangle.prototype[_is_MutableRectangle_default] = true;
>+  const left$ = Symbol("MutableRectangle.left");
>+  const top$ = Symbol("MutableRectangle.top");
>+  MutableRectangle[dart.implements] = () => [RectangleOfT()];
>+  dart.setGetterSignature(MutableRectangle, () => ({
>+    __proto__: dart.getGetters(MutableRectangle.__proto__),
>+    width: T,
>+    [$width]: T,
>+    height: T,
>+    [$height]: T
>+  }));
>+  dart.setSetterSignature(MutableRectangle, () => ({
>+    __proto__: dart.getSetters(MutableRectangle.__proto__),
>+    width: T,
>+    [$width]: T,
>+    height: T,
>+    [$height]: T
>+  }));
>+  dart.setLibraryUri(MutableRectangle, "dart:math");
>+  dart.setFieldSignature(MutableRectangle, () => ({
>+    __proto__: dart.getFields(MutableRectangle.__proto__),
>+    left: dart.fieldType(T),
>+    top: dart.fieldType(T),
>+    [_width]: dart.fieldType(T),
>+    [_height]: dart.fieldType(T)
>+  }));
>+  dart.defineExtensionAccessors(MutableRectangle, ['width', 'height', 'left', 'top']);
>+  return MutableRectangle;
>+});
>+math.MutableRectangle = math.MutableRectangle$();
>+dart.addTypeTests(math.MutableRectangle, _is_MutableRectangle_default);
>+math._clampToZero = function(T, value) {
>+  if (!(dart.notNull(value) < 0)) dart.assertFailed(null, "dart:math/rectangle.dart", 245, 10, "value < 0");
>+  return -dart.notNull(value) * 0;
>+};
>+mirrors.MirrorSystem = class MirrorSystem extends core.Object {
>+  findLibrary(libraryName) {
>+    return this.libraries[$values][$singleWhere](dart.fn(library => dart.equals(library.simpleName, libraryName), LibraryMirrorTobool()));
>+  }
>+  static getName(symbol) {
>+    return _js_mirrors.getName(symbol);
>+  }
>+  static getSymbol(name, library) {
>+    if (library === void 0) library = null;
>+    return _js_mirrors.getSymbol(name, library);
>+  }
>+};
>+(mirrors.MirrorSystem.new = function() {
>+}).prototype = mirrors.MirrorSystem.prototype;
>+dart.addTypeTests(mirrors.MirrorSystem);
>+dart.setMethodSignature(mirrors.MirrorSystem, () => ({
>+  __proto__: dart.getMethods(mirrors.MirrorSystem.__proto__),
>+  findLibrary: dart.fnType(mirrors.LibraryMirror, [core.Symbol])
>+}));
>+dart.setLibraryUri(mirrors.MirrorSystem, "dart:mirrors");
>+mirrors.currentMirrorSystem = function() {
>+  return _js_mirrors.currentJsMirrorSystem;
>+};
>+mirrors.reflect = function(reflectee) {
>+  return _js_mirrors.reflect(reflectee);
>+};
>+mirrors.reflectClass = function(key) {
>+  if (!core.Type.is(key) || dart.equals(key, dart.wrapType(dart.dynamic))) {
>+    dart.throw(new core.ArgumentError.new(dart.str(key) + " does not denote a class"));
>+  }
>+  let tm = mirrors.reflectType(key);
>+  if (!mirrors.ClassMirror.is(tm)) {
>+    dart.throw(new core.ArgumentError.new(dart.str(key) + " does not denote a class"));
>+  }
>+  return mirrors.ClassMirror._check(mirrors.ClassMirror.as(tm).originalDeclaration);
>+};
>+mirrors.reflectType = function(type, typeArguments) {
>+  if (typeArguments === void 0) typeArguments = null;
>+  if (typeArguments != null) {
>+    type = mirrors._instantiateClass(type, typeArguments);
>+  }
>+  return _js_mirrors.reflectType(type);
>+};
>+mirrors.Mirror = class Mirror extends core.Object {};
>+(mirrors.Mirror.new = function() {
>+}).prototype = mirrors.Mirror.prototype;
>+dart.addTypeTests(mirrors.Mirror);
>+dart.setLibraryUri(mirrors.Mirror, "dart:mirrors");
>+mirrors.IsolateMirror = class IsolateMirror extends core.Object {};
>+(mirrors.IsolateMirror.new = function() {
>+}).prototype = mirrors.IsolateMirror.prototype;
>+dart.addTypeTests(mirrors.IsolateMirror);
>+mirrors.IsolateMirror[dart.implements] = () => [mirrors.Mirror];
>+dart.setLibraryUri(mirrors.IsolateMirror, "dart:mirrors");
>+mirrors.DeclarationMirror = class DeclarationMirror extends core.Object {};
>+(mirrors.DeclarationMirror.new = function() {
>+}).prototype = mirrors.DeclarationMirror.prototype;
>+dart.addTypeTests(mirrors.DeclarationMirror);
>+mirrors.DeclarationMirror[dart.implements] = () => [mirrors.Mirror];
>+dart.setLibraryUri(mirrors.DeclarationMirror, "dart:mirrors");
>+mirrors.ObjectMirror = class ObjectMirror extends core.Object {};
>+(mirrors.ObjectMirror.new = function() {
>+}).prototype = mirrors.ObjectMirror.prototype;
>+dart.addTypeTests(mirrors.ObjectMirror);
>+mirrors.ObjectMirror[dart.implements] = () => [mirrors.Mirror];
>+dart.setLibraryUri(mirrors.ObjectMirror, "dart:mirrors");
>+mirrors.InstanceMirror = class InstanceMirror extends core.Object {};
>+(mirrors.InstanceMirror.new = function() {
>+}).prototype = mirrors.InstanceMirror.prototype;
>+dart.addTypeTests(mirrors.InstanceMirror);
>+mirrors.InstanceMirror[dart.implements] = () => [mirrors.ObjectMirror];
>+dart.setLibraryUri(mirrors.InstanceMirror, "dart:mirrors");
>+mirrors.ClosureMirror = class ClosureMirror extends core.Object {};
>+(mirrors.ClosureMirror.new = function() {
>+}).prototype = mirrors.ClosureMirror.prototype;
>+dart.addTypeTests(mirrors.ClosureMirror);
>+mirrors.ClosureMirror[dart.implements] = () => [mirrors.InstanceMirror];
>+dart.setLibraryUri(mirrors.ClosureMirror, "dart:mirrors");
>+mirrors.LibraryMirror = class LibraryMirror extends core.Object {};
>+(mirrors.LibraryMirror.new = function() {
>+}).prototype = mirrors.LibraryMirror.prototype;
>+dart.addTypeTests(mirrors.LibraryMirror);
>+mirrors.LibraryMirror[dart.implements] = () => [mirrors.DeclarationMirror, mirrors.ObjectMirror];
>+dart.setLibraryUri(mirrors.LibraryMirror, "dart:mirrors");
>+mirrors.LibraryDependencyMirror = class LibraryDependencyMirror extends core.Object {};
>+(mirrors.LibraryDependencyMirror.new = function() {
>+}).prototype = mirrors.LibraryDependencyMirror.prototype;
>+dart.addTypeTests(mirrors.LibraryDependencyMirror);
>+mirrors.LibraryDependencyMirror[dart.implements] = () => [mirrors.Mirror];
>+dart.setLibraryUri(mirrors.LibraryDependencyMirror, "dart:mirrors");
>+mirrors.CombinatorMirror = class CombinatorMirror extends core.Object {};
>+(mirrors.CombinatorMirror.new = function() {
>+}).prototype = mirrors.CombinatorMirror.prototype;
>+dart.addTypeTests(mirrors.CombinatorMirror);
>+mirrors.CombinatorMirror[dart.implements] = () => [mirrors.Mirror];
>+dart.setLibraryUri(mirrors.CombinatorMirror, "dart:mirrors");
>+mirrors.TypeMirror = class TypeMirror extends core.Object {};
>+(mirrors.TypeMirror.new = function() {
>+}).prototype = mirrors.TypeMirror.prototype;
>+dart.addTypeTests(mirrors.TypeMirror);
>+mirrors.TypeMirror[dart.implements] = () => [mirrors.DeclarationMirror];
>+dart.setLibraryUri(mirrors.TypeMirror, "dart:mirrors");
>+mirrors.ClassMirror = class ClassMirror extends core.Object {};
>+(mirrors.ClassMirror.new = function() {
>+}).prototype = mirrors.ClassMirror.prototype;
>+dart.addTypeTests(mirrors.ClassMirror);
>+mirrors.ClassMirror[dart.implements] = () => [mirrors.TypeMirror, mirrors.ObjectMirror];
>+dart.setLibraryUri(mirrors.ClassMirror, "dart:mirrors");
>+mirrors.FunctionTypeMirror = class FunctionTypeMirror extends core.Object {};
>+(mirrors.FunctionTypeMirror.new = function() {
>+}).prototype = mirrors.FunctionTypeMirror.prototype;
>+dart.addTypeTests(mirrors.FunctionTypeMirror);
>+mirrors.FunctionTypeMirror[dart.implements] = () => [mirrors.ClassMirror];
>+dart.setLibraryUri(mirrors.FunctionTypeMirror, "dart:mirrors");
>+mirrors.TypeVariableMirror = class TypeVariableMirror extends mirrors.TypeMirror {};
>+(mirrors.TypeVariableMirror.new = function() {
>+}).prototype = mirrors.TypeVariableMirror.prototype;
>+dart.addTypeTests(mirrors.TypeVariableMirror);
>+dart.setLibraryUri(mirrors.TypeVariableMirror, "dart:mirrors");
>+mirrors.TypedefMirror = class TypedefMirror extends core.Object {};
>+(mirrors.TypedefMirror.new = function() {
>+}).prototype = mirrors.TypedefMirror.prototype;
>+dart.addTypeTests(mirrors.TypedefMirror);
>+mirrors.TypedefMirror[dart.implements] = () => [mirrors.TypeMirror];
>+dart.setLibraryUri(mirrors.TypedefMirror, "dart:mirrors");
>+mirrors.MethodMirror = class MethodMirror extends core.Object {};
>+(mirrors.MethodMirror.new = function() {
>+}).prototype = mirrors.MethodMirror.prototype;
>+dart.addTypeTests(mirrors.MethodMirror);
>+mirrors.MethodMirror[dart.implements] = () => [mirrors.DeclarationMirror];
>+dart.setLibraryUri(mirrors.MethodMirror, "dart:mirrors");
>+mirrors.VariableMirror = class VariableMirror extends core.Object {};
>+(mirrors.VariableMirror.new = function() {
>+}).prototype = mirrors.VariableMirror.prototype;
>+dart.addTypeTests(mirrors.VariableMirror);
>+mirrors.VariableMirror[dart.implements] = () => [mirrors.DeclarationMirror];
>+dart.setLibraryUri(mirrors.VariableMirror, "dart:mirrors");
>+mirrors.ParameterMirror = class ParameterMirror extends core.Object {};
>+(mirrors.ParameterMirror.new = function() {
>+}).prototype = mirrors.ParameterMirror.prototype;
>+dart.addTypeTests(mirrors.ParameterMirror);
>+mirrors.ParameterMirror[dart.implements] = () => [mirrors.VariableMirror];
>+dart.setLibraryUri(mirrors.ParameterMirror, "dart:mirrors");
>+mirrors.SourceLocation = class SourceLocation extends core.Object {};
>+(mirrors.SourceLocation.new = function() {
>+}).prototype = mirrors.SourceLocation.prototype;
>+dart.addTypeTests(mirrors.SourceLocation);
>+dart.setLibraryUri(mirrors.SourceLocation, "dart:mirrors");
>+mirrors.Comment = class Comment extends core.Object {
>+  get text() {
>+    return this[text$];
>+  }
>+  set text(value) {
>+    super.text = value;
>+  }
>+  get trimmedText() {
>+    return this[trimmedText$];
>+  }
>+  set trimmedText(value) {
>+    super.trimmedText = value;
>+  }
>+  get isDocComment() {
>+    return this[isDocComment$];
>+  }
>+  set isDocComment(value) {
>+    super.isDocComment = value;
>+  }
>+};
>+(mirrors.Comment.new = function(text, trimmedText, isDocComment) {
>+  this[text$] = text;
>+  this[trimmedText$] = trimmedText;
>+  this[isDocComment$] = isDocComment;
>+}).prototype = mirrors.Comment.prototype;
>+dart.addTypeTests(mirrors.Comment);
>+const text$ = Symbol("Comment.text");
>+const trimmedText$ = Symbol("Comment.trimmedText");
>+const isDocComment$ = Symbol("Comment.isDocComment");
>+dart.setLibraryUri(mirrors.Comment, "dart:mirrors");
>+dart.setFieldSignature(mirrors.Comment, () => ({
>+  __proto__: dart.getFields(mirrors.Comment.__proto__),
>+  text: dart.finalFieldType(core.String),
>+  trimmedText: dart.finalFieldType(core.String),
>+  isDocComment: dart.finalFieldType(core.bool)
>+}));
>+mirrors.MirrorsUsed = class MirrorsUsed extends core.Object {
>+  get symbols() {
>+    return this[symbols$];
>+  }
>+  set symbols(value) {
>+    super.symbols = value;
>+  }
>+  get targets() {
>+    return this[targets$];
>+  }
>+  set targets(value) {
>+    super.targets = value;
>+  }
>+  get metaTargets() {
>+    return this[metaTargets$];
>+  }
>+  set metaTargets(value) {
>+    super.metaTargets = value;
>+  }
>+  get override() {
>+    return this[override$];
>+  }
>+  set override(value) {
>+    super.override = value;
>+  }
>+};
>+(mirrors.MirrorsUsed.new = function(opts) {
>+  let symbols = opts && 'symbols' in opts ? opts.symbols : null;
>+  let targets = opts && 'targets' in opts ? opts.targets : null;
>+  let metaTargets = opts && 'metaTargets' in opts ? opts.metaTargets : null;
>+  let override = opts && 'override' in opts ? opts.override : null;
>+  this[symbols$] = symbols;
>+  this[targets$] = targets;
>+  this[metaTargets$] = metaTargets;
>+  this[override$] = override;
>+}).prototype = mirrors.MirrorsUsed.prototype;
>+dart.addTypeTests(mirrors.MirrorsUsed);
>+const symbols$ = Symbol("MirrorsUsed.symbols");
>+const targets$ = Symbol("MirrorsUsed.targets");
>+const metaTargets$ = Symbol("MirrorsUsed.metaTargets");
>+const override$ = Symbol("MirrorsUsed.override");
>+dart.setLibraryUri(mirrors.MirrorsUsed, "dart:mirrors");
>+dart.setFieldSignature(mirrors.MirrorsUsed, () => ({
>+  __proto__: dart.getFields(mirrors.MirrorsUsed.__proto__),
>+  symbols: dart.finalFieldType(dart.dynamic),
>+  targets: dart.finalFieldType(dart.dynamic),
>+  metaTargets: dart.finalFieldType(dart.dynamic),
>+  override: dart.finalFieldType(dart.dynamic)
>+}));
>+mirrors._instantiateClass = function(type, typeArguments) {
>+  let unwrapped = dart.unwrapType(type);
>+  let genericClass = dart.getGenericClass(unwrapped);
>+  if (genericClass == null) {
>+    dart.throw(new core.ArgumentError.new("Type `" + dart.str(type) + "` must be generic to apply " + ("type arguments: `" + dart.str(typeArguments) + "`.")));
>+  }
>+  let typeArgsLenth = typeArguments[$length];
>+  let unwrappedArgs = core.List.new(typeArgsLenth);
>+  for (let i = 0; i < dart.notNull(typeArgsLenth); i++) {
>+    unwrappedArgs[$_set](i, dart.unwrapType(typeArguments[$_get](i)));
>+  }
>+  let typeFormals = dart.getGenericTypeFormals(genericClass);
>+  if (typeFormals[$length] != typeArgsLenth) {
>+    dart.throw(new core.ArgumentError.new("Type `" + dart.str(type) + "` has " + dart.str(typeFormals[$length]) + " type " + ("parameters, but " + dart.str(typeArgsLenth) + " type arguments were ") + ("passed: `" + dart.str(typeArguments) + "`.")));
>+  }
>+  return dart.wrapType(dart.instantiateClass(genericClass, unwrappedArgs));
>+};
>+typed_data.ByteBuffer = class ByteBuffer extends core.Object {};
>+(typed_data.ByteBuffer.new = function() {
>+}).prototype = typed_data.ByteBuffer.prototype;
>+dart.addTypeTests(typed_data.ByteBuffer);
>+dart.setLibraryUri(typed_data.ByteBuffer, "dart:typed_data");
>+typed_data.TypedData = class TypedData extends core.Object {};
>+(typed_data.TypedData.new = function() {
>+}).prototype = typed_data.TypedData.prototype;
>+dart.addTypeTests(typed_data.TypedData);
>+dart.setLibraryUri(typed_data.TypedData, "dart:typed_data");
>+typed_data._TypedIntList = class _TypedIntList extends typed_data.TypedData {};
>+(typed_data._TypedIntList.new = function() {
>+}).prototype = typed_data._TypedIntList.prototype;
>+dart.addTypeTests(typed_data._TypedIntList);
>+dart.setLibraryUri(typed_data._TypedIntList, "dart:typed_data");
>+typed_data._TypedFloatList = class _TypedFloatList extends typed_data.TypedData {};
>+(typed_data._TypedFloatList.new = function() {
>+}).prototype = typed_data._TypedFloatList.prototype;
>+dart.addTypeTests(typed_data._TypedFloatList);
>+dart.setLibraryUri(typed_data._TypedFloatList, "dart:typed_data");
>+const _littleEndian = dart.privateName(typed_data, "_littleEndian");
>+typed_data.Endian = class Endian extends core.Object {};
>+(typed_data.Endian.__ = function(littleEndian) {
>+  this[_littleEndian] = littleEndian;
>+}).prototype = typed_data.Endian.prototype;
>+dart.addTypeTests(typed_data.Endian);
>+dart.setLibraryUri(typed_data.Endian, "dart:typed_data");
>+dart.setFieldSignature(typed_data.Endian, () => ({
>+  __proto__: dart.getFields(typed_data.Endian.__proto__),
>+  [_littleEndian]: dart.finalFieldType(core.bool)
>+}));
>+dart.defineLazy(typed_data.Endian, {
>+  /*typed_data.Endian.big*/get big() {
>+    return dart.const(new typed_data.Endian.__(false));
>+  },
>+  /*typed_data.Endian.little*/get little() {
>+    return dart.const(new typed_data.Endian.__(true));
>+  },
>+  /*typed_data.Endian.host*/get host() {
>+    return typed_data.ByteData.view(typed_data.Uint16List.fromList(JSArrayOfint().of([1]))[$buffer])[$getInt8](0) === 1 ? typed_data.Endian.little : typed_data.Endian.big;
>+  }
>+});
>+typed_data.ByteData = class ByteData extends core.Object {
>+  static new(length) {
>+    return _native_typed_data.NativeByteData.new(length);
>+  }
>+  static view(buffer, offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return buffer[$asByteData](offsetInBytes, length);
>+  }
>+};
>+(typed_data.ByteData[dart.mixinNew] = function() {
>+}).prototype = typed_data.ByteData.prototype;
>+dart.addTypeTests(typed_data.ByteData);
>+typed_data.ByteData[dart.implements] = () => [typed_data.TypedData];
>+dart.setLibraryUri(typed_data.ByteData, "dart:typed_data");
>+typed_data.Int8List = class Int8List extends core.Object {
>+  static new(length) {
>+    return _native_typed_data.NativeInt8List.new(length);
>+  }
>+  static fromList(elements) {
>+    return _native_typed_data.NativeInt8List.fromList(elements);
>+  }
>+  static view(buffer, offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return buffer[$asInt8List](offsetInBytes, length);
>+  }
>+};
>+(typed_data.Int8List[dart.mixinNew] = function() {
>+}).prototype = typed_data.Int8List.prototype;
>+typed_data.Int8List.prototype[dart.isList] = true;
>+dart.addTypeTests(typed_data.Int8List);
>+typed_data.Int8List[dart.implements] = () => [ListOfint(), typed_data._TypedIntList];
>+dart.setLibraryUri(typed_data.Int8List, "dart:typed_data");
>+dart.defineLazy(typed_data.Int8List, {
>+  /*typed_data.Int8List.bytesPerElement*/get bytesPerElement() {
>+    return 1;
>+  }
>+});
>+typed_data.Uint8List = class Uint8List extends core.Object {
>+  static new(length) {
>+    return _native_typed_data.NativeUint8List.new(length);
>+  }
>+  static fromList(elements) {
>+    return _native_typed_data.NativeUint8List.fromList(elements);
>+  }
>+  static view(buffer, offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return buffer[$asUint8List](offsetInBytes, length);
>+  }
>+};
>+(typed_data.Uint8List[dart.mixinNew] = function() {
>+}).prototype = typed_data.Uint8List.prototype;
>+typed_data.Uint8List.prototype[dart.isList] = true;
>+dart.addTypeTests(typed_data.Uint8List);
>+typed_data.Uint8List[dart.implements] = () => [ListOfint(), typed_data._TypedIntList];
>+dart.setLibraryUri(typed_data.Uint8List, "dart:typed_data");
>+dart.defineLazy(typed_data.Uint8List, {
>+  /*typed_data.Uint8List.bytesPerElement*/get bytesPerElement() {
>+    return 1;
>+  }
>+});
>+typed_data.Uint8ClampedList = class Uint8ClampedList extends core.Object {
>+  static new(length) {
>+    return _native_typed_data.NativeUint8ClampedList.new(length);
>+  }
>+  static fromList(elements) {
>+    return _native_typed_data.NativeUint8ClampedList.fromList(elements);
>+  }
>+  static view(buffer, offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return buffer[$asUint8ClampedList](offsetInBytes, length);
>+  }
>+};
>+(typed_data.Uint8ClampedList[dart.mixinNew] = function() {
>+}).prototype = typed_data.Uint8ClampedList.prototype;
>+typed_data.Uint8ClampedList.prototype[dart.isList] = true;
>+dart.addTypeTests(typed_data.Uint8ClampedList);
>+typed_data.Uint8ClampedList[dart.implements] = () => [ListOfint(), typed_data._TypedIntList];
>+dart.setLibraryUri(typed_data.Uint8ClampedList, "dart:typed_data");
>+dart.defineLazy(typed_data.Uint8ClampedList, {
>+  /*typed_data.Uint8ClampedList.bytesPerElement*/get bytesPerElement() {
>+    return 1;
>+  }
>+});
>+typed_data.Int16List = class Int16List extends core.Object {
>+  static new(length) {
>+    return _native_typed_data.NativeInt16List.new(length);
>+  }
>+  static fromList(elements) {
>+    return _native_typed_data.NativeInt16List.fromList(elements);
>+  }
>+  static view(buffer, offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return buffer[$asInt16List](offsetInBytes, length);
>+  }
>+};
>+(typed_data.Int16List[dart.mixinNew] = function() {
>+}).prototype = typed_data.Int16List.prototype;
>+typed_data.Int16List.prototype[dart.isList] = true;
>+dart.addTypeTests(typed_data.Int16List);
>+typed_data.Int16List[dart.implements] = () => [ListOfint(), typed_data._TypedIntList];
>+dart.setLibraryUri(typed_data.Int16List, "dart:typed_data");
>+dart.defineLazy(typed_data.Int16List, {
>+  /*typed_data.Int16List.bytesPerElement*/get bytesPerElement() {
>+    return 2;
>+  }
>+});
>+typed_data.Uint16List = class Uint16List extends core.Object {
>+  static new(length) {
>+    return _native_typed_data.NativeUint16List.new(length);
>+  }
>+  static fromList(elements) {
>+    return _native_typed_data.NativeUint16List.fromList(elements);
>+  }
>+  static view(buffer, offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return buffer[$asUint16List](offsetInBytes, length);
>+  }
>+};
>+(typed_data.Uint16List[dart.mixinNew] = function() {
>+}).prototype = typed_data.Uint16List.prototype;
>+typed_data.Uint16List.prototype[dart.isList] = true;
>+dart.addTypeTests(typed_data.Uint16List);
>+typed_data.Uint16List[dart.implements] = () => [ListOfint(), typed_data._TypedIntList];
>+dart.setLibraryUri(typed_data.Uint16List, "dart:typed_data");
>+dart.defineLazy(typed_data.Uint16List, {
>+  /*typed_data.Uint16List.bytesPerElement*/get bytesPerElement() {
>+    return 2;
>+  }
>+});
>+typed_data.Int32List = class Int32List extends core.Object {
>+  static new(length) {
>+    return _native_typed_data.NativeInt32List.new(length);
>+  }
>+  static fromList(elements) {
>+    return _native_typed_data.NativeInt32List.fromList(elements);
>+  }
>+  static view(buffer, offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return buffer[$asInt32List](offsetInBytes, length);
>+  }
>+};
>+(typed_data.Int32List[dart.mixinNew] = function() {
>+}).prototype = typed_data.Int32List.prototype;
>+typed_data.Int32List.prototype[dart.isList] = true;
>+dart.addTypeTests(typed_data.Int32List);
>+typed_data.Int32List[dart.implements] = () => [ListOfint(), typed_data._TypedIntList];
>+dart.setLibraryUri(typed_data.Int32List, "dart:typed_data");
>+dart.defineLazy(typed_data.Int32List, {
>+  /*typed_data.Int32List.bytesPerElement*/get bytesPerElement() {
>+    return 4;
>+  }
>+});
>+typed_data.Uint32List = class Uint32List extends core.Object {
>+  static new(length) {
>+    return _native_typed_data.NativeUint32List.new(length);
>+  }
>+  static fromList(elements) {
>+    return _native_typed_data.NativeUint32List.fromList(elements);
>+  }
>+  static view(buffer, offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return buffer[$asUint32List](offsetInBytes, length);
>+  }
>+};
>+(typed_data.Uint32List[dart.mixinNew] = function() {
>+}).prototype = typed_data.Uint32List.prototype;
>+typed_data.Uint32List.prototype[dart.isList] = true;
>+dart.addTypeTests(typed_data.Uint32List);
>+typed_data.Uint32List[dart.implements] = () => [ListOfint(), typed_data._TypedIntList];
>+dart.setLibraryUri(typed_data.Uint32List, "dart:typed_data");
>+dart.defineLazy(typed_data.Uint32List, {
>+  /*typed_data.Uint32List.bytesPerElement*/get bytesPerElement() {
>+    return 4;
>+  }
>+});
>+typed_data.Int64List = class Int64List extends core.Object {
>+  static new(length) {
>+    dart.throw(new core.UnsupportedError.new("Int64List not supported by dart2js."));
>+  }
>+  static fromList(elements) {
>+    dart.throw(new core.UnsupportedError.new("Int64List not supported by dart2js."));
>+  }
>+  static view(buffer, offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return buffer[$asInt64List](offsetInBytes, length);
>+  }
>+};
>+(typed_data.Int64List[dart.mixinNew] = function() {
>+}).prototype = typed_data.Int64List.prototype;
>+typed_data.Int64List.prototype[dart.isList] = true;
>+dart.addTypeTests(typed_data.Int64List);
>+typed_data.Int64List[dart.implements] = () => [ListOfint(), typed_data._TypedIntList];
>+dart.setLibraryUri(typed_data.Int64List, "dart:typed_data");
>+dart.defineLazy(typed_data.Int64List, {
>+  /*typed_data.Int64List.bytesPerElement*/get bytesPerElement() {
>+    return 8;
>+  }
>+});
>+typed_data.Uint64List = class Uint64List extends core.Object {
>+  static new(length) {
>+    dart.throw(new core.UnsupportedError.new("Uint64List not supported by dart2js."));
>+  }
>+  static fromList(elements) {
>+    dart.throw(new core.UnsupportedError.new("Uint64List not supported by dart2js."));
>+  }
>+  static view(buffer, offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return buffer[$asUint64List](offsetInBytes, length);
>+  }
>+};
>+(typed_data.Uint64List[dart.mixinNew] = function() {
>+}).prototype = typed_data.Uint64List.prototype;
>+typed_data.Uint64List.prototype[dart.isList] = true;
>+dart.addTypeTests(typed_data.Uint64List);
>+typed_data.Uint64List[dart.implements] = () => [ListOfint(), typed_data._TypedIntList];
>+dart.setLibraryUri(typed_data.Uint64List, "dart:typed_data");
>+dart.defineLazy(typed_data.Uint64List, {
>+  /*typed_data.Uint64List.bytesPerElement*/get bytesPerElement() {
>+    return 8;
>+  }
>+});
>+typed_data.Float32List = class Float32List extends core.Object {
>+  static new(length) {
>+    return _native_typed_data.NativeFloat32List.new(length);
>+  }
>+  static fromList(elements) {
>+    return _native_typed_data.NativeFloat32List.fromList(elements);
>+  }
>+  static view(buffer, offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return buffer[$asFloat32List](offsetInBytes, length);
>+  }
>+};
>+(typed_data.Float32List[dart.mixinNew] = function() {
>+}).prototype = typed_data.Float32List.prototype;
>+typed_data.Float32List.prototype[dart.isList] = true;
>+dart.addTypeTests(typed_data.Float32List);
>+typed_data.Float32List[dart.implements] = () => [ListOfdouble(), typed_data._TypedFloatList];
>+dart.setLibraryUri(typed_data.Float32List, "dart:typed_data");
>+dart.defineLazy(typed_data.Float32List, {
>+  /*typed_data.Float32List.bytesPerElement*/get bytesPerElement() {
>+    return 4;
>+  }
>+});
>+typed_data.Float64List = class Float64List extends core.Object {
>+  static new(length) {
>+    return _native_typed_data.NativeFloat64List.new(length);
>+  }
>+  static fromList(elements) {
>+    return _native_typed_data.NativeFloat64List.fromList(elements);
>+  }
>+  static view(buffer, offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return buffer[$asFloat64List](offsetInBytes, length);
>+  }
>+};
>+(typed_data.Float64List[dart.mixinNew] = function() {
>+}).prototype = typed_data.Float64List.prototype;
>+typed_data.Float64List.prototype[dart.isList] = true;
>+dart.addTypeTests(typed_data.Float64List);
>+typed_data.Float64List[dart.implements] = () => [ListOfdouble(), typed_data._TypedFloatList];
>+dart.setLibraryUri(typed_data.Float64List, "dart:typed_data");
>+dart.defineLazy(typed_data.Float64List, {
>+  /*typed_data.Float64List.bytesPerElement*/get bytesPerElement() {
>+    return 8;
>+  }
>+});
>+typed_data.Float32x4List = class Float32x4List extends core.Object {
>+  static new(length) {
>+    return new _native_typed_data.NativeFloat32x4List.new(length);
>+  }
>+  static fromList(elements) {
>+    return _native_typed_data.NativeFloat32x4List.fromList(elements);
>+  }
>+  static view(buffer, offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return buffer[$asFloat32x4List](offsetInBytes, length);
>+  }
>+};
>+(typed_data.Float32x4List[dart.mixinNew] = function() {
>+}).prototype = typed_data.Float32x4List.prototype;
>+typed_data.Float32x4List.prototype[dart.isList] = true;
>+dart.addTypeTests(typed_data.Float32x4List);
>+typed_data.Float32x4List[dart.implements] = () => [ListOfFloat32x4(), typed_data.TypedData];
>+dart.setLibraryUri(typed_data.Float32x4List, "dart:typed_data");
>+dart.defineLazy(typed_data.Float32x4List, {
>+  /*typed_data.Float32x4List.bytesPerElement*/get bytesPerElement() {
>+    return 16;
>+  }
>+});
>+typed_data.Int32x4List = class Int32x4List extends core.Object {
>+  static new(length) {
>+    return new _native_typed_data.NativeInt32x4List.new(length);
>+  }
>+  static fromList(elements) {
>+    return _native_typed_data.NativeInt32x4List.fromList(elements);
>+  }
>+  static view(buffer, offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return buffer[$asInt32x4List](offsetInBytes, length);
>+  }
>+};
>+(typed_data.Int32x4List[dart.mixinNew] = function() {
>+}).prototype = typed_data.Int32x4List.prototype;
>+typed_data.Int32x4List.prototype[dart.isList] = true;
>+dart.addTypeTests(typed_data.Int32x4List);
>+typed_data.Int32x4List[dart.implements] = () => [ListOfInt32x4(), typed_data.TypedData];
>+dart.setLibraryUri(typed_data.Int32x4List, "dart:typed_data");
>+dart.defineLazy(typed_data.Int32x4List, {
>+  /*typed_data.Int32x4List.bytesPerElement*/get bytesPerElement() {
>+    return 16;
>+  }
>+});
>+typed_data.Float64x2List = class Float64x2List extends core.Object {
>+  static new(length) {
>+    return new _native_typed_data.NativeFloat64x2List.new(length);
>+  }
>+  static fromList(elements) {
>+    return _native_typed_data.NativeFloat64x2List.fromList(elements);
>+  }
>+  static view(buffer, offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return buffer[$asFloat64x2List](offsetInBytes, length);
>+  }
>+};
>+(typed_data.Float64x2List[dart.mixinNew] = function() {
>+}).prototype = typed_data.Float64x2List.prototype;
>+typed_data.Float64x2List.prototype[dart.isList] = true;
>+dart.addTypeTests(typed_data.Float64x2List);
>+typed_data.Float64x2List[dart.implements] = () => [ListOfFloat64x2(), typed_data.TypedData];
>+dart.setLibraryUri(typed_data.Float64x2List, "dart:typed_data");
>+dart.defineLazy(typed_data.Float64x2List, {
>+  /*typed_data.Float64x2List.bytesPerElement*/get bytesPerElement() {
>+    return 16;
>+  }
>+});
>+const _data$0 = dart.privateName(typed_data, "_data");
>+typed_data.UnmodifiableByteBufferView = class UnmodifiableByteBufferView extends core.Object {
>+  get lengthInBytes() {
>+    return this[_data$0][$lengthInBytes];
>+  }
>+  asUint8List(offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return new typed_data.UnmodifiableUint8ListView.new(this[_data$0][$asUint8List](offsetInBytes, length));
>+  }
>+  asInt8List(offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return new typed_data.UnmodifiableInt8ListView.new(this[_data$0][$asInt8List](offsetInBytes, length));
>+  }
>+  asUint8ClampedList(offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return new typed_data.UnmodifiableUint8ClampedListView.new(this[_data$0][$asUint8ClampedList](offsetInBytes, length));
>+  }
>+  asUint16List(offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return new typed_data.UnmodifiableUint16ListView.new(this[_data$0][$asUint16List](offsetInBytes, length));
>+  }
>+  asInt16List(offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return new typed_data.UnmodifiableInt16ListView.new(this[_data$0][$asInt16List](offsetInBytes, length));
>+  }
>+  asUint32List(offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return new typed_data.UnmodifiableUint32ListView.new(this[_data$0][$asUint32List](offsetInBytes, length));
>+  }
>+  asInt32List(offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return new typed_data.UnmodifiableInt32ListView.new(this[_data$0][$asInt32List](offsetInBytes, length));
>+  }
>+  asUint64List(offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return new typed_data.UnmodifiableUint64ListView.new(this[_data$0][$asUint64List](offsetInBytes, length));
>+  }
>+  asInt64List(offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return new typed_data.UnmodifiableInt64ListView.new(this[_data$0][$asInt64List](offsetInBytes, length));
>+  }
>+  asInt32x4List(offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return new typed_data.UnmodifiableInt32x4ListView.new(this[_data$0][$asInt32x4List](offsetInBytes, length));
>+  }
>+  asFloat32List(offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return new typed_data.UnmodifiableFloat32ListView.new(this[_data$0][$asFloat32List](offsetInBytes, length));
>+  }
>+  asFloat64List(offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return new typed_data.UnmodifiableFloat64ListView.new(this[_data$0][$asFloat64List](offsetInBytes, length));
>+  }
>+  asFloat32x4List(offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return new typed_data.UnmodifiableFloat32x4ListView.new(this[_data$0][$asFloat32x4List](offsetInBytes, length));
>+  }
>+  asFloat64x2List(offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return new typed_data.UnmodifiableFloat64x2ListView.new(this[_data$0][$asFloat64x2List](offsetInBytes, length));
>+  }
>+  asByteData(offsetInBytes, length) {
>+    if (offsetInBytes === void 0) offsetInBytes = 0;
>+    if (length === void 0) length = null;
>+    return new typed_data.UnmodifiableByteDataView.new(this[_data$0][$asByteData](offsetInBytes, length));
>+  }
>+};
>+(typed_data.UnmodifiableByteBufferView.new = function(data) {
>+  this[_data$0] = data;
>+}).prototype = typed_data.UnmodifiableByteBufferView.prototype;
>+dart.addTypeTests(typed_data.UnmodifiableByteBufferView);
>+typed_data.UnmodifiableByteBufferView[dart.implements] = () => [typed_data.ByteBuffer];
>+dart.setMethodSignature(typed_data.UnmodifiableByteBufferView, () => ({
>+  __proto__: dart.getMethods(typed_data.UnmodifiableByteBufferView.__proto__),
>+  asUint8List: dart.fnType(typed_data.Uint8List, [], [core.int, core.int]),
>+  [$asUint8List]: dart.fnType(typed_data.Uint8List, [], [core.int, core.int]),
>+  asInt8List: dart.fnType(typed_data.Int8List, [], [core.int, core.int]),
>+  [$asInt8List]: dart.fnType(typed_data.Int8List, [], [core.int, core.int]),
>+  asUint8ClampedList: dart.fnType(typed_data.Uint8ClampedList, [], [core.int, core.int]),
>+  [$asUint8ClampedList]: dart.fnType(typed_data.Uint8ClampedList, [], [core.int, core.int]),
>+  asUint16List: dart.fnType(typed_data.Uint16List, [], [core.int, core.int]),
>+  [$asUint16List]: dart.fnType(typed_data.Uint16List, [], [core.int, core.int]),
>+  asInt16List: dart.fnType(typed_data.Int16List, [], [core.int, core.int]),
>+  [$asInt16List]: dart.fnType(typed_data.Int16List, [], [core.int, core.int]),
>+  asUint32List: dart.fnType(typed_data.Uint32List, [], [core.int, core.int]),
>+  [$asUint32List]: dart.fnType(typed_data.Uint32List, [], [core.int, core.int]),
>+  asInt32List: dart.fnType(typed_data.Int32List, [], [core.int, core.int]),
>+  [$asInt32List]: dart.fnType(typed_data.Int32List, [], [core.int, core.int]),
>+  asUint64List: dart.fnType(typed_data.Uint64List, [], [core.int, core.int]),
>+  [$asUint64List]: dart.fnType(typed_data.Uint64List, [], [core.int, core.int]),
>+  asInt64List: dart.fnType(typed_data.Int64List, [], [core.int, core.int]),
>+  [$asInt64List]: dart.fnType(typed_data.Int64List, [], [core.int, core.int]),
>+  asInt32x4List: dart.fnType(typed_data.Int32x4List, [], [core.int, core.int]),
>+  [$asInt32x4List]: dart.fnType(typed_data.Int32x4List, [], [core.int, core.int]),
>+  asFloat32List: dart.fnType(typed_data.Float32List, [], [core.int, core.int]),
>+  [$asFloat32List]: dart.fnType(typed_data.Float32List, [], [core.int, core.int]),
>+  asFloat64List: dart.fnType(typed_data.Float64List, [], [core.int, core.int]),
>+  [$asFloat64List]: dart.fnType(typed_data.Float64List, [], [core.int, core.int]),
>+  asFloat32x4List: dart.fnType(typed_data.Float32x4List, [], [core.int, core.int]),
>+  [$asFloat32x4List]: dart.fnType(typed_data.Float32x4List, [], [core.int, core.int]),
>+  asFloat64x2List: dart.fnType(typed_data.Float64x2List, [], [core.int, core.int]),
>+  [$asFloat64x2List]: dart.fnType(typed_data.Float64x2List, [], [core.int, core.int]),
>+  asByteData: dart.fnType(typed_data.ByteData, [], [core.int, core.int]),
>+  [$asByteData]: dart.fnType(typed_data.ByteData, [], [core.int, core.int])
>+}));
>+dart.setGetterSignature(typed_data.UnmodifiableByteBufferView, () => ({
>+  __proto__: dart.getGetters(typed_data.UnmodifiableByteBufferView.__proto__),
>+  lengthInBytes: core.int,
>+  [$lengthInBytes]: core.int
>+}));
>+dart.setLibraryUri(typed_data.UnmodifiableByteBufferView, "dart:typed_data");
>+dart.setFieldSignature(typed_data.UnmodifiableByteBufferView, () => ({
>+  __proto__: dart.getFields(typed_data.UnmodifiableByteBufferView.__proto__),
>+  [_data$0]: dart.finalFieldType(typed_data.ByteBuffer)
>+}));
>+dart.defineExtensionMethods(typed_data.UnmodifiableByteBufferView, [
>+  'asUint8List',
>+  'asInt8List',
>+  'asUint8ClampedList',
>+  'asUint16List',
>+  'asInt16List',
>+  'asUint32List',
>+  'asInt32List',
>+  'asUint64List',
>+  'asInt64List',
>+  'asInt32x4List',
>+  'asFloat32List',
>+  'asFloat64List',
>+  'asFloat32x4List',
>+  'asFloat64x2List',
>+  'asByteData'
>+]);
>+dart.defineExtensionAccessors(typed_data.UnmodifiableByteBufferView, ['lengthInBytes']);
>+const _unsupported = dart.privateName(typed_data, "_unsupported");
>+typed_data.UnmodifiableByteDataView = class UnmodifiableByteDataView extends core.Object {
>+  getInt8(byteOffset) {
>+    return this[_data$0][$getInt8](byteOffset);
>+  }
>+  setInt8(byteOffset, value) {
>+    return this[_unsupported]();
>+  }
>+  getUint8(byteOffset) {
>+    return this[_data$0][$getUint8](byteOffset);
>+  }
>+  setUint8(byteOffset, value) {
>+    return this[_unsupported]();
>+  }
>+  getInt16(byteOffset, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    return this[_data$0][$getInt16](byteOffset, endian);
>+  }
>+  setInt16(byteOffset, value, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    return this[_unsupported]();
>+  }
>+  getUint16(byteOffset, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    return this[_data$0][$getUint16](byteOffset, endian);
>+  }
>+  setUint16(byteOffset, value, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    return this[_unsupported]();
>+  }
>+  getInt32(byteOffset, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    return this[_data$0][$getInt32](byteOffset, endian);
>+  }
>+  setInt32(byteOffset, value, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    return this[_unsupported]();
>+  }
>+  getUint32(byteOffset, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    return this[_data$0][$getUint32](byteOffset, endian);
>+  }
>+  setUint32(byteOffset, value, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    return this[_unsupported]();
>+  }
>+  getInt64(byteOffset, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    return this[_data$0][$getInt64](byteOffset, endian);
>+  }
>+  setInt64(byteOffset, value, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    return this[_unsupported]();
>+  }
>+  getUint64(byteOffset, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    return this[_data$0][$getUint64](byteOffset, endian);
>+  }
>+  setUint64(byteOffset, value, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    return this[_unsupported]();
>+  }
>+  getFloat32(byteOffset, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    return this[_data$0][$getFloat32](byteOffset, endian);
>+  }
>+  setFloat32(byteOffset, value, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    return this[_unsupported]();
>+  }
>+  getFloat64(byteOffset, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    return this[_data$0][$getFloat64](byteOffset, endian);
>+  }
>+  setFloat64(byteOffset, value, endian) {
>+    if (endian === void 0) endian = typed_data.Endian.big;
>+    return this[_unsupported]();
>+  }
>+  get elementSizeInBytes() {
>+    return this[_data$0][$elementSizeInBytes];
>+  }
>+  get offsetInBytes() {
>+    return this[_data$0][$offsetInBytes];
>+  }
>+  get lengthInBytes() {
>+    return this[_data$0][$lengthInBytes];
>+  }
>+  get buffer() {
>+    return new typed_data.UnmodifiableByteBufferView.new(this[_data$0][$buffer]);
>+  }
>+  [_unsupported]() {
>+    dart.throw(new core.UnsupportedError.new("An UnmodifiableByteDataView may not be modified"));
>+  }
>+};
>+(typed_data.UnmodifiableByteDataView.new = function(data) {
>+  this[_data$0] = data;
>+}).prototype = typed_data.UnmodifiableByteDataView.prototype;
>+dart.addTypeTests(typed_data.UnmodifiableByteDataView);
>+typed_data.UnmodifiableByteDataView[dart.implements] = () => [typed_data.ByteData];
>+dart.setMethodSignature(typed_data.UnmodifiableByteDataView, () => ({
>+  __proto__: dart.getMethods(typed_data.UnmodifiableByteDataView.__proto__),
>+  getInt8: dart.fnType(core.int, [core.int]),
>+  [$getInt8]: dart.fnType(core.int, [core.int]),
>+  setInt8: dart.fnType(dart.void, [core.int, core.int]),
>+  [$setInt8]: dart.fnType(dart.void, [core.int, core.int]),
>+  getUint8: dart.fnType(core.int, [core.int]),
>+  [$getUint8]: dart.fnType(core.int, [core.int]),
>+  setUint8: dart.fnType(dart.void, [core.int, core.int]),
>+  [$setUint8]: dart.fnType(dart.void, [core.int, core.int]),
>+  getInt16: dart.fnType(core.int, [core.int], [typed_data.Endian]),
>+  [$getInt16]: dart.fnType(core.int, [core.int], [typed_data.Endian]),
>+  setInt16: dart.fnType(dart.void, [core.int, core.int], [typed_data.Endian]),
>+  [$setInt16]: dart.fnType(dart.void, [core.int, core.int], [typed_data.Endian]),
>+  getUint16: dart.fnType(core.int, [core.int], [typed_data.Endian]),
>+  [$getUint16]: dart.fnType(core.int, [core.int], [typed_data.Endian]),
>+  setUint16: dart.fnType(dart.void, [core.int, core.int], [typed_data.Endian]),
>+  [$setUint16]: dart.fnType(dart.void, [core.int, core.int], [typed_data.Endian]),
>+  getInt32: dart.fnType(core.int, [core.int], [typed_data.Endian]),
>+  [$getInt32]: dart.fnType(core.int, [core.int], [typed_data.Endian]),
>+  setInt32: dart.fnType(dart.void, [core.int, core.int], [typed_data.Endian]),
>+  [$setInt32]: dart.fnType(dart.void, [core.int, core.int], [typed_data.Endian]),
>+  getUint32: dart.fnType(core.int, [core.int], [typed_data.Endian]),
>+  [$getUint32]: dart.fnType(core.int, [core.int], [typed_data.Endian]),
>+  setUint32: dart.fnType(dart.void, [core.int, core.int], [typed_data.Endian]),
>+  [$setUint32]: dart.fnType(dart.void, [core.int, core.int], [typed_data.Endian]),
>+  getInt64: dart.fnType(core.int, [core.int], [typed_data.Endian]),
>+  [$getInt64]: dart.fnType(core.int, [core.int], [typed_data.Endian]),
>+  setInt64: dart.fnType(dart.void, [core.int, core.int], [typed_data.Endian]),
>+  [$setInt64]: dart.fnType(dart.void, [core.int, core.int], [typed_data.Endian]),
>+  getUint64: dart.fnType(core.int, [core.int], [typed_data.Endian]),
>+  [$getUint64]: dart.fnType(core.int, [core.int], [typed_data.Endian]),
>+  setUint64: dart.fnType(dart.void, [core.int, core.int], [typed_data.Endian]),
>+  [$setUint64]: dart.fnType(dart.void, [core.int, core.int], [typed_data.Endian]),
>+  getFloat32: dart.fnType(core.double, [core.int], [typed_data.Endian]),
>+  [$getFloat32]: dart.fnType(core.double, [core.int], [typed_data.Endian]),
>+  setFloat32: dart.fnType(dart.void, [core.int, core.double], [typed_data.Endian]),
>+  [$setFloat32]: dart.fnType(dart.void, [core.int, core.double], [typed_data.Endian]),
>+  getFloat64: dart.fnType(core.double, [core.int], [typed_data.Endian]),
>+  [$getFloat64]: dart.fnType(core.double, [core.int], [typed_data.Endian]),
>+  setFloat64: dart.fnType(dart.void, [core.int, core.double], [typed_data.Endian]),
>+  [$setFloat64]: dart.fnType(dart.void, [core.int, core.double], [typed_data.Endian]),
>+  [_unsupported]: dart.fnType(dart.void, [])
>+}));
>+dart.setGetterSignature(typed_data.UnmodifiableByteDataView, () => ({
>+  __proto__: dart.getGetters(typed_data.UnmodifiableByteDataView.__proto__),
>+  elementSizeInBytes: core.int,
>+  [$elementSizeInBytes]: core.int,
>+  offsetInBytes: core.int,
>+  [$offsetInBytes]: core.int,
>+  lengthInBytes: core.int,
>+  [$lengthInBytes]: core.int,
>+  buffer: typed_data.ByteBuffer,
>+  [$buffer]: typed_data.ByteBuffer
>+}));
>+dart.setLibraryUri(typed_data.UnmodifiableByteDataView, "dart:typed_data");
>+dart.setFieldSignature(typed_data.UnmodifiableByteDataView, () => ({
>+  __proto__: dart.getFields(typed_data.UnmodifiableByteDataView.__proto__),
>+  [_data$0]: dart.finalFieldType(typed_data.ByteData)
>+}));
>+dart.defineExtensionMethods(typed_data.UnmodifiableByteDataView, [
>+  'getInt8',
>+  'setInt8',
>+  'getUint8',
>+  'setUint8',
>+  'getInt16',
>+  'setInt16',
>+  'getUint16',
>+  'setUint16',
>+  'getInt32',
>+  'setInt32',
>+  'getUint32',
>+  'setUint32',
>+  'getInt64',
>+  'setInt64',
>+  'getUint64',
>+  'setUint64',
>+  'getFloat32',
>+  'setFloat32',
>+  'getFloat64',
>+  'setFloat64'
>+]);
>+dart.defineExtensionAccessors(typed_data.UnmodifiableByteDataView, ['elementSizeInBytes', 'offsetInBytes', 'lengthInBytes', 'buffer']);
>+const _list$0 = dart.privateName(typed_data, "_list");
>+const _is__UnmodifiableListMixin_default = Symbol('_is__UnmodifiableListMixin_default');
>+typed_data._UnmodifiableListMixin$ = dart.generic((N, L, TD) => {
>+  class _UnmodifiableListMixin extends core.Object {
>+    get [_data$0]() {
>+      return TD.as(this[_list$0]);
>+    }
>+    get length() {
>+      return this[_list$0][$length];
>+    }
>+    _get(index) {
>+      return this[_list$0][$_get](index);
>+    }
>+    get elementSizeInBytes() {
>+      return this[_data$0][$elementSizeInBytes];
>+    }
>+    get offsetInBytes() {
>+      return this[_data$0][$offsetInBytes];
>+    }
>+    get lengthInBytes() {
>+      return this[_data$0][$lengthInBytes];
>+    }
>+    get buffer() {
>+      return new typed_data.UnmodifiableByteBufferView.new(this[_data$0][$buffer]);
>+    }
>+  }
>+  (_UnmodifiableListMixin.new = function() {
>+  }).prototype = _UnmodifiableListMixin.prototype;
>+  dart.addTypeTests(_UnmodifiableListMixin);
>+  _UnmodifiableListMixin.prototype[_is__UnmodifiableListMixin_default] = true;
>+  dart.setMethodSignature(_UnmodifiableListMixin, () => ({
>+    __proto__: dart.getMethods(_UnmodifiableListMixin.__proto__),
>+    _get: dart.fnType(N, [core.int])
>+  }));
>+  dart.setGetterSignature(_UnmodifiableListMixin, () => ({
>+    __proto__: dart.getGetters(_UnmodifiableListMixin.__proto__),
>+    [_data$0]: TD,
>+    length: core.int,
>+    elementSizeInBytes: core.int,
>+    offsetInBytes: core.int,
>+    lengthInBytes: core.int,
>+    buffer: typed_data.ByteBuffer
>+  }));
>+  dart.setLibraryUri(_UnmodifiableListMixin, "dart:typed_data");
>+  return _UnmodifiableListMixin;
>+});
>+typed_data._UnmodifiableListMixin = typed_data._UnmodifiableListMixin$();
>+dart.addTypeTests(typed_data._UnmodifiableListMixin, _is__UnmodifiableListMixin_default);
>+const UnmodifiableListBase__UnmodifiableListMixin$ = class UnmodifiableListBase__UnmodifiableListMixin extends _internal.UnmodifiableListBase$(core.int) {};
>+(UnmodifiableListBase__UnmodifiableListMixin$.new = function() {
>+}).prototype = UnmodifiableListBase__UnmodifiableListMixin$.prototype;
>+dart.applyMixin(UnmodifiableListBase__UnmodifiableListMixin$, typed_data._UnmodifiableListMixin$(core.int, typed_data.Uint8List, typed_data.Uint8List));
>+typed_data.UnmodifiableUint8ListView = class UnmodifiableUint8ListView extends UnmodifiableListBase__UnmodifiableListMixin$ {};
>+(typed_data.UnmodifiableUint8ListView.new = function(list) {
>+  this[_list$0] = list;
>+}).prototype = typed_data.UnmodifiableUint8ListView.prototype;
>+dart.addTypeTests(typed_data.UnmodifiableUint8ListView);
>+typed_data.UnmodifiableUint8ListView[dart.implements] = () => [typed_data.Uint8List];
>+dart.setLibraryUri(typed_data.UnmodifiableUint8ListView, "dart:typed_data");
>+dart.setFieldSignature(typed_data.UnmodifiableUint8ListView, () => ({
>+  __proto__: dart.getFields(typed_data.UnmodifiableUint8ListView.__proto__),
>+  [_list$0]: dart.finalFieldType(typed_data.Uint8List)
>+}));
>+dart.defineExtensionMethods(typed_data.UnmodifiableUint8ListView, ['_get']);
>+dart.defineExtensionAccessors(typed_data.UnmodifiableUint8ListView, [
>+  'length',
>+  'elementSizeInBytes',
>+  'offsetInBytes',
>+  'lengthInBytes',
>+  'buffer'
>+]);
>+const UnmodifiableListBase__UnmodifiableListMixin$$ = class UnmodifiableListBase__UnmodifiableListMixin extends _internal.UnmodifiableListBase$(core.int) {};
>+(UnmodifiableListBase__UnmodifiableListMixin$$.new = function() {
>+}).prototype = UnmodifiableListBase__UnmodifiableListMixin$$.prototype;
>+dart.applyMixin(UnmodifiableListBase__UnmodifiableListMixin$$, typed_data._UnmodifiableListMixin$(core.int, typed_data.Int8List, typed_data.Int8List));
>+typed_data.UnmodifiableInt8ListView = class UnmodifiableInt8ListView extends UnmodifiableListBase__UnmodifiableListMixin$$ {};
>+(typed_data.UnmodifiableInt8ListView.new = function(list) {
>+  this[_list$0] = list;
>+}).prototype = typed_data.UnmodifiableInt8ListView.prototype;
>+dart.addTypeTests(typed_data.UnmodifiableInt8ListView);
>+typed_data.UnmodifiableInt8ListView[dart.implements] = () => [typed_data.Int8List];
>+dart.setLibraryUri(typed_data.UnmodifiableInt8ListView, "dart:typed_data");
>+dart.setFieldSignature(typed_data.UnmodifiableInt8ListView, () => ({
>+  __proto__: dart.getFields(typed_data.UnmodifiableInt8ListView.__proto__),
>+  [_list$0]: dart.finalFieldType(typed_data.Int8List)
>+}));
>+dart.defineExtensionMethods(typed_data.UnmodifiableInt8ListView, ['_get']);
>+dart.defineExtensionAccessors(typed_data.UnmodifiableInt8ListView, [
>+  'length',
>+  'elementSizeInBytes',
>+  'offsetInBytes',
>+  'lengthInBytes',
>+  'buffer'
>+]);
>+const UnmodifiableListBase__UnmodifiableListMixin$$0 = class UnmodifiableListBase__UnmodifiableListMixin extends _internal.UnmodifiableListBase$(core.int) {};
>+(UnmodifiableListBase__UnmodifiableListMixin$$0.new = function() {
>+}).prototype = UnmodifiableListBase__UnmodifiableListMixin$$0.prototype;
>+dart.applyMixin(UnmodifiableListBase__UnmodifiableListMixin$$0, typed_data._UnmodifiableListMixin$(core.int, typed_data.Uint8ClampedList, typed_data.Uint8ClampedList));
>+typed_data.UnmodifiableUint8ClampedListView = class UnmodifiableUint8ClampedListView extends UnmodifiableListBase__UnmodifiableListMixin$$0 {};
>+(typed_data.UnmodifiableUint8ClampedListView.new = function(list) {
>+  this[_list$0] = list;
>+}).prototype = typed_data.UnmodifiableUint8ClampedListView.prototype;
>+dart.addTypeTests(typed_data.UnmodifiableUint8ClampedListView);
>+typed_data.UnmodifiableUint8ClampedListView[dart.implements] = () => [typed_data.Uint8ClampedList];
>+dart.setLibraryUri(typed_data.UnmodifiableUint8ClampedListView, "dart:typed_data");
>+dart.setFieldSignature(typed_data.UnmodifiableUint8ClampedListView, () => ({
>+  __proto__: dart.getFields(typed_data.UnmodifiableUint8ClampedListView.__proto__),
>+  [_list$0]: dart.finalFieldType(typed_data.Uint8ClampedList)
>+}));
>+dart.defineExtensionMethods(typed_data.UnmodifiableUint8ClampedListView, ['_get']);
>+dart.defineExtensionAccessors(typed_data.UnmodifiableUint8ClampedListView, [
>+  'length',
>+  'elementSizeInBytes',
>+  'offsetInBytes',
>+  'lengthInBytes',
>+  'buffer'
>+]);
>+const UnmodifiableListBase__UnmodifiableListMixin$$1 = class UnmodifiableListBase__UnmodifiableListMixin extends _internal.UnmodifiableListBase$(core.int) {};
>+(UnmodifiableListBase__UnmodifiableListMixin$$1.new = function() {
>+}).prototype = UnmodifiableListBase__UnmodifiableListMixin$$1.prototype;
>+dart.applyMixin(UnmodifiableListBase__UnmodifiableListMixin$$1, typed_data._UnmodifiableListMixin$(core.int, typed_data.Uint16List, typed_data.Uint16List));
>+typed_data.UnmodifiableUint16ListView = class UnmodifiableUint16ListView extends UnmodifiableListBase__UnmodifiableListMixin$$1 {};
>+(typed_data.UnmodifiableUint16ListView.new = function(list) {
>+  this[_list$0] = list;
>+}).prototype = typed_data.UnmodifiableUint16ListView.prototype;
>+dart.addTypeTests(typed_data.UnmodifiableUint16ListView);
>+typed_data.UnmodifiableUint16ListView[dart.implements] = () => [typed_data.Uint16List];
>+dart.setLibraryUri(typed_data.UnmodifiableUint16ListView, "dart:typed_data");
>+dart.setFieldSignature(typed_data.UnmodifiableUint16ListView, () => ({
>+  __proto__: dart.getFields(typed_data.UnmodifiableUint16ListView.__proto__),
>+  [_list$0]: dart.finalFieldType(typed_data.Uint16List)
>+}));
>+dart.defineExtensionMethods(typed_data.UnmodifiableUint16ListView, ['_get']);
>+dart.defineExtensionAccessors(typed_data.UnmodifiableUint16ListView, [
>+  'length',
>+  'elementSizeInBytes',
>+  'offsetInBytes',
>+  'lengthInBytes',
>+  'buffer'
>+]);
>+const UnmodifiableListBase__UnmodifiableListMixin$$2 = class UnmodifiableListBase__UnmodifiableListMixin extends _internal.UnmodifiableListBase$(core.int) {};
>+(UnmodifiableListBase__UnmodifiableListMixin$$2.new = function() {
>+}).prototype = UnmodifiableListBase__UnmodifiableListMixin$$2.prototype;
>+dart.applyMixin(UnmodifiableListBase__UnmodifiableListMixin$$2, typed_data._UnmodifiableListMixin$(core.int, typed_data.Int16List, typed_data.Int16List));
>+typed_data.UnmodifiableInt16ListView = class UnmodifiableInt16ListView extends UnmodifiableListBase__UnmodifiableListMixin$$2 {};
>+(typed_data.UnmodifiableInt16ListView.new = function(list) {
>+  this[_list$0] = list;
>+}).prototype = typed_data.UnmodifiableInt16ListView.prototype;
>+dart.addTypeTests(typed_data.UnmodifiableInt16ListView);
>+typed_data.UnmodifiableInt16ListView[dart.implements] = () => [typed_data.Int16List];
>+dart.setLibraryUri(typed_data.UnmodifiableInt16ListView, "dart:typed_data");
>+dart.setFieldSignature(typed_data.UnmodifiableInt16ListView, () => ({
>+  __proto__: dart.getFields(typed_data.UnmodifiableInt16ListView.__proto__),
>+  [_list$0]: dart.finalFieldType(typed_data.Int16List)
>+}));
>+dart.defineExtensionMethods(typed_data.UnmodifiableInt16ListView, ['_get']);
>+dart.defineExtensionAccessors(typed_data.UnmodifiableInt16ListView, [
>+  'length',
>+  'elementSizeInBytes',
>+  'offsetInBytes',
>+  'lengthInBytes',
>+  'buffer'
>+]);
>+const UnmodifiableListBase__UnmodifiableListMixin$$3 = class UnmodifiableListBase__UnmodifiableListMixin extends _internal.UnmodifiableListBase$(core.int) {};
>+(UnmodifiableListBase__UnmodifiableListMixin$$3.new = function() {
>+}).prototype = UnmodifiableListBase__UnmodifiableListMixin$$3.prototype;
>+dart.applyMixin(UnmodifiableListBase__UnmodifiableListMixin$$3, typed_data._UnmodifiableListMixin$(core.int, typed_data.Uint32List, typed_data.Uint32List));
>+typed_data.UnmodifiableUint32ListView = class UnmodifiableUint32ListView extends UnmodifiableListBase__UnmodifiableListMixin$$3 {};
>+(typed_data.UnmodifiableUint32ListView.new = function(list) {
>+  this[_list$0] = list;
>+}).prototype = typed_data.UnmodifiableUint32ListView.prototype;
>+dart.addTypeTests(typed_data.UnmodifiableUint32ListView);
>+typed_data.UnmodifiableUint32ListView[dart.implements] = () => [typed_data.Uint32List];
>+dart.setLibraryUri(typed_data.UnmodifiableUint32ListView, "dart:typed_data");
>+dart.setFieldSignature(typed_data.UnmodifiableUint32ListView, () => ({
>+  __proto__: dart.getFields(typed_data.UnmodifiableUint32ListView.__proto__),
>+  [_list$0]: dart.finalFieldType(typed_data.Uint32List)
>+}));
>+dart.defineExtensionMethods(typed_data.UnmodifiableUint32ListView, ['_get']);
>+dart.defineExtensionAccessors(typed_data.UnmodifiableUint32ListView, [
>+  'length',
>+  'elementSizeInBytes',
>+  'offsetInBytes',
>+  'lengthInBytes',
>+  'buffer'
>+]);
>+const UnmodifiableListBase__UnmodifiableListMixin$$4 = class UnmodifiableListBase__UnmodifiableListMixin extends _internal.UnmodifiableListBase$(core.int) {};
>+(UnmodifiableListBase__UnmodifiableListMixin$$4.new = function() {
>+}).prototype = UnmodifiableListBase__UnmodifiableListMixin$$4.prototype;
>+dart.applyMixin(UnmodifiableListBase__UnmodifiableListMixin$$4, typed_data._UnmodifiableListMixin$(core.int, typed_data.Int32List, typed_data.Int32List));
>+typed_data.UnmodifiableInt32ListView = class UnmodifiableInt32ListView extends UnmodifiableListBase__UnmodifiableListMixin$$4 {};
>+(typed_data.UnmodifiableInt32ListView.new = function(list) {
>+  this[_list$0] = list;
>+}).prototype = typed_data.UnmodifiableInt32ListView.prototype;
>+dart.addTypeTests(typed_data.UnmodifiableInt32ListView);
>+typed_data.UnmodifiableInt32ListView[dart.implements] = () => [typed_data.Int32List];
>+dart.setLibraryUri(typed_data.UnmodifiableInt32ListView, "dart:typed_data");
>+dart.setFieldSignature(typed_data.UnmodifiableInt32ListView, () => ({
>+  __proto__: dart.getFields(typed_data.UnmodifiableInt32ListView.__proto__),
>+  [_list$0]: dart.finalFieldType(typed_data.Int32List)
>+}));
>+dart.defineExtensionMethods(typed_data.UnmodifiableInt32ListView, ['_get']);
>+dart.defineExtensionAccessors(typed_data.UnmodifiableInt32ListView, [
>+  'length',
>+  'elementSizeInBytes',
>+  'offsetInBytes',
>+  'lengthInBytes',
>+  'buffer'
>+]);
>+const UnmodifiableListBase__UnmodifiableListMixin$$5 = class UnmodifiableListBase__UnmodifiableListMixin extends _internal.UnmodifiableListBase$(core.int) {};
>+(UnmodifiableListBase__UnmodifiableListMixin$$5.new = function() {
>+}).prototype = UnmodifiableListBase__UnmodifiableListMixin$$5.prototype;
>+dart.applyMixin(UnmodifiableListBase__UnmodifiableListMixin$$5, typed_data._UnmodifiableListMixin$(core.int, typed_data.Uint64List, typed_data.Uint64List));
>+typed_data.UnmodifiableUint64ListView = class UnmodifiableUint64ListView extends UnmodifiableListBase__UnmodifiableListMixin$$5 {};
>+(typed_data.UnmodifiableUint64ListView.new = function(list) {
>+  this[_list$0] = list;
>+}).prototype = typed_data.UnmodifiableUint64ListView.prototype;
>+dart.addTypeTests(typed_data.UnmodifiableUint64ListView);
>+typed_data.UnmodifiableUint64ListView[dart.implements] = () => [typed_data.Uint64List];
>+dart.setLibraryUri(typed_data.UnmodifiableUint64ListView, "dart:typed_data");
>+dart.setFieldSignature(typed_data.UnmodifiableUint64ListView, () => ({
>+  __proto__: dart.getFields(typed_data.UnmodifiableUint64ListView.__proto__),
>+  [_list$0]: dart.finalFieldType(typed_data.Uint64List)
>+}));
>+dart.defineExtensionMethods(typed_data.UnmodifiableUint64ListView, ['_get']);
>+dart.defineExtensionAccessors(typed_data.UnmodifiableUint64ListView, [
>+  'length',
>+  'elementSizeInBytes',
>+  'offsetInBytes',
>+  'lengthInBytes',
>+  'buffer'
>+]);
>+const UnmodifiableListBase__UnmodifiableListMixin$$6 = class UnmodifiableListBase__UnmodifiableListMixin extends _internal.UnmodifiableListBase$(core.int) {};
>+(UnmodifiableListBase__UnmodifiableListMixin$$6.new = function() {
>+}).prototype = UnmodifiableListBase__UnmodifiableListMixin$$6.prototype;
>+dart.applyMixin(UnmodifiableListBase__UnmodifiableListMixin$$6, typed_data._UnmodifiableListMixin$(core.int, typed_data.Int64List, typed_data.Int64List));
>+typed_data.UnmodifiableInt64ListView = class UnmodifiableInt64ListView extends UnmodifiableListBase__UnmodifiableListMixin$$6 {};
>+(typed_data.UnmodifiableInt64ListView.new = function(list) {
>+  this[_list$0] = list;
>+}).prototype = typed_data.UnmodifiableInt64ListView.prototype;
>+dart.addTypeTests(typed_data.UnmodifiableInt64ListView);
>+typed_data.UnmodifiableInt64ListView[dart.implements] = () => [typed_data.Int64List];
>+dart.setLibraryUri(typed_data.UnmodifiableInt64ListView, "dart:typed_data");
>+dart.setFieldSignature(typed_data.UnmodifiableInt64ListView, () => ({
>+  __proto__: dart.getFields(typed_data.UnmodifiableInt64ListView.__proto__),
>+  [_list$0]: dart.finalFieldType(typed_data.Int64List)
>+}));
>+dart.defineExtensionMethods(typed_data.UnmodifiableInt64ListView, ['_get']);
>+dart.defineExtensionAccessors(typed_data.UnmodifiableInt64ListView, [
>+  'length',
>+  'elementSizeInBytes',
>+  'offsetInBytes',
>+  'lengthInBytes',
>+  'buffer'
>+]);
>+const UnmodifiableListBase__UnmodifiableListMixin$$7 = class UnmodifiableListBase__UnmodifiableListMixin extends _internal.UnmodifiableListBase$(typed_data.Int32x4) {};
>+(UnmodifiableListBase__UnmodifiableListMixin$$7.new = function() {
>+}).prototype = UnmodifiableListBase__UnmodifiableListMixin$$7.prototype;
>+dart.applyMixin(UnmodifiableListBase__UnmodifiableListMixin$$7, typed_data._UnmodifiableListMixin$(typed_data.Int32x4, typed_data.Int32x4List, typed_data.Int32x4List));
>+typed_data.UnmodifiableInt32x4ListView = class UnmodifiableInt32x4ListView extends UnmodifiableListBase__UnmodifiableListMixin$$7 {};
>+(typed_data.UnmodifiableInt32x4ListView.new = function(list) {
>+  this[_list$0] = list;
>+}).prototype = typed_data.UnmodifiableInt32x4ListView.prototype;
>+dart.addTypeTests(typed_data.UnmodifiableInt32x4ListView);
>+typed_data.UnmodifiableInt32x4ListView[dart.implements] = () => [typed_data.Int32x4List];
>+dart.setLibraryUri(typed_data.UnmodifiableInt32x4ListView, "dart:typed_data");
>+dart.setFieldSignature(typed_data.UnmodifiableInt32x4ListView, () => ({
>+  __proto__: dart.getFields(typed_data.UnmodifiableInt32x4ListView.__proto__),
>+  [_list$0]: dart.finalFieldType(typed_data.Int32x4List)
>+}));
>+dart.defineExtensionMethods(typed_data.UnmodifiableInt32x4ListView, ['_get']);
>+dart.defineExtensionAccessors(typed_data.UnmodifiableInt32x4ListView, [
>+  'length',
>+  'elementSizeInBytes',
>+  'offsetInBytes',
>+  'lengthInBytes',
>+  'buffer'
>+]);
>+const UnmodifiableListBase__UnmodifiableListMixin$$8 = class UnmodifiableListBase__UnmodifiableListMixin extends _internal.UnmodifiableListBase$(typed_data.Float32x4) {};
>+(UnmodifiableListBase__UnmodifiableListMixin$$8.new = function() {
>+}).prototype = UnmodifiableListBase__UnmodifiableListMixin$$8.prototype;
>+dart.applyMixin(UnmodifiableListBase__UnmodifiableListMixin$$8, typed_data._UnmodifiableListMixin$(typed_data.Float32x4, typed_data.Float32x4List, typed_data.Float32x4List));
>+typed_data.UnmodifiableFloat32x4ListView = class UnmodifiableFloat32x4ListView extends UnmodifiableListBase__UnmodifiableListMixin$$8 {};
>+(typed_data.UnmodifiableFloat32x4ListView.new = function(list) {
>+  this[_list$0] = list;
>+}).prototype = typed_data.UnmodifiableFloat32x4ListView.prototype;
>+dart.addTypeTests(typed_data.UnmodifiableFloat32x4ListView);
>+typed_data.UnmodifiableFloat32x4ListView[dart.implements] = () => [typed_data.Float32x4List];
>+dart.setLibraryUri(typed_data.UnmodifiableFloat32x4ListView, "dart:typed_data");
>+dart.setFieldSignature(typed_data.UnmodifiableFloat32x4ListView, () => ({
>+  __proto__: dart.getFields(typed_data.UnmodifiableFloat32x4ListView.__proto__),
>+  [_list$0]: dart.finalFieldType(typed_data.Float32x4List)
>+}));
>+dart.defineExtensionMethods(typed_data.UnmodifiableFloat32x4ListView, ['_get']);
>+dart.defineExtensionAccessors(typed_data.UnmodifiableFloat32x4ListView, [
>+  'length',
>+  'elementSizeInBytes',
>+  'offsetInBytes',
>+  'lengthInBytes',
>+  'buffer'
>+]);
>+const UnmodifiableListBase__UnmodifiableListMixin$$9 = class UnmodifiableListBase__UnmodifiableListMixin extends _internal.UnmodifiableListBase$(typed_data.Float64x2) {};
>+(UnmodifiableListBase__UnmodifiableListMixin$$9.new = function() {
>+}).prototype = UnmodifiableListBase__UnmodifiableListMixin$$9.prototype;
>+dart.applyMixin(UnmodifiableListBase__UnmodifiableListMixin$$9, typed_data._UnmodifiableListMixin$(typed_data.Float64x2, typed_data.Float64x2List, typed_data.Float64x2List));
>+typed_data.UnmodifiableFloat64x2ListView = class UnmodifiableFloat64x2ListView extends UnmodifiableListBase__UnmodifiableListMixin$$9 {};
>+(typed_data.UnmodifiableFloat64x2ListView.new = function(list) {
>+  this[_list$0] = list;
>+}).prototype = typed_data.UnmodifiableFloat64x2ListView.prototype;
>+dart.addTypeTests(typed_data.UnmodifiableFloat64x2ListView);
>+typed_data.UnmodifiableFloat64x2ListView[dart.implements] = () => [typed_data.Float64x2List];
>+dart.setLibraryUri(typed_data.UnmodifiableFloat64x2ListView, "dart:typed_data");
>+dart.setFieldSignature(typed_data.UnmodifiableFloat64x2ListView, () => ({
>+  __proto__: dart.getFields(typed_data.UnmodifiableFloat64x2ListView.__proto__),
>+  [_list$0]: dart.finalFieldType(typed_data.Float64x2List)
>+}));
>+dart.defineExtensionMethods(typed_data.UnmodifiableFloat64x2ListView, ['_get']);
>+dart.defineExtensionAccessors(typed_data.UnmodifiableFloat64x2ListView, [
>+  'length',
>+  'elementSizeInBytes',
>+  'offsetInBytes',
>+  'lengthInBytes',
>+  'buffer'
>+]);
>+const UnmodifiableListBase__UnmodifiableListMixin$$10 = class UnmodifiableListBase__UnmodifiableListMixin extends _internal.UnmodifiableListBase$(core.double) {};
>+(UnmodifiableListBase__UnmodifiableListMixin$$10.new = function() {
>+}).prototype = UnmodifiableListBase__UnmodifiableListMixin$$10.prototype;
>+dart.applyMixin(UnmodifiableListBase__UnmodifiableListMixin$$10, typed_data._UnmodifiableListMixin$(core.double, typed_data.Float32List, typed_data.Float32List));
>+typed_data.UnmodifiableFloat32ListView = class UnmodifiableFloat32ListView extends UnmodifiableListBase__UnmodifiableListMixin$$10 {};
>+(typed_data.UnmodifiableFloat32ListView.new = function(list) {
>+  this[_list$0] = list;
>+}).prototype = typed_data.UnmodifiableFloat32ListView.prototype;
>+dart.addTypeTests(typed_data.UnmodifiableFloat32ListView);
>+typed_data.UnmodifiableFloat32ListView[dart.implements] = () => [typed_data.Float32List];
>+dart.setLibraryUri(typed_data.UnmodifiableFloat32ListView, "dart:typed_data");
>+dart.setFieldSignature(typed_data.UnmodifiableFloat32ListView, () => ({
>+  __proto__: dart.getFields(typed_data.UnmodifiableFloat32ListView.__proto__),
>+  [_list$0]: dart.finalFieldType(typed_data.Float32List)
>+}));
>+dart.defineExtensionMethods(typed_data.UnmodifiableFloat32ListView, ['_get']);
>+dart.defineExtensionAccessors(typed_data.UnmodifiableFloat32ListView, [
>+  'length',
>+  'elementSizeInBytes',
>+  'offsetInBytes',
>+  'lengthInBytes',
>+  'buffer'
>+]);
>+const UnmodifiableListBase__UnmodifiableListMixin$$11 = class UnmodifiableListBase__UnmodifiableListMixin extends _internal.UnmodifiableListBase$(core.double) {};
>+(UnmodifiableListBase__UnmodifiableListMixin$$11.new = function() {
>+}).prototype = UnmodifiableListBase__UnmodifiableListMixin$$11.prototype;
>+dart.applyMixin(UnmodifiableListBase__UnmodifiableListMixin$$11, typed_data._UnmodifiableListMixin$(core.double, typed_data.Float64List, typed_data.Float64List));
>+typed_data.UnmodifiableFloat64ListView = class UnmodifiableFloat64ListView extends UnmodifiableListBase__UnmodifiableListMixin$$11 {};
>+(typed_data.UnmodifiableFloat64ListView.new = function(list) {
>+  this[_list$0] = list;
>+}).prototype = typed_data.UnmodifiableFloat64ListView.prototype;
>+dart.addTypeTests(typed_data.UnmodifiableFloat64ListView);
>+typed_data.UnmodifiableFloat64ListView[dart.implements] = () => [typed_data.Float64List];
>+dart.setLibraryUri(typed_data.UnmodifiableFloat64ListView, "dart:typed_data");
>+dart.setFieldSignature(typed_data.UnmodifiableFloat64ListView, () => ({
>+  __proto__: dart.getFields(typed_data.UnmodifiableFloat64ListView.__proto__),
>+  [_list$0]: dart.finalFieldType(typed_data.Float64List)
>+}));
>+dart.defineExtensionMethods(typed_data.UnmodifiableFloat64ListView, ['_get']);
>+dart.defineExtensionAccessors(typed_data.UnmodifiableFloat64ListView, [
>+  'length',
>+  'elementSizeInBytes',
>+  'offsetInBytes',
>+  'lengthInBytes',
>+  'buffer'
>+]);
>+indexed_db._KeyRangeFactoryProvider = class _KeyRangeFactoryProvider extends core.Object {
>+  static createKeyRange_only(value) {
>+    return indexed_db._KeyRangeFactoryProvider._only(indexed_db._KeyRangeFactoryProvider._class(), indexed_db._KeyRangeFactoryProvider._translateKey(value));
>+  }
>+  static createKeyRange_lowerBound(bound, open) {
>+    if (open === void 0) open = false;
>+    return indexed_db._KeyRangeFactoryProvider._lowerBound(indexed_db._KeyRangeFactoryProvider._class(), indexed_db._KeyRangeFactoryProvider._translateKey(bound), open);
>+  }
>+  static createKeyRange_upperBound(bound, open) {
>+    if (open === void 0) open = false;
>+    return indexed_db._KeyRangeFactoryProvider._upperBound(indexed_db._KeyRangeFactoryProvider._class(), indexed_db._KeyRangeFactoryProvider._translateKey(bound), open);
>+  }
>+  static createKeyRange_bound(lower, upper, lowerOpen, upperOpen) {
>+    if (lowerOpen === void 0) lowerOpen = false;
>+    if (upperOpen === void 0) upperOpen = false;
>+    return indexed_db._KeyRangeFactoryProvider._bound(indexed_db._KeyRangeFactoryProvider._class(), indexed_db._KeyRangeFactoryProvider._translateKey(lower), indexed_db._KeyRangeFactoryProvider._translateKey(upper), lowerOpen, upperOpen);
>+  }
>+  static _class() {
>+    if (indexed_db._KeyRangeFactoryProvider._cachedClass != null) return indexed_db._KeyRangeFactoryProvider._cachedClass;
>+    return indexed_db._KeyRangeFactoryProvider._cachedClass = indexed_db._KeyRangeFactoryProvider._uncachedClass();
>+  }
>+  static _uncachedClass() {
>+    return window.webkitIDBKeyRange || window.mozIDBKeyRange || window.msIDBKeyRange || window.IDBKeyRange;
>+  }
>+  static _translateKey(idbkey) {
>+    return idbkey;
>+  }
>+  static _only(cls, value) {
>+    return cls.only(value);
>+  }
>+  static _lowerBound(cls, bound, open) {
>+    return cls.lowerBound(bound, open);
>+  }
>+  static _upperBound(cls, bound, open) {
>+    return cls.upperBound(bound, open);
>+  }
>+  static _bound(cls, lower, upper, lowerOpen, upperOpen) {
>+    return cls.bound(lower, upper, lowerOpen, upperOpen);
>+  }
>+};
>+(indexed_db._KeyRangeFactoryProvider.new = function() {
>+}).prototype = indexed_db._KeyRangeFactoryProvider.prototype;
>+dart.addTypeTests(indexed_db._KeyRangeFactoryProvider);
>+dart.setLibraryUri(indexed_db._KeyRangeFactoryProvider, "dart:indexed_db");
>+dart.defineLazy(indexed_db._KeyRangeFactoryProvider, {
>+  /*indexed_db._KeyRangeFactoryProvider._cachedClass*/get _cachedClass() {
>+    return null;
>+  },
>+  set _cachedClass(_) {}
>+});
>+indexed_db._convertNativeToDart_IDBKey = function(nativeKey) {
>+  function containsDate(object) {
>+    if (dart.test(html_common.isJavaScriptDate(object))) return true;
>+    if (core.List.is(object)) {
>+      for (let i = 0; i < dart.notNull(object[$length]); i++) {
>+        if (dart.dtest(containsDate(object[$_get](i)))) return true;
>+      }
>+    }
>+    return false;
>+  }
>+  dart.fn(containsDate, dynamicTobool());
>+  if (dart.test(containsDate(nativeKey))) {
>+    dart.throw(new core.UnimplementedError.new("Key containing DateTime"));
>+  }
>+  return nativeKey;
>+};
>+indexed_db._convertDartToNative_IDBKey = function(dartKey) {
>+  return dartKey;
>+};
>+indexed_db._convertNativeToDart_IDBAny = function(object) {
>+  return html_common.convertNativeToDart_AcceptStructuredClone(object, {mustCopy: false});
>+};
>+dart.defineLazy(indexed_db, {
>+  /*indexed_db._idbKey*/get _idbKey() {
>+    return "JSExtendableArray|=Object|num|String";
>+  },
>+  /*indexed_db._annotation_Creates_IDBKey*/get _annotation_Creates_IDBKey() {
>+    return dart.const(new _js_helper.Creates.new("JSExtendableArray|=Object|num|String"));
>+  },
>+  /*indexed_db._annotation_Returns_IDBKey*/get _annotation_Returns_IDBKey() {
>+    return dart.const(new _js_helper.Returns.new("JSExtendableArray|=Object|num|String"));
>+  }
>+});
>+const _delete$ = dart.privateName(indexed_db, "_delete");
>+const _update = dart.privateName(indexed_db, "_update");
>+const _update_1 = dart.privateName(indexed_db, "_update_1");
>+indexed_db.Cursor = class Cursor extends _interceptors.Interceptor {
>+  [$delete]() {
>+    try {
>+      return indexed_db._completeRequest(dart.dynamic, this[_delete$]());
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      let stacktrace = dart.stackTrace(e$);
>+      return async.Future.error(e, stacktrace);
>+    }
>+  }
>+  [$update](value) {
>+    try {
>+      return indexed_db._completeRequest(dart.dynamic, this[_update](value));
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      let stacktrace = dart.stackTrace(e$);
>+      return async.Future.error(e, stacktrace);
>+    }
>+  }
>+  [$next](key) {
>+    if (key === void 0) key = null;
>+    if (key == null) {
>+      this.continue();
>+    } else {
>+      this.continue(key);
>+    }
>+  }
>+  get [$direction]() {
>+    return this.direction;
>+  }
>+  get [$key]() {
>+    return this.key;
>+  }
>+  get [$primaryKey]() {
>+    return this.primaryKey;
>+  }
>+  get [$source]() {
>+    return this.source;
>+  }
>+  [$advance](...args) {
>+    return this.advance.apply(this, args);
>+  }
>+  [$continuePrimaryKey](...args) {
>+    return this.continuePrimaryKey.apply(this, args);
>+  }
>+  [_delete$](...args) {
>+    return this.delete.apply(this, args);
>+  }
>+  [_update](value) {
>+    let value_1 = html_common.convertDartToNative_SerializedScriptValue(value);
>+    return this[_update_1](value_1);
>+  }
>+  [_update_1](...args) {
>+    return this.update.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(indexed_db.Cursor);
>+const direction = Symbol("Cursor.direction");
>+const key = Symbol("Cursor.key");
>+const primaryKey = Symbol("Cursor.primaryKey");
>+const source = Symbol("Cursor.source");
>+dart.setMethodSignature(indexed_db.Cursor, () => ({
>+  __proto__: dart.getMethods(indexed_db.Cursor.__proto__),
>+  [$delete]: dart.fnType(async.Future, []),
>+  [$update]: dart.fnType(async.Future, [dart.dynamic]),
>+  [$next]: dart.fnType(dart.void, [], [core.Object]),
>+  [$advance]: dart.fnType(dart.void, [core.int]),
>+  [$continuePrimaryKey]: dart.fnType(dart.void, [core.Object, core.Object]),
>+  [_delete$]: dart.fnType(indexed_db.Request, []),
>+  [_update]: dart.fnType(indexed_db.Request, [dart.dynamic]),
>+  [_update_1]: dart.fnType(indexed_db.Request, [dart.dynamic])
>+}));
>+dart.setLibraryUri(indexed_db.Cursor, "dart:indexed_db");
>+dart.setFieldSignature(indexed_db.Cursor, () => ({
>+  __proto__: dart.getFields(indexed_db.Cursor.__proto__),
>+  [$direction]: dart.finalFieldType(core.String),
>+  [$key]: dart.finalFieldType(core.Object),
>+  [$primaryKey]: dart.finalFieldType(core.Object),
>+  [$source]: dart.finalFieldType(core.Object)
>+}));
>+dart.registerExtension("IDBCursor", indexed_db.Cursor);
>+const _get_value = dart.privateName(indexed_db, "_get_value");
>+indexed_db.CursorWithValue = class CursorWithValue extends indexed_db.Cursor {
>+  get [$value]() {
>+    return indexed_db._convertNativeToDart_IDBAny(this[_get_value]);
>+  }
>+  get [_get_value]() {
>+    return this.value;
>+  }
>+};
>+dart.addTypeTests(indexed_db.CursorWithValue);
>+dart.setGetterSignature(indexed_db.CursorWithValue, () => ({
>+  __proto__: dart.getGetters(indexed_db.CursorWithValue.__proto__),
>+  [$value]: dart.dynamic
>+}));
>+dart.setLibraryUri(indexed_db.CursorWithValue, "dart:indexed_db");
>+dart.setFieldSignature(indexed_db.CursorWithValue, () => ({
>+  __proto__: dart.getFields(indexed_db.CursorWithValue.__proto__),
>+  [_get_value]: dart.finalFieldType(dart.dynamic)
>+}));
>+dart.registerExtension("IDBCursorWithValue", indexed_db.CursorWithValue);
>+const _createObjectStore = dart.privateName(indexed_db, "_createObjectStore");
>+const _transaction = dart.privateName(indexed_db, "_transaction");
>+const _createObjectStore_1 = dart.privateName(indexed_db, "_createObjectStore_1");
>+const _createObjectStore_2 = dart.privateName(indexed_db, "_createObjectStore_2");
>+const _addEventListener = dart.privateName(html$, "_addEventListener");
>+const _removeEventListener = dart.privateName(html$, "_removeEventListener");
>+html$.EventTarget = class EventTarget extends _interceptors.Interceptor {
>+  get [$on]() {
>+    return new html$.Events.new(this);
>+  }
>+  [$addEventListener](type, listener, useCapture) {
>+    if (useCapture === void 0) useCapture = null;
>+    if (listener != null) {
>+      this[_addEventListener](type, listener, useCapture);
>+    }
>+  }
>+  [$removeEventListener](type, listener, useCapture) {
>+    if (useCapture === void 0) useCapture = null;
>+    if (listener != null) {
>+      this[_removeEventListener](type, listener, useCapture);
>+    }
>+  }
>+  [_addEventListener](...args) {
>+    return this.addEventListener.apply(this, args);
>+  }
>+  [$dispatchEvent](...args) {
>+    return this.dispatchEvent.apply(this, args);
>+  }
>+  [_removeEventListener](...args) {
>+    return this.removeEventListener.apply(this, args);
>+  }
>+};
>+(html$.EventTarget._created = function() {
>+  html$.EventTarget.__proto__.new.call(this);
>+}).prototype = html$.EventTarget.prototype;
>+dart.addTypeTests(html$.EventTarget);
>+dart.setMethodSignature(html$.EventTarget, () => ({
>+  __proto__: dart.getMethods(html$.EventTarget.__proto__),
>+  [$addEventListener]: dart.fnType(dart.void, [core.String, dart.fnType(dart.dynamic, [html$.Event])], [core.bool]),
>+  [$removeEventListener]: dart.fnType(dart.void, [core.String, dart.fnType(dart.dynamic, [html$.Event])], [core.bool]),
>+  [_addEventListener]: dart.fnType(dart.void, [core.String, dart.fnType(dart.dynamic, [html$.Event])], [core.bool]),
>+  [$dispatchEvent]: dart.fnType(core.bool, [html$.Event]),
>+  [_removeEventListener]: dart.fnType(dart.void, [core.String, dart.fnType(dart.dynamic, [html$.Event])], [core.bool])
>+}));
>+dart.setGetterSignature(html$.EventTarget, () => ({
>+  __proto__: dart.getGetters(html$.EventTarget.__proto__),
>+  [$on]: html$.Events
>+}));
>+dart.setLibraryUri(html$.EventTarget, "dart:html");
>+dart.registerExtension("EventTarget", html$.EventTarget);
>+indexed_db.Database = class Database extends html$.EventTarget {
>+  [$createObjectStore](name, opts) {
>+    let keyPath = opts && 'keyPath' in opts ? opts.keyPath : null;
>+    let autoIncrement = opts && 'autoIncrement' in opts ? opts.autoIncrement : null;
>+    let options = new _js_helper.LinkedMap.new();
>+    if (keyPath != null) {
>+      options[$_set]("keyPath", keyPath);
>+    }
>+    if (autoIncrement != null) {
>+      options[$_set]("autoIncrement", autoIncrement);
>+    }
>+    return this[_createObjectStore](name, options);
>+  }
>+  [$transaction](storeName_OR_storeNames, mode) {
>+    if (mode !== "readonly" && mode !== "readwrite") {
>+      dart.throw(new core.ArgumentError.new(mode));
>+    }
>+    return this[_transaction](storeName_OR_storeNames, mode);
>+  }
>+  [$transactionStore](storeName, mode) {
>+    if (mode !== "readonly" && mode !== "readwrite") {
>+      dart.throw(new core.ArgumentError.new(mode));
>+    }
>+    return this[_transaction](storeName, mode);
>+  }
>+  [$transactionList](storeNames, mode) {
>+    if (mode !== "readonly" && mode !== "readwrite") {
>+      dart.throw(new core.ArgumentError.new(mode));
>+    }
>+    let storeNames_1 = html_common.convertDartToNative_StringArray(storeNames);
>+    return this[_transaction](storeNames_1, mode);
>+  }
>+  [$transactionStores](storeNames, mode) {
>+    if (mode !== "readonly" && mode !== "readwrite") {
>+      dart.throw(new core.ArgumentError.new(mode));
>+    }
>+    return this[_transaction](storeNames, mode);
>+  }
>+  [_transaction](...args) {
>+    return this.transaction.apply(this, args);
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+  get [$objectStoreNames]() {
>+    return this.objectStoreNames;
>+  }
>+  get [$version]() {
>+    return this.version;
>+  }
>+  [$close](...args) {
>+    return this.close.apply(this, args);
>+  }
>+  [_createObjectStore](name, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      return this[_createObjectStore_1](name, options_1);
>+    }
>+    return this[_createObjectStore_2](name);
>+  }
>+  [_createObjectStore_1](...args) {
>+    return this.createObjectStore.apply(this, args);
>+  }
>+  [_createObjectStore_2](...args) {
>+    return this.createObjectStore.apply(this, args);
>+  }
>+  [$deleteObjectStore](...args) {
>+    return this.deleteObjectStore.apply(this, args);
>+  }
>+  get [$onAbort]() {
>+    return indexed_db.Database.abortEvent.forTarget(this);
>+  }
>+  get [$onClose]() {
>+    return indexed_db.Database.closeEvent.forTarget(this);
>+  }
>+  get [$onError]() {
>+    return indexed_db.Database.errorEvent.forTarget(this);
>+  }
>+  get [$onVersionChange]() {
>+    return indexed_db.Database.versionChangeEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(indexed_db.Database);
>+const name = Symbol("Database.name");
>+const objectStoreNames = Symbol("Database.objectStoreNames");
>+const version$ = Symbol("Database.version");
>+dart.setMethodSignature(indexed_db.Database, () => ({
>+  __proto__: dart.getMethods(indexed_db.Database.__proto__),
>+  [$createObjectStore]: dart.fnType(indexed_db.ObjectStore, [core.String], {keyPath: dart.dynamic, autoIncrement: core.bool}),
>+  [$transaction]: dart.fnType(indexed_db.Transaction, [dart.dynamic, core.String]),
>+  [$transactionStore]: dart.fnType(indexed_db.Transaction, [core.String, core.String]),
>+  [$transactionList]: dart.fnType(indexed_db.Transaction, [core.List$(core.String), core.String]),
>+  [$transactionStores]: dart.fnType(indexed_db.Transaction, [html$.DomStringList, core.String]),
>+  [_transaction]: dart.fnType(indexed_db.Transaction, [dart.dynamic, dart.dynamic]),
>+  [$close]: dart.fnType(dart.void, []),
>+  [_createObjectStore]: dart.fnType(indexed_db.ObjectStore, [core.String], [core.Map]),
>+  [_createObjectStore_1]: dart.fnType(indexed_db.ObjectStore, [dart.dynamic, dart.dynamic]),
>+  [_createObjectStore_2]: dart.fnType(indexed_db.ObjectStore, [dart.dynamic]),
>+  [$deleteObjectStore]: dart.fnType(dart.void, [core.String])
>+}));
>+dart.setGetterSignature(indexed_db.Database, () => ({
>+  __proto__: dart.getGetters(indexed_db.Database.__proto__),
>+  [$onAbort]: async.Stream$(html$.Event),
>+  [$onClose]: async.Stream$(html$.Event),
>+  [$onError]: async.Stream$(html$.Event),
>+  [$onVersionChange]: async.Stream$(indexed_db.VersionChangeEvent)
>+}));
>+dart.setLibraryUri(indexed_db.Database, "dart:indexed_db");
>+dart.setFieldSignature(indexed_db.Database, () => ({
>+  __proto__: dart.getFields(indexed_db.Database.__proto__),
>+  [$name]: dart.finalFieldType(core.String),
>+  [$objectStoreNames]: dart.finalFieldType(ListOfString()),
>+  [$version]: dart.finalFieldType(core.int)
>+}));
>+dart.defineLazy(indexed_db.Database, {
>+  /*indexed_db.Database.abortEvent*/get abortEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("abort"));
>+  },
>+  /*indexed_db.Database.closeEvent*/get closeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("close"));
>+  },
>+  /*indexed_db.Database.errorEvent*/get errorEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("error"));
>+  },
>+  /*indexed_db.Database.versionChangeEvent*/get versionChangeEvent() {
>+    return dart.const(new (EventStreamProviderOfVersionChangeEvent()).new("versionchange"));
>+  }
>+});
>+dart.registerExtension("IDBDatabase", indexed_db.Database);
>+const _open = dart.privateName(indexed_db, "_open");
>+const _deleteDatabase = dart.privateName(indexed_db, "_deleteDatabase");
>+indexed_db.IdbFactory = class IdbFactory extends _interceptors.Interceptor {
>+  static get supported() {
>+    return !!(window.indexedDB || window.webkitIndexedDB || window.mozIndexedDB);
>+  }
>+  [$open](name, opts) {
>+    let version = opts && 'version' in opts ? opts.version : null;
>+    let onUpgradeNeeded = opts && 'onUpgradeNeeded' in opts ? opts.onUpgradeNeeded : null;
>+    let onBlocked = opts && 'onBlocked' in opts ? opts.onBlocked : null;
>+    if (version == null !== (onUpgradeNeeded == null)) {
>+      return FutureOfDatabase().error(new core.ArgumentError.new("version and onUpgradeNeeded must be specified together"));
>+    }
>+    try {
>+      let request = null;
>+      if (version != null) {
>+        request = this[_open](name, version);
>+      } else {
>+        request = this[_open](name);
>+      }
>+      if (onUpgradeNeeded != null) {
>+        dart.dsend(dart.dload(request, 'onUpgradeNeeded'), 'listen', [onUpgradeNeeded]);
>+      }
>+      if (onBlocked != null) {
>+        dart.dsend(dart.dload(request, 'onBlocked'), 'listen', [onBlocked]);
>+      }
>+      return indexed_db._completeRequest(indexed_db.Database, indexed_db.Request._check(request));
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      let stacktrace = dart.stackTrace(e$);
>+      return FutureOfDatabase().error(e, stacktrace);
>+    }
>+  }
>+  [$deleteDatabase](name, opts) {
>+    let onBlocked = opts && 'onBlocked' in opts ? opts.onBlocked : null;
>+    try {
>+      let request = this[_deleteDatabase](name);
>+      if (onBlocked != null) {
>+        request[$onBlocked].listen(onBlocked);
>+      }
>+      let completer = CompleterOfIdbFactory().sync();
>+      request[$onSuccess].listen(dart.fn(e => {
>+        completer.complete(this);
>+      }, EventToNull()));
>+      request[$onError].listen(dart.bind(completer, 'completeError'));
>+      return completer.future;
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      let stacktrace = dart.stackTrace(e$);
>+      return FutureOfIdbFactory().error(e, stacktrace);
>+    }
>+  }
>+  get [$supportsDatabaseNames]() {
>+    return dart.test(indexed_db.IdbFactory.supported) && !!(this.getDatabaseNames || this.webkitGetDatabaseNames);
>+  }
>+  [$cmp](...args) {
>+    return this.cmp.apply(this, args);
>+  }
>+  [_deleteDatabase](...args) {
>+    return this.deleteDatabase.apply(this, args);
>+  }
>+  [_open](...args) {
>+    return this.open.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(indexed_db.IdbFactory);
>+dart.setMethodSignature(indexed_db.IdbFactory, () => ({
>+  __proto__: dart.getMethods(indexed_db.IdbFactory.__proto__),
>+  [$open]: dart.fnType(async.Future$(indexed_db.Database), [core.String], {version: core.int, onUpgradeNeeded: dart.fnType(dart.void, [indexed_db.VersionChangeEvent]), onBlocked: dart.fnType(dart.void, [html$.Event])}),
>+  [$deleteDatabase]: dart.fnType(async.Future$(indexed_db.IdbFactory), [core.String], {onBlocked: dart.fnType(dart.void, [html$.Event])}),
>+  [$cmp]: dart.fnType(core.int, [core.Object, core.Object]),
>+  [_deleteDatabase]: dart.fnType(indexed_db.OpenDBRequest, [core.String]),
>+  [_open]: dart.fnType(indexed_db.OpenDBRequest, [core.String], [core.int])
>+}));
>+dart.setGetterSignature(indexed_db.IdbFactory, () => ({
>+  __proto__: dart.getGetters(indexed_db.IdbFactory.__proto__),
>+  [$supportsDatabaseNames]: core.bool
>+}));
>+dart.setLibraryUri(indexed_db.IdbFactory, "dart:indexed_db");
>+dart.registerExtension("IDBFactory", indexed_db.IdbFactory);
>+indexed_db._completeRequest = function(T, request) {
>+  let completer = async.Completer$(T).sync();
>+  request[$onSuccess].listen(dart.fn(e => {
>+    let result = T._check(request[$result]);
>+    completer.complete(result);
>+  }, EventToNull()));
>+  request[$onError].listen(dart.bind(completer, 'completeError'));
>+  return completer.future;
>+};
>+const _count$0 = dart.privateName(indexed_db, "_count");
>+const _get = dart.privateName(indexed_db, "_get");
>+const _getKey$ = dart.privateName(indexed_db, "_getKey");
>+const _openCursor = dart.privateName(indexed_db, "_openCursor");
>+const _openKeyCursor = dart.privateName(indexed_db, "_openKeyCursor");
>+indexed_db.Index = class Index extends _interceptors.Interceptor {
>+  [$count](key_OR_range) {
>+    if (key_OR_range === void 0) key_OR_range = null;
>+    try {
>+      let request = this[_count$0](key_OR_range);
>+      return indexed_db._completeRequest(core.int, request);
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      let stacktrace = dart.stackTrace(e$);
>+      return FutureOfint().error(e, stacktrace);
>+    }
>+  }
>+  [$get](key) {
>+    try {
>+      let request = this[_get](key);
>+      return indexed_db._completeRequest(dart.dynamic, request);
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      let stacktrace = dart.stackTrace(e$);
>+      return async.Future.error(e, stacktrace);
>+    }
>+  }
>+  [$getKey](key) {
>+    try {
>+      let request = this[_getKey$](key);
>+      return indexed_db._completeRequest(dart.dynamic, request);
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      let stacktrace = dart.stackTrace(e$);
>+      return async.Future.error(e, stacktrace);
>+    }
>+  }
>+  [$openCursor](opts) {
>+    let key = opts && 'key' in opts ? opts.key : null;
>+    let range = opts && 'range' in opts ? opts.range : null;
>+    let direction = opts && 'direction' in opts ? opts.direction : null;
>+    let autoAdvance = opts && 'autoAdvance' in opts ? opts.autoAdvance : null;
>+    let key_OR_range = null;
>+    if (key != null) {
>+      if (range != null) {
>+        dart.throw(new core.ArgumentError.new("Cannot specify both key and range."));
>+      }
>+      key_OR_range = key;
>+    } else {
>+      key_OR_range = range;
>+    }
>+    let request = null;
>+    if (direction == null) {
>+      request = this[_openCursor](key_OR_range, "next");
>+    } else {
>+      request = this[_openCursor](key_OR_range, direction);
>+    }
>+    return indexed_db.ObjectStore._cursorStreamFromResult(indexed_db.CursorWithValue, indexed_db.Request._check(request), autoAdvance);
>+  }
>+  [$openKeyCursor](opts) {
>+    let key = opts && 'key' in opts ? opts.key : null;
>+    let range = opts && 'range' in opts ? opts.range : null;
>+    let direction = opts && 'direction' in opts ? opts.direction : null;
>+    let autoAdvance = opts && 'autoAdvance' in opts ? opts.autoAdvance : null;
>+    let key_OR_range = null;
>+    if (key != null) {
>+      if (range != null) {
>+        dart.throw(new core.ArgumentError.new("Cannot specify both key and range."));
>+      }
>+      key_OR_range = key;
>+    } else {
>+      key_OR_range = range;
>+    }
>+    let request = null;
>+    if (direction == null) {
>+      request = this[_openKeyCursor](key_OR_range, "next");
>+    } else {
>+      request = this[_openKeyCursor](key_OR_range, direction);
>+    }
>+    return indexed_db.ObjectStore._cursorStreamFromResult(indexed_db.Cursor, indexed_db.Request._check(request), autoAdvance);
>+  }
>+  get [$keyPath]() {
>+    return this.keyPath;
>+  }
>+  get [$multiEntry]() {
>+    return this.multiEntry;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+  set [$name](value) {
>+    this.name = value;
>+  }
>+  get [$objectStore]() {
>+    return this.objectStore;
>+  }
>+  get [$unique]() {
>+    return this.unique;
>+  }
>+  [_count$0](...args) {
>+    return this.count.apply(this, args);
>+  }
>+  [_get](...args) {
>+    return this.get.apply(this, args);
>+  }
>+  [$getAll](...args) {
>+    return this.getAll.apply(this, args);
>+  }
>+  [$getAllKeys](...args) {
>+    return this.getAllKeys.apply(this, args);
>+  }
>+  [_getKey$](...args) {
>+    return this.getKey.apply(this, args);
>+  }
>+  [_openCursor](...args) {
>+    return this.openCursor.apply(this, args);
>+  }
>+  [_openKeyCursor](...args) {
>+    return this.openKeyCursor.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(indexed_db.Index);
>+const keyPath = Symbol("Index.keyPath");
>+const multiEntry = Symbol("Index.multiEntry");
>+const name$4 = Symbol("Index.name");
>+const objectStore = Symbol("Index.objectStore");
>+const unique = Symbol("Index.unique");
>+dart.setMethodSignature(indexed_db.Index, () => ({
>+  __proto__: dart.getMethods(indexed_db.Index.__proto__),
>+  [$count]: dart.fnType(async.Future$(core.int), [], [dart.dynamic]),
>+  [$get]: dart.fnType(async.Future, [dart.dynamic]),
>+  [$getKey]: dart.fnType(async.Future, [dart.dynamic]),
>+  [$openCursor]: dart.fnType(async.Stream$(indexed_db.CursorWithValue), [], {key: dart.dynamic, range: indexed_db.KeyRange, direction: core.String, autoAdvance: core.bool}),
>+  [$openKeyCursor]: dart.fnType(async.Stream$(indexed_db.Cursor), [], {key: dart.dynamic, range: indexed_db.KeyRange, direction: core.String, autoAdvance: core.bool}),
>+  [_count$0]: dart.fnType(indexed_db.Request, [core.Object]),
>+  [_get]: dart.fnType(indexed_db.Request, [core.Object]),
>+  [$getAll]: dart.fnType(indexed_db.Request, [core.Object], [core.int]),
>+  [$getAllKeys]: dart.fnType(indexed_db.Request, [core.Object], [core.int]),
>+  [_getKey$]: dart.fnType(indexed_db.Request, [core.Object]),
>+  [_openCursor]: dart.fnType(indexed_db.Request, [core.Object], [core.String]),
>+  [_openKeyCursor]: dart.fnType(indexed_db.Request, [core.Object], [core.String])
>+}));
>+dart.setLibraryUri(indexed_db.Index, "dart:indexed_db");
>+dart.setFieldSignature(indexed_db.Index, () => ({
>+  __proto__: dart.getFields(indexed_db.Index.__proto__),
>+  [$keyPath]: dart.finalFieldType(core.Object),
>+  [$multiEntry]: dart.finalFieldType(core.bool),
>+  [$name]: dart.fieldType(core.String),
>+  [$objectStore]: dart.finalFieldType(indexed_db.ObjectStore),
>+  [$unique]: dart.finalFieldType(core.bool)
>+}));
>+dart.registerExtension("IDBIndex", indexed_db.Index);
>+indexed_db.KeyRange = class KeyRange extends _interceptors.Interceptor {
>+  static only(value) {
>+    return indexed_db._KeyRangeFactoryProvider.createKeyRange_only(value);
>+  }
>+  static lowerBound(bound, open) {
>+    if (open === void 0) open = false;
>+    return indexed_db._KeyRangeFactoryProvider.createKeyRange_lowerBound(bound, open);
>+  }
>+  static upperBound(bound, open) {
>+    if (open === void 0) open = false;
>+    return indexed_db._KeyRangeFactoryProvider.createKeyRange_upperBound(bound, open);
>+  }
>+  static bound(lower, upper, lowerOpen, upperOpen) {
>+    if (lowerOpen === void 0) lowerOpen = false;
>+    if (upperOpen === void 0) upperOpen = false;
>+    return indexed_db._KeyRangeFactoryProvider.createKeyRange_bound(lower, upper, lowerOpen, upperOpen);
>+  }
>+  get [$lower]() {
>+    return this.lower;
>+  }
>+  get [$lowerOpen]() {
>+    return this.lowerOpen;
>+  }
>+  get [$upper]() {
>+    return this.upper;
>+  }
>+  get [$upperOpen]() {
>+    return this.upperOpen;
>+  }
>+  [$includes](...args) {
>+    return this.includes.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(indexed_db.KeyRange);
>+const lower = Symbol("KeyRange.lower");
>+const lowerOpen = Symbol("KeyRange.lowerOpen");
>+const upper = Symbol("KeyRange.upper");
>+const upperOpen = Symbol("KeyRange.upperOpen");
>+dart.setMethodSignature(indexed_db.KeyRange, () => ({
>+  __proto__: dart.getMethods(indexed_db.KeyRange.__proto__),
>+  [$includes]: dart.fnType(core.bool, [core.Object])
>+}));
>+dart.setLibraryUri(indexed_db.KeyRange, "dart:indexed_db");
>+dart.setFieldSignature(indexed_db.KeyRange, () => ({
>+  __proto__: dart.getFields(indexed_db.KeyRange.__proto__),
>+  [$lower]: dart.finalFieldType(core.Object),
>+  [$lowerOpen]: dart.finalFieldType(core.bool),
>+  [$upper]: dart.finalFieldType(core.Object),
>+  [$upperOpen]: dart.finalFieldType(core.bool)
>+}));
>+dart.registerExtension("IDBKeyRange", indexed_db.KeyRange);
>+const _add$1 = dart.privateName(indexed_db, "_add");
>+const _clear$ = dart.privateName(indexed_db, "_clear");
>+const _put = dart.privateName(indexed_db, "_put");
>+const _createIndex = dart.privateName(indexed_db, "_createIndex");
>+const _add_1 = dart.privateName(indexed_db, "_add_1");
>+const _add_2 = dart.privateName(indexed_db, "_add_2");
>+const _createIndex_1 = dart.privateName(indexed_db, "_createIndex_1");
>+const _createIndex_2 = dart.privateName(indexed_db, "_createIndex_2");
>+const _put_1 = dart.privateName(indexed_db, "_put_1");
>+const _put_2 = dart.privateName(indexed_db, "_put_2");
>+indexed_db.ObjectStore = class ObjectStore extends _interceptors.Interceptor {
>+  [$add](value, key) {
>+    if (key === void 0) key = null;
>+    try {
>+      let request = null;
>+      if (key != null) {
>+        request = this[_add$1](value, key);
>+      } else {
>+        request = this[_add$1](value);
>+      }
>+      return indexed_db._completeRequest(dart.dynamic, indexed_db.Request._check(request));
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      let stacktrace = dart.stackTrace(e$);
>+      return async.Future.error(e, stacktrace);
>+    }
>+  }
>+  [$clear]() {
>+    try {
>+      return indexed_db._completeRequest(dart.dynamic, this[_clear$]());
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      let stacktrace = dart.stackTrace(e$);
>+      return async.Future.error(e, stacktrace);
>+    }
>+  }
>+  [$delete](key_OR_keyRange) {
>+    try {
>+      return indexed_db._completeRequest(dart.dynamic, this[_delete$](key_OR_keyRange));
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      let stacktrace = dart.stackTrace(e$);
>+      return async.Future.error(e, stacktrace);
>+    }
>+  }
>+  [$count](key_OR_range) {
>+    if (key_OR_range === void 0) key_OR_range = null;
>+    try {
>+      let request = this[_count$0](key_OR_range);
>+      return indexed_db._completeRequest(core.int, request);
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      let stacktrace = dart.stackTrace(e$);
>+      return FutureOfint().error(e, stacktrace);
>+    }
>+  }
>+  [$put](value, key) {
>+    if (key === void 0) key = null;
>+    try {
>+      let request = null;
>+      if (key != null) {
>+        request = this[_put](value, key);
>+      } else {
>+        request = this[_put](value);
>+      }
>+      return indexed_db._completeRequest(dart.dynamic, indexed_db.Request._check(request));
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      let stacktrace = dart.stackTrace(e$);
>+      return async.Future.error(e, stacktrace);
>+    }
>+  }
>+  [$getObject](key) {
>+    try {
>+      let request = this[_get](key);
>+      return indexed_db._completeRequest(dart.dynamic, request);
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      let stacktrace = dart.stackTrace(e$);
>+      return async.Future.error(e, stacktrace);
>+    }
>+  }
>+  [$openCursor](opts) {
>+    let key = opts && 'key' in opts ? opts.key : null;
>+    let range = opts && 'range' in opts ? opts.range : null;
>+    let direction = opts && 'direction' in opts ? opts.direction : null;
>+    let autoAdvance = opts && 'autoAdvance' in opts ? opts.autoAdvance : null;
>+    let key_OR_range = null;
>+    if (key != null) {
>+      if (range != null) {
>+        dart.throw(new core.ArgumentError.new("Cannot specify both key and range."));
>+      }
>+      key_OR_range = key;
>+    } else {
>+      key_OR_range = range;
>+    }
>+    let request = null;
>+    if (direction == null) {
>+      request = this[_openCursor](key_OR_range);
>+    } else {
>+      request = this[_openCursor](key_OR_range, direction);
>+    }
>+    return indexed_db.ObjectStore._cursorStreamFromResult(indexed_db.CursorWithValue, indexed_db.Request._check(request), autoAdvance);
>+  }
>+  [$createIndex](name, keyPath, opts) {
>+    let unique = opts && 'unique' in opts ? opts.unique : null;
>+    let multiEntry = opts && 'multiEntry' in opts ? opts.multiEntry : null;
>+    let options = new _js_helper.LinkedMap.new();
>+    if (unique != null) {
>+      options[$_set]("unique", unique);
>+    }
>+    if (multiEntry != null) {
>+      options[$_set]("multiEntry", multiEntry);
>+    }
>+    return this[_createIndex](name, keyPath, options);
>+  }
>+  get [$autoIncrement]() {
>+    return this.autoIncrement;
>+  }
>+  get [$indexNames]() {
>+    return this.indexNames;
>+  }
>+  get [$keyPath]() {
>+    return this.keyPath;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+  set [$name](value) {
>+    this.name = value;
>+  }
>+  get [$transaction]() {
>+    return this.transaction;
>+  }
>+  [_add$1](value, key) {
>+    if (key === void 0) key = null;
>+    if (key != null) {
>+      let value_1 = html_common.convertDartToNative_SerializedScriptValue(value);
>+      let key_2 = html_common.convertDartToNative_SerializedScriptValue(key);
>+      return this[_add_1](value_1, key_2);
>+    }
>+    let value_1 = html_common.convertDartToNative_SerializedScriptValue(value);
>+    return this[_add_2](value_1);
>+  }
>+  [_add_1](...args) {
>+    return this.add.apply(this, args);
>+  }
>+  [_add_2](...args) {
>+    return this.add.apply(this, args);
>+  }
>+  [_clear$](...args) {
>+    return this.clear.apply(this, args);
>+  }
>+  [_count$0](...args) {
>+    return this.count.apply(this, args);
>+  }
>+  [_createIndex](name, keyPath, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      return this[_createIndex_1](name, keyPath, options_1);
>+    }
>+    return this[_createIndex_2](name, keyPath);
>+  }
>+  [_createIndex_1](...args) {
>+    return this.createIndex.apply(this, args);
>+  }
>+  [_createIndex_2](...args) {
>+    return this.createIndex.apply(this, args);
>+  }
>+  [_delete$](...args) {
>+    return this.delete.apply(this, args);
>+  }
>+  [$deleteIndex](...args) {
>+    return this.deleteIndex.apply(this, args);
>+  }
>+  [_get](...args) {
>+    return this.get.apply(this, args);
>+  }
>+  [$getAll](...args) {
>+    return this.getAll.apply(this, args);
>+  }
>+  [$getAllKeys](...args) {
>+    return this.getAllKeys.apply(this, args);
>+  }
>+  [$getKey](...args) {
>+    return this.getKey.apply(this, args);
>+  }
>+  [$index](...args) {
>+    return this.index.apply(this, args);
>+  }
>+  [_openCursor](...args) {
>+    return this.openCursor.apply(this, args);
>+  }
>+  [$openKeyCursor](...args) {
>+    return this.openKeyCursor.apply(this, args);
>+  }
>+  [_put](value, key) {
>+    if (key === void 0) key = null;
>+    if (key != null) {
>+      let value_1 = html_common.convertDartToNative_SerializedScriptValue(value);
>+      let key_2 = html_common.convertDartToNative_SerializedScriptValue(key);
>+      return this[_put_1](value_1, key_2);
>+    }
>+    let value_1 = html_common.convertDartToNative_SerializedScriptValue(value);
>+    return this[_put_2](value_1);
>+  }
>+  [_put_1](...args) {
>+    return this.put.apply(this, args);
>+  }
>+  [_put_2](...args) {
>+    return this.put.apply(this, args);
>+  }
>+  static _cursorStreamFromResult(T, request, autoAdvance) {
>+    let controller = async.StreamController$(T).new({sync: true});
>+    request[$onError].listen(dart.bind(controller, 'addError'));
>+    request[$onSuccess].listen(dart.fn(e => {
>+      let cursor = T._check(request[$result]);
>+      if (cursor == null) {
>+        controller.close();
>+      } else {
>+        controller.add(cursor);
>+        if (autoAdvance === true && dart.test(controller.hasListener)) {
>+          cursor[$next]();
>+        }
>+      }
>+    }, EventToNull()));
>+    return controller.stream;
>+  }
>+};
>+dart.addTypeTests(indexed_db.ObjectStore);
>+const autoIncrement = Symbol("ObjectStore.autoIncrement");
>+const indexNames = Symbol("ObjectStore.indexNames");
>+const keyPath$ = Symbol("ObjectStore.keyPath");
>+const name$5 = Symbol("ObjectStore.name");
>+const transaction = Symbol("ObjectStore.transaction");
>+dart.setMethodSignature(indexed_db.ObjectStore, () => ({
>+  __proto__: dart.getMethods(indexed_db.ObjectStore.__proto__),
>+  [$add]: dart.fnType(async.Future, [dart.dynamic], [dart.dynamic]),
>+  [$clear]: dart.fnType(async.Future, []),
>+  [$delete]: dart.fnType(async.Future, [dart.dynamic]),
>+  [$count]: dart.fnType(async.Future$(core.int), [], [dart.dynamic]),
>+  [$put]: dart.fnType(async.Future, [dart.dynamic], [dart.dynamic]),
>+  [$getObject]: dart.fnType(async.Future, [dart.dynamic]),
>+  [$openCursor]: dart.fnType(async.Stream$(indexed_db.CursorWithValue), [], {key: dart.dynamic, range: indexed_db.KeyRange, direction: core.String, autoAdvance: core.bool}),
>+  [$createIndex]: dart.fnType(indexed_db.Index, [core.String, dart.dynamic], {unique: core.bool, multiEntry: core.bool}),
>+  [_add$1]: dart.fnType(indexed_db.Request, [dart.dynamic], [dart.dynamic]),
>+  [_add_1]: dart.fnType(indexed_db.Request, [dart.dynamic, dart.dynamic]),
>+  [_add_2]: dart.fnType(indexed_db.Request, [dart.dynamic]),
>+  [_clear$]: dart.fnType(indexed_db.Request, []),
>+  [_count$0]: dart.fnType(indexed_db.Request, [core.Object]),
>+  [_createIndex]: dart.fnType(indexed_db.Index, [core.String, core.Object], [core.Map]),
>+  [_createIndex_1]: dart.fnType(indexed_db.Index, [dart.dynamic, dart.dynamic, dart.dynamic]),
>+  [_createIndex_2]: dart.fnType(indexed_db.Index, [dart.dynamic, dart.dynamic]),
>+  [_delete$]: dart.fnType(indexed_db.Request, [core.Object]),
>+  [$deleteIndex]: dart.fnType(dart.void, [core.String]),
>+  [_get]: dart.fnType(indexed_db.Request, [core.Object]),
>+  [$getAll]: dart.fnType(indexed_db.Request, [core.Object], [core.int]),
>+  [$getAllKeys]: dart.fnType(indexed_db.Request, [core.Object], [core.int]),
>+  [$getKey]: dart.fnType(indexed_db.Request, [core.Object]),
>+  [$index]: dart.fnType(indexed_db.Index, [core.String]),
>+  [_openCursor]: dart.fnType(indexed_db.Request, [core.Object], [core.String]),
>+  [$openKeyCursor]: dart.fnType(indexed_db.Request, [core.Object], [core.String]),
>+  [_put]: dart.fnType(indexed_db.Request, [dart.dynamic], [dart.dynamic]),
>+  [_put_1]: dart.fnType(indexed_db.Request, [dart.dynamic, dart.dynamic]),
>+  [_put_2]: dart.fnType(indexed_db.Request, [dart.dynamic])
>+}));
>+dart.setLibraryUri(indexed_db.ObjectStore, "dart:indexed_db");
>+dart.setFieldSignature(indexed_db.ObjectStore, () => ({
>+  __proto__: dart.getFields(indexed_db.ObjectStore.__proto__),
>+  [$autoIncrement]: dart.finalFieldType(core.bool),
>+  [$indexNames]: dart.finalFieldType(ListOfString()),
>+  [$keyPath]: dart.finalFieldType(core.Object),
>+  [$name]: dart.fieldType(core.String),
>+  [$transaction]: dart.finalFieldType(indexed_db.Transaction)
>+}));
>+dart.registerExtension("IDBObjectStore", indexed_db.ObjectStore);
>+indexed_db.Observation = class Observation extends _interceptors.Interceptor {
>+  get [$key]() {
>+    return this.key;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  get [$value]() {
>+    return this.value;
>+  }
>+};
>+dart.addTypeTests(indexed_db.Observation);
>+const key$ = Symbol("Observation.key");
>+const type = Symbol("Observation.type");
>+const value = Symbol("Observation.value");
>+dart.setLibraryUri(indexed_db.Observation, "dart:indexed_db");
>+dart.setFieldSignature(indexed_db.Observation, () => ({
>+  __proto__: dart.getFields(indexed_db.Observation.__proto__),
>+  [$key]: dart.finalFieldType(core.Object),
>+  [$type]: dart.finalFieldType(core.String),
>+  [$value]: dart.finalFieldType(core.Object)
>+}));
>+dart.registerExtension("IDBObservation", indexed_db.Observation);
>+const _observe_1 = dart.privateName(indexed_db, "_observe_1");
>+indexed_db.Observer = class Observer extends _interceptors.Interceptor {
>+  static new(callback) {
>+    let callback_1 = _js_helper.convertDartClosureToJS(ObserverChangesTovoid(), callback, 1);
>+    return indexed_db.Observer._create_1(callback_1);
>+  }
>+  static _create_1(callback) {
>+    return new IDBObserver(callback);
>+  }
>+  [$observe](db, tx, options) {
>+    let options_1 = html_common.convertDartToNative_Dictionary(options);
>+    this[_observe_1](db, tx, options_1);
>+    return;
>+  }
>+  [_observe_1](...args) {
>+    return this.observe.apply(this, args);
>+  }
>+  [$unobserve](...args) {
>+    return this.unobserve.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(indexed_db.Observer);
>+dart.setMethodSignature(indexed_db.Observer, () => ({
>+  __proto__: dart.getMethods(indexed_db.Observer.__proto__),
>+  [$observe]: dart.fnType(dart.void, [indexed_db.Database, indexed_db.Transaction, core.Map]),
>+  [_observe_1]: dart.fnType(dart.void, [indexed_db.Database, indexed_db.Transaction, dart.dynamic]),
>+  [$unobserve]: dart.fnType(dart.void, [indexed_db.Database])
>+}));
>+dart.setLibraryUri(indexed_db.Observer, "dart:indexed_db");
>+dart.registerExtension("IDBObserver", indexed_db.Observer);
>+indexed_db.ObserverChanges = class ObserverChanges extends _interceptors.Interceptor {
>+  get [$database]() {
>+    return this.database;
>+  }
>+  get [$records]() {
>+    return this.records;
>+  }
>+  get [$transaction]() {
>+    return this.transaction;
>+  }
>+};
>+dart.addTypeTests(indexed_db.ObserverChanges);
>+const database = Symbol("ObserverChanges.database");
>+const records = Symbol("ObserverChanges.records");
>+const transaction$ = Symbol("ObserverChanges.transaction");
>+dart.setLibraryUri(indexed_db.ObserverChanges, "dart:indexed_db");
>+dart.setFieldSignature(indexed_db.ObserverChanges, () => ({
>+  __proto__: dart.getFields(indexed_db.ObserverChanges.__proto__),
>+  [$database]: dart.finalFieldType(indexed_db.Database),
>+  [$records]: dart.finalFieldType(core.Object),
>+  [$transaction]: dart.finalFieldType(indexed_db.Transaction)
>+}));
>+dart.registerExtension("IDBObserverChanges", indexed_db.ObserverChanges);
>+const _get_result = dart.privateName(indexed_db, "_get_result");
>+indexed_db.Request = class Request extends html$.EventTarget {
>+  get [$error]() {
>+    return this.error;
>+  }
>+  get [$readyState]() {
>+    return this.readyState;
>+  }
>+  get [$result]() {
>+    return indexed_db._convertNativeToDart_IDBAny(this[_get_result]);
>+  }
>+  get [_get_result]() {
>+    return this.result;
>+  }
>+  get [$source]() {
>+    return this.source;
>+  }
>+  get [$transaction]() {
>+    return this.transaction;
>+  }
>+  get [$onError]() {
>+    return indexed_db.Request.errorEvent.forTarget(this);
>+  }
>+  get [$onSuccess]() {
>+    return indexed_db.Request.successEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(indexed_db.Request);
>+const error = Symbol("Request.error");
>+const readyState = Symbol("Request.readyState");
>+const source$0 = Symbol("Request.source");
>+const transaction$0 = Symbol("Request.transaction");
>+dart.setGetterSignature(indexed_db.Request, () => ({
>+  __proto__: dart.getGetters(indexed_db.Request.__proto__),
>+  [$result]: dart.dynamic,
>+  [$onError]: async.Stream$(html$.Event),
>+  [$onSuccess]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(indexed_db.Request, "dart:indexed_db");
>+dart.setFieldSignature(indexed_db.Request, () => ({
>+  __proto__: dart.getFields(indexed_db.Request.__proto__),
>+  [$error]: dart.finalFieldType(html$.DomException),
>+  [$readyState]: dart.finalFieldType(core.String),
>+  [_get_result]: dart.finalFieldType(dart.dynamic),
>+  [$source]: dart.finalFieldType(core.Object),
>+  [$transaction]: dart.finalFieldType(indexed_db.Transaction)
>+}));
>+dart.defineLazy(indexed_db.Request, {
>+  /*indexed_db.Request.errorEvent*/get errorEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("error"));
>+  },
>+  /*indexed_db.Request.successEvent*/get successEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("success"));
>+  }
>+});
>+dart.registerExtension("IDBRequest", indexed_db.Request);
>+indexed_db.OpenDBRequest = class OpenDBRequest extends indexed_db.Request {
>+  get [$onBlocked]() {
>+    return indexed_db.OpenDBRequest.blockedEvent.forTarget(this);
>+  }
>+  get [$onUpgradeNeeded]() {
>+    return indexed_db.OpenDBRequest.upgradeNeededEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(indexed_db.OpenDBRequest);
>+dart.setGetterSignature(indexed_db.OpenDBRequest, () => ({
>+  __proto__: dart.getGetters(indexed_db.OpenDBRequest.__proto__),
>+  [$onBlocked]: async.Stream$(html$.Event),
>+  [$onUpgradeNeeded]: async.Stream$(indexed_db.VersionChangeEvent)
>+}));
>+dart.setLibraryUri(indexed_db.OpenDBRequest, "dart:indexed_db");
>+dart.defineLazy(indexed_db.OpenDBRequest, {
>+  /*indexed_db.OpenDBRequest.blockedEvent*/get blockedEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("blocked"));
>+  },
>+  /*indexed_db.OpenDBRequest.upgradeNeededEvent*/get upgradeNeededEvent() {
>+    return dart.const(new (EventStreamProviderOfVersionChangeEvent()).new("upgradeneeded"));
>+  }
>+});
>+dart.registerExtension("IDBOpenDBRequest", indexed_db.OpenDBRequest);
>+dart.registerExtension("IDBVersionChangeRequest", indexed_db.OpenDBRequest);
>+indexed_db.Transaction = class Transaction extends html$.EventTarget {
>+  get [$completed]() {
>+    let completer = CompleterOfDatabase().new();
>+    FutureOfNull()._check(this[$onComplete].first.then(core.Null, dart.fn(_ => {
>+      completer.complete(this.db);
>+    }, EventToNull())));
>+    FutureOfNull()._check(this[$onError].first.then(core.Null, dart.fn(e => {
>+      completer.completeError(e);
>+    }, EventToNull())));
>+    FutureOfNull()._check(this[$onAbort].first.then(core.Null, dart.fn(e => {
>+      if (!dart.test(completer.isCompleted)) {
>+        completer.completeError(e);
>+      }
>+    }, EventToNull())));
>+    return completer.future;
>+  }
>+  get [$db]() {
>+    return this.db;
>+  }
>+  get [$error]() {
>+    return this.error;
>+  }
>+  get [$mode]() {
>+    return this.mode;
>+  }
>+  get [$objectStoreNames]() {
>+    return this.objectStoreNames;
>+  }
>+  [$abort](...args) {
>+    return this.abort.apply(this, args);
>+  }
>+  [$objectStore](...args) {
>+    return this.objectStore.apply(this, args);
>+  }
>+  get [$onAbort]() {
>+    return indexed_db.Transaction.abortEvent.forTarget(this);
>+  }
>+  get [$onComplete]() {
>+    return indexed_db.Transaction.completeEvent.forTarget(this);
>+  }
>+  get [$onError]() {
>+    return indexed_db.Transaction.errorEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(indexed_db.Transaction);
>+const db = Symbol("Transaction.db");
>+const error$0 = Symbol("Transaction.error");
>+const mode = Symbol("Transaction.mode");
>+const objectStoreNames$ = Symbol("Transaction.objectStoreNames");
>+dart.setMethodSignature(indexed_db.Transaction, () => ({
>+  __proto__: dart.getMethods(indexed_db.Transaction.__proto__),
>+  [$abort]: dart.fnType(dart.void, []),
>+  [$objectStore]: dart.fnType(indexed_db.ObjectStore, [core.String])
>+}));
>+dart.setGetterSignature(indexed_db.Transaction, () => ({
>+  __proto__: dart.getGetters(indexed_db.Transaction.__proto__),
>+  [$completed]: async.Future$(indexed_db.Database),
>+  [$onAbort]: async.Stream$(html$.Event),
>+  [$onComplete]: async.Stream$(html$.Event),
>+  [$onError]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(indexed_db.Transaction, "dart:indexed_db");
>+dart.setFieldSignature(indexed_db.Transaction, () => ({
>+  __proto__: dart.getFields(indexed_db.Transaction.__proto__),
>+  [$db]: dart.finalFieldType(indexed_db.Database),
>+  [$error]: dart.finalFieldType(html$.DomException),
>+  [$mode]: dart.finalFieldType(core.String),
>+  [$objectStoreNames]: dart.finalFieldType(ListOfString())
>+}));
>+dart.defineLazy(indexed_db.Transaction, {
>+  /*indexed_db.Transaction.abortEvent*/get abortEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("abort"));
>+  },
>+  /*indexed_db.Transaction.completeEvent*/get completeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("complete"));
>+  },
>+  /*indexed_db.Transaction.errorEvent*/get errorEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("error"));
>+  }
>+});
>+dart.registerExtension("IDBTransaction", indexed_db.Transaction);
>+const _createEvent = dart.privateName(html$, "_createEvent");
>+const _initEvent = dart.privateName(html$, "_initEvent");
>+const _selector = dart.privateName(html$, "_selector");
>+const _get_currentTarget = dart.privateName(html$, "_get_currentTarget");
>+const _get_target = dart.privateName(html$, "_get_target");
>+html$.Event = class Event$ extends _interceptors.Interceptor {
>+  static new(type, opts) {
>+    let canBubble = opts && 'canBubble' in opts ? opts.canBubble : true;
>+    let cancelable = opts && 'cancelable' in opts ? opts.cancelable : true;
>+    return html$.Event.eventType("Event", type, {canBubble: canBubble, cancelable: cancelable});
>+  }
>+  static eventType(type, name, opts) {
>+    let canBubble = opts && 'canBubble' in opts ? opts.canBubble : true;
>+    let cancelable = opts && 'cancelable' in opts ? opts.cancelable : true;
>+    let e = html$.document[_createEvent](type);
>+    e[_initEvent](name, canBubble, cancelable);
>+    return e;
>+  }
>+  get [_selector]() {
>+    return this._selector;
>+  }
>+  set [_selector](value) {
>+    this._selector = value;
>+  }
>+  get [$matchingTarget]() {
>+    if (this[_selector] == null) {
>+      dart.throw(new core.UnsupportedError.new("Cannot call matchingTarget if this Event did" + " not arise as a result of event delegation."));
>+    }
>+    let currentTarget = html$.Element._check(this[$currentTarget]);
>+    let target = html$.Element._check(this[$target]);
>+    let matchedTarget = null;
>+    do {
>+      if (dart.test(target[$matches](this[_selector]))) return target;
>+      target = target[$parent];
>+    } while (target != null && !dart.equals(target, currentTarget[$parent]));
>+    dart.throw(new core.StateError.new("No selector matched for populating matchedTarget."));
>+  }
>+  get [$path]() {
>+    return !!this.composedPath ? this.composedPath() : JSArrayOfEventTarget().of([]);
>+  }
>+  static __(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.Event._create_1(type, eventInitDict_1);
>+    }
>+    return html$.Event._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new Event(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new Event(type);
>+  }
>+  get [$bubbles]() {
>+    return this.bubbles;
>+  }
>+  get [$cancelable]() {
>+    return this.cancelable;
>+  }
>+  get [$composed]() {
>+    return this.composed;
>+  }
>+  get [$currentTarget]() {
>+    return html$._convertNativeToDart_EventTarget(this[_get_currentTarget]);
>+  }
>+  get [_get_currentTarget]() {
>+    return this.currentTarget;
>+  }
>+  get [$defaultPrevented]() {
>+    return this.defaultPrevented;
>+  }
>+  get [$eventPhase]() {
>+    return this.eventPhase;
>+  }
>+  get [$isTrusted]() {
>+    return this.isTrusted;
>+  }
>+  get [$target]() {
>+    return html$._convertNativeToDart_EventTarget(this[_get_target]);
>+  }
>+  get [_get_target]() {
>+    return this.target;
>+  }
>+  get [$timeStamp]() {
>+    return this.timeStamp;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  [$composedPath](...args) {
>+    return this.composedPath.apply(this, args);
>+  }
>+  [_initEvent](...args) {
>+    return this.initEvent.apply(this, args);
>+  }
>+  [$preventDefault](...args) {
>+    return this.preventDefault.apply(this, args);
>+  }
>+  [$stopImmediatePropagation](...args) {
>+    return this.stopImmediatePropagation.apply(this, args);
>+  }
>+  [$stopPropagation](...args) {
>+    return this.stopPropagation.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.Event);
>+const bubbles = Symbol("Event.bubbles");
>+const cancelable = Symbol("Event.cancelable");
>+const composed = Symbol("Event.composed");
>+const defaultPrevented = Symbol("Event.defaultPrevented");
>+const eventPhase = Symbol("Event.eventPhase");
>+const isTrusted = Symbol("Event.isTrusted");
>+const timeStamp = Symbol("Event.timeStamp");
>+const type$2 = Symbol("Event.type");
>+dart.setMethodSignature(html$.Event, () => ({
>+  __proto__: dart.getMethods(html$.Event.__proto__),
>+  [$composedPath]: dart.fnType(core.List$(html$.EventTarget), []),
>+  [_initEvent]: dart.fnType(dart.void, [core.String], [core.bool, core.bool]),
>+  [$preventDefault]: dart.fnType(dart.void, []),
>+  [$stopImmediatePropagation]: dart.fnType(dart.void, []),
>+  [$stopPropagation]: dart.fnType(dart.void, [])
>+}));
>+dart.setGetterSignature(html$.Event, () => ({
>+  __proto__: dart.getGetters(html$.Event.__proto__),
>+  [$matchingTarget]: html$.Element,
>+  [$path]: core.List$(html$.EventTarget),
>+  [$currentTarget]: html$.EventTarget,
>+  [$target]: html$.EventTarget
>+}));
>+dart.setLibraryUri(html$.Event, "dart:html");
>+dart.setFieldSignature(html$.Event, () => ({
>+  __proto__: dart.getFields(html$.Event.__proto__),
>+  [_selector]: dart.fieldType(core.String),
>+  [$bubbles]: dart.finalFieldType(core.bool),
>+  [$cancelable]: dart.finalFieldType(core.bool),
>+  [$composed]: dart.finalFieldType(core.bool),
>+  [_get_currentTarget]: dart.finalFieldType(dart.dynamic),
>+  [$defaultPrevented]: dart.finalFieldType(core.bool),
>+  [$eventPhase]: dart.finalFieldType(core.int),
>+  [$isTrusted]: dart.finalFieldType(core.bool),
>+  [_get_target]: dart.finalFieldType(dart.dynamic),
>+  [$timeStamp]: dart.finalFieldType(core.num),
>+  [$type]: dart.finalFieldType(core.String)
>+}));
>+dart.defineLazy(html$.Event, {
>+  /*html$.Event.AT_TARGET*/get AT_TARGET() {
>+    return 2;
>+  },
>+  /*html$.Event.BUBBLING_PHASE*/get BUBBLING_PHASE() {
>+    return 3;
>+  },
>+  /*html$.Event.CAPTURING_PHASE*/get CAPTURING_PHASE() {
>+    return 1;
>+  }
>+});
>+dart.registerExtension("Event", html$.Event);
>+dart.registerExtension("InputEvent", html$.Event);
>+indexed_db.VersionChangeEvent = class VersionChangeEvent extends html$.Event {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return indexed_db.VersionChangeEvent._create_1(type, eventInitDict_1);
>+    }
>+    return indexed_db.VersionChangeEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new IDBVersionChangeEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new IDBVersionChangeEvent(type);
>+  }
>+  get [$dataLoss]() {
>+    return this.dataLoss;
>+  }
>+  get [$dataLossMessage]() {
>+    return this.dataLossMessage;
>+  }
>+  get [$newVersion]() {
>+    return this.newVersion;
>+  }
>+  get [$oldVersion]() {
>+    return this.oldVersion;
>+  }
>+  get [$target]() {
>+    return this.target;
>+  }
>+};
>+dart.addTypeTests(indexed_db.VersionChangeEvent);
>+const dataLoss = Symbol("VersionChangeEvent.dataLoss");
>+const dataLossMessage = Symbol("VersionChangeEvent.dataLossMessage");
>+const newVersion = Symbol("VersionChangeEvent.newVersion");
>+const oldVersion = Symbol("VersionChangeEvent.oldVersion");
>+const target = Symbol("VersionChangeEvent.target");
>+dart.setLibraryUri(indexed_db.VersionChangeEvent, "dart:indexed_db");
>+dart.setFieldSignature(indexed_db.VersionChangeEvent, () => ({
>+  __proto__: dart.getFields(indexed_db.VersionChangeEvent.__proto__),
>+  [$dataLoss]: dart.finalFieldType(core.String),
>+  [$dataLossMessage]: dart.finalFieldType(core.String),
>+  [$newVersion]: dart.finalFieldType(core.int),
>+  [$oldVersion]: dart.finalFieldType(core.int),
>+  [$target]: dart.finalFieldType(indexed_db.OpenDBRequest)
>+}));
>+dart.registerExtension("IDBVersionChangeEvent", indexed_db.VersionChangeEvent);
>+dart.copyProperties(html$, {
>+  get window() {
>+    return window;
>+  }
>+});
>+dart.copyProperties(html$, {
>+  get document() {
>+    return document;
>+  }
>+});
>+html$.promiseToFuture = function(T, jsPromise) {
>+  let completer = async.Completer$(T).new();
>+  let thenSuccessCode = promiseValue => completer.complete(async.FutureOr$(T)._check(promiseValue));
>+  dart.fn(thenSuccessCode, dynamicTovoid());
>+  let thenErrorCode = promiseError => completer.completeError(promiseError);
>+  dart.fn(thenErrorCode, dynamicTovoid());
>+  jsPromise.then(_js_helper.convertDartClosureToJS(dynamicTovoid(), thenSuccessCode, 1), _js_helper.convertDartClosureToJS(dynamicTovoid(), thenErrorCode, 1));
>+  return completer.future;
>+};
>+html$.promiseToFutureAsMap = function(jsPromise) {
>+  let completer = CompleterOfMapOfString$dynamic().new();
>+  let thenSuccessCode = promiseValue => completer.complete(html_common.convertNativeToDart_Dictionary(promiseValue));
>+  dart.fn(thenSuccessCode, dynamicTovoid());
>+  let thenErrorCode = promiseError => completer.completeError(promiseError);
>+  dart.fn(thenErrorCode, dynamicTovoid());
>+  jsPromise.then(_js_helper.convertDartClosureToJS(dynamicTovoid(), thenSuccessCode, 1), _js_helper.convertDartClosureToJS(dynamicTovoid(), thenErrorCode, 1));
>+  return completer.future;
>+};
>+const _attributes$ = dart.privateName(html$, "_attributes");
>+const _innerHtml = dart.privateName(html$, "_innerHtml");
>+const _localName = dart.privateName(html$, "_localName");
>+const _namespaceUri = dart.privateName(html$, "_namespaceUri");
>+const _scrollHeight = dart.privateName(html$, "_scrollHeight");
>+const _scrollLeft = dart.privateName(html$, "_scrollLeft");
>+const _scrollTop = dart.privateName(html$, "_scrollTop");
>+const _scrollWidth = dart.privateName(html$, "_scrollWidth");
>+const _childElementCount = dart.privateName(html$, "_childElementCount");
>+const _children = dart.privateName(html$, "_children");
>+const _firstElementChild = dart.privateName(html$, "_firstElementChild");
>+const _lastElementChild = dart.privateName(html$, "_lastElementChild");
>+const _getAttribute = dart.privateName(html$, "_getAttribute");
>+const _getAttributeNS = dart.privateName(html$, "_getAttributeNS");
>+const _hasAttribute = dart.privateName(html$, "_hasAttribute");
>+const _hasAttributeNS = dart.privateName(html$, "_hasAttributeNS");
>+const _removeAttribute = dart.privateName(html$, "_removeAttribute");
>+const _removeAttributeNS = dart.privateName(html$, "_removeAttributeNS");
>+const _setAttribute = dart.privateName(html$, "_setAttribute");
>+const _setAttributeNS = dart.privateName(html$, "_setAttributeNS");
>+const _querySelectorAll = dart.privateName(html$, "_querySelectorAll");
>+const _setApplyScroll = dart.privateName(html$, "_setApplyScroll");
>+const _setDistributeScroll = dart.privateName(html$, "_setDistributeScroll");
>+const _getComputedStyle = dart.privateName(html$, "_getComputedStyle");
>+const _getClientRects = dart.privateName(html$, "_getClientRects");
>+const _animate = dart.privateName(html$, "_animate");
>+const _scrollIntoView = dart.privateName(html$, "_scrollIntoView");
>+const _scrollIntoViewIfNeeded = dart.privateName(html$, "_scrollIntoViewIfNeeded");
>+const _insertAdjacentText = dart.privateName(html$, "_insertAdjacentText");
>+const _insertAdjacentNode = dart.privateName(html$, "_insertAdjacentNode");
>+const _insertAdjacentHtml = dart.privateName(html$, "_insertAdjacentHtml");
>+const _insertAdjacentElement = dart.privateName(html$, "_insertAdjacentElement");
>+const _canBeUsedToCreateContextualFragment = dart.privateName(html$, "_canBeUsedToCreateContextualFragment");
>+const _cannotBeUsedToCreateContextualFragment = dart.privateName(html$, "_cannotBeUsedToCreateContextualFragment");
>+const _attachShadow_1 = dart.privateName(html$, "_attachShadow_1");
>+const _getElementsByTagName = dart.privateName(html$, "_getElementsByTagName");
>+const _scroll_1 = dart.privateName(html$, "_scroll_1");
>+const _scroll_2 = dart.privateName(html$, "_scroll_2");
>+const _scroll_3 = dart.privateName(html$, "_scroll_3");
>+const _scrollBy_1 = dart.privateName(html$, "_scrollBy_1");
>+const _scrollBy_2 = dart.privateName(html$, "_scrollBy_2");
>+const _scrollBy_3 = dart.privateName(html$, "_scrollBy_3");
>+const _scrollTo_1 = dart.privateName(html$, "_scrollTo_1");
>+const _scrollTo_2 = dart.privateName(html$, "_scrollTo_2");
>+const _scrollTo_3 = dart.privateName(html$, "_scrollTo_3");
>+const _removeChild = dart.privateName(html$, "_removeChild");
>+const _replaceChild = dart.privateName(html$, "_replaceChild");
>+const _this = dart.privateName(html$, "_this");
>+const _clearChildren = dart.privateName(html$, "_clearChildren");
>+const _getRootNode_1 = dart.privateName(html$, "_getRootNode_1");
>+const _getRootNode_2 = dart.privateName(html$, "_getRootNode_2");
>+html$.Node = class Node extends html$.EventTarget {
>+  get [$nodes]() {
>+    return new html$._ChildNodeListLazy.new(this);
>+  }
>+  set [$nodes](value) {
>+    let copy = value[$toList]();
>+    this[$text] = "";
>+    for (let node of copy) {
>+      this[$append](node);
>+    }
>+  }
>+  [$remove]() {
>+    if (this.parentNode != null) {
>+      let parent = this.parentNode;
>+      this.parentNode[_removeChild](this);
>+    }
>+  }
>+  [$replaceWith](otherNode) {
>+    try {
>+      let parent = this.parentNode;
>+      parent[_replaceChild](otherNode, this);
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+    }
>+    ;
>+    return this;
>+  }
>+  [$insertAllBefore](newNodes, refChild) {
>+    if (html$._ChildNodeListLazy.is(newNodes)) {
>+      let otherList = newNodes;
>+      if (otherList[_this] === this) {
>+        dart.throw(new core.ArgumentError.new(newNodes));
>+      }
>+      for (let i = 0, len = otherList.length; i < dart.notNull(len); ++i) {
>+        this.insertBefore(otherList[_this].firstChild, refChild);
>+      }
>+    } else {
>+      for (let node of newNodes) {
>+        this.insertBefore(node, refChild);
>+      }
>+    }
>+  }
>+  [_clearChildren]() {
>+    while (this.firstChild != null) {
>+      this[_removeChild](this.firstChild);
>+    }
>+  }
>+  [$toString]() {
>+    let value = this.nodeValue;
>+    return value == null ? super[$toString]() : value;
>+  }
>+  get [$childNodes]() {
>+    return this.childNodes;
>+  }
>+  get [$baseUri]() {
>+    return this.baseURI;
>+  }
>+  get [$firstChild]() {
>+    return this.firstChild;
>+  }
>+  get [$isConnected]() {
>+    return this.isConnected;
>+  }
>+  get [$lastChild]() {
>+    return this.lastChild;
>+  }
>+  get [$nextNode]() {
>+    return this.nextSibling;
>+  }
>+  get [$nodeName]() {
>+    return this.nodeName;
>+  }
>+  get [$nodeType]() {
>+    return this.nodeType;
>+  }
>+  get [$nodeValue]() {
>+    return this.nodeValue;
>+  }
>+  get [$ownerDocument]() {
>+    return this.ownerDocument;
>+  }
>+  get [$parent]() {
>+    return this.parentElement;
>+  }
>+  get [$parentNode]() {
>+    return this.parentNode;
>+  }
>+  get [$previousNode]() {
>+    return this.previousSibling;
>+  }
>+  get [$text]() {
>+    return this.textContent;
>+  }
>+  set [$text](value) {
>+    this.textContent = value;
>+  }
>+  [$append](...args) {
>+    return this.appendChild.apply(this, args);
>+  }
>+  [$clone](...args) {
>+    return this.cloneNode.apply(this, args);
>+  }
>+  [$contains](...args) {
>+    return this.contains.apply(this, args);
>+  }
>+  [$getRootNode](options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      return this[_getRootNode_1](options_1);
>+    }
>+    return this[_getRootNode_2]();
>+  }
>+  [_getRootNode_1](...args) {
>+    return this.getRootNode.apply(this, args);
>+  }
>+  [_getRootNode_2](...args) {
>+    return this.getRootNode.apply(this, args);
>+  }
>+  [$hasChildNodes](...args) {
>+    return this.hasChildNodes.apply(this, args);
>+  }
>+  [$insertBefore](...args) {
>+    return this.insertBefore.apply(this, args);
>+  }
>+  [_removeChild](...args) {
>+    return this.removeChild.apply(this, args);
>+  }
>+  [_replaceChild](...args) {
>+    return this.replaceChild.apply(this, args);
>+  }
>+};
>+(html$.Node._created = function() {
>+  this[childNodes] = null;
>+  this[baseUri] = null;
>+  this[firstChild] = null;
>+  this[isConnected] = null;
>+  this[lastChild] = null;
>+  this[nextNode] = null;
>+  this[nodeName] = null;
>+  this[nodeType] = null;
>+  this[nodeValue] = null;
>+  this[ownerDocument] = null;
>+  this[parent] = null;
>+  this[parentNode] = null;
>+  this[previousNode] = null;
>+  this[text] = null;
>+  html$.Node.__proto__._created.call(this);
>+}).prototype = html$.Node.prototype;
>+dart.addTypeTests(html$.Node);
>+const childNodes = Symbol("Node.childNodes");
>+const baseUri = Symbol("Node.baseUri");
>+const firstChild = Symbol("Node.firstChild");
>+const isConnected = Symbol("Node.isConnected");
>+const lastChild = Symbol("Node.lastChild");
>+const nextNode = Symbol("Node.nextNode");
>+const nodeName = Symbol("Node.nodeName");
>+const nodeType = Symbol("Node.nodeType");
>+const nodeValue = Symbol("Node.nodeValue");
>+const ownerDocument = Symbol("Node.ownerDocument");
>+const parent = Symbol("Node.parent");
>+const parentNode = Symbol("Node.parentNode");
>+const previousNode = Symbol("Node.previousNode");
>+const text = Symbol("Node.text");
>+dart.setMethodSignature(html$.Node, () => ({
>+  __proto__: dart.getMethods(html$.Node.__proto__),
>+  [$remove]: dart.fnType(dart.void, []),
>+  [$replaceWith]: dart.fnType(html$.Node, [html$.Node]),
>+  [$insertAllBefore]: dart.fnType(html$.Node, [core.Iterable$(html$.Node), html$.Node]),
>+  [_clearChildren]: dart.fnType(dart.void, []),
>+  [$append]: dart.fnType(html$.Node, [html$.Node]),
>+  [$clone]: dart.fnType(html$.Node, [core.bool]),
>+  [$contains]: dart.fnType(core.bool, [html$.Node]),
>+  [$getRootNode]: dart.fnType(html$.Node, [], [core.Map]),
>+  [_getRootNode_1]: dart.fnType(html$.Node, [dart.dynamic]),
>+  [_getRootNode_2]: dart.fnType(html$.Node, []),
>+  [$hasChildNodes]: dart.fnType(core.bool, []),
>+  [$insertBefore]: dart.fnType(html$.Node, [html$.Node, html$.Node]),
>+  [_removeChild]: dart.fnType(html$.Node, [html$.Node]),
>+  [_replaceChild]: dart.fnType(html$.Node, [html$.Node, html$.Node])
>+}));
>+dart.setGetterSignature(html$.Node, () => ({
>+  __proto__: dart.getGetters(html$.Node.__proto__),
>+  [$nodes]: core.List$(html$.Node)
>+}));
>+dart.setSetterSignature(html$.Node, () => ({
>+  __proto__: dart.getSetters(html$.Node.__proto__),
>+  [$nodes]: core.Iterable$(html$.Node)
>+}));
>+dart.setLibraryUri(html$.Node, "dart:html");
>+dart.setFieldSignature(html$.Node, () => ({
>+  __proto__: dart.getFields(html$.Node.__proto__),
>+  [$childNodes]: dart.finalFieldType(ListOfNode()),
>+  [$baseUri]: dart.finalFieldType(core.String),
>+  [$firstChild]: dart.finalFieldType(html$.Node),
>+  [$isConnected]: dart.finalFieldType(core.bool),
>+  [$lastChild]: dart.finalFieldType(html$.Node),
>+  [$nextNode]: dart.finalFieldType(html$.Node),
>+  [$nodeName]: dart.finalFieldType(core.String),
>+  [$nodeType]: dart.finalFieldType(core.int),
>+  [$nodeValue]: dart.finalFieldType(core.String),
>+  [$ownerDocument]: dart.finalFieldType(html$.Document),
>+  [$parent]: dart.finalFieldType(html$.Element),
>+  [$parentNode]: dart.finalFieldType(html$.Node),
>+  [$previousNode]: dart.finalFieldType(html$.Node),
>+  [$text]: dart.fieldType(core.String)
>+}));
>+dart.defineLazy(html$.Node, {
>+  /*html$.Node.ATTRIBUTE_NODE*/get ATTRIBUTE_NODE() {
>+    return 2;
>+  },
>+  /*html$.Node.CDATA_SECTION_NODE*/get CDATA_SECTION_NODE() {
>+    return 4;
>+  },
>+  /*html$.Node.COMMENT_NODE*/get COMMENT_NODE() {
>+    return 8;
>+  },
>+  /*html$.Node.DOCUMENT_FRAGMENT_NODE*/get DOCUMENT_FRAGMENT_NODE() {
>+    return 11;
>+  },
>+  /*html$.Node.DOCUMENT_NODE*/get DOCUMENT_NODE() {
>+    return 9;
>+  },
>+  /*html$.Node.DOCUMENT_TYPE_NODE*/get DOCUMENT_TYPE_NODE() {
>+    return 10;
>+  },
>+  /*html$.Node.ELEMENT_NODE*/get ELEMENT_NODE() {
>+    return 1;
>+  },
>+  /*html$.Node.ENTITY_NODE*/get ENTITY_NODE() {
>+    return 6;
>+  },
>+  /*html$.Node.ENTITY_REFERENCE_NODE*/get ENTITY_REFERENCE_NODE() {
>+    return 5;
>+  },
>+  /*html$.Node.NOTATION_NODE*/get NOTATION_NODE() {
>+    return 12;
>+  },
>+  /*html$.Node.PROCESSING_INSTRUCTION_NODE*/get PROCESSING_INSTRUCTION_NODE() {
>+    return 7;
>+  },
>+  /*html$.Node.TEXT_NODE*/get TEXT_NODE() {
>+    return 3;
>+  }
>+});
>+dart.registerExtension("Node", html$.Node);
>+html$.Element = class Element extends html$.Node {
>+  static html(html, opts) {
>+    let validator = opts && 'validator' in opts ? opts.validator : null;
>+    let treeSanitizer = opts && 'treeSanitizer' in opts ? opts.treeSanitizer : null;
>+    let fragment = html$.document.body[$createFragment](html, {validator: validator, treeSanitizer: treeSanitizer});
>+    return html$.Element._check(fragment[$nodes][$where](dart.fn(e => html$.Element.is(e), NodeTobool()))[$single]);
>+  }
>+  static tag(tag, typeExtention) {
>+    if (typeExtention === void 0) typeExtention = null;
>+    return html$.Element._check(html$._ElementFactoryProvider.createElement_tag(tag, typeExtention));
>+  }
>+  static a() {
>+    return html$.AnchorElement.new();
>+  }
>+  static article() {
>+    return html$.Element.tag("article");
>+  }
>+  static aside() {
>+    return html$.Element.tag("aside");
>+  }
>+  static audio() {
>+    return html$.Element.tag("audio");
>+  }
>+  static br() {
>+    return html$.BRElement.new();
>+  }
>+  static canvas() {
>+    return html$.CanvasElement.new();
>+  }
>+  static div() {
>+    return html$.DivElement.new();
>+  }
>+  static footer() {
>+    return html$.Element.tag("footer");
>+  }
>+  static header() {
>+    return html$.Element.tag("header");
>+  }
>+  static hr() {
>+    return html$.Element.tag("hr");
>+  }
>+  static iframe() {
>+    return html$.Element.tag("iframe");
>+  }
>+  static img() {
>+    return html$.Element.tag("img");
>+  }
>+  static li() {
>+    return html$.Element.tag("li");
>+  }
>+  static nav() {
>+    return html$.Element.tag("nav");
>+  }
>+  static ol() {
>+    return html$.Element.tag("ol");
>+  }
>+  static option() {
>+    return html$.Element.tag("option");
>+  }
>+  static p() {
>+    return html$.Element.tag("p");
>+  }
>+  static pre() {
>+    return html$.Element.tag("pre");
>+  }
>+  static section() {
>+    return html$.Element.tag("section");
>+  }
>+  static select() {
>+    return html$.Element.tag("select");
>+  }
>+  static span() {
>+    return html$.Element.tag("span");
>+  }
>+  static svg() {
>+    return html$.Element.tag("svg");
>+  }
>+  static table() {
>+    return html$.Element.tag("table");
>+  }
>+  static td() {
>+    return html$.Element.tag("td");
>+  }
>+  static textarea() {
>+    return html$.Element.tag("textarea");
>+  }
>+  static th() {
>+    return html$.Element.tag("th");
>+  }
>+  static tr() {
>+    return html$.Element.tag("tr");
>+  }
>+  static ul() {
>+    return html$.Element.tag("ul");
>+  }
>+  static video() {
>+    return html$.Element.tag("video");
>+  }
>+  get [$attributes]() {
>+    return new html$._ElementAttributeMap.new(this);
>+  }
>+  set [$attributes](value) {
>+    let attributes = this[$attributes];
>+    attributes[$clear]();
>+    for (let key of value[$keys]) {
>+      attributes[$_set](key, value[$_get](key));
>+    }
>+  }
>+  [$getAttribute](name) {
>+    if (!(name != null)) dart.assertFailed("Attribute name cannot be null", "dart:html", 12321, 12, "name != null");
>+    return this[_getAttribute](name);
>+  }
>+  [$getAttributeNS](namespaceURI, name) {
>+    if (!(name != null)) dart.assertFailed("Attribute name cannot be null", "dart:html", 12329, 12, "name != null");
>+    return this[_getAttributeNS](namespaceURI, name);
>+  }
>+  [$hasAttribute](name) {
>+    if (!(name != null)) dart.assertFailed("Attribute name cannot be null", "dart:html", 12336, 12, "name != null");
>+    return this[_hasAttribute](name);
>+  }
>+  [$hasAttributeNS](namespaceURI, name) {
>+    if (!(name != null)) dart.assertFailed("Attribute name cannot be null", "dart:html", 12344, 12, "name != null");
>+    return this[_hasAttributeNS](namespaceURI, name);
>+  }
>+  [$removeAttribute](name) {
>+    if (!(name != null)) dart.assertFailed("Attribute name cannot be null", "dart:html", 12351, 12, "name != null");
>+    this[_removeAttribute](name);
>+  }
>+  [$removeAttributeNS](namespaceURI, name) {
>+    if (!(name != null)) dart.assertFailed("Attribute name cannot be null", "dart:html", 12358, 12, "name != null");
>+    this[_removeAttributeNS](namespaceURI, name);
>+  }
>+  [$setAttribute](name, value) {
>+    if (!(name != null)) dart.assertFailed("Attribute name cannot be null", "dart:html", 12365, 12, "name != null");
>+    this[_setAttribute](name, value);
>+  }
>+  [$setAttributeNS](namespaceURI, name, value) {
>+    if (!(name != null)) dart.assertFailed("Attribute name cannot be null", "dart:html", 12373, 12, "name != null");
>+    this[_setAttributeNS](namespaceURI, name, value);
>+  }
>+  get [$children]() {
>+    return new html$._ChildrenElementList._wrap(this);
>+  }
>+  set [$children](value) {
>+    let copy = value[$toList]();
>+    let children = this[$children];
>+    children[$clear]();
>+    children[$addAll](copy);
>+  }
>+  [$querySelectorAll](T, selectors) {
>+    return new (html$._FrozenElementList$(T))._wrap(this[_querySelectorAll](selectors));
>+  }
>+  [_setApplyScroll](...args) {
>+    return this.setApplyScroll.apply(this, args);
>+  }
>+  [$setApplyScroll](nativeScrollBehavior) {
>+    let completer = CompleterOfScrollState().new();
>+    this[_setApplyScroll](dart.fn(value => {
>+      completer.complete(value);
>+    }, ScrollStateToNull()), nativeScrollBehavior);
>+    return completer.future;
>+  }
>+  [_setDistributeScroll](...args) {
>+    return this.setDistributeScroll.apply(this, args);
>+  }
>+  [$setDistributeScroll](nativeScrollBehavior) {
>+    let completer = CompleterOfScrollState().new();
>+    this[_setDistributeScroll](dart.fn(value => {
>+      completer.complete(value);
>+    }, ScrollStateToNull()), nativeScrollBehavior);
>+    return completer.future;
>+  }
>+  get [$classes]() {
>+    return new html$._ElementCssClassSet.new(this);
>+  }
>+  set [$classes](value) {
>+    let classSet = this[$classes];
>+    classSet.clear();
>+    classSet.addAll(value);
>+  }
>+  get [$dataset]() {
>+    return new html$._DataAttributeMap.new(this[$attributes]);
>+  }
>+  set [$dataset](value) {
>+    let data = this[$dataset];
>+    data[$clear]();
>+    for (let key of value[$keys]) {
>+      data[$_set](key, value[$_get](key));
>+    }
>+  }
>+  [$getNamespacedAttributes](namespace) {
>+    return new html$._NamespacedAttributeMap.new(this, namespace);
>+  }
>+  [$getComputedStyle](pseudoElement) {
>+    if (pseudoElement === void 0) pseudoElement = null;
>+    if (pseudoElement == null) {
>+      pseudoElement = "";
>+    }
>+    return html$.window[_getComputedStyle](this, pseudoElement);
>+  }
>+  get [$client]() {
>+    return new (RectangleOfnum()).new(this.clientLeft, this.clientTop, this.clientWidth, this.clientHeight);
>+  }
>+  get [$offset]() {
>+    return new (RectangleOfnum()).new(this[$offsetLeft], this[$offsetTop], this[$offsetWidth], this[$offsetHeight]);
>+  }
>+  [$appendText](text) {
>+    this[$append](html$.Text.new(text));
>+  }
>+  [$appendHtml](text, opts) {
>+    let validator = opts && 'validator' in opts ? opts.validator : null;
>+    let treeSanitizer = opts && 'treeSanitizer' in opts ? opts.treeSanitizer : null;
>+    this[$insertAdjacentHtml]("beforeend", text, {validator: validator, treeSanitizer: treeSanitizer});
>+  }
>+  static isTagSupported(tag) {
>+    let e = html$._ElementFactoryProvider.createElement_tag(tag, null);
>+    return html$.Element.is(e) && !html$.UnknownElement.is(e);
>+  }
>+  [$attached]() {
>+    this[$enteredView]();
>+  }
>+  [$detached]() {
>+    this[$leftView]();
>+  }
>+  [$enteredView]() {}
>+  [$getClientRects]() {
>+    let value = this[_getClientRects]();
>+    let jsProto = value.prototype;
>+    if (jsProto == null) {
>+      value.prototype = Object.create(null);
>+    }
>+    _js_helper.applyExtension("DOMRectList", value);
>+    return value;
>+  }
>+  [$leftView]() {}
>+  [$animate](frames, timing) {
>+    if (timing === void 0) timing = null;
>+    if (!core.Iterable.is(frames) || !dart.test(frames[$every](dart.fn(x => core.Map.is(x), MapOfString$dynamicTobool())))) {
>+      dart.throw(new core.ArgumentError.new("The frames parameter should be a List of Maps " + "with frame information"));
>+    }
>+    let convertedFrames = null;
>+    if (core.Iterable.is(frames)) {
>+      convertedFrames = frames[$map](dart.dynamic, dart.fn(html_common.convertDartToNative_Dictionary, Map__Todynamic()))[$toList]();
>+    } else {
>+      convertedFrames = frames;
>+    }
>+    let convertedTiming = core.Map.is(timing) ? html_common.convertDartToNative_Dictionary(timing) : timing;
>+    return convertedTiming == null ? this[_animate](convertedFrames) : this[_animate](convertedFrames, convertedTiming);
>+  }
>+  [_animate](...args) {
>+    return this.animate.apply(this, args);
>+  }
>+  [$attributeChanged](name, oldValue, newValue) {}
>+  get [$localName]() {
>+    return this[_localName];
>+  }
>+  get [$namespaceUri]() {
>+    return this[_namespaceUri];
>+  }
>+  [$toString]() {
>+    return this[$localName];
>+  }
>+  [$scrollIntoView](alignment) {
>+    if (alignment === void 0) alignment = null;
>+    let hasScrollIntoViewIfNeeded = true;
>+    hasScrollIntoViewIfNeeded = !!this.scrollIntoViewIfNeeded;
>+    if (dart.equals(alignment, html$.ScrollAlignment.TOP)) {
>+      this[_scrollIntoView](true);
>+    } else if (dart.equals(alignment, html$.ScrollAlignment.BOTTOM)) {
>+      this[_scrollIntoView](false);
>+    } else if (hasScrollIntoViewIfNeeded) {
>+      if (dart.equals(alignment, html$.ScrollAlignment.CENTER)) {
>+        this[_scrollIntoViewIfNeeded](true);
>+      } else {
>+        this[_scrollIntoViewIfNeeded]();
>+      }
>+    } else {
>+      this[_scrollIntoView]();
>+    }
>+  }
>+  static _determineMouseWheelEventType(e) {
>+    return "wheel";
>+  }
>+  static _determineTransitionEventType(e) {
>+    if (dart.test(html_common.Device.isWebKit)) {
>+      return "webkitTransitionEnd";
>+    } else if (dart.test(html_common.Device.isOpera)) {
>+      return "oTransitionEnd";
>+    }
>+    return "transitionend";
>+  }
>+  [$insertAdjacentText](where, text) {
>+    if (!!this.insertAdjacentText) {
>+      this[_insertAdjacentText](where, text);
>+    } else {
>+      this[_insertAdjacentNode](where, html$.Text.new(text));
>+    }
>+  }
>+  [_insertAdjacentText](...args) {
>+    return this.insertAdjacentText.apply(this, args);
>+  }
>+  [$insertAdjacentHtml](where, html, opts) {
>+    let validator = opts && 'validator' in opts ? opts.validator : null;
>+    let treeSanitizer = opts && 'treeSanitizer' in opts ? opts.treeSanitizer : null;
>+    if (html$._TrustedHtmlTreeSanitizer.is(treeSanitizer)) {
>+      this[_insertAdjacentHtml](where, html);
>+    } else {
>+      this[_insertAdjacentNode](where, this[$createFragment](html, {validator: validator, treeSanitizer: treeSanitizer}));
>+    }
>+  }
>+  [_insertAdjacentHtml](...args) {
>+    return this.insertAdjacentHTML.apply(this, args);
>+  }
>+  [$insertAdjacentElement](where, element) {
>+    if (!!this.insertAdjacentElement) {
>+      this[_insertAdjacentElement](where, element);
>+    } else {
>+      this[_insertAdjacentNode](where, element);
>+    }
>+    return element;
>+  }
>+  [_insertAdjacentElement](...args) {
>+    return this.insertAdjacentElement.apply(this, args);
>+  }
>+  [_insertAdjacentNode](where, node) {
>+    switch (where[$toLowerCase]()) {
>+      case "beforebegin":
>+      {
>+        this.parentNode.insertBefore(node, this);
>+        break;
>+      }
>+      case "afterbegin":
>+      {
>+        let first = dart.notNull(this[$nodes][$length]) > 0 ? this[$nodes][$_get](0) : null;
>+        this.insertBefore(node, first);
>+        break;
>+      }
>+      case "beforeend":
>+      {
>+        this[$append](node);
>+        break;
>+      }
>+      case "afterend":
>+      {
>+        this.parentNode.insertBefore(node, this[$nextNode]);
>+        break;
>+      }
>+      default:
>+      {
>+        dart.throw(new core.ArgumentError.new("Invalid position " + dart.str(where)));
>+      }
>+    }
>+  }
>+  [$matches](selectors) {
>+    if (!!this.matches) {
>+      return this.matches(selectors);
>+    } else if (!!this.webkitMatchesSelector) {
>+      return this.webkitMatchesSelector(selectors);
>+    } else if (!!this.mozMatchesSelector) {
>+      return this.mozMatchesSelector(selectors);
>+    } else if (!!this.msMatchesSelector) {
>+      return this.msMatchesSelector(selectors);
>+    } else if (!!this.oMatchesSelector) {
>+      return this.oMatchesSelector(selectors);
>+    } else {
>+      dart.throw(new core.UnsupportedError.new("Not supported on this platform"));
>+    }
>+  }
>+  [$matchesWithAncestors](selectors) {
>+    let elem = this;
>+    do {
>+      if (dart.test(elem[$matches](selectors))) return true;
>+      elem = elem[$parent];
>+    } while (elem != null);
>+    return false;
>+  }
>+  [$createShadowRoot]() {
>+    return (this.createShadowRoot || this.webkitCreateShadowRoot).call(this);
>+  }
>+  get [$shadowRoot]() {
>+    return this.shadowRoot || this.webkitShadowRoot;
>+  }
>+  get [$contentEdge]() {
>+    return new html$._ContentCssRect.new(this);
>+  }
>+  get [$paddingEdge]() {
>+    return new html$._PaddingCssRect.new(this);
>+  }
>+  get [$borderEdge]() {
>+    return new html$._BorderCssRect.new(this);
>+  }
>+  get [$marginEdge]() {
>+    return new html$._MarginCssRect.new(this);
>+  }
>+  get [$documentOffset]() {
>+    return this[$offsetTo](html$.document.documentElement);
>+  }
>+  [$offsetTo](parent) {
>+    return html$.Element._offsetToHelper(this, parent);
>+  }
>+  static _offsetToHelper(current, parent) {
>+    let sameAsParent = current == parent;
>+    let foundAsParent = sameAsParent || parent.tagName === "HTML";
>+    if (current == null || sameAsParent) {
>+      if (foundAsParent) return new (PointOfnum()).new(0, 0);
>+      dart.throw(new core.ArgumentError.new("Specified element is not a transitive offset " + "parent of this element."));
>+    }
>+    let parentOffset = current.offsetParent;
>+    let p = html$.Element._offsetToHelper(parentOffset, parent);
>+    return new (PointOfnum()).new(dart.notNull(p.x) + dart.notNull(current[$offsetLeft]), dart.notNull(p.y) + dart.notNull(current[$offsetTop]));
>+  }
>+  [$createFragment](html, opts) {
>+    let validator = opts && 'validator' in opts ? opts.validator : null;
>+    let treeSanitizer = opts && 'treeSanitizer' in opts ? opts.treeSanitizer : null;
>+    if (treeSanitizer == null) {
>+      if (validator == null) {
>+        if (html$.Element._defaultValidator == null) {
>+          html$.Element._defaultValidator = new html$.NodeValidatorBuilder.common();
>+        }
>+        validator = html$.Element._defaultValidator;
>+      }
>+      if (html$.Element._defaultSanitizer == null) {
>+        html$.Element._defaultSanitizer = new html$._ValidatingTreeSanitizer.new(validator);
>+      } else {
>+        html$.Element._defaultSanitizer.validator = validator;
>+      }
>+      treeSanitizer = html$.Element._defaultSanitizer;
>+    } else if (validator != null) {
>+      dart.throw(new core.ArgumentError.new("validator can only be passed if treeSanitizer is null"));
>+    }
>+    if (html$.Element._parseDocument == null) {
>+      html$.Element._parseDocument = html$.document.implementation[$createHtmlDocument]("");
>+      html$.Element._parseRange = html$.Element._parseDocument.createRange();
>+      let base = html$.BaseElement._check(html$.Element._parseDocument[$createElement]("base"));
>+      base.href = html$.document[$baseUri];
>+      html$.Element._parseDocument[$head][$append](base);
>+    }
>+    if (html$.Element._parseDocument.body == null) {
>+      html$.Element._parseDocument.body = html$.BodyElement._check(html$.Element._parseDocument[$createElement]("body"));
>+    }
>+    let contextElement = null;
>+    if (html$.BodyElement.is(this)) {
>+      contextElement = html$.Element._parseDocument.body;
>+    } else {
>+      contextElement = html$.Element._parseDocument[$createElement](this.tagName);
>+      html$.Element._parseDocument.body[$append](html$.Node._check(contextElement));
>+    }
>+    let fragment = null;
>+    if (dart.test(html$.Range.supportsCreateContextualFragment) && dart.test(this[_canBeUsedToCreateContextualFragment])) {
>+      html$.Element._parseRange.selectNodeContents(html$.Node._check(contextElement));
>+      fragment = html$.Element._parseRange.createContextualFragment(html);
>+    } else {
>+      dart.dput(contextElement, _innerHtml, html);
>+      fragment = html$.Element._parseDocument.createDocumentFragment();
>+      while (dart.dload(contextElement, 'firstChild') != null) {
>+        dart.dsend(fragment, 'append', [dart.dload(contextElement, 'firstChild')]);
>+      }
>+    }
>+    if (!dart.equals(contextElement, html$.Element._parseDocument.body)) {
>+      dart.dsend(contextElement, 'remove', []);
>+    }
>+    treeSanitizer.sanitizeTree(html$.Node._check(fragment));
>+    html$.document.adoptNode(html$.Node._check(fragment));
>+    return html$.DocumentFragment._check(fragment);
>+  }
>+  get [_canBeUsedToCreateContextualFragment]() {
>+    return !dart.test(this[_cannotBeUsedToCreateContextualFragment]);
>+  }
>+  get [_cannotBeUsedToCreateContextualFragment]() {
>+    return html$.Element._tagsForWhichCreateContextualFragmentIsNotSupported[$contains](this.tagName);
>+  }
>+  set [$innerHtml](html) {
>+    this[$setInnerHtml](html);
>+  }
>+  [$setInnerHtml](html, opts) {
>+    let validator = opts && 'validator' in opts ? opts.validator : null;
>+    let treeSanitizer = opts && 'treeSanitizer' in opts ? opts.treeSanitizer : null;
>+    this[$text] = null;
>+    if (html$._TrustedHtmlTreeSanitizer.is(treeSanitizer)) {
>+      this[_innerHtml] = html;
>+    } else {
>+      this[$append](this[$createFragment](html, {validator: validator, treeSanitizer: treeSanitizer}));
>+    }
>+  }
>+  get [$innerHtml]() {
>+    return this[_innerHtml];
>+  }
>+  get [$on]() {
>+    return new html$.ElementEvents.new(this);
>+  }
>+  static _hasCorruptedAttributes(element) {
>+    return (function(element) {
>+      if (!(element.attributes instanceof NamedNodeMap)) {
>+        return true;
>+      }
>+      var childNodes = element.childNodes;
>+      if (element.lastChild && element.lastChild !== childNodes[childNodes.length - 1]) {
>+        return true;
>+      }
>+      if (element.children) {
>+        if (!(element.children instanceof HTMLCollection || element.children instanceof NodeList)) {
>+          return true;
>+        }
>+      }
>+      var length = 0;
>+      if (element.children) {
>+        length = element.children.length;
>+      }
>+      for (var i = 0; i < length; i++) {
>+        var child = element.children[i];
>+        if (child.id == 'attributes' || child.name == 'attributes' || child.id == 'lastChild' || child.name == 'lastChild' || child.id == 'children' || child.name == 'children') {
>+          return true;
>+        }
>+      }
>+      return false;
>+    })(element);
>+  }
>+  static _hasCorruptedAttributesAdditionalCheck(element) {
>+    return !(element.attributes instanceof NamedNodeMap);
>+  }
>+  static _safeTagName(element) {
>+    let result = "element tag unavailable";
>+    try {
>+      if (typeof dart.dload(element, 'tagName') == 'string') {
>+        result = core.String._check(dart.dload(element, 'tagName'));
>+      }
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+    }
>+    return result;
>+  }
>+  get [$offsetParent]() {
>+    return this.offsetParent;
>+  }
>+  get [$offsetHeight]() {
>+    return this.offsetHeight[$round]();
>+  }
>+  get [$offsetLeft]() {
>+    return this.offsetLeft[$round]();
>+  }
>+  get [$offsetTop]() {
>+    return this.offsetTop[$round]();
>+  }
>+  get [$offsetWidth]() {
>+    return this.offsetWidth[$round]();
>+  }
>+  get [$scrollHeight]() {
>+    return this.scrollHeight[$round]();
>+  }
>+  get [$scrollLeft]() {
>+    return this.scrollLeft[$round]();
>+  }
>+  set [$scrollLeft](value) {
>+    this.scrollLeft = value[$round]();
>+  }
>+  get [$scrollTop]() {
>+    return this.scrollTop[$round]();
>+  }
>+  set [$scrollTop](value) {
>+    this.scrollTop = value[$round]();
>+  }
>+  get [$scrollWidth]() {
>+    return this.scrollWidth[$round]();
>+  }
>+  get [$contentEditable]() {
>+    return this.contentEditable;
>+  }
>+  set [$contentEditable](value) {
>+    this.contentEditable = value;
>+  }
>+  get [$dir]() {
>+    return this.dir;
>+  }
>+  set [$dir](value) {
>+    this.dir = value;
>+  }
>+  get [$draggable]() {
>+    return this.draggable;
>+  }
>+  set [$draggable](value) {
>+    this.draggable = value;
>+  }
>+  get [$hidden]() {
>+    return this.hidden;
>+  }
>+  set [$hidden](value) {
>+    this.hidden = value;
>+  }
>+  get [$inert]() {
>+    return this.inert;
>+  }
>+  set [$inert](value) {
>+    this.inert = value;
>+  }
>+  get [$inputMode]() {
>+    return this.inputMode;
>+  }
>+  set [$inputMode](value) {
>+    this.inputMode = value;
>+  }
>+  get [$isContentEditable]() {
>+    return this.isContentEditable;
>+  }
>+  get [$lang]() {
>+    return this.lang;
>+  }
>+  set [$lang](value) {
>+    this.lang = value;
>+  }
>+  get [$spellcheck]() {
>+    return this.spellcheck;
>+  }
>+  set [$spellcheck](value) {
>+    this.spellcheck = value;
>+  }
>+  get [$style]() {
>+    return this.style;
>+  }
>+  get [$tabIndex]() {
>+    return this.tabIndex;
>+  }
>+  set [$tabIndex](value) {
>+    this.tabIndex = value;
>+  }
>+  get [$title]() {
>+    return this.title;
>+  }
>+  set [$title](value) {
>+    this.title = value;
>+  }
>+  get [$translate]() {
>+    return this.translate;
>+  }
>+  set [$translate](value) {
>+    this.translate = value;
>+  }
>+  [$blur](...args) {
>+    return this.blur.apply(this, args);
>+  }
>+  [$click](...args) {
>+    return this.click.apply(this, args);
>+  }
>+  [$focus](...args) {
>+    return this.focus.apply(this, args);
>+  }
>+  get [$accessibleNode]() {
>+    return this.accessibleNode;
>+  }
>+  get [$assignedSlot]() {
>+    return this.assignedSlot;
>+  }
>+  get [_attributes$]() {
>+    return this.attributes;
>+  }
>+  get [$className]() {
>+    return this.className;
>+  }
>+  set [$className](value) {
>+    this.className = value;
>+  }
>+  get [$clientHeight]() {
>+    return this.clientHeight;
>+  }
>+  get [$clientLeft]() {
>+    return this.clientLeft;
>+  }
>+  get [$clientTop]() {
>+    return this.clientTop;
>+  }
>+  get [$clientWidth]() {
>+    return this.clientWidth;
>+  }
>+  get [$computedName]() {
>+    return this.computedName;
>+  }
>+  get [$computedRole]() {
>+    return this.computedRole;
>+  }
>+  get [$id]() {
>+    return this.id;
>+  }
>+  set [$id](value) {
>+    this.id = value;
>+  }
>+  get [_innerHtml]() {
>+    return this.innerHTML;
>+  }
>+  set [_innerHtml](value) {
>+    this.innerHTML = value;
>+  }
>+  get [$innerText]() {
>+    return this.innerText;
>+  }
>+  set [$innerText](value) {
>+    this.innerText = value;
>+  }
>+  get [_localName]() {
>+    return this.localName;
>+  }
>+  get [_namespaceUri]() {
>+    return this.namespaceURI;
>+  }
>+  get [$outerHtml]() {
>+    return this.outerHTML;
>+  }
>+  get [_scrollHeight]() {
>+    return this.scrollHeight;
>+  }
>+  get [_scrollLeft]() {
>+    return this.scrollLeft;
>+  }
>+  set [_scrollLeft](value) {
>+    this.scrollLeft = value;
>+  }
>+  get [_scrollTop]() {
>+    return this.scrollTop;
>+  }
>+  set [_scrollTop](value) {
>+    this.scrollTop = value;
>+  }
>+  get [_scrollWidth]() {
>+    return this.scrollWidth;
>+  }
>+  get [$slot]() {
>+    return this.slot;
>+  }
>+  set [$slot](value) {
>+    this.slot = value;
>+  }
>+  get [$styleMap]() {
>+    return this.styleMap;
>+  }
>+  get [$tagName]() {
>+    return this.tagName;
>+  }
>+  [$attachShadow](shadowRootInitDict) {
>+    let shadowRootInitDict_1 = html_common.convertDartToNative_Dictionary(shadowRootInitDict);
>+    return this[_attachShadow_1](shadowRootInitDict_1);
>+  }
>+  [_attachShadow_1](...args) {
>+    return this.attachShadow.apply(this, args);
>+  }
>+  [$closest](...args) {
>+    return this.closest.apply(this, args);
>+  }
>+  [$getAnimations](...args) {
>+    return this.getAnimations.apply(this, args);
>+  }
>+  [_getAttribute](...args) {
>+    return this.getAttribute.apply(this, args);
>+  }
>+  [_getAttributeNS](...args) {
>+    return this.getAttributeNS.apply(this, args);
>+  }
>+  [$getAttributeNames](...args) {
>+    return this.getAttributeNames.apply(this, args);
>+  }
>+  [$getBoundingClientRect](...args) {
>+    return this.getBoundingClientRect.apply(this, args);
>+  }
>+  [_getClientRects](...args) {
>+    return this.getClientRects.apply(this, args);
>+  }
>+  [$getDestinationInsertionPoints](...args) {
>+    return this.getDestinationInsertionPoints.apply(this, args);
>+  }
>+  [$getElementsByClassName](...args) {
>+    return this.getElementsByClassName.apply(this, args);
>+  }
>+  [_getElementsByTagName](...args) {
>+    return this.getElementsByTagName.apply(this, args);
>+  }
>+  [_hasAttribute](...args) {
>+    return this.hasAttribute.apply(this, args);
>+  }
>+  [_hasAttributeNS](...args) {
>+    return this.hasAttributeNS.apply(this, args);
>+  }
>+  [$hasPointerCapture](...args) {
>+    return this.hasPointerCapture.apply(this, args);
>+  }
>+  [$releasePointerCapture](...args) {
>+    return this.releasePointerCapture.apply(this, args);
>+  }
>+  [_removeAttribute](...args) {
>+    return this.removeAttribute.apply(this, args);
>+  }
>+  [_removeAttributeNS](...args) {
>+    return this.removeAttributeNS.apply(this, args);
>+  }
>+  [$requestPointerLock](...args) {
>+    return this.requestPointerLock.apply(this, args);
>+  }
>+  [$scroll](options_OR_x, y) {
>+    if (options_OR_x === void 0) options_OR_x = null;
>+    if (y === void 0) y = null;
>+    if (options_OR_x == null && y == null) {
>+      this[_scroll_1]();
>+      return;
>+    }
>+    if (core.Map.is(options_OR_x) && y == null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options_OR_x);
>+      this[_scroll_2](options_1);
>+      return;
>+    }
>+    if (y != null && typeof options_OR_x == 'number') {
>+      this[_scroll_3](options_OR_x, y);
>+      return;
>+    }
>+    dart.throw(new core.ArgumentError.new("Incorrect number or type of arguments"));
>+  }
>+  [_scroll_1](...args) {
>+    return this.scroll.apply(this, args);
>+  }
>+  [_scroll_2](...args) {
>+    return this.scroll.apply(this, args);
>+  }
>+  [_scroll_3](...args) {
>+    return this.scroll.apply(this, args);
>+  }
>+  [$scrollBy](options_OR_x, y) {
>+    if (options_OR_x === void 0) options_OR_x = null;
>+    if (y === void 0) y = null;
>+    if (options_OR_x == null && y == null) {
>+      this[_scrollBy_1]();
>+      return;
>+    }
>+    if (core.Map.is(options_OR_x) && y == null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options_OR_x);
>+      this[_scrollBy_2](options_1);
>+      return;
>+    }
>+    if (y != null && typeof options_OR_x == 'number') {
>+      this[_scrollBy_3](options_OR_x, y);
>+      return;
>+    }
>+    dart.throw(new core.ArgumentError.new("Incorrect number or type of arguments"));
>+  }
>+  [_scrollBy_1](...args) {
>+    return this.scrollBy.apply(this, args);
>+  }
>+  [_scrollBy_2](...args) {
>+    return this.scrollBy.apply(this, args);
>+  }
>+  [_scrollBy_3](...args) {
>+    return this.scrollBy.apply(this, args);
>+  }
>+  [_scrollIntoView](...args) {
>+    return this.scrollIntoView.apply(this, args);
>+  }
>+  [_scrollIntoViewIfNeeded](...args) {
>+    return this.scrollIntoViewIfNeeded.apply(this, args);
>+  }
>+  [$scrollTo](options_OR_x, y) {
>+    if (options_OR_x === void 0) options_OR_x = null;
>+    if (y === void 0) y = null;
>+    if (options_OR_x == null && y == null) {
>+      this[_scrollTo_1]();
>+      return;
>+    }
>+    if (core.Map.is(options_OR_x) && y == null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options_OR_x);
>+      this[_scrollTo_2](options_1);
>+      return;
>+    }
>+    if (y != null && typeof options_OR_x == 'number') {
>+      this[_scrollTo_3](options_OR_x, y);
>+      return;
>+    }
>+    dart.throw(new core.ArgumentError.new("Incorrect number or type of arguments"));
>+  }
>+  [_scrollTo_1](...args) {
>+    return this.scrollTo.apply(this, args);
>+  }
>+  [_scrollTo_2](...args) {
>+    return this.scrollTo.apply(this, args);
>+  }
>+  [_scrollTo_3](...args) {
>+    return this.scrollTo.apply(this, args);
>+  }
>+  [_setAttribute](...args) {
>+    return this.setAttribute.apply(this, args);
>+  }
>+  [_setAttributeNS](...args) {
>+    return this.setAttributeNS.apply(this, args);
>+  }
>+  [$setPointerCapture](...args) {
>+    return this.setPointerCapture.apply(this, args);
>+  }
>+  [$requestFullscreen](...args) {
>+    return this.webkitRequestFullscreen.apply(this, args);
>+  }
>+  [$after](...args) {
>+    return this.after.apply(this, args);
>+  }
>+  [$before](...args) {
>+    return this.before.apply(this, args);
>+  }
>+  get [$nextElementSibling]() {
>+    return this.nextElementSibling;
>+  }
>+  get [$previousElementSibling]() {
>+    return this.previousElementSibling;
>+  }
>+  get [_childElementCount]() {
>+    return this.childElementCount;
>+  }
>+  get [_children]() {
>+    return this.children;
>+  }
>+  get [_firstElementChild]() {
>+    return this.firstElementChild;
>+  }
>+  get [_lastElementChild]() {
>+    return this.lastElementChild;
>+  }
>+  [$querySelector](...args) {
>+    return this.querySelector.apply(this, args);
>+  }
>+  [_querySelectorAll](...args) {
>+    return this.querySelectorAll.apply(this, args);
>+  }
>+  get [$onAbort]() {
>+    return html$.Element.abortEvent.forElement(this);
>+  }
>+  get [$onBeforeCopy]() {
>+    return html$.Element.beforeCopyEvent.forElement(this);
>+  }
>+  get [$onBeforeCut]() {
>+    return html$.Element.beforeCutEvent.forElement(this);
>+  }
>+  get [$onBeforePaste]() {
>+    return html$.Element.beforePasteEvent.forElement(this);
>+  }
>+  get [$onBlur]() {
>+    return html$.Element.blurEvent.forElement(this);
>+  }
>+  get [$onCanPlay]() {
>+    return html$.Element.canPlayEvent.forElement(this);
>+  }
>+  get [$onCanPlayThrough]() {
>+    return html$.Element.canPlayThroughEvent.forElement(this);
>+  }
>+  get [$onChange]() {
>+    return html$.Element.changeEvent.forElement(this);
>+  }
>+  get [$onClick]() {
>+    return html$.Element.clickEvent.forElement(this);
>+  }
>+  get [$onContextMenu]() {
>+    return html$.Element.contextMenuEvent.forElement(this);
>+  }
>+  get [$onCopy]() {
>+    return html$.Element.copyEvent.forElement(this);
>+  }
>+  get [$onCut]() {
>+    return html$.Element.cutEvent.forElement(this);
>+  }
>+  get [$onDoubleClick]() {
>+    return html$.Element.doubleClickEvent.forElement(this);
>+  }
>+  get [$onDrag]() {
>+    return html$.Element.dragEvent.forElement(this);
>+  }
>+  get [$onDragEnd]() {
>+    return html$.Element.dragEndEvent.forElement(this);
>+  }
>+  get [$onDragEnter]() {
>+    return html$.Element.dragEnterEvent.forElement(this);
>+  }
>+  get [$onDragLeave]() {
>+    return html$.Element.dragLeaveEvent.forElement(this);
>+  }
>+  get [$onDragOver]() {
>+    return html$.Element.dragOverEvent.forElement(this);
>+  }
>+  get [$onDragStart]() {
>+    return html$.Element.dragStartEvent.forElement(this);
>+  }
>+  get [$onDrop]() {
>+    return html$.Element.dropEvent.forElement(this);
>+  }
>+  get [$onDurationChange]() {
>+    return html$.Element.durationChangeEvent.forElement(this);
>+  }
>+  get [$onEmptied]() {
>+    return html$.Element.emptiedEvent.forElement(this);
>+  }
>+  get [$onEnded]() {
>+    return html$.Element.endedEvent.forElement(this);
>+  }
>+  get [$onError]() {
>+    return html$.Element.errorEvent.forElement(this);
>+  }
>+  get [$onFocus]() {
>+    return html$.Element.focusEvent.forElement(this);
>+  }
>+  get [$onInput]() {
>+    return html$.Element.inputEvent.forElement(this);
>+  }
>+  get [$onInvalid]() {
>+    return html$.Element.invalidEvent.forElement(this);
>+  }
>+  get [$onKeyDown]() {
>+    return html$.Element.keyDownEvent.forElement(this);
>+  }
>+  get [$onKeyPress]() {
>+    return html$.Element.keyPressEvent.forElement(this);
>+  }
>+  get [$onKeyUp]() {
>+    return html$.Element.keyUpEvent.forElement(this);
>+  }
>+  get [$onLoad]() {
>+    return html$.Element.loadEvent.forElement(this);
>+  }
>+  get [$onLoadedData]() {
>+    return html$.Element.loadedDataEvent.forElement(this);
>+  }
>+  get [$onLoadedMetadata]() {
>+    return html$.Element.loadedMetadataEvent.forElement(this);
>+  }
>+  get [$onMouseDown]() {
>+    return html$.Element.mouseDownEvent.forElement(this);
>+  }
>+  get [$onMouseEnter]() {
>+    return html$.Element.mouseEnterEvent.forElement(this);
>+  }
>+  get [$onMouseLeave]() {
>+    return html$.Element.mouseLeaveEvent.forElement(this);
>+  }
>+  get [$onMouseMove]() {
>+    return html$.Element.mouseMoveEvent.forElement(this);
>+  }
>+  get [$onMouseOut]() {
>+    return html$.Element.mouseOutEvent.forElement(this);
>+  }
>+  get [$onMouseOver]() {
>+    return html$.Element.mouseOverEvent.forElement(this);
>+  }
>+  get [$onMouseUp]() {
>+    return html$.Element.mouseUpEvent.forElement(this);
>+  }
>+  get [$onMouseWheel]() {
>+    return html$.Element.mouseWheelEvent.forElement(this);
>+  }
>+  get [$onPaste]() {
>+    return html$.Element.pasteEvent.forElement(this);
>+  }
>+  get [$onPause]() {
>+    return html$.Element.pauseEvent.forElement(this);
>+  }
>+  get [$onPlay]() {
>+    return html$.Element.playEvent.forElement(this);
>+  }
>+  get [$onPlaying]() {
>+    return html$.Element.playingEvent.forElement(this);
>+  }
>+  get [$onRateChange]() {
>+    return html$.Element.rateChangeEvent.forElement(this);
>+  }
>+  get [$onReset]() {
>+    return html$.Element.resetEvent.forElement(this);
>+  }
>+  get [$onResize]() {
>+    return html$.Element.resizeEvent.forElement(this);
>+  }
>+  get [$onScroll]() {
>+    return html$.Element.scrollEvent.forElement(this);
>+  }
>+  get [$onSearch]() {
>+    return html$.Element.searchEvent.forElement(this);
>+  }
>+  get [$onSeeked]() {
>+    return html$.Element.seekedEvent.forElement(this);
>+  }
>+  get [$onSeeking]() {
>+    return html$.Element.seekingEvent.forElement(this);
>+  }
>+  get [$onSelect]() {
>+    return html$.Element.selectEvent.forElement(this);
>+  }
>+  get [$onSelectStart]() {
>+    return html$.Element.selectStartEvent.forElement(this);
>+  }
>+  get [$onStalled]() {
>+    return html$.Element.stalledEvent.forElement(this);
>+  }
>+  get [$onSubmit]() {
>+    return html$.Element.submitEvent.forElement(this);
>+  }
>+  get [$onSuspend]() {
>+    return html$.Element.suspendEvent.forElement(this);
>+  }
>+  get [$onTimeUpdate]() {
>+    return html$.Element.timeUpdateEvent.forElement(this);
>+  }
>+  get [$onTouchCancel]() {
>+    return html$.Element.touchCancelEvent.forElement(this);
>+  }
>+  get [$onTouchEnd]() {
>+    return html$.Element.touchEndEvent.forElement(this);
>+  }
>+  get [$onTouchEnter]() {
>+    return html$.Element.touchEnterEvent.forElement(this);
>+  }
>+  get [$onTouchLeave]() {
>+    return html$.Element.touchLeaveEvent.forElement(this);
>+  }
>+  get [$onTouchMove]() {
>+    return html$.Element.touchMoveEvent.forElement(this);
>+  }
>+  get [$onTouchStart]() {
>+    return html$.Element.touchStartEvent.forElement(this);
>+  }
>+  get [$onTransitionEnd]() {
>+    return html$.Element.transitionEndEvent.forElement(this);
>+  }
>+  get [$onVolumeChange]() {
>+    return html$.Element.volumeChangeEvent.forElement(this);
>+  }
>+  get [$onWaiting]() {
>+    return html$.Element.waitingEvent.forElement(this);
>+  }
>+  get [$onFullscreenChange]() {
>+    return html$.Element.fullscreenChangeEvent.forElement(this);
>+  }
>+  get [$onFullscreenError]() {
>+    return html$.Element.fullscreenErrorEvent.forElement(this);
>+  }
>+  get [$onWheel]() {
>+    return html$.Element.wheelEvent.forElement(this);
>+  }
>+};
>+(html$.Element.created = function() {
>+  this[offsetParent] = null;
>+  this[contentEditable] = null;
>+  this[dir] = null;
>+  this[draggable] = null;
>+  this[hidden] = null;
>+  this[inert] = null;
>+  this[inputMode] = null;
>+  this[lang] = null;
>+  this[spellcheck] = null;
>+  this[style] = null;
>+  this[tabIndex] = null;
>+  this[title] = null;
>+  this[translate] = null;
>+  this[accessibleNode] = null;
>+  this[assignedSlot] = null;
>+  this[_attributes$] = null;
>+  this[className] = null;
>+  this[clientHeight] = null;
>+  this[clientLeft] = null;
>+  this[clientTop] = null;
>+  this[clientWidth] = null;
>+  this[computedName] = null;
>+  this[computedRole] = null;
>+  this[id] = null;
>+  this[_innerHtml] = null;
>+  this[innerText] = null;
>+  this[_localName] = null;
>+  this[_namespaceUri] = null;
>+  this[_scrollHeight] = null;
>+  this[_scrollLeft] = null;
>+  this[_scrollTop] = null;
>+  this[_scrollWidth] = null;
>+  this[slot] = null;
>+  this[styleMap] = null;
>+  this[tagName] = null;
>+  this[nextElementSibling] = null;
>+  this[previousElementSibling] = null;
>+  this[_childElementCount] = null;
>+  this[_children] = null;
>+  this[_firstElementChild] = null;
>+  this[_lastElementChild] = null;
>+  html$.Element.__proto__._created.call(this);
>+}).prototype = html$.Element.prototype;
>+dart.addTypeTests(html$.Element);
>+const offsetParent = Symbol("Element.offsetParent");
>+const contentEditable = Symbol("Element.contentEditable");
>+const dir = Symbol("Element.dir");
>+const draggable = Symbol("Element.draggable");
>+const hidden = Symbol("Element.hidden");
>+const inert = Symbol("Element.inert");
>+const inputMode = Symbol("Element.inputMode");
>+const lang = Symbol("Element.lang");
>+const spellcheck = Symbol("Element.spellcheck");
>+const style = Symbol("Element.style");
>+const tabIndex = Symbol("Element.tabIndex");
>+const title = Symbol("Element.title");
>+const translate = Symbol("Element.translate");
>+const accessibleNode = Symbol("Element.accessibleNode");
>+const assignedSlot = Symbol("Element.assignedSlot");
>+const className = Symbol("Element.className");
>+const clientHeight = Symbol("Element.clientHeight");
>+const clientLeft = Symbol("Element.clientLeft");
>+const clientTop = Symbol("Element.clientTop");
>+const clientWidth = Symbol("Element.clientWidth");
>+const computedName = Symbol("Element.computedName");
>+const computedRole = Symbol("Element.computedRole");
>+const id = Symbol("Element.id");
>+const innerText = Symbol("Element.innerText");
>+const slot = Symbol("Element.slot");
>+const styleMap = Symbol("Element.styleMap");
>+const tagName = Symbol("Element.tagName");
>+const nextElementSibling = Symbol("Element.nextElementSibling");
>+const previousElementSibling = Symbol("Element.previousElementSibling");
>+html$.Element[dart.implements] = () => [html$.NonDocumentTypeChildNode, html$.GlobalEventHandlers, html$.ParentNode, html$.ChildNode];
>+dart.setMethodSignature(html$.Element, () => ({
>+  __proto__: dart.getMethods(html$.Element.__proto__),
>+  [$getAttribute]: dart.fnType(core.String, [core.String]),
>+  [$getAttributeNS]: dart.fnType(core.String, [core.String, core.String]),
>+  [$hasAttribute]: dart.fnType(core.bool, [core.String]),
>+  [$hasAttributeNS]: dart.fnType(core.bool, [core.String, core.String]),
>+  [$removeAttribute]: dart.fnType(dart.void, [core.String]),
>+  [$removeAttributeNS]: dart.fnType(dart.void, [core.String, core.String]),
>+  [$setAttribute]: dart.fnType(dart.void, [core.String, core.String]),
>+  [$setAttributeNS]: dart.fnType(dart.void, [core.String, core.String, core.String]),
>+  [$querySelectorAll]: dart.gFnType(T => [html$.ElementList$(T), [core.String]], T => [html$.Element]),
>+  [_setApplyScroll]: dart.fnType(dart.void, [dart.fnType(dart.void, [html$.ScrollState]), core.String]),
>+  [$setApplyScroll]: dart.fnType(async.Future$(html$.ScrollState), [core.String]),
>+  [_setDistributeScroll]: dart.fnType(dart.void, [dart.fnType(dart.void, [html$.ScrollState]), core.String]),
>+  [$setDistributeScroll]: dart.fnType(async.Future$(html$.ScrollState), [core.String]),
>+  [$getNamespacedAttributes]: dart.fnType(core.Map$(core.String, core.String), [core.String]),
>+  [$getComputedStyle]: dart.fnType(html$.CssStyleDeclaration, [], [core.String]),
>+  [$appendText]: dart.fnType(dart.void, [core.String]),
>+  [$appendHtml]: dart.fnType(dart.void, [core.String], {validator: html$.NodeValidator, treeSanitizer: html$.NodeTreeSanitizer}),
>+  [$attached]: dart.fnType(dart.void, []),
>+  [$detached]: dart.fnType(dart.void, []),
>+  [$enteredView]: dart.fnType(dart.void, []),
>+  [$getClientRects]: dart.fnType(core.List$(math.Rectangle$(core.num)), []),
>+  [$leftView]: dart.fnType(dart.void, []),
>+  [$animate]: dart.fnType(html$.Animation, [core.Iterable$(core.Map$(core.String, dart.dynamic))], [dart.dynamic]),
>+  [_animate]: dart.fnType(html$.Animation, [core.Object], [dart.dynamic]),
>+  [$attributeChanged]: dart.fnType(dart.void, [core.String, core.String, core.String]),
>+  [$scrollIntoView]: dart.fnType(dart.void, [], [html$.ScrollAlignment]),
>+  [$insertAdjacentText]: dart.fnType(dart.void, [core.String, core.String]),
>+  [_insertAdjacentText]: dart.fnType(dart.void, [core.String, core.String]),
>+  [$insertAdjacentHtml]: dart.fnType(dart.void, [core.String, core.String], {validator: html$.NodeValidator, treeSanitizer: html$.NodeTreeSanitizer}),
>+  [_insertAdjacentHtml]: dart.fnType(dart.void, [core.String, core.String]),
>+  [$insertAdjacentElement]: dart.fnType(html$.Element, [core.String, html$.Element]),
>+  [_insertAdjacentElement]: dart.fnType(dart.void, [core.String, html$.Element]),
>+  [_insertAdjacentNode]: dart.fnType(dart.void, [core.String, html$.Node]),
>+  [$matches]: dart.fnType(core.bool, [core.String]),
>+  [$matchesWithAncestors]: dart.fnType(core.bool, [core.String]),
>+  [$createShadowRoot]: dart.fnType(html$.ShadowRoot, []),
>+  [$offsetTo]: dart.fnType(math.Point$(core.num), [html$.Element]),
>+  [$createFragment]: dart.fnType(html$.DocumentFragment, [core.String], {validator: html$.NodeValidator, treeSanitizer: html$.NodeTreeSanitizer}),
>+  [$setInnerHtml]: dart.fnType(dart.void, [core.String], {validator: html$.NodeValidator, treeSanitizer: html$.NodeTreeSanitizer}),
>+  [$blur]: dart.fnType(dart.void, []),
>+  [$click]: dart.fnType(dart.void, []),
>+  [$focus]: dart.fnType(dart.void, []),
>+  [$attachShadow]: dart.fnType(html$.ShadowRoot, [core.Map]),
>+  [_attachShadow_1]: dart.fnType(html$.ShadowRoot, [dart.dynamic]),
>+  [$closest]: dart.fnType(html$.Element, [core.String]),
>+  [$getAnimations]: dart.fnType(core.List$(html$.Animation), []),
>+  [_getAttribute]: dart.fnType(core.String, [core.String]),
>+  [_getAttributeNS]: dart.fnType(core.String, [core.String, core.String]),
>+  [$getAttributeNames]: dart.fnType(core.List$(core.String), []),
>+  [$getBoundingClientRect]: dart.fnType(math.Rectangle$(core.num), []),
>+  [_getClientRects]: dart.fnType(core.List$(math.Rectangle$(core.num)), []),
>+  [$getDestinationInsertionPoints]: dart.fnType(core.List$(html$.Node), []),
>+  [$getElementsByClassName]: dart.fnType(core.List$(html$.Node), [core.String]),
>+  [_getElementsByTagName]: dart.fnType(core.List$(html$.Node), [core.String]),
>+  [_hasAttribute]: dart.fnType(core.bool, [core.String]),
>+  [_hasAttributeNS]: dart.fnType(core.bool, [core.String, core.String]),
>+  [$hasPointerCapture]: dart.fnType(core.bool, [core.int]),
>+  [$releasePointerCapture]: dart.fnType(dart.void, [core.int]),
>+  [_removeAttribute]: dart.fnType(dart.void, [core.String]),
>+  [_removeAttributeNS]: dart.fnType(dart.void, [core.String, core.String]),
>+  [$requestPointerLock]: dart.fnType(dart.void, []),
>+  [$scroll]: dart.fnType(dart.void, [], [dart.dynamic, core.num]),
>+  [_scroll_1]: dart.fnType(dart.void, []),
>+  [_scroll_2]: dart.fnType(dart.void, [dart.dynamic]),
>+  [_scroll_3]: dart.fnType(dart.void, [core.num, dart.dynamic]),
>+  [$scrollBy]: dart.fnType(dart.void, [], [dart.dynamic, core.num]),
>+  [_scrollBy_1]: dart.fnType(dart.void, []),
>+  [_scrollBy_2]: dart.fnType(dart.void, [dart.dynamic]),
>+  [_scrollBy_3]: dart.fnType(dart.void, [core.num, dart.dynamic]),
>+  [_scrollIntoView]: dart.fnType(dart.void, [], [core.Object]),
>+  [_scrollIntoViewIfNeeded]: dart.fnType(dart.void, [], [core.bool]),
>+  [$scrollTo]: dart.fnType(dart.void, [], [dart.dynamic, core.num]),
>+  [_scrollTo_1]: dart.fnType(dart.void, []),
>+  [_scrollTo_2]: dart.fnType(dart.void, [dart.dynamic]),
>+  [_scrollTo_3]: dart.fnType(dart.void, [core.num, dart.dynamic]),
>+  [_setAttribute]: dart.fnType(dart.void, [core.String, core.String]),
>+  [_setAttributeNS]: dart.fnType(dart.void, [core.String, core.String, core.String]),
>+  [$setPointerCapture]: dart.fnType(dart.void, [core.int]),
>+  [$requestFullscreen]: dart.fnType(dart.void, []),
>+  [$after]: dart.fnType(dart.void, [core.Object]),
>+  [$before]: dart.fnType(dart.void, [core.Object]),
>+  [$querySelector]: dart.fnType(html$.Element, [core.String]),
>+  [_querySelectorAll]: dart.fnType(core.List$(html$.Node), [core.String])
>+}));
>+dart.setGetterSignature(html$.Element, () => ({
>+  __proto__: dart.getGetters(html$.Element.__proto__),
>+  [$attributes]: core.Map$(core.String, core.String),
>+  [$children]: core.List$(html$.Element),
>+  [$classes]: html$.CssClassSet,
>+  [$dataset]: core.Map$(core.String, core.String),
>+  [$client]: math.Rectangle$(core.num),
>+  [$offset]: math.Rectangle$(core.num),
>+  [$localName]: core.String,
>+  [$namespaceUri]: core.String,
>+  [$shadowRoot]: html$.ShadowRoot,
>+  [$contentEdge]: html$.CssRect,
>+  [$paddingEdge]: html$.CssRect,
>+  [$borderEdge]: html$.CssRect,
>+  [$marginEdge]: html$.CssRect,
>+  [$documentOffset]: math.Point$(core.num),
>+  [_canBeUsedToCreateContextualFragment]: core.bool,
>+  [_cannotBeUsedToCreateContextualFragment]: core.bool,
>+  [$innerHtml]: core.String,
>+  [$on]: html$.ElementEvents,
>+  [$offsetHeight]: core.int,
>+  [$offsetLeft]: core.int,
>+  [$offsetTop]: core.int,
>+  [$offsetWidth]: core.int,
>+  [$scrollHeight]: core.int,
>+  [$scrollLeft]: core.int,
>+  [$scrollTop]: core.int,
>+  [$scrollWidth]: core.int,
>+  [$isContentEditable]: core.bool,
>+  [$outerHtml]: core.String,
>+  [$onAbort]: html$.ElementStream$(html$.Event),
>+  [$onBeforeCopy]: html$.ElementStream$(html$.Event),
>+  [$onBeforeCut]: html$.ElementStream$(html$.Event),
>+  [$onBeforePaste]: html$.ElementStream$(html$.Event),
>+  [$onBlur]: html$.ElementStream$(html$.Event),
>+  [$onCanPlay]: html$.ElementStream$(html$.Event),
>+  [$onCanPlayThrough]: html$.ElementStream$(html$.Event),
>+  [$onChange]: html$.ElementStream$(html$.Event),
>+  [$onClick]: html$.ElementStream$(html$.MouseEvent),
>+  [$onContextMenu]: html$.ElementStream$(html$.MouseEvent),
>+  [$onCopy]: html$.ElementStream$(html$.ClipboardEvent),
>+  [$onCut]: html$.ElementStream$(html$.ClipboardEvent),
>+  [$onDoubleClick]: html$.ElementStream$(html$.Event),
>+  [$onDrag]: html$.ElementStream$(html$.MouseEvent),
>+  [$onDragEnd]: html$.ElementStream$(html$.MouseEvent),
>+  [$onDragEnter]: html$.ElementStream$(html$.MouseEvent),
>+  [$onDragLeave]: html$.ElementStream$(html$.MouseEvent),
>+  [$onDragOver]: html$.ElementStream$(html$.MouseEvent),
>+  [$onDragStart]: html$.ElementStream$(html$.MouseEvent),
>+  [$onDrop]: html$.ElementStream$(html$.MouseEvent),
>+  [$onDurationChange]: html$.ElementStream$(html$.Event),
>+  [$onEmptied]: html$.ElementStream$(html$.Event),
>+  [$onEnded]: html$.ElementStream$(html$.Event),
>+  [$onError]: html$.ElementStream$(html$.Event),
>+  [$onFocus]: html$.ElementStream$(html$.Event),
>+  [$onInput]: html$.ElementStream$(html$.Event),
>+  [$onInvalid]: html$.ElementStream$(html$.Event),
>+  [$onKeyDown]: html$.ElementStream$(html$.KeyboardEvent),
>+  [$onKeyPress]: html$.ElementStream$(html$.KeyboardEvent),
>+  [$onKeyUp]: html$.ElementStream$(html$.KeyboardEvent),
>+  [$onLoad]: html$.ElementStream$(html$.Event),
>+  [$onLoadedData]: html$.ElementStream$(html$.Event),
>+  [$onLoadedMetadata]: html$.ElementStream$(html$.Event),
>+  [$onMouseDown]: html$.ElementStream$(html$.MouseEvent),
>+  [$onMouseEnter]: html$.ElementStream$(html$.MouseEvent),
>+  [$onMouseLeave]: html$.ElementStream$(html$.MouseEvent),
>+  [$onMouseMove]: html$.ElementStream$(html$.MouseEvent),
>+  [$onMouseOut]: html$.ElementStream$(html$.MouseEvent),
>+  [$onMouseOver]: html$.ElementStream$(html$.MouseEvent),
>+  [$onMouseUp]: html$.ElementStream$(html$.MouseEvent),
>+  [$onMouseWheel]: html$.ElementStream$(html$.WheelEvent),
>+  [$onPaste]: html$.ElementStream$(html$.ClipboardEvent),
>+  [$onPause]: html$.ElementStream$(html$.Event),
>+  [$onPlay]: html$.ElementStream$(html$.Event),
>+  [$onPlaying]: html$.ElementStream$(html$.Event),
>+  [$onRateChange]: html$.ElementStream$(html$.Event),
>+  [$onReset]: html$.ElementStream$(html$.Event),
>+  [$onResize]: html$.ElementStream$(html$.Event),
>+  [$onScroll]: html$.ElementStream$(html$.Event),
>+  [$onSearch]: html$.ElementStream$(html$.Event),
>+  [$onSeeked]: html$.ElementStream$(html$.Event),
>+  [$onSeeking]: html$.ElementStream$(html$.Event),
>+  [$onSelect]: html$.ElementStream$(html$.Event),
>+  [$onSelectStart]: html$.ElementStream$(html$.Event),
>+  [$onStalled]: html$.ElementStream$(html$.Event),
>+  [$onSubmit]: html$.ElementStream$(html$.Event),
>+  [$onSuspend]: html$.ElementStream$(html$.Event),
>+  [$onTimeUpdate]: html$.ElementStream$(html$.Event),
>+  [$onTouchCancel]: html$.ElementStream$(html$.TouchEvent),
>+  [$onTouchEnd]: html$.ElementStream$(html$.TouchEvent),
>+  [$onTouchEnter]: html$.ElementStream$(html$.TouchEvent),
>+  [$onTouchLeave]: html$.ElementStream$(html$.TouchEvent),
>+  [$onTouchMove]: html$.ElementStream$(html$.TouchEvent),
>+  [$onTouchStart]: html$.ElementStream$(html$.TouchEvent),
>+  [$onTransitionEnd]: html$.ElementStream$(html$.TransitionEvent),
>+  [$onVolumeChange]: html$.ElementStream$(html$.Event),
>+  [$onWaiting]: html$.ElementStream$(html$.Event),
>+  [$onFullscreenChange]: html$.ElementStream$(html$.Event),
>+  [$onFullscreenError]: html$.ElementStream$(html$.Event),
>+  [$onWheel]: html$.ElementStream$(html$.WheelEvent)
>+}));
>+dart.setSetterSignature(html$.Element, () => ({
>+  __proto__: dart.getSetters(html$.Element.__proto__),
>+  [$attributes]: core.Map$(core.String, core.String),
>+  [$children]: core.List$(html$.Element),
>+  [$classes]: core.Iterable$(core.String),
>+  [$dataset]: core.Map$(core.String, core.String),
>+  [$innerHtml]: core.String,
>+  [$scrollLeft]: core.int,
>+  [$scrollTop]: core.int
>+}));
>+dart.setLibraryUri(html$.Element, "dart:html");
>+dart.setFieldSignature(html$.Element, () => ({
>+  __proto__: dart.getFields(html$.Element.__proto__),
>+  [$offsetParent]: dart.finalFieldType(html$.Element),
>+  [$contentEditable]: dart.fieldType(core.String),
>+  [$dir]: dart.fieldType(core.String),
>+  [$draggable]: dart.fieldType(core.bool),
>+  [$hidden]: dart.fieldType(core.bool),
>+  [$inert]: dart.fieldType(core.bool),
>+  [$inputMode]: dart.fieldType(core.String),
>+  [$lang]: dart.fieldType(core.String),
>+  [$spellcheck]: dart.fieldType(core.bool),
>+  [$style]: dart.finalFieldType(html$.CssStyleDeclaration),
>+  [$tabIndex]: dart.fieldType(core.int),
>+  [$title]: dart.fieldType(core.String),
>+  [$translate]: dart.fieldType(core.bool),
>+  [$accessibleNode]: dart.finalFieldType(html$.AccessibleNode),
>+  [$assignedSlot]: dart.finalFieldType(html$.SlotElement),
>+  [_attributes$]: dart.finalFieldType(html$._NamedNodeMap),
>+  [$className]: dart.fieldType(core.String),
>+  [$clientHeight]: dart.finalFieldType(core.int),
>+  [$clientLeft]: dart.finalFieldType(core.int),
>+  [$clientTop]: dart.finalFieldType(core.int),
>+  [$clientWidth]: dart.finalFieldType(core.int),
>+  [$computedName]: dart.finalFieldType(core.String),
>+  [$computedRole]: dart.finalFieldType(core.String),
>+  [$id]: dart.fieldType(core.String),
>+  [_innerHtml]: dart.fieldType(core.String),
>+  [$innerText]: dart.fieldType(core.String),
>+  [_localName]: dart.finalFieldType(core.String),
>+  [_namespaceUri]: dart.finalFieldType(core.String),
>+  [_scrollHeight]: dart.finalFieldType(core.int),
>+  [_scrollLeft]: dart.fieldType(core.num),
>+  [_scrollTop]: dart.fieldType(core.num),
>+  [_scrollWidth]: dart.finalFieldType(core.int),
>+  [$slot]: dart.fieldType(core.String),
>+  [$styleMap]: dart.finalFieldType(html$.StylePropertyMap),
>+  [$tagName]: dart.finalFieldType(core.String),
>+  [$nextElementSibling]: dart.finalFieldType(html$.Element),
>+  [$previousElementSibling]: dart.finalFieldType(html$.Element),
>+  [_childElementCount]: dart.finalFieldType(core.int),
>+  [_children]: dart.finalFieldType(ListOfNode()),
>+  [_firstElementChild]: dart.finalFieldType(html$.Element),
>+  [_lastElementChild]: dart.finalFieldType(html$.Element)
>+}));
>+dart.defineLazy(html$.Element, {
>+  /*html$.Element.mouseWheelEvent*/get mouseWheelEvent() {
>+    return dart.const(new (_CustomEventStreamProviderOfWheelEvent()).new(dart.fn(html$.Element._determineMouseWheelEventType, EventTargetToString())));
>+  },
>+  /*html$.Element.transitionEndEvent*/get transitionEndEvent() {
>+    return dart.const(new (_CustomEventStreamProviderOfTransitionEvent()).new(dart.fn(html$.Element._determineTransitionEventType, EventTargetToString())));
>+  },
>+  /*html$.Element._parseDocument*/get _parseDocument() {
>+    return null;
>+  },
>+  set _parseDocument(_) {},
>+  /*html$.Element._parseRange*/get _parseRange() {
>+    return null;
>+  },
>+  set _parseRange(_) {},
>+  /*html$.Element._defaultValidator*/get _defaultValidator() {
>+    return null;
>+  },
>+  set _defaultValidator(_) {},
>+  /*html$.Element._defaultSanitizer*/get _defaultSanitizer() {
>+    return null;
>+  },
>+  set _defaultSanitizer(_) {},
>+  /*html$.Element._tagsForWhichCreateContextualFragmentIsNotSupported*/get _tagsForWhichCreateContextualFragmentIsNotSupported() {
>+    return dart.constList(["HEAD", "AREA", "BASE", "BASEFONT", "BR", "COL", "COLGROUP", "EMBED", "FRAME", "FRAMESET", "HR", "IMAGE", "IMG", "INPUT", "ISINDEX", "LINK", "META", "PARAM", "SOURCE", "STYLE", "TITLE", "WBR"], core.String);
>+  },
>+  /*html$.Element.abortEvent*/get abortEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("abort"));
>+  },
>+  /*html$.Element.beforeCopyEvent*/get beforeCopyEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("beforecopy"));
>+  },
>+  /*html$.Element.beforeCutEvent*/get beforeCutEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("beforecut"));
>+  },
>+  /*html$.Element.beforePasteEvent*/get beforePasteEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("beforepaste"));
>+  },
>+  /*html$.Element.blurEvent*/get blurEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("blur"));
>+  },
>+  /*html$.Element.canPlayEvent*/get canPlayEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("canplay"));
>+  },
>+  /*html$.Element.canPlayThroughEvent*/get canPlayThroughEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("canplaythrough"));
>+  },
>+  /*html$.Element.changeEvent*/get changeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("change"));
>+  },
>+  /*html$.Element.clickEvent*/get clickEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("click"));
>+  },
>+  /*html$.Element.contextMenuEvent*/get contextMenuEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("contextmenu"));
>+  },
>+  /*html$.Element.copyEvent*/get copyEvent() {
>+    return dart.const(new (EventStreamProviderOfClipboardEvent()).new("copy"));
>+  },
>+  /*html$.Element.cutEvent*/get cutEvent() {
>+    return dart.const(new (EventStreamProviderOfClipboardEvent()).new("cut"));
>+  },
>+  /*html$.Element.doubleClickEvent*/get doubleClickEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("dblclick"));
>+  },
>+  /*html$.Element.dragEvent*/get dragEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("drag"));
>+  },
>+  /*html$.Element.dragEndEvent*/get dragEndEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("dragend"));
>+  },
>+  /*html$.Element.dragEnterEvent*/get dragEnterEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("dragenter"));
>+  },
>+  /*html$.Element.dragLeaveEvent*/get dragLeaveEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("dragleave"));
>+  },
>+  /*html$.Element.dragOverEvent*/get dragOverEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("dragover"));
>+  },
>+  /*html$.Element.dragStartEvent*/get dragStartEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("dragstart"));
>+  },
>+  /*html$.Element.dropEvent*/get dropEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("drop"));
>+  },
>+  /*html$.Element.durationChangeEvent*/get durationChangeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("durationchange"));
>+  },
>+  /*html$.Element.emptiedEvent*/get emptiedEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("emptied"));
>+  },
>+  /*html$.Element.endedEvent*/get endedEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("ended"));
>+  },
>+  /*html$.Element.errorEvent*/get errorEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("error"));
>+  },
>+  /*html$.Element.focusEvent*/get focusEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("focus"));
>+  },
>+  /*html$.Element.inputEvent*/get inputEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("input"));
>+  },
>+  /*html$.Element.invalidEvent*/get invalidEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("invalid"));
>+  },
>+  /*html$.Element.keyDownEvent*/get keyDownEvent() {
>+    return dart.const(new (EventStreamProviderOfKeyboardEvent()).new("keydown"));
>+  },
>+  /*html$.Element.keyPressEvent*/get keyPressEvent() {
>+    return dart.const(new (EventStreamProviderOfKeyboardEvent()).new("keypress"));
>+  },
>+  /*html$.Element.keyUpEvent*/get keyUpEvent() {
>+    return dart.const(new (EventStreamProviderOfKeyboardEvent()).new("keyup"));
>+  },
>+  /*html$.Element.loadEvent*/get loadEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("load"));
>+  },
>+  /*html$.Element.loadedDataEvent*/get loadedDataEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("loadeddata"));
>+  },
>+  /*html$.Element.loadedMetadataEvent*/get loadedMetadataEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("loadedmetadata"));
>+  },
>+  /*html$.Element.mouseDownEvent*/get mouseDownEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("mousedown"));
>+  },
>+  /*html$.Element.mouseEnterEvent*/get mouseEnterEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("mouseenter"));
>+  },
>+  /*html$.Element.mouseLeaveEvent*/get mouseLeaveEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("mouseleave"));
>+  },
>+  /*html$.Element.mouseMoveEvent*/get mouseMoveEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("mousemove"));
>+  },
>+  /*html$.Element.mouseOutEvent*/get mouseOutEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("mouseout"));
>+  },
>+  /*html$.Element.mouseOverEvent*/get mouseOverEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("mouseover"));
>+  },
>+  /*html$.Element.mouseUpEvent*/get mouseUpEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("mouseup"));
>+  },
>+  /*html$.Element.pasteEvent*/get pasteEvent() {
>+    return dart.const(new (EventStreamProviderOfClipboardEvent()).new("paste"));
>+  },
>+  /*html$.Element.pauseEvent*/get pauseEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("pause"));
>+  },
>+  /*html$.Element.playEvent*/get playEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("play"));
>+  },
>+  /*html$.Element.playingEvent*/get playingEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("playing"));
>+  },
>+  /*html$.Element.rateChangeEvent*/get rateChangeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("ratechange"));
>+  },
>+  /*html$.Element.resetEvent*/get resetEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("reset"));
>+  },
>+  /*html$.Element.resizeEvent*/get resizeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("resize"));
>+  },
>+  /*html$.Element.scrollEvent*/get scrollEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("scroll"));
>+  },
>+  /*html$.Element.searchEvent*/get searchEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("search"));
>+  },
>+  /*html$.Element.seekedEvent*/get seekedEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("seeked"));
>+  },
>+  /*html$.Element.seekingEvent*/get seekingEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("seeking"));
>+  },
>+  /*html$.Element.selectEvent*/get selectEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("select"));
>+  },
>+  /*html$.Element.selectStartEvent*/get selectStartEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("selectstart"));
>+  },
>+  /*html$.Element.stalledEvent*/get stalledEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("stalled"));
>+  },
>+  /*html$.Element.submitEvent*/get submitEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("submit"));
>+  },
>+  /*html$.Element.suspendEvent*/get suspendEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("suspend"));
>+  },
>+  /*html$.Element.timeUpdateEvent*/get timeUpdateEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("timeupdate"));
>+  },
>+  /*html$.Element.touchCancelEvent*/get touchCancelEvent() {
>+    return dart.const(new (EventStreamProviderOfTouchEvent()).new("touchcancel"));
>+  },
>+  /*html$.Element.touchEndEvent*/get touchEndEvent() {
>+    return dart.const(new (EventStreamProviderOfTouchEvent()).new("touchend"));
>+  },
>+  /*html$.Element.touchEnterEvent*/get touchEnterEvent() {
>+    return dart.const(new (EventStreamProviderOfTouchEvent()).new("touchenter"));
>+  },
>+  /*html$.Element.touchLeaveEvent*/get touchLeaveEvent() {
>+    return dart.const(new (EventStreamProviderOfTouchEvent()).new("touchleave"));
>+  },
>+  /*html$.Element.touchMoveEvent*/get touchMoveEvent() {
>+    return dart.const(new (EventStreamProviderOfTouchEvent()).new("touchmove"));
>+  },
>+  /*html$.Element.touchStartEvent*/get touchStartEvent() {
>+    return dart.const(new (EventStreamProviderOfTouchEvent()).new("touchstart"));
>+  },
>+  /*html$.Element.volumeChangeEvent*/get volumeChangeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("volumechange"));
>+  },
>+  /*html$.Element.waitingEvent*/get waitingEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("waiting"));
>+  },
>+  /*html$.Element.fullscreenChangeEvent*/get fullscreenChangeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("webkitfullscreenchange"));
>+  },
>+  /*html$.Element.fullscreenErrorEvent*/get fullscreenErrorEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("webkitfullscreenerror"));
>+  },
>+  /*html$.Element.wheelEvent*/get wheelEvent() {
>+    return dart.const(new (EventStreamProviderOfWheelEvent()).new("wheel"));
>+  }
>+});
>+dart.registerExtension("Element", html$.Element);
>+html$.HtmlElement = class HtmlElement extends html$.Element {
>+  static new() {
>+    dart.throw(new core.UnsupportedError.new("Not supported"));
>+  }
>+  get [$nonce]() {
>+    return this.nonce;
>+  }
>+  set [$nonce](value) {
>+    this.nonce = value;
>+  }
>+};
>+(html$.HtmlElement.created = function() {
>+  this[nonce] = null;
>+  html$.HtmlElement.__proto__.created.call(this);
>+}).prototype = html$.HtmlElement.prototype;
>+dart.addTypeTests(html$.HtmlElement);
>+const nonce = Symbol("HtmlElement.nonce");
>+html$.HtmlElement[dart.implements] = () => [html$.NoncedElement];
>+dart.setLibraryUri(html$.HtmlElement, "dart:html");
>+dart.setFieldSignature(html$.HtmlElement, () => ({
>+  __proto__: dart.getFields(html$.HtmlElement.__proto__),
>+  [$nonce]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("HTMLElement", html$.HtmlElement);
>+dart.copyProperties(html$, {
>+  get _workerSelf() {
>+    return self;
>+  }
>+});
>+html$.ExtendableEvent = class ExtendableEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.ExtendableEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.ExtendableEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new ExtendableEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new ExtendableEvent(type);
>+  }
>+  [$waitUntil](...args) {
>+    return this.waitUntil.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.ExtendableEvent);
>+dart.setMethodSignature(html$.ExtendableEvent, () => ({
>+  __proto__: dart.getMethods(html$.ExtendableEvent.__proto__),
>+  [$waitUntil]: dart.fnType(dart.void, [async.Future])
>+}));
>+dart.setLibraryUri(html$.ExtendableEvent, "dart:html");
>+dart.registerExtension("ExtendableEvent", html$.ExtendableEvent);
>+html$.AbortPaymentEvent = class AbortPaymentEvent$ extends html$.ExtendableEvent {
>+  static new(type, eventInitDict) {
>+    let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+    return html$.AbortPaymentEvent._create_1(type, eventInitDict_1);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new AbortPaymentEvent(type, eventInitDict);
>+  }
>+  [$respondWith](...args) {
>+    return this.respondWith.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.AbortPaymentEvent);
>+dart.setMethodSignature(html$.AbortPaymentEvent, () => ({
>+  __proto__: dart.getMethods(html$.AbortPaymentEvent.__proto__),
>+  [$respondWith]: dart.fnType(dart.void, [async.Future])
>+}));
>+dart.setLibraryUri(html$.AbortPaymentEvent, "dart:html");
>+dart.registerExtension("AbortPaymentEvent", html$.AbortPaymentEvent);
>+html$.Sensor = class Sensor extends html$.EventTarget {
>+  get [$activated]() {
>+    return this.activated;
>+  }
>+  get [$hasReading]() {
>+    return this.hasReading;
>+  }
>+  get [$timestamp]() {
>+    return this.timestamp;
>+  }
>+  [$start](...args) {
>+    return this.start.apply(this, args);
>+  }
>+  [$stop](...args) {
>+    return this.stop.apply(this, args);
>+  }
>+  get [$onError]() {
>+    return html$.Sensor.errorEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.Sensor);
>+const activated = Symbol("Sensor.activated");
>+const hasReading = Symbol("Sensor.hasReading");
>+const timestamp = Symbol("Sensor.timestamp");
>+dart.setMethodSignature(html$.Sensor, () => ({
>+  __proto__: dart.getMethods(html$.Sensor.__proto__),
>+  [$start]: dart.fnType(dart.void, []),
>+  [$stop]: dart.fnType(dart.void, [])
>+}));
>+dart.setGetterSignature(html$.Sensor, () => ({
>+  __proto__: dart.getGetters(html$.Sensor.__proto__),
>+  [$onError]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.Sensor, "dart:html");
>+dart.setFieldSignature(html$.Sensor, () => ({
>+  __proto__: dart.getFields(html$.Sensor.__proto__),
>+  [$activated]: dart.finalFieldType(core.bool),
>+  [$hasReading]: dart.finalFieldType(core.bool),
>+  [$timestamp]: dart.finalFieldType(core.num)
>+}));
>+dart.defineLazy(html$.Sensor, {
>+  /*html$.Sensor.errorEvent*/get errorEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("error"));
>+  }
>+});
>+dart.registerExtension("Sensor", html$.Sensor);
>+html$.OrientationSensor = class OrientationSensor extends html$.Sensor {
>+  get [$quaternion]() {
>+    return this.quaternion;
>+  }
>+  [$populateMatrix](...args) {
>+    return this.populateMatrix.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.OrientationSensor);
>+const quaternion = Symbol("OrientationSensor.quaternion");
>+dart.setMethodSignature(html$.OrientationSensor, () => ({
>+  __proto__: dart.getMethods(html$.OrientationSensor.__proto__),
>+  [$populateMatrix]: dart.fnType(dart.void, [core.Object])
>+}));
>+dart.setLibraryUri(html$.OrientationSensor, "dart:html");
>+dart.setFieldSignature(html$.OrientationSensor, () => ({
>+  __proto__: dart.getFields(html$.OrientationSensor.__proto__),
>+  [$quaternion]: dart.finalFieldType(ListOfnum())
>+}));
>+dart.registerExtension("OrientationSensor", html$.OrientationSensor);
>+html$.AbsoluteOrientationSensor = class AbsoluteOrientationSensor$ extends html$.OrientationSensor {
>+  static new(sensorOptions) {
>+    if (sensorOptions === void 0) sensorOptions = null;
>+    if (sensorOptions != null) {
>+      let sensorOptions_1 = html_common.convertDartToNative_Dictionary(sensorOptions);
>+      return html$.AbsoluteOrientationSensor._create_1(sensorOptions_1);
>+    }
>+    return html$.AbsoluteOrientationSensor._create_2();
>+  }
>+  static _create_1(sensorOptions) {
>+    return new AbsoluteOrientationSensor(sensorOptions);
>+  }
>+  static _create_2() {
>+    return new AbsoluteOrientationSensor();
>+  }
>+};
>+dart.addTypeTests(html$.AbsoluteOrientationSensor);
>+dart.setLibraryUri(html$.AbsoluteOrientationSensor, "dart:html");
>+dart.registerExtension("AbsoluteOrientationSensor", html$.AbsoluteOrientationSensor);
>+html$.AbstractWorker = class AbstractWorker extends _interceptors.Interceptor {
>+  get onError() {
>+    return html$.AbstractWorker.errorEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.AbstractWorker);
>+html$.AbstractWorker[dart.implements] = () => [html$.EventTarget];
>+dart.setGetterSignature(html$.AbstractWorker, () => ({
>+  __proto__: dart.getGetters(html$.AbstractWorker.__proto__),
>+  onError: async.Stream$(html$.Event),
>+  [$onError]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.AbstractWorker, "dart:html");
>+dart.defineExtensionAccessors(html$.AbstractWorker, ['onError']);
>+dart.defineLazy(html$.AbstractWorker, {
>+  /*html$.AbstractWorker.errorEvent*/get errorEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("error"));
>+  }
>+});
>+html$.Accelerometer = class Accelerometer$ extends html$.Sensor {
>+  static new(sensorOptions) {
>+    if (sensorOptions === void 0) sensorOptions = null;
>+    if (sensorOptions != null) {
>+      let sensorOptions_1 = html_common.convertDartToNative_Dictionary(sensorOptions);
>+      return html$.Accelerometer._create_1(sensorOptions_1);
>+    }
>+    return html$.Accelerometer._create_2();
>+  }
>+  static _create_1(sensorOptions) {
>+    return new Accelerometer(sensorOptions);
>+  }
>+  static _create_2() {
>+    return new Accelerometer();
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+  get [$z]() {
>+    return this.z;
>+  }
>+};
>+dart.addTypeTests(html$.Accelerometer);
>+const x = Symbol("Accelerometer.x");
>+const y = Symbol("Accelerometer.y");
>+const z = Symbol("Accelerometer.z");
>+dart.setLibraryUri(html$.Accelerometer, "dart:html");
>+dart.setFieldSignature(html$.Accelerometer, () => ({
>+  __proto__: dart.getFields(html$.Accelerometer.__proto__),
>+  [$x]: dart.finalFieldType(core.num),
>+  [$y]: dart.finalFieldType(core.num),
>+  [$z]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("Accelerometer", html$.Accelerometer);
>+html$.AccessibleNode = class AccessibleNode$ extends html$.EventTarget {
>+  static new() {
>+    return html$.AccessibleNode._create_1();
>+  }
>+  static _create_1() {
>+    return new AccessibleNode();
>+  }
>+  get [$activeDescendant]() {
>+    return this.activeDescendant;
>+  }
>+  set [$activeDescendant](value) {
>+    this.activeDescendant = value;
>+  }
>+  get [$atomic]() {
>+    return this.atomic;
>+  }
>+  set [$atomic](value) {
>+    this.atomic = value;
>+  }
>+  get [$autocomplete]() {
>+    return this.autocomplete;
>+  }
>+  set [$autocomplete](value) {
>+    this.autocomplete = value;
>+  }
>+  get [$busy]() {
>+    return this.busy;
>+  }
>+  set [$busy](value) {
>+    this.busy = value;
>+  }
>+  get [$checked]() {
>+    return this.checked;
>+  }
>+  set [$checked](value) {
>+    this.checked = value;
>+  }
>+  get [$colCount]() {
>+    return this.colCount;
>+  }
>+  set [$colCount](value) {
>+    this.colCount = value;
>+  }
>+  get [$colIndex]() {
>+    return this.colIndex;
>+  }
>+  set [$colIndex](value) {
>+    this.colIndex = value;
>+  }
>+  get [$colSpan]() {
>+    return this.colSpan;
>+  }
>+  set [$colSpan](value) {
>+    this.colSpan = value;
>+  }
>+  get [$controls]() {
>+    return this.controls;
>+  }
>+  set [$controls](value) {
>+    this.controls = value;
>+  }
>+  get [$current]() {
>+    return this.current;
>+  }
>+  set [$current](value) {
>+    this.current = value;
>+  }
>+  get [$describedBy]() {
>+    return this.describedBy;
>+  }
>+  set [$describedBy](value) {
>+    this.describedBy = value;
>+  }
>+  get [$details]() {
>+    return this.details;
>+  }
>+  set [$details](value) {
>+    this.details = value;
>+  }
>+  get [$disabled]() {
>+    return this.disabled;
>+  }
>+  set [$disabled](value) {
>+    this.disabled = value;
>+  }
>+  get [$errorMessage]() {
>+    return this.errorMessage;
>+  }
>+  set [$errorMessage](value) {
>+    this.errorMessage = value;
>+  }
>+  get [$expanded]() {
>+    return this.expanded;
>+  }
>+  set [$expanded](value) {
>+    this.expanded = value;
>+  }
>+  get [$flowTo]() {
>+    return this.flowTo;
>+  }
>+  set [$flowTo](value) {
>+    this.flowTo = value;
>+  }
>+  get [$hasPopUp]() {
>+    return this.hasPopUp;
>+  }
>+  set [$hasPopUp](value) {
>+    this.hasPopUp = value;
>+  }
>+  get [$hidden]() {
>+    return this.hidden;
>+  }
>+  set [$hidden](value) {
>+    this.hidden = value;
>+  }
>+  get [$invalid]() {
>+    return this.invalid;
>+  }
>+  set [$invalid](value) {
>+    this.invalid = value;
>+  }
>+  get [$keyShortcuts]() {
>+    return this.keyShortcuts;
>+  }
>+  set [$keyShortcuts](value) {
>+    this.keyShortcuts = value;
>+  }
>+  get [$label]() {
>+    return this.label;
>+  }
>+  set [$label](value) {
>+    this.label = value;
>+  }
>+  get [$labeledBy]() {
>+    return this.labeledBy;
>+  }
>+  set [$labeledBy](value) {
>+    this.labeledBy = value;
>+  }
>+  get [$level]() {
>+    return this.level;
>+  }
>+  set [$level](value) {
>+    this.level = value;
>+  }
>+  get [$live]() {
>+    return this.live;
>+  }
>+  set [$live](value) {
>+    this.live = value;
>+  }
>+  get [$modal]() {
>+    return this.modal;
>+  }
>+  set [$modal](value) {
>+    this.modal = value;
>+  }
>+  get [$multiline]() {
>+    return this.multiline;
>+  }
>+  set [$multiline](value) {
>+    this.multiline = value;
>+  }
>+  get [$multiselectable]() {
>+    return this.multiselectable;
>+  }
>+  set [$multiselectable](value) {
>+    this.multiselectable = value;
>+  }
>+  get [$orientation]() {
>+    return this.orientation;
>+  }
>+  set [$orientation](value) {
>+    this.orientation = value;
>+  }
>+  get [$owns]() {
>+    return this.owns;
>+  }
>+  set [$owns](value) {
>+    this.owns = value;
>+  }
>+  get [$placeholder]() {
>+    return this.placeholder;
>+  }
>+  set [$placeholder](value) {
>+    this.placeholder = value;
>+  }
>+  get [$posInSet]() {
>+    return this.posInSet;
>+  }
>+  set [$posInSet](value) {
>+    this.posInSet = value;
>+  }
>+  get [$pressed]() {
>+    return this.pressed;
>+  }
>+  set [$pressed](value) {
>+    this.pressed = value;
>+  }
>+  get [$readOnly]() {
>+    return this.readOnly;
>+  }
>+  set [$readOnly](value) {
>+    this.readOnly = value;
>+  }
>+  get [$relevant]() {
>+    return this.relevant;
>+  }
>+  set [$relevant](value) {
>+    this.relevant = value;
>+  }
>+  get [$required]() {
>+    return this.required;
>+  }
>+  set [$required](value) {
>+    this.required = value;
>+  }
>+  get [$role]() {
>+    return this.role;
>+  }
>+  set [$role](value) {
>+    this.role = value;
>+  }
>+  get [$roleDescription]() {
>+    return this.roleDescription;
>+  }
>+  set [$roleDescription](value) {
>+    this.roleDescription = value;
>+  }
>+  get [$rowCount]() {
>+    return this.rowCount;
>+  }
>+  set [$rowCount](value) {
>+    this.rowCount = value;
>+  }
>+  get [$rowIndex]() {
>+    return this.rowIndex;
>+  }
>+  set [$rowIndex](value) {
>+    this.rowIndex = value;
>+  }
>+  get [$rowSpan]() {
>+    return this.rowSpan;
>+  }
>+  set [$rowSpan](value) {
>+    this.rowSpan = value;
>+  }
>+  get [$selected]() {
>+    return this.selected;
>+  }
>+  set [$selected](value) {
>+    this.selected = value;
>+  }
>+  get [$setSize]() {
>+    return this.setSize;
>+  }
>+  set [$setSize](value) {
>+    this.setSize = value;
>+  }
>+  get [$sort]() {
>+    return this.sort;
>+  }
>+  set [$sort](value) {
>+    this.sort = value;
>+  }
>+  get [$valueMax]() {
>+    return this.valueMax;
>+  }
>+  set [$valueMax](value) {
>+    this.valueMax = value;
>+  }
>+  get [$valueMin]() {
>+    return this.valueMin;
>+  }
>+  set [$valueMin](value) {
>+    this.valueMin = value;
>+  }
>+  get [$valueNow]() {
>+    return this.valueNow;
>+  }
>+  set [$valueNow](value) {
>+    this.valueNow = value;
>+  }
>+  get [$valueText]() {
>+    return this.valueText;
>+  }
>+  set [$valueText](value) {
>+    this.valueText = value;
>+  }
>+  [$appendChild](...args) {
>+    return this.appendChild.apply(this, args);
>+  }
>+  get [$onAccessibleClick]() {
>+    return html$.AccessibleNode.accessibleClickEvent.forTarget(this);
>+  }
>+  get [$onAccessibleContextMenu]() {
>+    return html$.AccessibleNode.accessibleContextMenuEvent.forTarget(this);
>+  }
>+  get [$onAccessibleDecrement]() {
>+    return html$.AccessibleNode.accessibleDecrementEvent.forTarget(this);
>+  }
>+  get [$onAccessibleFocus]() {
>+    return html$.AccessibleNode.accessibleFocusEvent.forTarget(this);
>+  }
>+  get [$onAccessibleIncrement]() {
>+    return html$.AccessibleNode.accessibleIncrementEvent.forTarget(this);
>+  }
>+  get [$onAccessibleScrollIntoView]() {
>+    return html$.AccessibleNode.accessibleScrollIntoViewEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.AccessibleNode);
>+const activeDescendant = Symbol("AccessibleNode.activeDescendant");
>+const atomic = Symbol("AccessibleNode.atomic");
>+const autocomplete = Symbol("AccessibleNode.autocomplete");
>+const busy = Symbol("AccessibleNode.busy");
>+const checked = Symbol("AccessibleNode.checked");
>+const colCount = Symbol("AccessibleNode.colCount");
>+const colIndex = Symbol("AccessibleNode.colIndex");
>+const colSpan = Symbol("AccessibleNode.colSpan");
>+const controls = Symbol("AccessibleNode.controls");
>+const current = Symbol("AccessibleNode.current");
>+const describedBy = Symbol("AccessibleNode.describedBy");
>+const details = Symbol("AccessibleNode.details");
>+const disabled = Symbol("AccessibleNode.disabled");
>+const errorMessage = Symbol("AccessibleNode.errorMessage");
>+const expanded = Symbol("AccessibleNode.expanded");
>+const flowTo = Symbol("AccessibleNode.flowTo");
>+const hasPopUp = Symbol("AccessibleNode.hasPopUp");
>+const hidden$ = Symbol("AccessibleNode.hidden");
>+const invalid = Symbol("AccessibleNode.invalid");
>+const keyShortcuts = Symbol("AccessibleNode.keyShortcuts");
>+const label = Symbol("AccessibleNode.label");
>+const labeledBy = Symbol("AccessibleNode.labeledBy");
>+const level = Symbol("AccessibleNode.level");
>+const live = Symbol("AccessibleNode.live");
>+const modal = Symbol("AccessibleNode.modal");
>+const multiline = Symbol("AccessibleNode.multiline");
>+const multiselectable = Symbol("AccessibleNode.multiselectable");
>+const orientation = Symbol("AccessibleNode.orientation");
>+const owns = Symbol("AccessibleNode.owns");
>+const placeholder = Symbol("AccessibleNode.placeholder");
>+const posInSet = Symbol("AccessibleNode.posInSet");
>+const pressed = Symbol("AccessibleNode.pressed");
>+const readOnly = Symbol("AccessibleNode.readOnly");
>+const relevant = Symbol("AccessibleNode.relevant");
>+const required = Symbol("AccessibleNode.required");
>+const role = Symbol("AccessibleNode.role");
>+const roleDescription = Symbol("AccessibleNode.roleDescription");
>+const rowCount = Symbol("AccessibleNode.rowCount");
>+const rowIndex = Symbol("AccessibleNode.rowIndex");
>+const rowSpan = Symbol("AccessibleNode.rowSpan");
>+const selected = Symbol("AccessibleNode.selected");
>+const setSize = Symbol("AccessibleNode.setSize");
>+const sort = Symbol("AccessibleNode.sort");
>+const valueMax = Symbol("AccessibleNode.valueMax");
>+const valueMin = Symbol("AccessibleNode.valueMin");
>+const valueNow = Symbol("AccessibleNode.valueNow");
>+const valueText = Symbol("AccessibleNode.valueText");
>+dart.setMethodSignature(html$.AccessibleNode, () => ({
>+  __proto__: dart.getMethods(html$.AccessibleNode.__proto__),
>+  [$appendChild]: dart.fnType(dart.void, [html$.AccessibleNode])
>+}));
>+dart.setGetterSignature(html$.AccessibleNode, () => ({
>+  __proto__: dart.getGetters(html$.AccessibleNode.__proto__),
>+  [$onAccessibleClick]: async.Stream$(html$.Event),
>+  [$onAccessibleContextMenu]: async.Stream$(html$.Event),
>+  [$onAccessibleDecrement]: async.Stream$(html$.Event),
>+  [$onAccessibleFocus]: async.Stream$(html$.Event),
>+  [$onAccessibleIncrement]: async.Stream$(html$.Event),
>+  [$onAccessibleScrollIntoView]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.AccessibleNode, "dart:html");
>+dart.setFieldSignature(html$.AccessibleNode, () => ({
>+  __proto__: dart.getFields(html$.AccessibleNode.__proto__),
>+  [$activeDescendant]: dart.fieldType(html$.AccessibleNode),
>+  [$atomic]: dart.fieldType(core.bool),
>+  [$autocomplete]: dart.fieldType(core.String),
>+  [$busy]: dart.fieldType(core.bool),
>+  [$checked]: dart.fieldType(core.String),
>+  [$colCount]: dart.fieldType(core.int),
>+  [$colIndex]: dart.fieldType(core.int),
>+  [$colSpan]: dart.fieldType(core.int),
>+  [$controls]: dart.fieldType(html$.AccessibleNodeList),
>+  [$current]: dart.fieldType(core.String),
>+  [$describedBy]: dart.fieldType(html$.AccessibleNodeList),
>+  [$details]: dart.fieldType(html$.AccessibleNode),
>+  [$disabled]: dart.fieldType(core.bool),
>+  [$errorMessage]: dart.fieldType(html$.AccessibleNode),
>+  [$expanded]: dart.fieldType(core.bool),
>+  [$flowTo]: dart.fieldType(html$.AccessibleNodeList),
>+  [$hasPopUp]: dart.fieldType(core.String),
>+  [$hidden]: dart.fieldType(core.bool),
>+  [$invalid]: dart.fieldType(core.String),
>+  [$keyShortcuts]: dart.fieldType(core.String),
>+  [$label]: dart.fieldType(core.String),
>+  [$labeledBy]: dart.fieldType(html$.AccessibleNodeList),
>+  [$level]: dart.fieldType(core.int),
>+  [$live]: dart.fieldType(core.String),
>+  [$modal]: dart.fieldType(core.bool),
>+  [$multiline]: dart.fieldType(core.bool),
>+  [$multiselectable]: dart.fieldType(core.bool),
>+  [$orientation]: dart.fieldType(core.String),
>+  [$owns]: dart.fieldType(html$.AccessibleNodeList),
>+  [$placeholder]: dart.fieldType(core.String),
>+  [$posInSet]: dart.fieldType(core.int),
>+  [$pressed]: dart.fieldType(core.String),
>+  [$readOnly]: dart.fieldType(core.bool),
>+  [$relevant]: dart.fieldType(core.String),
>+  [$required]: dart.fieldType(core.bool),
>+  [$role]: dart.fieldType(core.String),
>+  [$roleDescription]: dart.fieldType(core.String),
>+  [$rowCount]: dart.fieldType(core.int),
>+  [$rowIndex]: dart.fieldType(core.int),
>+  [$rowSpan]: dart.fieldType(core.int),
>+  [$selected]: dart.fieldType(core.bool),
>+  [$setSize]: dart.fieldType(core.int),
>+  [$sort]: dart.fieldType(core.String),
>+  [$valueMax]: dart.fieldType(core.num),
>+  [$valueMin]: dart.fieldType(core.num),
>+  [$valueNow]: dart.fieldType(core.num),
>+  [$valueText]: dart.fieldType(core.String)
>+}));
>+dart.defineLazy(html$.AccessibleNode, {
>+  /*html$.AccessibleNode.accessibleClickEvent*/get accessibleClickEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("accessibleclick"));
>+  },
>+  /*html$.AccessibleNode.accessibleContextMenuEvent*/get accessibleContextMenuEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("accessiblecontextmenu"));
>+  },
>+  /*html$.AccessibleNode.accessibleDecrementEvent*/get accessibleDecrementEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("accessibledecrement"));
>+  },
>+  /*html$.AccessibleNode.accessibleFocusEvent*/get accessibleFocusEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("accessiblefocus"));
>+  },
>+  /*html$.AccessibleNode.accessibleIncrementEvent*/get accessibleIncrementEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("accessibleincrement"));
>+  },
>+  /*html$.AccessibleNode.accessibleScrollIntoViewEvent*/get accessibleScrollIntoViewEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("accessiblescrollintoview"));
>+  }
>+});
>+dart.registerExtension("AccessibleNode", html$.AccessibleNode);
>+const __setter__ = dart.privateName(html$, "__setter__");
>+html$.AccessibleNodeList = class AccessibleNodeList$ extends _interceptors.Interceptor {
>+  static new(nodes) {
>+    if (nodes === void 0) nodes = null;
>+    if (nodes != null) {
>+      return html$.AccessibleNodeList._create_1(nodes);
>+    }
>+    return html$.AccessibleNodeList._create_2();
>+  }
>+  static _create_1(nodes) {
>+    return new AccessibleNodeList(nodes);
>+  }
>+  static _create_2() {
>+    return new AccessibleNodeList();
>+  }
>+  get [$length]() {
>+    return this.length;
>+  }
>+  set [$length](value) {
>+    this.length = value;
>+  }
>+  [__setter__](...args) {
>+    return this.__setter__.apply(this, args);
>+  }
>+  [$add](...args) {
>+    return this.add.apply(this, args);
>+  }
>+  [$item](...args) {
>+    return this.item.apply(this, args);
>+  }
>+  [$remove](...args) {
>+    return this.remove.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.AccessibleNodeList);
>+const length = Symbol("AccessibleNodeList.length");
>+dart.setMethodSignature(html$.AccessibleNodeList, () => ({
>+  __proto__: dart.getMethods(html$.AccessibleNodeList.__proto__),
>+  [__setter__]: dart.fnType(dart.void, [core.int, html$.AccessibleNode]),
>+  [$add]: dart.fnType(dart.void, [html$.AccessibleNode, html$.AccessibleNode]),
>+  [$item]: dart.fnType(html$.AccessibleNode, [core.int]),
>+  [$remove]: dart.fnType(dart.void, [core.int])
>+}));
>+dart.setLibraryUri(html$.AccessibleNodeList, "dart:html");
>+dart.setFieldSignature(html$.AccessibleNodeList, () => ({
>+  __proto__: dart.getFields(html$.AccessibleNodeList.__proto__),
>+  [$length]: dart.fieldType(core.int)
>+}));
>+dart.registerExtension("AccessibleNodeList", html$.AccessibleNodeList);
>+html$.AmbientLightSensor = class AmbientLightSensor$ extends html$.Sensor {
>+  static new(sensorOptions) {
>+    if (sensorOptions === void 0) sensorOptions = null;
>+    if (sensorOptions != null) {
>+      let sensorOptions_1 = html_common.convertDartToNative_Dictionary(sensorOptions);
>+      return html$.AmbientLightSensor._create_1(sensorOptions_1);
>+    }
>+    return html$.AmbientLightSensor._create_2();
>+  }
>+  static _create_1(sensorOptions) {
>+    return new AmbientLightSensor(sensorOptions);
>+  }
>+  static _create_2() {
>+    return new AmbientLightSensor();
>+  }
>+  get [$illuminance]() {
>+    return this.illuminance;
>+  }
>+};
>+dart.addTypeTests(html$.AmbientLightSensor);
>+const illuminance = Symbol("AmbientLightSensor.illuminance");
>+dart.setLibraryUri(html$.AmbientLightSensor, "dart:html");
>+dart.setFieldSignature(html$.AmbientLightSensor, () => ({
>+  __proto__: dart.getFields(html$.AmbientLightSensor.__proto__),
>+  [$illuminance]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("AmbientLightSensor", html$.AmbientLightSensor);
>+html$.AnchorElement = class AnchorElement extends html$.HtmlElement {
>+  static new(opts) {
>+    let href = opts && 'href' in opts ? opts.href : null;
>+    let e = html$.document.createElement("a");
>+    if (href != null) e.href = href;
>+    return e;
>+  }
>+  get [$download]() {
>+    return this.download;
>+  }
>+  set [$download](value) {
>+    this.download = value;
>+  }
>+  get [$hreflang]() {
>+    return this.hreflang;
>+  }
>+  set [$hreflang](value) {
>+    this.hreflang = value;
>+  }
>+  get [$referrerPolicy]() {
>+    return this.referrerPolicy;
>+  }
>+  set [$referrerPolicy](value) {
>+    this.referrerPolicy = value;
>+  }
>+  get [$rel]() {
>+    return this.rel;
>+  }
>+  set [$rel](value) {
>+    this.rel = value;
>+  }
>+  get [$target]() {
>+    return this.target;
>+  }
>+  set [$target](value) {
>+    this.target = value;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  set [$type](value) {
>+    this.type = value;
>+  }
>+  get [$hash]() {
>+    return this.hash;
>+  }
>+  set [$hash](value) {
>+    this.hash = value;
>+  }
>+  get [$host]() {
>+    return this.host;
>+  }
>+  set [$host](value) {
>+    this.host = value;
>+  }
>+  get [$hostname]() {
>+    return this.hostname;
>+  }
>+  set [$hostname](value) {
>+    this.hostname = value;
>+  }
>+  get [$href]() {
>+    return this.href;
>+  }
>+  set [$href](value) {
>+    this.href = value;
>+  }
>+  get [$origin]() {
>+    return this.origin;
>+  }
>+  get [$password]() {
>+    return this.password;
>+  }
>+  set [$password](value) {
>+    this.password = value;
>+  }
>+  get [$pathname]() {
>+    return this.pathname;
>+  }
>+  set [$pathname](value) {
>+    this.pathname = value;
>+  }
>+  get [$port]() {
>+    return this.port;
>+  }
>+  set [$port](value) {
>+    this.port = value;
>+  }
>+  get [$protocol]() {
>+    return this.protocol;
>+  }
>+  set [$protocol](value) {
>+    this.protocol = value;
>+  }
>+  get [$search]() {
>+    return this.search;
>+  }
>+  set [$search](value) {
>+    this.search = value;
>+  }
>+  get [$username]() {
>+    return this.username;
>+  }
>+  set [$username](value) {
>+    this.username = value;
>+  }
>+  [$toString]() {
>+    return String(this);
>+  }
>+};
>+(html$.AnchorElement.created = function() {
>+  this[download] = null;
>+  this[hreflang] = null;
>+  this[referrerPolicy] = null;
>+  this[rel] = null;
>+  this[target$] = null;
>+  this[type$3] = null;
>+  this[hash] = null;
>+  this[host] = null;
>+  this[hostname] = null;
>+  this[href] = null;
>+  this[origin] = null;
>+  this[password] = null;
>+  this[pathname] = null;
>+  this[port] = null;
>+  this[protocol] = null;
>+  this[search] = null;
>+  this[username] = null;
>+  html$.AnchorElement.__proto__.created.call(this);
>+}).prototype = html$.AnchorElement.prototype;
>+dart.addTypeTests(html$.AnchorElement);
>+const download = Symbol("AnchorElement.download");
>+const hreflang = Symbol("AnchorElement.hreflang");
>+const referrerPolicy = Symbol("AnchorElement.referrerPolicy");
>+const rel = Symbol("AnchorElement.rel");
>+const target$ = Symbol("AnchorElement.target");
>+const type$3 = Symbol("AnchorElement.type");
>+const hash = Symbol("AnchorElement.hash");
>+const host = Symbol("AnchorElement.host");
>+const hostname = Symbol("AnchorElement.hostname");
>+const href = Symbol("AnchorElement.href");
>+const origin = Symbol("AnchorElement.origin");
>+const password = Symbol("AnchorElement.password");
>+const pathname = Symbol("AnchorElement.pathname");
>+const port = Symbol("AnchorElement.port");
>+const protocol = Symbol("AnchorElement.protocol");
>+const search = Symbol("AnchorElement.search");
>+const username = Symbol("AnchorElement.username");
>+html$.AnchorElement[dart.implements] = () => [html$.HtmlHyperlinkElementUtils];
>+dart.setLibraryUri(html$.AnchorElement, "dart:html");
>+dart.setFieldSignature(html$.AnchorElement, () => ({
>+  __proto__: dart.getFields(html$.AnchorElement.__proto__),
>+  [$download]: dart.fieldType(core.String),
>+  [$hreflang]: dart.fieldType(core.String),
>+  [$referrerPolicy]: dart.fieldType(core.String),
>+  [$rel]: dart.fieldType(core.String),
>+  [$target]: dart.fieldType(core.String),
>+  [$type]: dart.fieldType(core.String),
>+  [$hash]: dart.fieldType(core.String),
>+  [$host]: dart.fieldType(core.String),
>+  [$hostname]: dart.fieldType(core.String),
>+  [$href]: dart.fieldType(core.String),
>+  [$origin]: dart.finalFieldType(core.String),
>+  [$password]: dart.fieldType(core.String),
>+  [$pathname]: dart.fieldType(core.String),
>+  [$port]: dart.fieldType(core.String),
>+  [$protocol]: dart.fieldType(core.String),
>+  [$search]: dart.fieldType(core.String),
>+  [$username]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("HTMLAnchorElement", html$.AnchorElement);
>+html$.Animation = class Animation$ extends html$.EventTarget {
>+  static new(effect, timeline) {
>+    if (effect === void 0) effect = null;
>+    if (timeline === void 0) timeline = null;
>+    if (timeline != null) {
>+      return html$.Animation._create_1(effect, timeline);
>+    }
>+    if (effect != null) {
>+      return html$.Animation._create_2(effect);
>+    }
>+    return html$.Animation._create_3();
>+  }
>+  static _create_1(effect, timeline) {
>+    return new Animation(effect, timeline);
>+  }
>+  static _create_2(effect) {
>+    return new Animation(effect);
>+  }
>+  static _create_3() {
>+    return new Animation();
>+  }
>+  static get supported() {
>+    return !!document.body.animate;
>+  }
>+  get [$currentTime]() {
>+    return this.currentTime;
>+  }
>+  set [$currentTime](value) {
>+    this.currentTime = value;
>+  }
>+  get [$effect]() {
>+    return this.effect;
>+  }
>+  set [$effect](value) {
>+    this.effect = value;
>+  }
>+  get [$finished]() {
>+    return html$.promiseToFuture(html$.Animation, this.finished);
>+  }
>+  get [$id]() {
>+    return this.id;
>+  }
>+  set [$id](value) {
>+    this.id = value;
>+  }
>+  get [$playState]() {
>+    return this.playState;
>+  }
>+  get [$playbackRate]() {
>+    return this.playbackRate;
>+  }
>+  set [$playbackRate](value) {
>+    this.playbackRate = value;
>+  }
>+  get [$ready]() {
>+    return html$.promiseToFuture(html$.Animation, this.ready);
>+  }
>+  get [$startTime]() {
>+    return this.startTime;
>+  }
>+  set [$startTime](value) {
>+    this.startTime = value;
>+  }
>+  get [$timeline]() {
>+    return this.timeline;
>+  }
>+  [$cancel](...args) {
>+    return this.cancel.apply(this, args);
>+  }
>+  [$finish](...args) {
>+    return this.finish.apply(this, args);
>+  }
>+  [$pause](...args) {
>+    return this.pause.apply(this, args);
>+  }
>+  [$play](...args) {
>+    return this.play.apply(this, args);
>+  }
>+  [$reverse](...args) {
>+    return this.reverse.apply(this, args);
>+  }
>+  get [$onCancel]() {
>+    return html$.Animation.cancelEvent.forTarget(this);
>+  }
>+  get [$onFinish]() {
>+    return html$.Animation.finishEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.Animation);
>+const currentTime = Symbol("Animation.currentTime");
>+const effect = Symbol("Animation.effect");
>+const id$0 = Symbol("Animation.id");
>+const playState = Symbol("Animation.playState");
>+const playbackRate = Symbol("Animation.playbackRate");
>+const startTime = Symbol("Animation.startTime");
>+const timeline = Symbol("Animation.timeline");
>+dart.setMethodSignature(html$.Animation, () => ({
>+  __proto__: dart.getMethods(html$.Animation.__proto__),
>+  [$cancel]: dart.fnType(dart.void, []),
>+  [$finish]: dart.fnType(dart.void, []),
>+  [$pause]: dart.fnType(dart.void, []),
>+  [$play]: dart.fnType(dart.void, []),
>+  [$reverse]: dart.fnType(dart.void, [])
>+}));
>+dart.setGetterSignature(html$.Animation, () => ({
>+  __proto__: dart.getGetters(html$.Animation.__proto__),
>+  [$finished]: async.Future$(html$.Animation),
>+  [$ready]: async.Future$(html$.Animation),
>+  [$onCancel]: async.Stream$(html$.Event),
>+  [$onFinish]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.Animation, "dart:html");
>+dart.setFieldSignature(html$.Animation, () => ({
>+  __proto__: dart.getFields(html$.Animation.__proto__),
>+  [$currentTime]: dart.fieldType(core.num),
>+  [$effect]: dart.fieldType(html$.AnimationEffectReadOnly),
>+  [$id]: dart.fieldType(core.String),
>+  [$playState]: dart.finalFieldType(core.String),
>+  [$playbackRate]: dart.fieldType(core.num),
>+  [$startTime]: dart.fieldType(core.num),
>+  [$timeline]: dart.finalFieldType(html$.AnimationTimeline)
>+}));
>+dart.defineLazy(html$.Animation, {
>+  /*html$.Animation.cancelEvent*/get cancelEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("cancel"));
>+  },
>+  /*html$.Animation.finishEvent*/get finishEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("finish"));
>+  }
>+});
>+dart.registerExtension("Animation", html$.Animation);
>+const _getComputedTiming_1 = dart.privateName(html$, "_getComputedTiming_1");
>+html$.AnimationEffectReadOnly = class AnimationEffectReadOnly extends _interceptors.Interceptor {
>+  get [$timing]() {
>+    return this.timing;
>+  }
>+  [$getComputedTiming]() {
>+    return html_common.convertNativeToDart_Dictionary(this[_getComputedTiming_1]());
>+  }
>+  [_getComputedTiming_1](...args) {
>+    return this.getComputedTiming.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.AnimationEffectReadOnly);
>+const timing = Symbol("AnimationEffectReadOnly.timing");
>+dart.setMethodSignature(html$.AnimationEffectReadOnly, () => ({
>+  __proto__: dart.getMethods(html$.AnimationEffectReadOnly.__proto__),
>+  [$getComputedTiming]: dart.fnType(core.Map, []),
>+  [_getComputedTiming_1]: dart.fnType(dart.dynamic, [])
>+}));
>+dart.setLibraryUri(html$.AnimationEffectReadOnly, "dart:html");
>+dart.setFieldSignature(html$.AnimationEffectReadOnly, () => ({
>+  __proto__: dart.getFields(html$.AnimationEffectReadOnly.__proto__),
>+  [$timing]: dart.finalFieldType(html$.AnimationEffectTimingReadOnly)
>+}));
>+dart.registerExtension("AnimationEffectReadOnly", html$.AnimationEffectReadOnly);
>+html$.AnimationEffectTimingReadOnly = class AnimationEffectTimingReadOnly extends _interceptors.Interceptor {
>+  get [$delay]() {
>+    return this.delay;
>+  }
>+  get [$direction]() {
>+    return this.direction;
>+  }
>+  get [$duration]() {
>+    return this.duration;
>+  }
>+  get [$easing]() {
>+    return this.easing;
>+  }
>+  get [$endDelay]() {
>+    return this.endDelay;
>+  }
>+  get [$fill]() {
>+    return this.fill;
>+  }
>+  get [$iterationStart]() {
>+    return this.iterationStart;
>+  }
>+  get [$iterations]() {
>+    return this.iterations;
>+  }
>+};
>+dart.addTypeTests(html$.AnimationEffectTimingReadOnly);
>+const delay = Symbol("AnimationEffectTimingReadOnly.delay");
>+const direction$ = Symbol("AnimationEffectTimingReadOnly.direction");
>+const duration = Symbol("AnimationEffectTimingReadOnly.duration");
>+const easing = Symbol("AnimationEffectTimingReadOnly.easing");
>+const endDelay = Symbol("AnimationEffectTimingReadOnly.endDelay");
>+const fill = Symbol("AnimationEffectTimingReadOnly.fill");
>+const iterationStart = Symbol("AnimationEffectTimingReadOnly.iterationStart");
>+const iterations = Symbol("AnimationEffectTimingReadOnly.iterations");
>+dart.setLibraryUri(html$.AnimationEffectTimingReadOnly, "dart:html");
>+dart.setFieldSignature(html$.AnimationEffectTimingReadOnly, () => ({
>+  __proto__: dart.getFields(html$.AnimationEffectTimingReadOnly.__proto__),
>+  [$delay]: dart.finalFieldType(core.num),
>+  [$direction]: dart.finalFieldType(core.String),
>+  [$duration]: dart.finalFieldType(core.Object),
>+  [$easing]: dart.finalFieldType(core.String),
>+  [$endDelay]: dart.finalFieldType(core.num),
>+  [$fill]: dart.finalFieldType(core.String),
>+  [$iterationStart]: dart.finalFieldType(core.num),
>+  [$iterations]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("AnimationEffectTimingReadOnly", html$.AnimationEffectTimingReadOnly);
>+html$.AnimationEffectTiming = class AnimationEffectTiming extends html$.AnimationEffectTimingReadOnly {
>+  get [$delay]() {
>+    return this.delay;
>+  }
>+  set [$delay](value) {
>+    this.delay = value;
>+  }
>+  get [$direction]() {
>+    return this.direction;
>+  }
>+  set [$direction](value) {
>+    this.direction = value;
>+  }
>+  get [$duration]() {
>+    return this.duration;
>+  }
>+  set [$duration](value) {
>+    this.duration = value;
>+  }
>+  get [$easing]() {
>+    return this.easing;
>+  }
>+  set [$easing](value) {
>+    this.easing = value;
>+  }
>+  get [$endDelay]() {
>+    return this.endDelay;
>+  }
>+  set [$endDelay](value) {
>+    this.endDelay = value;
>+  }
>+  get [$fill]() {
>+    return this.fill;
>+  }
>+  set [$fill](value) {
>+    this.fill = value;
>+  }
>+  get [$iterationStart]() {
>+    return this.iterationStart;
>+  }
>+  set [$iterationStart](value) {
>+    this.iterationStart = value;
>+  }
>+  get [$iterations]() {
>+    return this.iterations;
>+  }
>+  set [$iterations](value) {
>+    this.iterations = value;
>+  }
>+};
>+dart.addTypeTests(html$.AnimationEffectTiming);
>+dart.setSetterSignature(html$.AnimationEffectTiming, () => ({
>+  __proto__: dart.getSetters(html$.AnimationEffectTiming.__proto__),
>+  [$delay]: core.num,
>+  [$direction]: core.String,
>+  [$duration]: core.Object,
>+  [$easing]: core.String,
>+  [$endDelay]: core.num,
>+  [$fill]: core.String,
>+  [$iterationStart]: core.num,
>+  [$iterations]: core.num
>+}));
>+dart.setLibraryUri(html$.AnimationEffectTiming, "dart:html");
>+dart.registerExtension("AnimationEffectTiming", html$.AnimationEffectTiming);
>+html$.AnimationEvent = class AnimationEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.AnimationEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.AnimationEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new AnimationEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new AnimationEvent(type);
>+  }
>+  get [$animationName]() {
>+    return this.animationName;
>+  }
>+  get [$elapsedTime]() {
>+    return this.elapsedTime;
>+  }
>+};
>+dart.addTypeTests(html$.AnimationEvent);
>+const animationName = Symbol("AnimationEvent.animationName");
>+const elapsedTime = Symbol("AnimationEvent.elapsedTime");
>+dart.setLibraryUri(html$.AnimationEvent, "dart:html");
>+dart.setFieldSignature(html$.AnimationEvent, () => ({
>+  __proto__: dart.getFields(html$.AnimationEvent.__proto__),
>+  [$animationName]: dart.finalFieldType(core.String),
>+  [$elapsedTime]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("AnimationEvent", html$.AnimationEvent);
>+html$.AnimationPlaybackEvent = class AnimationPlaybackEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.AnimationPlaybackEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.AnimationPlaybackEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new AnimationPlaybackEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new AnimationPlaybackEvent(type);
>+  }
>+  get [$currentTime]() {
>+    return this.currentTime;
>+  }
>+  get [$timelineTime]() {
>+    return this.timelineTime;
>+  }
>+};
>+dart.addTypeTests(html$.AnimationPlaybackEvent);
>+const currentTime$ = Symbol("AnimationPlaybackEvent.currentTime");
>+const timelineTime = Symbol("AnimationPlaybackEvent.timelineTime");
>+dart.setLibraryUri(html$.AnimationPlaybackEvent, "dart:html");
>+dart.setFieldSignature(html$.AnimationPlaybackEvent, () => ({
>+  __proto__: dart.getFields(html$.AnimationPlaybackEvent.__proto__),
>+  [$currentTime]: dart.finalFieldType(core.num),
>+  [$timelineTime]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("AnimationPlaybackEvent", html$.AnimationPlaybackEvent);
>+html$.AnimationTimeline = class AnimationTimeline extends _interceptors.Interceptor {
>+  get [$currentTime]() {
>+    return this.currentTime;
>+  }
>+};
>+dart.addTypeTests(html$.AnimationTimeline);
>+const currentTime$0 = Symbol("AnimationTimeline.currentTime");
>+dart.setLibraryUri(html$.AnimationTimeline, "dart:html");
>+dart.setFieldSignature(html$.AnimationTimeline, () => ({
>+  __proto__: dart.getFields(html$.AnimationTimeline.__proto__),
>+  [$currentTime]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("AnimationTimeline", html$.AnimationTimeline);
>+html$.WorkletGlobalScope = class WorkletGlobalScope extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$.WorkletGlobalScope);
>+dart.setLibraryUri(html$.WorkletGlobalScope, "dart:html");
>+dart.registerExtension("WorkletGlobalScope", html$.WorkletGlobalScope);
>+html$.AnimationWorkletGlobalScope = class AnimationWorkletGlobalScope extends html$.WorkletGlobalScope {
>+  [$registerAnimator](...args) {
>+    return this.registerAnimator.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.AnimationWorkletGlobalScope);
>+dart.setMethodSignature(html$.AnimationWorkletGlobalScope, () => ({
>+  __proto__: dart.getMethods(html$.AnimationWorkletGlobalScope.__proto__),
>+  [$registerAnimator]: dart.fnType(dart.void, [core.String, core.Object])
>+}));
>+dart.setLibraryUri(html$.AnimationWorkletGlobalScope, "dart:html");
>+dart.registerExtension("AnimationWorkletGlobalScope", html$.AnimationWorkletGlobalScope);
>+html$.ApplicationCache = class ApplicationCache extends html$.EventTarget {
>+  static get supported() {
>+    return !!window.applicationCache;
>+  }
>+  get [$status]() {
>+    return this.status;
>+  }
>+  [$abort](...args) {
>+    return this.abort.apply(this, args);
>+  }
>+  [$swapCache](...args) {
>+    return this.swapCache.apply(this, args);
>+  }
>+  [$update](...args) {
>+    return this.update.apply(this, args);
>+  }
>+  get [$onCached]() {
>+    return html$.ApplicationCache.cachedEvent.forTarget(this);
>+  }
>+  get [$onChecking]() {
>+    return html$.ApplicationCache.checkingEvent.forTarget(this);
>+  }
>+  get [$onDownloading]() {
>+    return html$.ApplicationCache.downloadingEvent.forTarget(this);
>+  }
>+  get [$onError]() {
>+    return html$.ApplicationCache.errorEvent.forTarget(this);
>+  }
>+  get [$onNoUpdate]() {
>+    return html$.ApplicationCache.noUpdateEvent.forTarget(this);
>+  }
>+  get [$onObsolete]() {
>+    return html$.ApplicationCache.obsoleteEvent.forTarget(this);
>+  }
>+  get [$onProgress]() {
>+    return html$.ApplicationCache.progressEvent.forTarget(this);
>+  }
>+  get [$onUpdateReady]() {
>+    return html$.ApplicationCache.updateReadyEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.ApplicationCache);
>+const status = Symbol("ApplicationCache.status");
>+dart.setMethodSignature(html$.ApplicationCache, () => ({
>+  __proto__: dart.getMethods(html$.ApplicationCache.__proto__),
>+  [$abort]: dart.fnType(dart.void, []),
>+  [$swapCache]: dart.fnType(dart.void, []),
>+  [$update]: dart.fnType(dart.void, [])
>+}));
>+dart.setGetterSignature(html$.ApplicationCache, () => ({
>+  __proto__: dart.getGetters(html$.ApplicationCache.__proto__),
>+  [$onCached]: async.Stream$(html$.Event),
>+  [$onChecking]: async.Stream$(html$.Event),
>+  [$onDownloading]: async.Stream$(html$.Event),
>+  [$onError]: async.Stream$(html$.Event),
>+  [$onNoUpdate]: async.Stream$(html$.Event),
>+  [$onObsolete]: async.Stream$(html$.Event),
>+  [$onProgress]: async.Stream$(html$.ProgressEvent),
>+  [$onUpdateReady]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.ApplicationCache, "dart:html");
>+dart.setFieldSignature(html$.ApplicationCache, () => ({
>+  __proto__: dart.getFields(html$.ApplicationCache.__proto__),
>+  [$status]: dart.finalFieldType(core.int)
>+}));
>+dart.defineLazy(html$.ApplicationCache, {
>+  /*html$.ApplicationCache.cachedEvent*/get cachedEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("cached"));
>+  },
>+  /*html$.ApplicationCache.checkingEvent*/get checkingEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("checking"));
>+  },
>+  /*html$.ApplicationCache.downloadingEvent*/get downloadingEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("downloading"));
>+  },
>+  /*html$.ApplicationCache.errorEvent*/get errorEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("error"));
>+  },
>+  /*html$.ApplicationCache.noUpdateEvent*/get noUpdateEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("noupdate"));
>+  },
>+  /*html$.ApplicationCache.obsoleteEvent*/get obsoleteEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("obsolete"));
>+  },
>+  /*html$.ApplicationCache.progressEvent*/get progressEvent() {
>+    return dart.const(new (EventStreamProviderOfProgressEvent()).new("progress"));
>+  },
>+  /*html$.ApplicationCache.updateReadyEvent*/get updateReadyEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("updateready"));
>+  },
>+  /*html$.ApplicationCache.CHECKING*/get CHECKING() {
>+    return 2;
>+  },
>+  /*html$.ApplicationCache.DOWNLOADING*/get DOWNLOADING() {
>+    return 3;
>+  },
>+  /*html$.ApplicationCache.IDLE*/get IDLE() {
>+    return 1;
>+  },
>+  /*html$.ApplicationCache.OBSOLETE*/get OBSOLETE() {
>+    return 5;
>+  },
>+  /*html$.ApplicationCache.UNCACHED*/get UNCACHED() {
>+    return 0;
>+  },
>+  /*html$.ApplicationCache.UPDATEREADY*/get UPDATEREADY() {
>+    return 4;
>+  }
>+});
>+dart.registerExtension("ApplicationCache", html$.ApplicationCache);
>+dart.registerExtension("DOMApplicationCache", html$.ApplicationCache);
>+dart.registerExtension("OfflineResourceList", html$.ApplicationCache);
>+html$.ApplicationCacheErrorEvent = class ApplicationCacheErrorEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.ApplicationCacheErrorEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.ApplicationCacheErrorEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new ApplicationCacheErrorEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new ApplicationCacheErrorEvent(type);
>+  }
>+  get [$message]() {
>+    return this.message;
>+  }
>+  get [$reason]() {
>+    return this.reason;
>+  }
>+  get [$status]() {
>+    return this.status;
>+  }
>+  get [$url]() {
>+    return this.url;
>+  }
>+};
>+dart.addTypeTests(html$.ApplicationCacheErrorEvent);
>+const message = Symbol("ApplicationCacheErrorEvent.message");
>+const reason = Symbol("ApplicationCacheErrorEvent.reason");
>+const status$ = Symbol("ApplicationCacheErrorEvent.status");
>+const url = Symbol("ApplicationCacheErrorEvent.url");
>+dart.setLibraryUri(html$.ApplicationCacheErrorEvent, "dart:html");
>+dart.setFieldSignature(html$.ApplicationCacheErrorEvent, () => ({
>+  __proto__: dart.getFields(html$.ApplicationCacheErrorEvent.__proto__),
>+  [$message]: dart.finalFieldType(core.String),
>+  [$reason]: dart.finalFieldType(core.String),
>+  [$status]: dart.finalFieldType(core.int),
>+  [$url]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("ApplicationCacheErrorEvent", html$.ApplicationCacheErrorEvent);
>+html$.AreaElement = class AreaElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("area");
>+  }
>+  get [$alt]() {
>+    return this.alt;
>+  }
>+  set [$alt](value) {
>+    this.alt = value;
>+  }
>+  get [$coords]() {
>+    return this.coords;
>+  }
>+  set [$coords](value) {
>+    this.coords = value;
>+  }
>+  get [$download]() {
>+    return this.download;
>+  }
>+  set [$download](value) {
>+    this.download = value;
>+  }
>+  get [$referrerPolicy]() {
>+    return this.referrerPolicy;
>+  }
>+  set [$referrerPolicy](value) {
>+    this.referrerPolicy = value;
>+  }
>+  get [$rel]() {
>+    return this.rel;
>+  }
>+  set [$rel](value) {
>+    this.rel = value;
>+  }
>+  get [$shape]() {
>+    return this.shape;
>+  }
>+  set [$shape](value) {
>+    this.shape = value;
>+  }
>+  get [$target]() {
>+    return this.target;
>+  }
>+  set [$target](value) {
>+    this.target = value;
>+  }
>+  get [$hash]() {
>+    return this.hash;
>+  }
>+  set [$hash](value) {
>+    this.hash = value;
>+  }
>+  get [$host]() {
>+    return this.host;
>+  }
>+  set [$host](value) {
>+    this.host = value;
>+  }
>+  get [$hostname]() {
>+    return this.hostname;
>+  }
>+  set [$hostname](value) {
>+    this.hostname = value;
>+  }
>+  get [$href]() {
>+    return this.href;
>+  }
>+  set [$href](value) {
>+    this.href = value;
>+  }
>+  get [$origin]() {
>+    return this.origin;
>+  }
>+  get [$password]() {
>+    return this.password;
>+  }
>+  set [$password](value) {
>+    this.password = value;
>+  }
>+  get [$pathname]() {
>+    return this.pathname;
>+  }
>+  set [$pathname](value) {
>+    this.pathname = value;
>+  }
>+  get [$port]() {
>+    return this.port;
>+  }
>+  set [$port](value) {
>+    this.port = value;
>+  }
>+  get [$protocol]() {
>+    return this.protocol;
>+  }
>+  set [$protocol](value) {
>+    this.protocol = value;
>+  }
>+  get [$search]() {
>+    return this.search;
>+  }
>+  set [$search](value) {
>+    this.search = value;
>+  }
>+  get [$username]() {
>+    return this.username;
>+  }
>+  set [$username](value) {
>+    this.username = value;
>+  }
>+  [$toString]() {
>+    return String(this);
>+  }
>+};
>+(html$.AreaElement.created = function() {
>+  this[alt] = null;
>+  this[coords] = null;
>+  this[download$] = null;
>+  this[referrerPolicy$] = null;
>+  this[rel$] = null;
>+  this[shape] = null;
>+  this[target$0] = null;
>+  this[hash$] = null;
>+  this[host$] = null;
>+  this[hostname$] = null;
>+  this[href$] = null;
>+  this[origin$] = null;
>+  this[password$] = null;
>+  this[pathname$] = null;
>+  this[port$1] = null;
>+  this[protocol$] = null;
>+  this[search$] = null;
>+  this[username$] = null;
>+  html$.AreaElement.__proto__.created.call(this);
>+}).prototype = html$.AreaElement.prototype;
>+dart.addTypeTests(html$.AreaElement);
>+const alt = Symbol("AreaElement.alt");
>+const coords = Symbol("AreaElement.coords");
>+const download$ = Symbol("AreaElement.download");
>+const referrerPolicy$ = Symbol("AreaElement.referrerPolicy");
>+const rel$ = Symbol("AreaElement.rel");
>+const shape = Symbol("AreaElement.shape");
>+const target$0 = Symbol("AreaElement.target");
>+const hash$ = Symbol("AreaElement.hash");
>+const host$ = Symbol("AreaElement.host");
>+const hostname$ = Symbol("AreaElement.hostname");
>+const href$ = Symbol("AreaElement.href");
>+const origin$ = Symbol("AreaElement.origin");
>+const password$ = Symbol("AreaElement.password");
>+const pathname$ = Symbol("AreaElement.pathname");
>+const port$1 = Symbol("AreaElement.port");
>+const protocol$ = Symbol("AreaElement.protocol");
>+const search$ = Symbol("AreaElement.search");
>+const username$ = Symbol("AreaElement.username");
>+html$.AreaElement[dart.implements] = () => [html$.HtmlHyperlinkElementUtils];
>+dart.setLibraryUri(html$.AreaElement, "dart:html");
>+dart.setFieldSignature(html$.AreaElement, () => ({
>+  __proto__: dart.getFields(html$.AreaElement.__proto__),
>+  [$alt]: dart.fieldType(core.String),
>+  [$coords]: dart.fieldType(core.String),
>+  [$download]: dart.fieldType(core.String),
>+  [$referrerPolicy]: dart.fieldType(core.String),
>+  [$rel]: dart.fieldType(core.String),
>+  [$shape]: dart.fieldType(core.String),
>+  [$target]: dart.fieldType(core.String),
>+  [$hash]: dart.fieldType(core.String),
>+  [$host]: dart.fieldType(core.String),
>+  [$hostname]: dart.fieldType(core.String),
>+  [$href]: dart.fieldType(core.String),
>+  [$origin]: dart.finalFieldType(core.String),
>+  [$password]: dart.fieldType(core.String),
>+  [$pathname]: dart.fieldType(core.String),
>+  [$port]: dart.fieldType(core.String),
>+  [$protocol]: dart.fieldType(core.String),
>+  [$search]: dart.fieldType(core.String),
>+  [$username]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("HTMLAreaElement", html$.AreaElement);
>+html$.MediaElement = class MediaElement extends html$.HtmlElement {
>+  get [$audioTracks]() {
>+    return this.audioTracks;
>+  }
>+  get [$autoplay]() {
>+    return this.autoplay;
>+  }
>+  set [$autoplay](value) {
>+    this.autoplay = value;
>+  }
>+  get [$buffered]() {
>+    return this.buffered;
>+  }
>+  get [$controls]() {
>+    return this.controls;
>+  }
>+  set [$controls](value) {
>+    this.controls = value;
>+  }
>+  get [$controlsList]() {
>+    return this.controlsList;
>+  }
>+  get [$crossOrigin]() {
>+    return this.crossOrigin;
>+  }
>+  set [$crossOrigin](value) {
>+    this.crossOrigin = value;
>+  }
>+  get [$currentSrc]() {
>+    return this.currentSrc;
>+  }
>+  get [$currentTime]() {
>+    return this.currentTime;
>+  }
>+  set [$currentTime](value) {
>+    this.currentTime = value;
>+  }
>+  get [$defaultMuted]() {
>+    return this.defaultMuted;
>+  }
>+  set [$defaultMuted](value) {
>+    this.defaultMuted = value;
>+  }
>+  get [$defaultPlaybackRate]() {
>+    return this.defaultPlaybackRate;
>+  }
>+  set [$defaultPlaybackRate](value) {
>+    this.defaultPlaybackRate = value;
>+  }
>+  get [$disableRemotePlayback]() {
>+    return this.disableRemotePlayback;
>+  }
>+  set [$disableRemotePlayback](value) {
>+    this.disableRemotePlayback = value;
>+  }
>+  get [$duration]() {
>+    return this.duration;
>+  }
>+  get [$ended]() {
>+    return this.ended;
>+  }
>+  get [$error]() {
>+    return this.error;
>+  }
>+  get [$loop]() {
>+    return this.loop;
>+  }
>+  set [$loop](value) {
>+    this.loop = value;
>+  }
>+  get [$mediaKeys]() {
>+    return this.mediaKeys;
>+  }
>+  get [$muted]() {
>+    return this.muted;
>+  }
>+  set [$muted](value) {
>+    this.muted = value;
>+  }
>+  get [$networkState]() {
>+    return this.networkState;
>+  }
>+  get [$paused]() {
>+    return this.paused;
>+  }
>+  get [$playbackRate]() {
>+    return this.playbackRate;
>+  }
>+  set [$playbackRate](value) {
>+    this.playbackRate = value;
>+  }
>+  get [$played]() {
>+    return this.played;
>+  }
>+  get [$preload]() {
>+    return this.preload;
>+  }
>+  set [$preload](value) {
>+    this.preload = value;
>+  }
>+  get [$readyState]() {
>+    return this.readyState;
>+  }
>+  get [$remote]() {
>+    return this.remote;
>+  }
>+  get [$seekable]() {
>+    return this.seekable;
>+  }
>+  get [$seeking]() {
>+    return this.seeking;
>+  }
>+  get [$sinkId]() {
>+    return this.sinkId;
>+  }
>+  get [$src]() {
>+    return this.src;
>+  }
>+  set [$src](value) {
>+    this.src = value;
>+  }
>+  get [$srcObject]() {
>+    return this.srcObject;
>+  }
>+  set [$srcObject](value) {
>+    this.srcObject = value;
>+  }
>+  get [$textTracks]() {
>+    return this.textTracks;
>+  }
>+  get [$videoTracks]() {
>+    return this.videoTracks;
>+  }
>+  get [$volume]() {
>+    return this.volume;
>+  }
>+  set [$volume](value) {
>+    this.volume = value;
>+  }
>+  get [$audioDecodedByteCount]() {
>+    return this.webkitAudioDecodedByteCount;
>+  }
>+  get [$videoDecodedByteCount]() {
>+    return this.webkitVideoDecodedByteCount;
>+  }
>+  [$addTextTrack](...args) {
>+    return this.addTextTrack.apply(this, args);
>+  }
>+  [$canPlayType](...args) {
>+    return this.canPlayType.apply(this, args);
>+  }
>+  [$captureStream](...args) {
>+    return this.captureStream.apply(this, args);
>+  }
>+  [$load](...args) {
>+    return this.load.apply(this, args);
>+  }
>+  [$pause](...args) {
>+    return this.pause.apply(this, args);
>+  }
>+  [$play]() {
>+    return html$.promiseToFuture(dart.dynamic, this.play());
>+  }
>+  [$setMediaKeys](mediaKeys) {
>+    return html$.promiseToFuture(dart.dynamic, this.setMediaKeys(mediaKeys));
>+  }
>+  [$setSinkId](sinkId) {
>+    return html$.promiseToFuture(dart.dynamic, this.setSinkId(sinkId));
>+  }
>+};
>+(html$.MediaElement.created = function() {
>+  this[audioTracks] = null;
>+  this[autoplay] = null;
>+  this[buffered] = null;
>+  this[controls$] = null;
>+  this[controlsList] = null;
>+  this[crossOrigin] = null;
>+  this[currentSrc] = null;
>+  this[currentTime$1] = null;
>+  this[defaultMuted] = null;
>+  this[defaultPlaybackRate] = null;
>+  this[disableRemotePlayback] = null;
>+  this[duration$0] = null;
>+  this[ended] = null;
>+  this[error$1] = null;
>+  this[loop] = null;
>+  this[mediaKeys] = null;
>+  this[muted] = null;
>+  this[networkState] = null;
>+  this[paused] = null;
>+  this[playbackRate$] = null;
>+  this[played] = null;
>+  this[preload] = null;
>+  this[readyState$] = null;
>+  this[remote] = null;
>+  this[seekable] = null;
>+  this[seeking] = null;
>+  this[sinkId] = null;
>+  this[src] = null;
>+  this[srcObject] = null;
>+  this[textTracks] = null;
>+  this[videoTracks] = null;
>+  this[volume] = null;
>+  this[audioDecodedByteCount] = null;
>+  this[videoDecodedByteCount] = null;
>+  html$.MediaElement.__proto__.created.call(this);
>+}).prototype = html$.MediaElement.prototype;
>+dart.addTypeTests(html$.MediaElement);
>+const audioTracks = Symbol("MediaElement.audioTracks");
>+const autoplay = Symbol("MediaElement.autoplay");
>+const buffered = Symbol("MediaElement.buffered");
>+const controls$ = Symbol("MediaElement.controls");
>+const controlsList = Symbol("MediaElement.controlsList");
>+const crossOrigin = Symbol("MediaElement.crossOrigin");
>+const currentSrc = Symbol("MediaElement.currentSrc");
>+const currentTime$1 = Symbol("MediaElement.currentTime");
>+const defaultMuted = Symbol("MediaElement.defaultMuted");
>+const defaultPlaybackRate = Symbol("MediaElement.defaultPlaybackRate");
>+const disableRemotePlayback = Symbol("MediaElement.disableRemotePlayback");
>+const duration$0 = Symbol("MediaElement.duration");
>+const ended = Symbol("MediaElement.ended");
>+const error$1 = Symbol("MediaElement.error");
>+const loop = Symbol("MediaElement.loop");
>+const mediaKeys = Symbol("MediaElement.mediaKeys");
>+const muted = Symbol("MediaElement.muted");
>+const networkState = Symbol("MediaElement.networkState");
>+const paused = Symbol("MediaElement.paused");
>+const playbackRate$ = Symbol("MediaElement.playbackRate");
>+const played = Symbol("MediaElement.played");
>+const preload = Symbol("MediaElement.preload");
>+const readyState$ = Symbol("MediaElement.readyState");
>+const remote = Symbol("MediaElement.remote");
>+const seekable = Symbol("MediaElement.seekable");
>+const seeking = Symbol("MediaElement.seeking");
>+const sinkId = Symbol("MediaElement.sinkId");
>+const src = Symbol("MediaElement.src");
>+const srcObject = Symbol("MediaElement.srcObject");
>+const textTracks = Symbol("MediaElement.textTracks");
>+const videoTracks = Symbol("MediaElement.videoTracks");
>+const volume = Symbol("MediaElement.volume");
>+const audioDecodedByteCount = Symbol("MediaElement.audioDecodedByteCount");
>+const videoDecodedByteCount = Symbol("MediaElement.videoDecodedByteCount");
>+dart.setMethodSignature(html$.MediaElement, () => ({
>+  __proto__: dart.getMethods(html$.MediaElement.__proto__),
>+  [$addTextTrack]: dart.fnType(html$.TextTrack, [core.String], [core.String, core.String]),
>+  [$canPlayType]: dart.fnType(core.String, [core.String], [core.String]),
>+  [$captureStream]: dart.fnType(html$.MediaStream, []),
>+  [$load]: dart.fnType(dart.void, []),
>+  [$pause]: dart.fnType(dart.void, []),
>+  [$play]: dart.fnType(async.Future, []),
>+  [$setMediaKeys]: dart.fnType(async.Future, [html$.MediaKeys]),
>+  [$setSinkId]: dart.fnType(async.Future, [core.String])
>+}));
>+dart.setLibraryUri(html$.MediaElement, "dart:html");
>+dart.setFieldSignature(html$.MediaElement, () => ({
>+  __proto__: dart.getFields(html$.MediaElement.__proto__),
>+  [$audioTracks]: dart.finalFieldType(web_audio.AudioTrackList),
>+  [$autoplay]: dart.fieldType(core.bool),
>+  [$buffered]: dart.finalFieldType(html$.TimeRanges),
>+  [$controls]: dart.fieldType(core.bool),
>+  [$controlsList]: dart.finalFieldType(html$.DomTokenList),
>+  [$crossOrigin]: dart.fieldType(core.String),
>+  [$currentSrc]: dart.finalFieldType(core.String),
>+  [$currentTime]: dart.fieldType(core.num),
>+  [$defaultMuted]: dart.fieldType(core.bool),
>+  [$defaultPlaybackRate]: dart.fieldType(core.num),
>+  [$disableRemotePlayback]: dart.fieldType(core.bool),
>+  [$duration]: dart.finalFieldType(core.num),
>+  [$ended]: dart.finalFieldType(core.bool),
>+  [$error]: dart.finalFieldType(html$.MediaError),
>+  [$loop]: dart.fieldType(core.bool),
>+  [$mediaKeys]: dart.finalFieldType(html$.MediaKeys),
>+  [$muted]: dart.fieldType(core.bool),
>+  [$networkState]: dart.finalFieldType(core.int),
>+  [$paused]: dart.finalFieldType(core.bool),
>+  [$playbackRate]: dart.fieldType(core.num),
>+  [$played]: dart.finalFieldType(html$.TimeRanges),
>+  [$preload]: dart.fieldType(core.String),
>+  [$readyState]: dart.finalFieldType(core.int),
>+  [$remote]: dart.finalFieldType(html$.RemotePlayback),
>+  [$seekable]: dart.finalFieldType(html$.TimeRanges),
>+  [$seeking]: dart.finalFieldType(core.bool),
>+  [$sinkId]: dart.finalFieldType(core.String),
>+  [$src]: dart.fieldType(core.String),
>+  [$srcObject]: dart.fieldType(html$.MediaStream),
>+  [$textTracks]: dart.finalFieldType(html$.TextTrackList),
>+  [$videoTracks]: dart.finalFieldType(html$.VideoTrackList),
>+  [$volume]: dart.fieldType(core.num),
>+  [$audioDecodedByteCount]: dart.finalFieldType(core.int),
>+  [$videoDecodedByteCount]: dart.finalFieldType(core.int)
>+}));
>+dart.defineLazy(html$.MediaElement, {
>+  /*html$.MediaElement.HAVE_CURRENT_DATA*/get HAVE_CURRENT_DATA() {
>+    return 2;
>+  },
>+  /*html$.MediaElement.HAVE_ENOUGH_DATA*/get HAVE_ENOUGH_DATA() {
>+    return 4;
>+  },
>+  /*html$.MediaElement.HAVE_FUTURE_DATA*/get HAVE_FUTURE_DATA() {
>+    return 3;
>+  },
>+  /*html$.MediaElement.HAVE_METADATA*/get HAVE_METADATA() {
>+    return 1;
>+  },
>+  /*html$.MediaElement.HAVE_NOTHING*/get HAVE_NOTHING() {
>+    return 0;
>+  },
>+  /*html$.MediaElement.NETWORK_EMPTY*/get NETWORK_EMPTY() {
>+    return 0;
>+  },
>+  /*html$.MediaElement.NETWORK_IDLE*/get NETWORK_IDLE() {
>+    return 1;
>+  },
>+  /*html$.MediaElement.NETWORK_LOADING*/get NETWORK_LOADING() {
>+    return 2;
>+  },
>+  /*html$.MediaElement.NETWORK_NO_SOURCE*/get NETWORK_NO_SOURCE() {
>+    return 3;
>+  }
>+});
>+dart.registerExtension("HTMLMediaElement", html$.MediaElement);
>+html$.AudioElement = class AudioElement extends html$.MediaElement {
>+  static __(src) {
>+    if (src === void 0) src = null;
>+    if (src != null) {
>+      return html$.AudioElement._create_1(src);
>+    }
>+    return html$.AudioElement._create_2();
>+  }
>+  static _create_1(src) {
>+    return new Audio(src);
>+  }
>+  static _create_2() {
>+    return new Audio();
>+  }
>+  static new(src) {
>+    if (src === void 0) src = null;
>+    return html$.AudioElement.__(src);
>+  }
>+};
>+(html$.AudioElement.created = function() {
>+  html$.AudioElement.__proto__.created.call(this);
>+}).prototype = html$.AudioElement.prototype;
>+dart.addTypeTests(html$.AudioElement);
>+dart.setLibraryUri(html$.AudioElement, "dart:html");
>+dart.registerExtension("HTMLAudioElement", html$.AudioElement);
>+html$.AuthenticatorResponse = class AuthenticatorResponse extends _interceptors.Interceptor {
>+  get [$clientDataJson]() {
>+    return this.clientDataJSON;
>+  }
>+};
>+dart.addTypeTests(html$.AuthenticatorResponse);
>+const clientDataJson = Symbol("AuthenticatorResponse.clientDataJson");
>+dart.setLibraryUri(html$.AuthenticatorResponse, "dart:html");
>+dart.setFieldSignature(html$.AuthenticatorResponse, () => ({
>+  __proto__: dart.getFields(html$.AuthenticatorResponse.__proto__),
>+  [$clientDataJson]: dart.finalFieldType(typed_data.ByteBuffer)
>+}));
>+dart.registerExtension("AuthenticatorResponse", html$.AuthenticatorResponse);
>+html$.AuthenticatorAssertionResponse = class AuthenticatorAssertionResponse extends html$.AuthenticatorResponse {
>+  get [$authenticatorData]() {
>+    return this.authenticatorData;
>+  }
>+  get [$signature]() {
>+    return this.signature;
>+  }
>+};
>+dart.addTypeTests(html$.AuthenticatorAssertionResponse);
>+const authenticatorData = Symbol("AuthenticatorAssertionResponse.authenticatorData");
>+const signature = Symbol("AuthenticatorAssertionResponse.signature");
>+dart.setLibraryUri(html$.AuthenticatorAssertionResponse, "dart:html");
>+dart.setFieldSignature(html$.AuthenticatorAssertionResponse, () => ({
>+  __proto__: dart.getFields(html$.AuthenticatorAssertionResponse.__proto__),
>+  [$authenticatorData]: dart.finalFieldType(typed_data.ByteBuffer),
>+  [$signature]: dart.finalFieldType(typed_data.ByteBuffer)
>+}));
>+dart.registerExtension("AuthenticatorAssertionResponse", html$.AuthenticatorAssertionResponse);
>+html$.AuthenticatorAttestationResponse = class AuthenticatorAttestationResponse extends html$.AuthenticatorResponse {
>+  get [$attestationObject]() {
>+    return this.attestationObject;
>+  }
>+};
>+dart.addTypeTests(html$.AuthenticatorAttestationResponse);
>+const attestationObject = Symbol("AuthenticatorAttestationResponse.attestationObject");
>+dart.setLibraryUri(html$.AuthenticatorAttestationResponse, "dart:html");
>+dart.setFieldSignature(html$.AuthenticatorAttestationResponse, () => ({
>+  __proto__: dart.getFields(html$.AuthenticatorAttestationResponse.__proto__),
>+  [$attestationObject]: dart.finalFieldType(typed_data.ByteBuffer)
>+}));
>+dart.registerExtension("AuthenticatorAttestationResponse", html$.AuthenticatorAttestationResponse);
>+html$.BRElement = class BRElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("br");
>+  }
>+};
>+(html$.BRElement.created = function() {
>+  html$.BRElement.__proto__.created.call(this);
>+}).prototype = html$.BRElement.prototype;
>+dart.addTypeTests(html$.BRElement);
>+dart.setLibraryUri(html$.BRElement, "dart:html");
>+dart.registerExtension("HTMLBRElement", html$.BRElement);
>+html$.BackgroundFetchEvent = class BackgroundFetchEvent$ extends html$.ExtendableEvent {
>+  static new(type, init) {
>+    let init_1 = html_common.convertDartToNative_Dictionary(init);
>+    return html$.BackgroundFetchEvent._create_1(type, init_1);
>+  }
>+  static _create_1(type, init) {
>+    return new BackgroundFetchEvent(type, init);
>+  }
>+  get [$id]() {
>+    return this.id;
>+  }
>+};
>+dart.addTypeTests(html$.BackgroundFetchEvent);
>+const id$1 = Symbol("BackgroundFetchEvent.id");
>+dart.setLibraryUri(html$.BackgroundFetchEvent, "dart:html");
>+dart.setFieldSignature(html$.BackgroundFetchEvent, () => ({
>+  __proto__: dart.getFields(html$.BackgroundFetchEvent.__proto__),
>+  [$id]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("BackgroundFetchEvent", html$.BackgroundFetchEvent);
>+html$.BackgroundFetchClickEvent = class BackgroundFetchClickEvent$ extends html$.BackgroundFetchEvent {
>+  static new(type, init) {
>+    let init_1 = html_common.convertDartToNative_Dictionary(init);
>+    return html$.BackgroundFetchClickEvent._create_1(type, init_1);
>+  }
>+  static _create_1(type, init) {
>+    return new BackgroundFetchClickEvent(type, init);
>+  }
>+  get [$state]() {
>+    return this.state;
>+  }
>+};
>+dart.addTypeTests(html$.BackgroundFetchClickEvent);
>+const state = Symbol("BackgroundFetchClickEvent.state");
>+dart.setLibraryUri(html$.BackgroundFetchClickEvent, "dart:html");
>+dart.setFieldSignature(html$.BackgroundFetchClickEvent, () => ({
>+  __proto__: dart.getFields(html$.BackgroundFetchClickEvent.__proto__),
>+  [$state]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("BackgroundFetchClickEvent", html$.BackgroundFetchClickEvent);
>+html$.BackgroundFetchFailEvent = class BackgroundFetchFailEvent$ extends html$.BackgroundFetchEvent {
>+  static new(type, init) {
>+    let init_1 = html_common.convertDartToNative_Dictionary(init);
>+    return html$.BackgroundFetchFailEvent._create_1(type, init_1);
>+  }
>+  static _create_1(type, init) {
>+    return new BackgroundFetchFailEvent(type, init);
>+  }
>+  get [$fetches]() {
>+    return this.fetches;
>+  }
>+};
>+dart.addTypeTests(html$.BackgroundFetchFailEvent);
>+const fetches = Symbol("BackgroundFetchFailEvent.fetches");
>+dart.setLibraryUri(html$.BackgroundFetchFailEvent, "dart:html");
>+dart.setFieldSignature(html$.BackgroundFetchFailEvent, () => ({
>+  __proto__: dart.getFields(html$.BackgroundFetchFailEvent.__proto__),
>+  [$fetches]: dart.finalFieldType(ListOfBackgroundFetchSettledFetch())
>+}));
>+dart.registerExtension("BackgroundFetchFailEvent", html$.BackgroundFetchFailEvent);
>+html$.BackgroundFetchFetch = class BackgroundFetchFetch extends _interceptors.Interceptor {
>+  get [$request]() {
>+    return this.request;
>+  }
>+};
>+dart.addTypeTests(html$.BackgroundFetchFetch);
>+const request = Symbol("BackgroundFetchFetch.request");
>+dart.setLibraryUri(html$.BackgroundFetchFetch, "dart:html");
>+dart.setFieldSignature(html$.BackgroundFetchFetch, () => ({
>+  __proto__: dart.getFields(html$.BackgroundFetchFetch.__proto__),
>+  [$request]: dart.finalFieldType(html$._Request)
>+}));
>+dart.registerExtension("BackgroundFetchFetch", html$.BackgroundFetchFetch);
>+html$.BackgroundFetchManager = class BackgroundFetchManager extends _interceptors.Interceptor {
>+  [$fetch](id, requests, options) {
>+    if (options === void 0) options = null;
>+    let options_dict = null;
>+    if (options != null) {
>+      options_dict = html_common.convertDartToNative_Dictionary(options);
>+    }
>+    return html$.promiseToFuture(html$.BackgroundFetchRegistration, this.fetch(id, requests, options_dict));
>+  }
>+  [$get](id) {
>+    return html$.promiseToFuture(html$.BackgroundFetchRegistration, this.get(id));
>+  }
>+  [$getIds]() {
>+    return html$.promiseToFuture(ListOfString(), this.getIds());
>+  }
>+};
>+dart.addTypeTests(html$.BackgroundFetchManager);
>+dart.setMethodSignature(html$.BackgroundFetchManager, () => ({
>+  __proto__: dart.getMethods(html$.BackgroundFetchManager.__proto__),
>+  [$fetch]: dart.fnType(async.Future$(html$.BackgroundFetchRegistration), [core.String, core.Object], [core.Map]),
>+  [$get]: dart.fnType(async.Future$(html$.BackgroundFetchRegistration), [core.String]),
>+  [$getIds]: dart.fnType(async.Future$(core.List$(core.String)), [])
>+}));
>+dart.setLibraryUri(html$.BackgroundFetchManager, "dart:html");
>+dart.registerExtension("BackgroundFetchManager", html$.BackgroundFetchManager);
>+html$.BackgroundFetchRegistration = class BackgroundFetchRegistration extends html$.EventTarget {
>+  get [$downloadTotal]() {
>+    return this.downloadTotal;
>+  }
>+  get [$downloaded]() {
>+    return this.downloaded;
>+  }
>+  get [$id]() {
>+    return this.id;
>+  }
>+  get [$title]() {
>+    return this.title;
>+  }
>+  get [$totalDownloadSize]() {
>+    return this.totalDownloadSize;
>+  }
>+  get [$uploadTotal]() {
>+    return this.uploadTotal;
>+  }
>+  get [$uploaded]() {
>+    return this.uploaded;
>+  }
>+  [$abort]() {
>+    return html$.promiseToFuture(core.bool, this.abort());
>+  }
>+};
>+dart.addTypeTests(html$.BackgroundFetchRegistration);
>+const downloadTotal = Symbol("BackgroundFetchRegistration.downloadTotal");
>+const downloaded = Symbol("BackgroundFetchRegistration.downloaded");
>+const id$2 = Symbol("BackgroundFetchRegistration.id");
>+const title$ = Symbol("BackgroundFetchRegistration.title");
>+const totalDownloadSize = Symbol("BackgroundFetchRegistration.totalDownloadSize");
>+const uploadTotal = Symbol("BackgroundFetchRegistration.uploadTotal");
>+const uploaded = Symbol("BackgroundFetchRegistration.uploaded");
>+dart.setMethodSignature(html$.BackgroundFetchRegistration, () => ({
>+  __proto__: dart.getMethods(html$.BackgroundFetchRegistration.__proto__),
>+  [$abort]: dart.fnType(async.Future$(core.bool), [])
>+}));
>+dart.setLibraryUri(html$.BackgroundFetchRegistration, "dart:html");
>+dart.setFieldSignature(html$.BackgroundFetchRegistration, () => ({
>+  __proto__: dart.getFields(html$.BackgroundFetchRegistration.__proto__),
>+  [$downloadTotal]: dart.finalFieldType(core.int),
>+  [$downloaded]: dart.finalFieldType(core.int),
>+  [$id]: dart.finalFieldType(core.String),
>+  [$title]: dart.finalFieldType(core.String),
>+  [$totalDownloadSize]: dart.finalFieldType(core.int),
>+  [$uploadTotal]: dart.finalFieldType(core.int),
>+  [$uploaded]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("BackgroundFetchRegistration", html$.BackgroundFetchRegistration);
>+html$.BackgroundFetchSettledFetch = class BackgroundFetchSettledFetch$ extends html$.BackgroundFetchFetch {
>+  static new(request, response) {
>+    return html$.BackgroundFetchSettledFetch._create_1(request, response);
>+  }
>+  static _create_1(request, response) {
>+    return new BackgroundFetchSettledFetch(request, response);
>+  }
>+  get [$response]() {
>+    return this.response;
>+  }
>+};
>+dart.addTypeTests(html$.BackgroundFetchSettledFetch);
>+const response = Symbol("BackgroundFetchSettledFetch.response");
>+dart.setLibraryUri(html$.BackgroundFetchSettledFetch, "dart:html");
>+dart.setFieldSignature(html$.BackgroundFetchSettledFetch, () => ({
>+  __proto__: dart.getFields(html$.BackgroundFetchSettledFetch.__proto__),
>+  [$response]: dart.finalFieldType(html$._Response)
>+}));
>+dart.registerExtension("BackgroundFetchSettledFetch", html$.BackgroundFetchSettledFetch);
>+html$.BackgroundFetchedEvent = class BackgroundFetchedEvent$ extends html$.BackgroundFetchEvent {
>+  static new(type, init) {
>+    let init_1 = html_common.convertDartToNative_Dictionary(init);
>+    return html$.BackgroundFetchedEvent._create_1(type, init_1);
>+  }
>+  static _create_1(type, init) {
>+    return new BackgroundFetchedEvent(type, init);
>+  }
>+  get [$fetches]() {
>+    return this.fetches;
>+  }
>+  [$updateUI](title) {
>+    return html$.promiseToFuture(dart.dynamic, this.updateUI(title));
>+  }
>+};
>+dart.addTypeTests(html$.BackgroundFetchedEvent);
>+const fetches$ = Symbol("BackgroundFetchedEvent.fetches");
>+dart.setMethodSignature(html$.BackgroundFetchedEvent, () => ({
>+  __proto__: dart.getMethods(html$.BackgroundFetchedEvent.__proto__),
>+  [$updateUI]: dart.fnType(async.Future, [core.String])
>+}));
>+dart.setLibraryUri(html$.BackgroundFetchedEvent, "dart:html");
>+dart.setFieldSignature(html$.BackgroundFetchedEvent, () => ({
>+  __proto__: dart.getFields(html$.BackgroundFetchedEvent.__proto__),
>+  [$fetches]: dart.finalFieldType(ListOfBackgroundFetchSettledFetch())
>+}));
>+dart.registerExtension("BackgroundFetchedEvent", html$.BackgroundFetchedEvent);
>+html$.BarProp = class BarProp extends _interceptors.Interceptor {
>+  get [$visible]() {
>+    return this.visible;
>+  }
>+};
>+dart.addTypeTests(html$.BarProp);
>+const visible = Symbol("BarProp.visible");
>+dart.setLibraryUri(html$.BarProp, "dart:html");
>+dart.setFieldSignature(html$.BarProp, () => ({
>+  __proto__: dart.getFields(html$.BarProp.__proto__),
>+  [$visible]: dart.finalFieldType(core.bool)
>+}));
>+dart.registerExtension("BarProp", html$.BarProp);
>+html$.BarcodeDetector = class BarcodeDetector$ extends _interceptors.Interceptor {
>+  static new() {
>+    return html$.BarcodeDetector._create_1();
>+  }
>+  static _create_1() {
>+    return new BarcodeDetector();
>+  }
>+  [$detect](image) {
>+    return html$.promiseToFuture(ListOfDetectedBarcode(), this.detect(image));
>+  }
>+};
>+dart.addTypeTests(html$.BarcodeDetector);
>+dart.setMethodSignature(html$.BarcodeDetector, () => ({
>+  __proto__: dart.getMethods(html$.BarcodeDetector.__proto__),
>+  [$detect]: dart.fnType(async.Future$(core.List$(html$.DetectedBarcode)), [dart.dynamic])
>+}));
>+dart.setLibraryUri(html$.BarcodeDetector, "dart:html");
>+dart.registerExtension("BarcodeDetector", html$.BarcodeDetector);
>+html$.BaseElement = class BaseElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("base");
>+  }
>+  get [$href]() {
>+    return this.href;
>+  }
>+  set [$href](value) {
>+    this.href = value;
>+  }
>+  get [$target]() {
>+    return this.target;
>+  }
>+  set [$target](value) {
>+    this.target = value;
>+  }
>+};
>+(html$.BaseElement.created = function() {
>+  this[href$0] = null;
>+  this[target$1] = null;
>+  html$.BaseElement.__proto__.created.call(this);
>+}).prototype = html$.BaseElement.prototype;
>+dart.addTypeTests(html$.BaseElement);
>+const href$0 = Symbol("BaseElement.href");
>+const target$1 = Symbol("BaseElement.target");
>+dart.setLibraryUri(html$.BaseElement, "dart:html");
>+dart.setFieldSignature(html$.BaseElement, () => ({
>+  __proto__: dart.getFields(html$.BaseElement.__proto__),
>+  [$href]: dart.fieldType(core.String),
>+  [$target]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("HTMLBaseElement", html$.BaseElement);
>+html$.BatteryManager = class BatteryManager extends html$.EventTarget {
>+  get [$charging]() {
>+    return this.charging;
>+  }
>+  get [$chargingTime]() {
>+    return this.chargingTime;
>+  }
>+  get [$dischargingTime]() {
>+    return this.dischargingTime;
>+  }
>+  get [$level]() {
>+    return this.level;
>+  }
>+};
>+dart.addTypeTests(html$.BatteryManager);
>+const charging = Symbol("BatteryManager.charging");
>+const chargingTime = Symbol("BatteryManager.chargingTime");
>+const dischargingTime = Symbol("BatteryManager.dischargingTime");
>+const level$3 = Symbol("BatteryManager.level");
>+dart.setLibraryUri(html$.BatteryManager, "dart:html");
>+dart.setFieldSignature(html$.BatteryManager, () => ({
>+  __proto__: dart.getFields(html$.BatteryManager.__proto__),
>+  [$charging]: dart.finalFieldType(core.bool),
>+  [$chargingTime]: dart.finalFieldType(core.num),
>+  [$dischargingTime]: dart.finalFieldType(core.num),
>+  [$level]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("BatteryManager", html$.BatteryManager);
>+html$.BeforeInstallPromptEvent = class BeforeInstallPromptEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.BeforeInstallPromptEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.BeforeInstallPromptEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new BeforeInstallPromptEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new BeforeInstallPromptEvent(type);
>+  }
>+  get [$platforms]() {
>+    return this.platforms;
>+  }
>+  get [$userChoice]() {
>+    return html$.promiseToFutureAsMap(this.userChoice);
>+  }
>+  [$prompt]() {
>+    return html$.promiseToFuture(dart.dynamic, this.prompt());
>+  }
>+};
>+dart.addTypeTests(html$.BeforeInstallPromptEvent);
>+const platforms = Symbol("BeforeInstallPromptEvent.platforms");
>+dart.setMethodSignature(html$.BeforeInstallPromptEvent, () => ({
>+  __proto__: dart.getMethods(html$.BeforeInstallPromptEvent.__proto__),
>+  [$prompt]: dart.fnType(async.Future, [])
>+}));
>+dart.setGetterSignature(html$.BeforeInstallPromptEvent, () => ({
>+  __proto__: dart.getGetters(html$.BeforeInstallPromptEvent.__proto__),
>+  [$userChoice]: async.Future$(core.Map$(core.String, dart.dynamic))
>+}));
>+dart.setLibraryUri(html$.BeforeInstallPromptEvent, "dart:html");
>+dart.setFieldSignature(html$.BeforeInstallPromptEvent, () => ({
>+  __proto__: dart.getFields(html$.BeforeInstallPromptEvent.__proto__),
>+  [$platforms]: dart.finalFieldType(ListOfString())
>+}));
>+dart.registerExtension("BeforeInstallPromptEvent", html$.BeforeInstallPromptEvent);
>+html$.BeforeUnloadEvent = class BeforeUnloadEvent extends html$.Event {
>+  get [$returnValue]() {
>+    return this.returnValue;
>+  }
>+  set [$returnValue](value) {
>+    this.returnValue = value;
>+  }
>+};
>+dart.addTypeTests(html$.BeforeUnloadEvent);
>+dart.setGetterSignature(html$.BeforeUnloadEvent, () => ({
>+  __proto__: dart.getGetters(html$.BeforeUnloadEvent.__proto__),
>+  [$returnValue]: core.String
>+}));
>+dart.setSetterSignature(html$.BeforeUnloadEvent, () => ({
>+  __proto__: dart.getSetters(html$.BeforeUnloadEvent.__proto__),
>+  [$returnValue]: core.String
>+}));
>+dart.setLibraryUri(html$.BeforeUnloadEvent, "dart:html");
>+dart.registerExtension("BeforeUnloadEvent", html$.BeforeUnloadEvent);
>+html$.Blob = class Blob extends _interceptors.Interceptor {
>+  get [$size]() {
>+    return this.size;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  [$slice](...args) {
>+    return this.slice.apply(this, args);
>+  }
>+  static new(blobParts, type, endings) {
>+    if (type === void 0) type = null;
>+    if (endings === void 0) endings = null;
>+    if (type == null && endings == null) {
>+      return html$.Blob._check(html$.Blob._create_1(blobParts));
>+    }
>+    let bag = html$.Blob._create_bag();
>+    if (type != null) html$.Blob._bag_set(bag, "type", type);
>+    if (endings != null) html$.Blob._bag_set(bag, "endings", endings);
>+    return html$.Blob._check(html$.Blob._create_2(blobParts, bag));
>+  }
>+  static _create_1(parts) {
>+    return new self.Blob(parts);
>+  }
>+  static _create_2(parts, bag) {
>+    return new self.Blob(parts, bag);
>+  }
>+  static _create_bag() {
>+    return {};
>+  }
>+  static _bag_set(bag, key, value) {
>+    bag[key] = value;
>+  }
>+};
>+dart.addTypeTests(html$.Blob);
>+const size = Symbol("Blob.size");
>+const type$4 = Symbol("Blob.type");
>+dart.setMethodSignature(html$.Blob, () => ({
>+  __proto__: dart.getMethods(html$.Blob.__proto__),
>+  [$slice]: dart.fnType(html$.Blob, [], [core.int, core.int, core.String])
>+}));
>+dart.setLibraryUri(html$.Blob, "dart:html");
>+dart.setFieldSignature(html$.Blob, () => ({
>+  __proto__: dart.getFields(html$.Blob.__proto__),
>+  [$size]: dart.finalFieldType(core.int),
>+  [$type]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("Blob", html$.Blob);
>+html$.BlobEvent = class BlobEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+    return html$.BlobEvent._create_1(type, eventInitDict_1);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new BlobEvent(type, eventInitDict);
>+  }
>+  get [$data]() {
>+    return this.data;
>+  }
>+  get [$timecode]() {
>+    return this.timecode;
>+  }
>+};
>+dart.addTypeTests(html$.BlobEvent);
>+const data = Symbol("BlobEvent.data");
>+const timecode = Symbol("BlobEvent.timecode");
>+dart.setLibraryUri(html$.BlobEvent, "dart:html");
>+dart.setFieldSignature(html$.BlobEvent, () => ({
>+  __proto__: dart.getFields(html$.BlobEvent.__proto__),
>+  [$data]: dart.finalFieldType(html$.Blob),
>+  [$timecode]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("BlobEvent", html$.BlobEvent);
>+html$.BluetoothRemoteGattDescriptor = class BluetoothRemoteGattDescriptor extends _interceptors.Interceptor {
>+  get [$characteristic]() {
>+    return this.characteristic;
>+  }
>+  get [$uuid]() {
>+    return this.uuid;
>+  }
>+  get [$value]() {
>+    return this.value;
>+  }
>+  [$readValue]() {
>+    return html$.promiseToFuture(dart.dynamic, this.readValue());
>+  }
>+  [$writeValue](value) {
>+    return html$.promiseToFuture(dart.dynamic, this.writeValue(value));
>+  }
>+};
>+dart.addTypeTests(html$.BluetoothRemoteGattDescriptor);
>+const characteristic = Symbol("BluetoothRemoteGattDescriptor.characteristic");
>+const uuid = Symbol("BluetoothRemoteGattDescriptor.uuid");
>+const value$0 = Symbol("BluetoothRemoteGattDescriptor.value");
>+dart.setMethodSignature(html$.BluetoothRemoteGattDescriptor, () => ({
>+  __proto__: dart.getMethods(html$.BluetoothRemoteGattDescriptor.__proto__),
>+  [$readValue]: dart.fnType(async.Future, []),
>+  [$writeValue]: dart.fnType(async.Future, [dart.dynamic])
>+}));
>+dart.setLibraryUri(html$.BluetoothRemoteGattDescriptor, "dart:html");
>+dart.setFieldSignature(html$.BluetoothRemoteGattDescriptor, () => ({
>+  __proto__: dart.getFields(html$.BluetoothRemoteGattDescriptor.__proto__),
>+  [$characteristic]: dart.finalFieldType(html$._BluetoothRemoteGATTCharacteristic),
>+  [$uuid]: dart.finalFieldType(core.String),
>+  [$value]: dart.finalFieldType(typed_data.ByteData)
>+}));
>+dart.registerExtension("BluetoothRemoteGATTDescriptor", html$.BluetoothRemoteGattDescriptor);
>+html$.Body = class Body extends _interceptors.Interceptor {
>+  get [$bodyUsed]() {
>+    return this.bodyUsed;
>+  }
>+  [$arrayBuffer]() {
>+    return html$.promiseToFuture(dart.dynamic, this.arrayBuffer());
>+  }
>+  [$blob]() {
>+    return html$.promiseToFuture(html$.Blob, this.blob());
>+  }
>+  [$formData]() {
>+    return html$.promiseToFuture(html$.FormData, this.formData());
>+  }
>+  [$json]() {
>+    return html$.promiseToFuture(dart.dynamic, this.json());
>+  }
>+  [$text]() {
>+    return html$.promiseToFuture(core.String, this.text());
>+  }
>+};
>+dart.addTypeTests(html$.Body);
>+const bodyUsed = Symbol("Body.bodyUsed");
>+dart.setMethodSignature(html$.Body, () => ({
>+  __proto__: dart.getMethods(html$.Body.__proto__),
>+  [$arrayBuffer]: dart.fnType(async.Future, []),
>+  [$blob]: dart.fnType(async.Future$(html$.Blob), []),
>+  [$formData]: dart.fnType(async.Future$(html$.FormData), []),
>+  [$json]: dart.fnType(async.Future, []),
>+  [$text]: dart.fnType(async.Future$(core.String), [])
>+}));
>+dart.setLibraryUri(html$.Body, "dart:html");
>+dart.setFieldSignature(html$.Body, () => ({
>+  __proto__: dart.getFields(html$.Body.__proto__),
>+  [$bodyUsed]: dart.finalFieldType(core.bool)
>+}));
>+dart.registerExtension("Body", html$.Body);
>+html$.BodyElement = class BodyElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("body");
>+  }
>+  get [$onBlur]() {
>+    return html$.BodyElement.blurEvent.forElement(this);
>+  }
>+  get [$onError]() {
>+    return html$.BodyElement.errorEvent.forElement(this);
>+  }
>+  get [$onFocus]() {
>+    return html$.BodyElement.focusEvent.forElement(this);
>+  }
>+  get [$onHashChange]() {
>+    return html$.BodyElement.hashChangeEvent.forElement(this);
>+  }
>+  get [$onLoad]() {
>+    return html$.BodyElement.loadEvent.forElement(this);
>+  }
>+  get [$onMessage]() {
>+    return html$.BodyElement.messageEvent.forElement(this);
>+  }
>+  get [$onOffline]() {
>+    return html$.BodyElement.offlineEvent.forElement(this);
>+  }
>+  get [$onOnline]() {
>+    return html$.BodyElement.onlineEvent.forElement(this);
>+  }
>+  get [$onPopState]() {
>+    return html$.BodyElement.popStateEvent.forElement(this);
>+  }
>+  get [$onResize]() {
>+    return html$.BodyElement.resizeEvent.forElement(this);
>+  }
>+  get [$onScroll]() {
>+    return html$.BodyElement.scrollEvent.forElement(this);
>+  }
>+  get [$onStorage]() {
>+    return html$.BodyElement.storageEvent.forElement(this);
>+  }
>+  get [$onUnload]() {
>+    return html$.BodyElement.unloadEvent.forElement(this);
>+  }
>+};
>+(html$.BodyElement.created = function() {
>+  html$.BodyElement.__proto__.created.call(this);
>+}).prototype = html$.BodyElement.prototype;
>+dart.addTypeTests(html$.BodyElement);
>+html$.BodyElement[dart.implements] = () => [html$.WindowEventHandlers];
>+dart.setGetterSignature(html$.BodyElement, () => ({
>+  __proto__: dart.getGetters(html$.BodyElement.__proto__),
>+  [$onHashChange]: html$.ElementStream$(html$.Event),
>+  [$onMessage]: html$.ElementStream$(html$.MessageEvent),
>+  [$onOffline]: html$.ElementStream$(html$.Event),
>+  [$onOnline]: html$.ElementStream$(html$.Event),
>+  [$onPopState]: html$.ElementStream$(html$.PopStateEvent),
>+  [$onStorage]: html$.ElementStream$(html$.StorageEvent),
>+  [$onUnload]: html$.ElementStream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.BodyElement, "dart:html");
>+dart.defineLazy(html$.BodyElement, {
>+  /*html$.BodyElement.blurEvent*/get blurEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("blur"));
>+  },
>+  /*html$.BodyElement.errorEvent*/get errorEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("error"));
>+  },
>+  /*html$.BodyElement.focusEvent*/get focusEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("focus"));
>+  },
>+  /*html$.BodyElement.hashChangeEvent*/get hashChangeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("hashchange"));
>+  },
>+  /*html$.BodyElement.loadEvent*/get loadEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("load"));
>+  },
>+  /*html$.BodyElement.messageEvent*/get messageEvent() {
>+    return dart.const(new (EventStreamProviderOfMessageEvent()).new("message"));
>+  },
>+  /*html$.BodyElement.offlineEvent*/get offlineEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("offline"));
>+  },
>+  /*html$.BodyElement.onlineEvent*/get onlineEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("online"));
>+  },
>+  /*html$.BodyElement.popStateEvent*/get popStateEvent() {
>+    return dart.const(new (EventStreamProviderOfPopStateEvent()).new("popstate"));
>+  },
>+  /*html$.BodyElement.resizeEvent*/get resizeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("resize"));
>+  },
>+  /*html$.BodyElement.scrollEvent*/get scrollEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("scroll"));
>+  },
>+  /*html$.BodyElement.storageEvent*/get storageEvent() {
>+    return dart.const(new (EventStreamProviderOfStorageEvent()).new("storage"));
>+  },
>+  /*html$.BodyElement.unloadEvent*/get unloadEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("unload"));
>+  }
>+});
>+dart.registerExtension("HTMLBodyElement", html$.BodyElement);
>+html$.BroadcastChannel = class BroadcastChannel$ extends html$.EventTarget {
>+  static new(name) {
>+    return html$.BroadcastChannel._create_1(name);
>+  }
>+  static _create_1(name) {
>+    return new BroadcastChannel(name);
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+  [$close](...args) {
>+    return this.close.apply(this, args);
>+  }
>+  [$postMessage](...args) {
>+    return this.postMessage.apply(this, args);
>+  }
>+  get [$onMessage]() {
>+    return html$.BroadcastChannel.messageEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.BroadcastChannel);
>+const name$6 = Symbol("BroadcastChannel.name");
>+dart.setMethodSignature(html$.BroadcastChannel, () => ({
>+  __proto__: dart.getMethods(html$.BroadcastChannel.__proto__),
>+  [$close]: dart.fnType(dart.void, []),
>+  [$postMessage]: dart.fnType(dart.void, [core.Object])
>+}));
>+dart.setGetterSignature(html$.BroadcastChannel, () => ({
>+  __proto__: dart.getGetters(html$.BroadcastChannel.__proto__),
>+  [$onMessage]: async.Stream$(html$.MessageEvent)
>+}));
>+dart.setLibraryUri(html$.BroadcastChannel, "dart:html");
>+dart.setFieldSignature(html$.BroadcastChannel, () => ({
>+  __proto__: dart.getFields(html$.BroadcastChannel.__proto__),
>+  [$name]: dart.finalFieldType(core.String)
>+}));
>+dart.defineLazy(html$.BroadcastChannel, {
>+  /*html$.BroadcastChannel.messageEvent*/get messageEvent() {
>+    return dart.const(new (EventStreamProviderOfMessageEvent()).new("message"));
>+  }
>+});
>+dart.registerExtension("BroadcastChannel", html$.BroadcastChannel);
>+html$.BudgetState = class BudgetState extends _interceptors.Interceptor {
>+  get [$budgetAt]() {
>+    return this.budgetAt;
>+  }
>+  get [$time]() {
>+    return this.time;
>+  }
>+};
>+dart.addTypeTests(html$.BudgetState);
>+const budgetAt = Symbol("BudgetState.budgetAt");
>+const time = Symbol("BudgetState.time");
>+dart.setLibraryUri(html$.BudgetState, "dart:html");
>+dart.setFieldSignature(html$.BudgetState, () => ({
>+  __proto__: dart.getFields(html$.BudgetState.__proto__),
>+  [$budgetAt]: dart.finalFieldType(core.num),
>+  [$time]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("BudgetState", html$.BudgetState);
>+html$.ButtonElement = class ButtonElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("button");
>+  }
>+  get [$autofocus]() {
>+    return this.autofocus;
>+  }
>+  set [$autofocus](value) {
>+    this.autofocus = value;
>+  }
>+  get [$disabled]() {
>+    return this.disabled;
>+  }
>+  set [$disabled](value) {
>+    this.disabled = value;
>+  }
>+  get [$form]() {
>+    return this.form;
>+  }
>+  get [$formAction]() {
>+    return this.formAction;
>+  }
>+  set [$formAction](value) {
>+    this.formAction = value;
>+  }
>+  get [$formEnctype]() {
>+    return this.formEnctype;
>+  }
>+  set [$formEnctype](value) {
>+    this.formEnctype = value;
>+  }
>+  get [$formMethod]() {
>+    return this.formMethod;
>+  }
>+  set [$formMethod](value) {
>+    this.formMethod = value;
>+  }
>+  get [$formNoValidate]() {
>+    return this.formNoValidate;
>+  }
>+  set [$formNoValidate](value) {
>+    this.formNoValidate = value;
>+  }
>+  get [$formTarget]() {
>+    return this.formTarget;
>+  }
>+  set [$formTarget](value) {
>+    this.formTarget = value;
>+  }
>+  get [$labels]() {
>+    return this.labels;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+  set [$name](value) {
>+    this.name = value;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  set [$type](value) {
>+    this.type = value;
>+  }
>+  get [$validationMessage]() {
>+    return this.validationMessage;
>+  }
>+  get [$validity]() {
>+    return this.validity;
>+  }
>+  get [$value]() {
>+    return this.value;
>+  }
>+  set [$value](value) {
>+    this.value = value;
>+  }
>+  get [$willValidate]() {
>+    return this.willValidate;
>+  }
>+  [$checkValidity](...args) {
>+    return this.checkValidity.apply(this, args);
>+  }
>+  [$reportValidity](...args) {
>+    return this.reportValidity.apply(this, args);
>+  }
>+  [$setCustomValidity](...args) {
>+    return this.setCustomValidity.apply(this, args);
>+  }
>+};
>+(html$.ButtonElement.created = function() {
>+  this[autofocus] = null;
>+  this[disabled$] = null;
>+  this[form] = null;
>+  this[formAction] = null;
>+  this[formEnctype] = null;
>+  this[formMethod] = null;
>+  this[formNoValidate] = null;
>+  this[formTarget] = null;
>+  this[labels] = null;
>+  this[name$7] = null;
>+  this[type$5] = null;
>+  this[validationMessage] = null;
>+  this[validity] = null;
>+  this[value$1] = null;
>+  this[willValidate] = null;
>+  html$.ButtonElement.__proto__.created.call(this);
>+}).prototype = html$.ButtonElement.prototype;
>+dart.addTypeTests(html$.ButtonElement);
>+const autofocus = Symbol("ButtonElement.autofocus");
>+const disabled$ = Symbol("ButtonElement.disabled");
>+const form = Symbol("ButtonElement.form");
>+const formAction = Symbol("ButtonElement.formAction");
>+const formEnctype = Symbol("ButtonElement.formEnctype");
>+const formMethod = Symbol("ButtonElement.formMethod");
>+const formNoValidate = Symbol("ButtonElement.formNoValidate");
>+const formTarget = Symbol("ButtonElement.formTarget");
>+const labels = Symbol("ButtonElement.labels");
>+const name$7 = Symbol("ButtonElement.name");
>+const type$5 = Symbol("ButtonElement.type");
>+const validationMessage = Symbol("ButtonElement.validationMessage");
>+const validity = Symbol("ButtonElement.validity");
>+const value$1 = Symbol("ButtonElement.value");
>+const willValidate = Symbol("ButtonElement.willValidate");
>+dart.setMethodSignature(html$.ButtonElement, () => ({
>+  __proto__: dart.getMethods(html$.ButtonElement.__proto__),
>+  [$checkValidity]: dart.fnType(core.bool, []),
>+  [$reportValidity]: dart.fnType(core.bool, []),
>+  [$setCustomValidity]: dart.fnType(dart.void, [core.String])
>+}));
>+dart.setLibraryUri(html$.ButtonElement, "dart:html");
>+dart.setFieldSignature(html$.ButtonElement, () => ({
>+  __proto__: dart.getFields(html$.ButtonElement.__proto__),
>+  [$autofocus]: dart.fieldType(core.bool),
>+  [$disabled]: dart.fieldType(core.bool),
>+  [$form]: dart.finalFieldType(html$.FormElement),
>+  [$formAction]: dart.fieldType(core.String),
>+  [$formEnctype]: dart.fieldType(core.String),
>+  [$formMethod]: dart.fieldType(core.String),
>+  [$formNoValidate]: dart.fieldType(core.bool),
>+  [$formTarget]: dart.fieldType(core.String),
>+  [$labels]: dart.finalFieldType(ListOfNode()),
>+  [$name]: dart.fieldType(core.String),
>+  [$type]: dart.fieldType(core.String),
>+  [$validationMessage]: dart.finalFieldType(core.String),
>+  [$validity]: dart.finalFieldType(html$.ValidityState),
>+  [$value]: dart.fieldType(core.String),
>+  [$willValidate]: dart.finalFieldType(core.bool)
>+}));
>+dart.registerExtension("HTMLButtonElement", html$.ButtonElement);
>+html$.CharacterData = class CharacterData extends html$.Node {
>+  get [$data]() {
>+    return this.data;
>+  }
>+  set [$data](value) {
>+    this.data = value;
>+  }
>+  get [$length]() {
>+    return this.length;
>+  }
>+  [$appendData](...args) {
>+    return this.appendData.apply(this, args);
>+  }
>+  [$deleteData](...args) {
>+    return this.deleteData.apply(this, args);
>+  }
>+  [$insertData](...args) {
>+    return this.insertData.apply(this, args);
>+  }
>+  [$replaceData](...args) {
>+    return this.replaceData.apply(this, args);
>+  }
>+  [$substringData](...args) {
>+    return this.substringData.apply(this, args);
>+  }
>+  [$after](...args) {
>+    return this.after.apply(this, args);
>+  }
>+  [$before](...args) {
>+    return this.before.apply(this, args);
>+  }
>+  get [$nextElementSibling]() {
>+    return this.nextElementSibling;
>+  }
>+  get [$previousElementSibling]() {
>+    return this.previousElementSibling;
>+  }
>+};
>+dart.addTypeTests(html$.CharacterData);
>+const data$0 = Symbol("CharacterData.data");
>+const length$0 = Symbol("CharacterData.length");
>+const nextElementSibling$ = Symbol("CharacterData.nextElementSibling");
>+const previousElementSibling$ = Symbol("CharacterData.previousElementSibling");
>+html$.CharacterData[dart.implements] = () => [html$.NonDocumentTypeChildNode, html$.ChildNode];
>+dart.setMethodSignature(html$.CharacterData, () => ({
>+  __proto__: dart.getMethods(html$.CharacterData.__proto__),
>+  [$appendData]: dart.fnType(dart.void, [core.String]),
>+  [$deleteData]: dart.fnType(dart.void, [core.int, core.int]),
>+  [$insertData]: dart.fnType(dart.void, [core.int, core.String]),
>+  [$replaceData]: dart.fnType(dart.void, [core.int, core.int, core.String]),
>+  [$substringData]: dart.fnType(core.String, [core.int, core.int]),
>+  [$after]: dart.fnType(dart.void, [core.Object]),
>+  [$before]: dart.fnType(dart.void, [core.Object])
>+}));
>+dart.setLibraryUri(html$.CharacterData, "dart:html");
>+dart.setFieldSignature(html$.CharacterData, () => ({
>+  __proto__: dart.getFields(html$.CharacterData.__proto__),
>+  [$data]: dart.fieldType(core.String),
>+  [$length]: dart.finalFieldType(core.int),
>+  [$nextElementSibling]: dart.finalFieldType(html$.Element),
>+  [$previousElementSibling]: dart.finalFieldType(html$.Element)
>+}));
>+dart.registerExtension("CharacterData", html$.CharacterData);
>+html$.Text = class Text extends html$.CharacterData {
>+  static new(data) {
>+    return html$.document.createTextNode(data);
>+  }
>+  get [$assignedSlot]() {
>+    return this.assignedSlot;
>+  }
>+  get [$wholeText]() {
>+    return this.wholeText;
>+  }
>+  [$getDestinationInsertionPoints](...args) {
>+    return this.getDestinationInsertionPoints.apply(this, args);
>+  }
>+  [$splitText](...args) {
>+    return this.splitText.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.Text);
>+const assignedSlot$ = Symbol("Text.assignedSlot");
>+const wholeText = Symbol("Text.wholeText");
>+dart.setMethodSignature(html$.Text, () => ({
>+  __proto__: dart.getMethods(html$.Text.__proto__),
>+  [$getDestinationInsertionPoints]: dart.fnType(core.List$(html$.Node), []),
>+  [$splitText]: dart.fnType(html$.Text, [core.int])
>+}));
>+dart.setLibraryUri(html$.Text, "dart:html");
>+dart.setFieldSignature(html$.Text, () => ({
>+  __proto__: dart.getFields(html$.Text.__proto__),
>+  [$assignedSlot]: dart.finalFieldType(html$.SlotElement),
>+  [$wholeText]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("Text", html$.Text);
>+html$.CDataSection = class CDataSection extends html$.Text {};
>+dart.addTypeTests(html$.CDataSection);
>+dart.setLibraryUri(html$.CDataSection, "dart:html");
>+dart.registerExtension("CDATASection", html$.CDataSection);
>+html$.CacheStorage = class CacheStorage extends _interceptors.Interceptor {
>+  [$delete](cacheName) {
>+    return html$.promiseToFuture(dart.dynamic, this.delete(cacheName));
>+  }
>+  [$has](cacheName) {
>+    return html$.promiseToFuture(dart.dynamic, this.has(cacheName));
>+  }
>+  [$keys]() {
>+    return html$.promiseToFuture(dart.dynamic, this.keys());
>+  }
>+  [$match](request, options) {
>+    if (options === void 0) options = null;
>+    let options_dict = null;
>+    if (options != null) {
>+      options_dict = html_common.convertDartToNative_Dictionary(options);
>+    }
>+    return html$.promiseToFuture(dart.dynamic, this.match(request, options_dict));
>+  }
>+  [$open](cacheName) {
>+    return html$.promiseToFuture(dart.dynamic, this.open(cacheName));
>+  }
>+};
>+dart.addTypeTests(html$.CacheStorage);
>+dart.setMethodSignature(html$.CacheStorage, () => ({
>+  __proto__: dart.getMethods(html$.CacheStorage.__proto__),
>+  [$delete]: dart.fnType(async.Future, [core.String]),
>+  [$has]: dart.fnType(async.Future, [core.String]),
>+  [$keys]: dart.fnType(async.Future, []),
>+  [$match]: dart.fnType(async.Future, [dart.dynamic], [core.Map]),
>+  [$open]: dart.fnType(async.Future, [core.String])
>+}));
>+dart.setLibraryUri(html$.CacheStorage, "dart:html");
>+dart.registerExtension("CacheStorage", html$.CacheStorage);
>+html$.CanMakePaymentEvent = class CanMakePaymentEvent$ extends html$.ExtendableEvent {
>+  static new(type, eventInitDict) {
>+    let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+    return html$.CanMakePaymentEvent._create_1(type, eventInitDict_1);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new CanMakePaymentEvent(type, eventInitDict);
>+  }
>+  get [$methodData]() {
>+    return this.methodData;
>+  }
>+  get [$modifiers]() {
>+    return this.modifiers;
>+  }
>+  get [$paymentRequestOrigin]() {
>+    return this.paymentRequestOrigin;
>+  }
>+  get [$topLevelOrigin]() {
>+    return this.topLevelOrigin;
>+  }
>+  [$respondWith](...args) {
>+    return this.respondWith.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.CanMakePaymentEvent);
>+const methodData = Symbol("CanMakePaymentEvent.methodData");
>+const modifiers = Symbol("CanMakePaymentEvent.modifiers");
>+const paymentRequestOrigin = Symbol("CanMakePaymentEvent.paymentRequestOrigin");
>+const topLevelOrigin = Symbol("CanMakePaymentEvent.topLevelOrigin");
>+dart.setMethodSignature(html$.CanMakePaymentEvent, () => ({
>+  __proto__: dart.getMethods(html$.CanMakePaymentEvent.__proto__),
>+  [$respondWith]: dart.fnType(dart.void, [async.Future])
>+}));
>+dart.setLibraryUri(html$.CanMakePaymentEvent, "dart:html");
>+dart.setFieldSignature(html$.CanMakePaymentEvent, () => ({
>+  __proto__: dart.getFields(html$.CanMakePaymentEvent.__proto__),
>+  [$methodData]: dart.finalFieldType(core.List),
>+  [$modifiers]: dart.finalFieldType(core.List),
>+  [$paymentRequestOrigin]: dart.finalFieldType(core.String),
>+  [$topLevelOrigin]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("CanMakePaymentEvent", html$.CanMakePaymentEvent);
>+const _getCapabilities_1 = dart.privateName(html$, "_getCapabilities_1");
>+const _getConstraints_1 = dart.privateName(html$, "_getConstraints_1");
>+const _getSettings_1 = dart.privateName(html$, "_getSettings_1");
>+html$.MediaStreamTrack = class MediaStreamTrack extends html$.EventTarget {
>+  get [$contentHint]() {
>+    return this.contentHint;
>+  }
>+  set [$contentHint](value) {
>+    this.contentHint = value;
>+  }
>+  get [$enabled]() {
>+    return this.enabled;
>+  }
>+  set [$enabled](value) {
>+    this.enabled = value;
>+  }
>+  get [$id]() {
>+    return this.id;
>+  }
>+  get [$kind]() {
>+    return this.kind;
>+  }
>+  get [$label]() {
>+    return this.label;
>+  }
>+  get [$muted]() {
>+    return this.muted;
>+  }
>+  get [$readyState]() {
>+    return this.readyState;
>+  }
>+  [$applyConstraints](constraints) {
>+    if (constraints === void 0) constraints = null;
>+    let constraints_dict = null;
>+    if (constraints != null) {
>+      constraints_dict = html_common.convertDartToNative_Dictionary(constraints);
>+    }
>+    return html$.promiseToFuture(dart.dynamic, this.applyConstraints(constraints_dict));
>+  }
>+  [$clone](...args) {
>+    return this.clone.apply(this, args);
>+  }
>+  [$getCapabilities]() {
>+    return html_common.convertNativeToDart_Dictionary(this[_getCapabilities_1]());
>+  }
>+  [_getCapabilities_1](...args) {
>+    return this.getCapabilities.apply(this, args);
>+  }
>+  [$getConstraints]() {
>+    return html_common.convertNativeToDart_Dictionary(this[_getConstraints_1]());
>+  }
>+  [_getConstraints_1](...args) {
>+    return this.getConstraints.apply(this, args);
>+  }
>+  [$getSettings]() {
>+    return html_common.convertNativeToDart_Dictionary(this[_getSettings_1]());
>+  }
>+  [_getSettings_1](...args) {
>+    return this.getSettings.apply(this, args);
>+  }
>+  [$stop](...args) {
>+    return this.stop.apply(this, args);
>+  }
>+  get [$onEnded]() {
>+    return html$.MediaStreamTrack.endedEvent.forTarget(this);
>+  }
>+  get [$onMute]() {
>+    return html$.MediaStreamTrack.muteEvent.forTarget(this);
>+  }
>+  get [$onUnmute]() {
>+    return html$.MediaStreamTrack.unmuteEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.MediaStreamTrack);
>+const contentHint = Symbol("MediaStreamTrack.contentHint");
>+const enabled = Symbol("MediaStreamTrack.enabled");
>+const id$3 = Symbol("MediaStreamTrack.id");
>+const kind = Symbol("MediaStreamTrack.kind");
>+const label$ = Symbol("MediaStreamTrack.label");
>+const muted$ = Symbol("MediaStreamTrack.muted");
>+const readyState$0 = Symbol("MediaStreamTrack.readyState");
>+dart.setMethodSignature(html$.MediaStreamTrack, () => ({
>+  __proto__: dart.getMethods(html$.MediaStreamTrack.__proto__),
>+  [$applyConstraints]: dart.fnType(async.Future, [], [core.Map]),
>+  [$clone]: dart.fnType(html$.MediaStreamTrack, []),
>+  [$getCapabilities]: dart.fnType(core.Map, []),
>+  [_getCapabilities_1]: dart.fnType(dart.dynamic, []),
>+  [$getConstraints]: dart.fnType(core.Map, []),
>+  [_getConstraints_1]: dart.fnType(dart.dynamic, []),
>+  [$getSettings]: dart.fnType(core.Map, []),
>+  [_getSettings_1]: dart.fnType(dart.dynamic, []),
>+  [$stop]: dart.fnType(dart.void, [])
>+}));
>+dart.setGetterSignature(html$.MediaStreamTrack, () => ({
>+  __proto__: dart.getGetters(html$.MediaStreamTrack.__proto__),
>+  [$onEnded]: async.Stream$(html$.Event),
>+  [$onMute]: async.Stream$(html$.Event),
>+  [$onUnmute]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.MediaStreamTrack, "dart:html");
>+dart.setFieldSignature(html$.MediaStreamTrack, () => ({
>+  __proto__: dart.getFields(html$.MediaStreamTrack.__proto__),
>+  [$contentHint]: dart.fieldType(core.String),
>+  [$enabled]: dart.fieldType(core.bool),
>+  [$id]: dart.finalFieldType(core.String),
>+  [$kind]: dart.finalFieldType(core.String),
>+  [$label]: dart.finalFieldType(core.String),
>+  [$muted]: dart.finalFieldType(core.bool),
>+  [$readyState]: dart.finalFieldType(core.String)
>+}));
>+dart.defineLazy(html$.MediaStreamTrack, {
>+  /*html$.MediaStreamTrack.endedEvent*/get endedEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("ended"));
>+  },
>+  /*html$.MediaStreamTrack.muteEvent*/get muteEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("mute"));
>+  },
>+  /*html$.MediaStreamTrack.unmuteEvent*/get unmuteEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("unmute"));
>+  }
>+});
>+dart.registerExtension("MediaStreamTrack", html$.MediaStreamTrack);
>+html$.CanvasCaptureMediaStreamTrack = class CanvasCaptureMediaStreamTrack extends html$.MediaStreamTrack {
>+  get [$canvas]() {
>+    return this.canvas;
>+  }
>+  [$requestFrame](...args) {
>+    return this.requestFrame.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.CanvasCaptureMediaStreamTrack);
>+const canvas = Symbol("CanvasCaptureMediaStreamTrack.canvas");
>+dart.setMethodSignature(html$.CanvasCaptureMediaStreamTrack, () => ({
>+  __proto__: dart.getMethods(html$.CanvasCaptureMediaStreamTrack.__proto__),
>+  [$requestFrame]: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(html$.CanvasCaptureMediaStreamTrack, "dart:html");
>+dart.setFieldSignature(html$.CanvasCaptureMediaStreamTrack, () => ({
>+  __proto__: dart.getFields(html$.CanvasCaptureMediaStreamTrack.__proto__),
>+  [$canvas]: dart.finalFieldType(html$.CanvasElement)
>+}));
>+dart.registerExtension("CanvasCaptureMediaStreamTrack", html$.CanvasCaptureMediaStreamTrack);
>+const _getContext_1 = dart.privateName(html$, "_getContext_1");
>+const _getContext_2 = dart.privateName(html$, "_getContext_2");
>+const _toDataUrl = dart.privateName(html$, "_toDataUrl");
>+const _toBlob = dart.privateName(html$, "_toBlob");
>+html$.CanvasElement = class CanvasElement extends html$.HtmlElement {
>+  static new(opts) {
>+    let width = opts && 'width' in opts ? opts.width : null;
>+    let height = opts && 'height' in opts ? opts.height : null;
>+    let e = html$.document.createElement("canvas");
>+    if (width != null) e.width = width;
>+    if (height != null) e.height = height;
>+    return e;
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  set [$height](value) {
>+    this.height = value;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  set [$width](value) {
>+    this.width = value;
>+  }
>+  [$captureStream](...args) {
>+    return this.captureStream.apply(this, args);
>+  }
>+  [$getContext](contextId, attributes) {
>+    if (attributes === void 0) attributes = null;
>+    if (attributes != null) {
>+      let attributes_1 = html_common.convertDartToNative_Dictionary(attributes);
>+      return this[_getContext_1](contextId, attributes_1);
>+    }
>+    return this[_getContext_2](contextId);
>+  }
>+  [_getContext_1](...args) {
>+    return this.getContext.apply(this, args);
>+  }
>+  [_getContext_2](...args) {
>+    return this.getContext.apply(this, args);
>+  }
>+  [_toDataUrl](...args) {
>+    return this.toDataURL.apply(this, args);
>+  }
>+  [$transferControlToOffscreen](...args) {
>+    return this.transferControlToOffscreen.apply(this, args);
>+  }
>+  get [$onWebGlContextLost]() {
>+    return html$.CanvasElement.webGlContextLostEvent.forElement(this);
>+  }
>+  get [$onWebGlContextRestored]() {
>+    return html$.CanvasElement.webGlContextRestoredEvent.forElement(this);
>+  }
>+  get [$context2D]() {
>+    return this.getContext("2d");
>+  }
>+  [$getContext3d](opts) {
>+    let alpha = opts && 'alpha' in opts ? opts.alpha : true;
>+    let depth = opts && 'depth' in opts ? opts.depth : true;
>+    let stencil = opts && 'stencil' in opts ? opts.stencil : false;
>+    let antialias = opts && 'antialias' in opts ? opts.antialias : true;
>+    let premultipliedAlpha = opts && 'premultipliedAlpha' in opts ? opts.premultipliedAlpha : true;
>+    let preserveDrawingBuffer = opts && 'preserveDrawingBuffer' in opts ? opts.preserveDrawingBuffer : false;
>+    let options = new (IdentityMapOfString$dynamic()).from(["alpha", alpha, "depth", depth, "stencil", stencil, "antialias", antialias, "premultipliedAlpha", premultipliedAlpha, "preserveDrawingBuffer", preserveDrawingBuffer]);
>+    let context = this[$getContext]("webgl", options);
>+    if (context == null) {
>+      context = this[$getContext]("experimental-webgl", options);
>+    }
>+    return web_gl.RenderingContext._check(context);
>+  }
>+  [$toDataUrl](type, quality) {
>+    if (type === void 0) type = "image/png";
>+    if (quality === void 0) quality = null;
>+    return this[_toDataUrl](type, quality);
>+  }
>+  [_toBlob](...args) {
>+    return this.toBlob.apply(this, args);
>+  }
>+  [$toBlob](type, arguments$0) {
>+    if (arguments$0 === void 0) arguments$0 = null;
>+    let completer = CompleterOfBlob().new();
>+    this[_toBlob](dart.fn(value => {
>+      completer.complete(value);
>+    }, BlobToNull()), type, arguments$0);
>+    return completer.future;
>+  }
>+};
>+(html$.CanvasElement.created = function() {
>+  this[height] = null;
>+  this[width] = null;
>+  html$.CanvasElement.__proto__.created.call(this);
>+}).prototype = html$.CanvasElement.prototype;
>+dart.addTypeTests(html$.CanvasElement);
>+const height = Symbol("CanvasElement.height");
>+const width = Symbol("CanvasElement.width");
>+html$.CanvasElement[dart.implements] = () => [html$.CanvasImageSource];
>+dart.setMethodSignature(html$.CanvasElement, () => ({
>+  __proto__: dart.getMethods(html$.CanvasElement.__proto__),
>+  [$captureStream]: dart.fnType(html$.MediaStream, [], [core.num]),
>+  [$getContext]: dart.fnType(core.Object, [core.String], [core.Map]),
>+  [_getContext_1]: dart.fnType(core.Object, [dart.dynamic, dart.dynamic]),
>+  [_getContext_2]: dart.fnType(core.Object, [dart.dynamic]),
>+  [_toDataUrl]: dart.fnType(core.String, [core.String], [dart.dynamic]),
>+  [$transferControlToOffscreen]: dart.fnType(html$.OffscreenCanvas, []),
>+  [$getContext3d]: dart.fnType(web_gl.RenderingContext, [], {alpha: dart.dynamic, depth: dart.dynamic, stencil: dart.dynamic, antialias: dart.dynamic, premultipliedAlpha: dart.dynamic, preserveDrawingBuffer: dart.dynamic}),
>+  [$toDataUrl]: dart.fnType(core.String, [], [core.String, core.num]),
>+  [_toBlob]: dart.fnType(dart.void, [dart.fnType(dart.void, [html$.Blob]), core.String], [core.Object]),
>+  [$toBlob]: dart.fnType(async.Future$(html$.Blob), [core.String], [core.Object])
>+}));
>+dart.setGetterSignature(html$.CanvasElement, () => ({
>+  __proto__: dart.getGetters(html$.CanvasElement.__proto__),
>+  [$onWebGlContextLost]: html$.ElementStream$(web_gl.ContextEvent),
>+  [$onWebGlContextRestored]: html$.ElementStream$(web_gl.ContextEvent),
>+  [$context2D]: html$.CanvasRenderingContext2D
>+}));
>+dart.setLibraryUri(html$.CanvasElement, "dart:html");
>+dart.setFieldSignature(html$.CanvasElement, () => ({
>+  __proto__: dart.getFields(html$.CanvasElement.__proto__),
>+  [$height]: dart.fieldType(core.int),
>+  [$width]: dart.fieldType(core.int)
>+}));
>+dart.defineLazy(html$.CanvasElement, {
>+  /*html$.CanvasElement.webGlContextLostEvent*/get webGlContextLostEvent() {
>+    return dart.const(new (EventStreamProviderOfContextEvent()).new("webglcontextlost"));
>+  },
>+  /*html$.CanvasElement.webGlContextRestoredEvent*/get webGlContextRestoredEvent() {
>+    return dart.const(new (EventStreamProviderOfContextEvent()).new("webglcontextrestored"));
>+  }
>+});
>+dart.registerExtension("HTMLCanvasElement", html$.CanvasElement);
>+html$.CanvasGradient = class CanvasGradient extends _interceptors.Interceptor {
>+  [$addColorStop](...args) {
>+    return this.addColorStop.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.CanvasGradient);
>+dart.setMethodSignature(html$.CanvasGradient, () => ({
>+  __proto__: dart.getMethods(html$.CanvasGradient.__proto__),
>+  [$addColorStop]: dart.fnType(dart.void, [core.num, core.String])
>+}));
>+dart.setLibraryUri(html$.CanvasGradient, "dart:html");
>+dart.registerExtension("CanvasGradient", html$.CanvasGradient);
>+html$.CanvasPattern = class CanvasPattern extends _interceptors.Interceptor {
>+  [$setTransform](...args) {
>+    return this.setTransform.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.CanvasPattern);
>+dart.setMethodSignature(html$.CanvasPattern, () => ({
>+  __proto__: dart.getMethods(html$.CanvasPattern.__proto__),
>+  [$setTransform]: dart.fnType(dart.void, [svg$.Matrix])
>+}));
>+dart.setLibraryUri(html$.CanvasPattern, "dart:html");
>+dart.registerExtension("CanvasPattern", html$.CanvasPattern);
>+html$.CanvasRenderingContext = class CanvasRenderingContext extends core.Object {};
>+(html$.CanvasRenderingContext.new = function() {
>+}).prototype = html$.CanvasRenderingContext.prototype;
>+dart.addTypeTests(html$.CanvasRenderingContext);
>+dart.setLibraryUri(html$.CanvasRenderingContext, "dart:html");
>+const _addHitRegion_1 = dart.privateName(html$, "_addHitRegion_1");
>+const _addHitRegion_2 = dart.privateName(html$, "_addHitRegion_2");
>+const _createImageData_1 = dart.privateName(html$, "_createImageData_1");
>+const _createImageData_2 = dart.privateName(html$, "_createImageData_2");
>+const _createImageData_3 = dart.privateName(html$, "_createImageData_3");
>+const _createImageData_4 = dart.privateName(html$, "_createImageData_4");
>+const _createImageData_5 = dart.privateName(html$, "_createImageData_5");
>+const _getContextAttributes_1 = dart.privateName(html$, "_getContextAttributes_1");
>+const _getImageData_1 = dart.privateName(html$, "_getImageData_1");
>+const _getLineDash = dart.privateName(html$, "_getLineDash");
>+const _putImageData_1 = dart.privateName(html$, "_putImageData_1");
>+const _putImageData_2 = dart.privateName(html$, "_putImageData_2");
>+const _arc = dart.privateName(html$, "_arc");
>+html$.CanvasRenderingContext2D = class CanvasRenderingContext2D extends _interceptors.Interceptor {
>+  get [$canvas]() {
>+    return this.canvas;
>+  }
>+  get [$currentTransform]() {
>+    return this.currentTransform;
>+  }
>+  set [$currentTransform](value) {
>+    this.currentTransform = value;
>+  }
>+  get [$direction]() {
>+    return this.direction;
>+  }
>+  set [$direction](value) {
>+    this.direction = value;
>+  }
>+  get [$fillStyle]() {
>+    return this.fillStyle;
>+  }
>+  set [$fillStyle](value) {
>+    this.fillStyle = value;
>+  }
>+  get [$filter]() {
>+    return this.filter;
>+  }
>+  set [$filter](value) {
>+    this.filter = value;
>+  }
>+  get [$font]() {
>+    return this.font;
>+  }
>+  set [$font](value) {
>+    this.font = value;
>+  }
>+  get [$globalAlpha]() {
>+    return this.globalAlpha;
>+  }
>+  set [$globalAlpha](value) {
>+    this.globalAlpha = value;
>+  }
>+  get [$globalCompositeOperation]() {
>+    return this.globalCompositeOperation;
>+  }
>+  set [$globalCompositeOperation](value) {
>+    this.globalCompositeOperation = value;
>+  }
>+  get [$imageSmoothingEnabled]() {
>+    return this.imageSmoothingEnabled;
>+  }
>+  set [$imageSmoothingEnabled](value) {
>+    this.imageSmoothingEnabled = value;
>+  }
>+  get [$imageSmoothingQuality]() {
>+    return this.imageSmoothingQuality;
>+  }
>+  set [$imageSmoothingQuality](value) {
>+    this.imageSmoothingQuality = value;
>+  }
>+  get [$lineCap]() {
>+    return this.lineCap;
>+  }
>+  set [$lineCap](value) {
>+    this.lineCap = value;
>+  }
>+  get [$lineJoin]() {
>+    return this.lineJoin;
>+  }
>+  set [$lineJoin](value) {
>+    this.lineJoin = value;
>+  }
>+  get [$lineWidth]() {
>+    return this.lineWidth;
>+  }
>+  set [$lineWidth](value) {
>+    this.lineWidth = value;
>+  }
>+  get [$miterLimit]() {
>+    return this.miterLimit;
>+  }
>+  set [$miterLimit](value) {
>+    this.miterLimit = value;
>+  }
>+  get [$shadowBlur]() {
>+    return this.shadowBlur;
>+  }
>+  set [$shadowBlur](value) {
>+    this.shadowBlur = value;
>+  }
>+  get [$shadowColor]() {
>+    return this.shadowColor;
>+  }
>+  set [$shadowColor](value) {
>+    this.shadowColor = value;
>+  }
>+  get [$shadowOffsetX]() {
>+    return this.shadowOffsetX;
>+  }
>+  set [$shadowOffsetX](value) {
>+    this.shadowOffsetX = value;
>+  }
>+  get [$shadowOffsetY]() {
>+    return this.shadowOffsetY;
>+  }
>+  set [$shadowOffsetY](value) {
>+    this.shadowOffsetY = value;
>+  }
>+  get [$strokeStyle]() {
>+    return this.strokeStyle;
>+  }
>+  set [$strokeStyle](value) {
>+    this.strokeStyle = value;
>+  }
>+  get [$textAlign]() {
>+    return this.textAlign;
>+  }
>+  set [$textAlign](value) {
>+    this.textAlign = value;
>+  }
>+  get [$textBaseline]() {
>+    return this.textBaseline;
>+  }
>+  set [$textBaseline](value) {
>+    this.textBaseline = value;
>+  }
>+  [$addHitRegion](options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      this[_addHitRegion_1](options_1);
>+      return;
>+    }
>+    this[_addHitRegion_2]();
>+    return;
>+  }
>+  [_addHitRegion_1](...args) {
>+    return this.addHitRegion.apply(this, args);
>+  }
>+  [_addHitRegion_2](...args) {
>+    return this.addHitRegion.apply(this, args);
>+  }
>+  [$beginPath](...args) {
>+    return this.beginPath.apply(this, args);
>+  }
>+  [$clearHitRegions](...args) {
>+    return this.clearHitRegions.apply(this, args);
>+  }
>+  [$clearRect](...args) {
>+    return this.clearRect.apply(this, args);
>+  }
>+  [$clip](...args) {
>+    return this.clip.apply(this, args);
>+  }
>+  [$createImageData](data_OR_imagedata_OR_sw, sh_OR_sw, imageDataColorSettings_OR_sh, imageDataColorSettings) {
>+    if (sh_OR_sw === void 0) sh_OR_sw = null;
>+    if (imageDataColorSettings_OR_sh === void 0) imageDataColorSettings_OR_sh = null;
>+    if (imageDataColorSettings === void 0) imageDataColorSettings = null;
>+    if (html$.ImageData.is(data_OR_imagedata_OR_sw) && sh_OR_sw == null && imageDataColorSettings_OR_sh == null && imageDataColorSettings == null) {
>+      let imagedata_1 = html_common.convertDartToNative_ImageData(data_OR_imagedata_OR_sw);
>+      return html_common.convertNativeToDart_ImageData(this[_createImageData_1](imagedata_1));
>+    }
>+    if (sh_OR_sw != null && core.int.is(data_OR_imagedata_OR_sw) && imageDataColorSettings_OR_sh == null && imageDataColorSettings == null) {
>+      return html_common.convertNativeToDart_ImageData(this[_createImageData_2](data_OR_imagedata_OR_sw, sh_OR_sw));
>+    }
>+    if (core.Map.is(imageDataColorSettings_OR_sh) && sh_OR_sw != null && core.int.is(data_OR_imagedata_OR_sw) && imageDataColorSettings == null) {
>+      let imageDataColorSettings_1 = html_common.convertDartToNative_Dictionary(imageDataColorSettings_OR_sh);
>+      return html_common.convertNativeToDart_ImageData(this[_createImageData_3](data_OR_imagedata_OR_sw, sh_OR_sw, imageDataColorSettings_1));
>+    }
>+    if (core.int.is(imageDataColorSettings_OR_sh) && sh_OR_sw != null && data_OR_imagedata_OR_sw != null && imageDataColorSettings == null) {
>+      return html_common.convertNativeToDart_ImageData(this[_createImageData_4](data_OR_imagedata_OR_sw, sh_OR_sw, imageDataColorSettings_OR_sh));
>+    }
>+    if (imageDataColorSettings != null && core.int.is(imageDataColorSettings_OR_sh) && sh_OR_sw != null && data_OR_imagedata_OR_sw != null) {
>+      let imageDataColorSettings_1 = html_common.convertDartToNative_Dictionary(imageDataColorSettings);
>+      return html_common.convertNativeToDart_ImageData(this[_createImageData_5](data_OR_imagedata_OR_sw, sh_OR_sw, imageDataColorSettings_OR_sh, imageDataColorSettings_1));
>+    }
>+    dart.throw(new core.ArgumentError.new("Incorrect number or type of arguments"));
>+  }
>+  [_createImageData_1](...args) {
>+    return this.createImageData.apply(this, args);
>+  }
>+  [_createImageData_2](...args) {
>+    return this.createImageData.apply(this, args);
>+  }
>+  [_createImageData_3](...args) {
>+    return this.createImageData.apply(this, args);
>+  }
>+  [_createImageData_4](...args) {
>+    return this.createImageData.apply(this, args);
>+  }
>+  [_createImageData_5](...args) {
>+    return this.createImageData.apply(this, args);
>+  }
>+  [$createLinearGradient](...args) {
>+    return this.createLinearGradient.apply(this, args);
>+  }
>+  [$createPattern](...args) {
>+    return this.createPattern.apply(this, args);
>+  }
>+  [$createRadialGradient](...args) {
>+    return this.createRadialGradient.apply(this, args);
>+  }
>+  [$drawFocusIfNeeded](...args) {
>+    return this.drawFocusIfNeeded.apply(this, args);
>+  }
>+  [$fill](...args) {
>+    return this.fill.apply(this, args);
>+  }
>+  [$fillRect](...args) {
>+    return this.fillRect.apply(this, args);
>+  }
>+  [$getContextAttributes]() {
>+    return html_common.convertNativeToDart_Dictionary(this[_getContextAttributes_1]());
>+  }
>+  [_getContextAttributes_1](...args) {
>+    return this.getContextAttributes.apply(this, args);
>+  }
>+  [$getImageData](sx, sy, sw, sh) {
>+    return html_common.convertNativeToDart_ImageData(this[_getImageData_1](sx, sy, sw, sh));
>+  }
>+  [_getImageData_1](...args) {
>+    return this.getImageData.apply(this, args);
>+  }
>+  [_getLineDash](...args) {
>+    return this.getLineDash.apply(this, args);
>+  }
>+  [$isContextLost](...args) {
>+    return this.isContextLost.apply(this, args);
>+  }
>+  [$isPointInPath](...args) {
>+    return this.isPointInPath.apply(this, args);
>+  }
>+  [$isPointInStroke](...args) {
>+    return this.isPointInStroke.apply(this, args);
>+  }
>+  [$measureText](...args) {
>+    return this.measureText.apply(this, args);
>+  }
>+  [$putImageData](imagedata, dx, dy, dirtyX, dirtyY, dirtyWidth, dirtyHeight) {
>+    if (dirtyX === void 0) dirtyX = null;
>+    if (dirtyY === void 0) dirtyY = null;
>+    if (dirtyWidth === void 0) dirtyWidth = null;
>+    if (dirtyHeight === void 0) dirtyHeight = null;
>+    if (dirtyX == null && dirtyY == null && dirtyWidth == null && dirtyHeight == null) {
>+      let imagedata_1 = html_common.convertDartToNative_ImageData(imagedata);
>+      this[_putImageData_1](imagedata_1, dx, dy);
>+      return;
>+    }
>+    if (dirtyHeight != null && dirtyWidth != null && dirtyY != null && dirtyX != null) {
>+      let imagedata_1 = html_common.convertDartToNative_ImageData(imagedata);
>+      this[_putImageData_2](imagedata_1, dx, dy, dirtyX, dirtyY, dirtyWidth, dirtyHeight);
>+      return;
>+    }
>+    dart.throw(new core.ArgumentError.new("Incorrect number or type of arguments"));
>+  }
>+  [_putImageData_1](...args) {
>+    return this.putImageData.apply(this, args);
>+  }
>+  [_putImageData_2](...args) {
>+    return this.putImageData.apply(this, args);
>+  }
>+  [$removeHitRegion](...args) {
>+    return this.removeHitRegion.apply(this, args);
>+  }
>+  [$resetTransform](...args) {
>+    return this.resetTransform.apply(this, args);
>+  }
>+  [$restore](...args) {
>+    return this.restore.apply(this, args);
>+  }
>+  [$rotate](...args) {
>+    return this.rotate.apply(this, args);
>+  }
>+  [$save](...args) {
>+    return this.save.apply(this, args);
>+  }
>+  [$scale](...args) {
>+    return this.scale.apply(this, args);
>+  }
>+  [$scrollPathIntoView](...args) {
>+    return this.scrollPathIntoView.apply(this, args);
>+  }
>+  [$setTransform](...args) {
>+    return this.setTransform.apply(this, args);
>+  }
>+  [$stroke](...args) {
>+    return this.stroke.apply(this, args);
>+  }
>+  [$strokeRect](...args) {
>+    return this.strokeRect.apply(this, args);
>+  }
>+  [$strokeText](...args) {
>+    return this.strokeText.apply(this, args);
>+  }
>+  [$transform](...args) {
>+    return this.transform.apply(this, args);
>+  }
>+  [$translate](...args) {
>+    return this.translate.apply(this, args);
>+  }
>+  [_arc](...args) {
>+    return this.arc.apply(this, args);
>+  }
>+  [$arcTo](...args) {
>+    return this.arcTo.apply(this, args);
>+  }
>+  [$bezierCurveTo](...args) {
>+    return this.bezierCurveTo.apply(this, args);
>+  }
>+  [$closePath](...args) {
>+    return this.closePath.apply(this, args);
>+  }
>+  [$ellipse](...args) {
>+    return this.ellipse.apply(this, args);
>+  }
>+  [$lineTo](...args) {
>+    return this.lineTo.apply(this, args);
>+  }
>+  [$moveTo](...args) {
>+    return this.moveTo.apply(this, args);
>+  }
>+  [$quadraticCurveTo](...args) {
>+    return this.quadraticCurveTo.apply(this, args);
>+  }
>+  [$rect](...args) {
>+    return this.rect.apply(this, args);
>+  }
>+  [$createImageDataFromImageData](imagedata) {
>+    return this.createImageData(imagedata);
>+  }
>+  [$setFillColorRgb](r, g, b, a) {
>+    if (a === void 0) a = 1;
>+    this.fillStyle = "rgba(" + dart.str(r) + ", " + dart.str(g) + ", " + dart.str(b) + ", " + dart.str(a) + ")";
>+  }
>+  [$setFillColorHsl](h, s, l, a) {
>+    if (a === void 0) a = 1;
>+    this.fillStyle = "hsla(" + dart.str(h) + ", " + dart.str(s) + "%, " + dart.str(l) + "%, " + dart.str(a) + ")";
>+  }
>+  [$setStrokeColorRgb](r, g, b, a) {
>+    if (a === void 0) a = 1;
>+    this.strokeStyle = "rgba(" + dart.str(r) + ", " + dart.str(g) + ", " + dart.str(b) + ", " + dart.str(a) + ")";
>+  }
>+  [$setStrokeColorHsl](h, s, l, a) {
>+    if (a === void 0) a = 1;
>+    this.strokeStyle = "hsla(" + dart.str(h) + ", " + dart.str(s) + "%, " + dart.str(l) + "%, " + dart.str(a) + ")";
>+  }
>+  [$arc](x, y, radius, startAngle, endAngle, anticlockwise) {
>+    if (anticlockwise === void 0) anticlockwise = false;
>+    this.arc(x, y, radius, startAngle, endAngle, anticlockwise);
>+  }
>+  [$createPatternFromImage](image, repetitionType) {
>+    return this.createPattern(image, repetitionType);
>+  }
>+  [$drawImageToRect](source, destRect, opts) {
>+    let sourceRect = opts && 'sourceRect' in opts ? opts.sourceRect : null;
>+    if (sourceRect == null) {
>+      this[$drawImageScaled](source, destRect[$left], destRect[$top], destRect[$width], destRect[$height]);
>+    } else {
>+      this[$drawImageScaledFromSource](source, sourceRect[$left], sourceRect[$top], sourceRect[$width], sourceRect[$height], destRect[$left], destRect[$top], destRect[$width], destRect[$height]);
>+    }
>+  }
>+  [$drawImage](...args) {
>+    return this.drawImage.apply(this, args);
>+  }
>+  [$drawImageScaled](...args) {
>+    return this.drawImage.apply(this, args);
>+  }
>+  [$drawImageScaledFromSource](...args) {
>+    return this.drawImage.apply(this, args);
>+  }
>+  get [$lineDashOffset]() {
>+    return this.lineDashOffset || this.webkitLineDashOffset;
>+  }
>+  set [$lineDashOffset](value) {
>+    typeof this.lineDashOffset != "undefined" ? this.lineDashOffset = value : this.webkitLineDashOffset = value;
>+  }
>+  [$getLineDash]() {
>+    if (!!this.getLineDash) {
>+      return this.getLineDash();
>+    } else if (!!this.webkitLineDash) {
>+      return this.webkitLineDash;
>+    }
>+  }
>+  [$setLineDash](dash) {
>+    if (!!this.setLineDash) {
>+      this.setLineDash(dash);
>+    } else if (!!this.webkitLineDash) {
>+      this.webkitLineDash = dash;
>+    }
>+  }
>+  [$fillText](text, x, y, maxWidth) {
>+    if (maxWidth === void 0) maxWidth = null;
>+    if (maxWidth != null) {
>+      this.fillText(text, x, y, maxWidth);
>+    } else {
>+      this.fillText(text, x, y);
>+    }
>+  }
>+  get [$backingStorePixelRatio]() {
>+    return 1.0;
>+  }
>+};
>+dart.addTypeTests(html$.CanvasRenderingContext2D);
>+const canvas$ = Symbol("CanvasRenderingContext2D.canvas");
>+const currentTransform = Symbol("CanvasRenderingContext2D.currentTransform");
>+const direction$0 = Symbol("CanvasRenderingContext2D.direction");
>+const fillStyle = Symbol("CanvasRenderingContext2D.fillStyle");
>+const filter = Symbol("CanvasRenderingContext2D.filter");
>+const font = Symbol("CanvasRenderingContext2D.font");
>+const globalAlpha = Symbol("CanvasRenderingContext2D.globalAlpha");
>+const globalCompositeOperation = Symbol("CanvasRenderingContext2D.globalCompositeOperation");
>+const imageSmoothingEnabled = Symbol("CanvasRenderingContext2D.imageSmoothingEnabled");
>+const imageSmoothingQuality = Symbol("CanvasRenderingContext2D.imageSmoothingQuality");
>+const lineCap = Symbol("CanvasRenderingContext2D.lineCap");
>+const lineJoin = Symbol("CanvasRenderingContext2D.lineJoin");
>+const lineWidth = Symbol("CanvasRenderingContext2D.lineWidth");
>+const miterLimit = Symbol("CanvasRenderingContext2D.miterLimit");
>+const shadowBlur = Symbol("CanvasRenderingContext2D.shadowBlur");
>+const shadowColor = Symbol("CanvasRenderingContext2D.shadowColor");
>+const shadowOffsetX = Symbol("CanvasRenderingContext2D.shadowOffsetX");
>+const shadowOffsetY = Symbol("CanvasRenderingContext2D.shadowOffsetY");
>+const strokeStyle = Symbol("CanvasRenderingContext2D.strokeStyle");
>+const textAlign = Symbol("CanvasRenderingContext2D.textAlign");
>+const textBaseline = Symbol("CanvasRenderingContext2D.textBaseline");
>+html$.CanvasRenderingContext2D[dart.implements] = () => [html$.CanvasRenderingContext];
>+dart.setMethodSignature(html$.CanvasRenderingContext2D, () => ({
>+  __proto__: dart.getMethods(html$.CanvasRenderingContext2D.__proto__),
>+  [$addHitRegion]: dart.fnType(dart.void, [], [core.Map]),
>+  [_addHitRegion_1]: dart.fnType(dart.void, [dart.dynamic]),
>+  [_addHitRegion_2]: dart.fnType(dart.void, []),
>+  [$beginPath]: dart.fnType(dart.void, []),
>+  [$clearHitRegions]: dart.fnType(dart.void, []),
>+  [$clearRect]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num]),
>+  [$clip]: dart.fnType(dart.void, [], [dart.dynamic, core.String]),
>+  [$createImageData]: dart.fnType(html$.ImageData, [dart.dynamic], [core.int, dart.dynamic, core.Map]),
>+  [_createImageData_1]: dart.fnType(dart.dynamic, [dart.dynamic]),
>+  [_createImageData_2]: dart.fnType(dart.dynamic, [core.int, dart.dynamic]),
>+  [_createImageData_3]: dart.fnType(dart.dynamic, [core.int, dart.dynamic, dart.dynamic]),
>+  [_createImageData_4]: dart.fnType(dart.dynamic, [dart.dynamic, dart.dynamic, core.int]),
>+  [_createImageData_5]: dart.fnType(dart.dynamic, [dart.dynamic, dart.dynamic, core.int, dart.dynamic]),
>+  [$createLinearGradient]: dart.fnType(html$.CanvasGradient, [core.num, core.num, core.num, core.num]),
>+  [$createPattern]: dart.fnType(html$.CanvasPattern, [core.Object, core.String]),
>+  [$createRadialGradient]: dart.fnType(html$.CanvasGradient, [core.num, core.num, core.num, core.num, core.num, core.num]),
>+  [$drawFocusIfNeeded]: dart.fnType(dart.void, [dart.dynamic], [html$.Element]),
>+  [$fill]: dart.fnType(dart.void, [], [dart.dynamic, core.String]),
>+  [$fillRect]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num]),
>+  [$getContextAttributes]: dart.fnType(core.Map, []),
>+  [_getContextAttributes_1]: dart.fnType(dart.dynamic, []),
>+  [$getImageData]: dart.fnType(html$.ImageData, [core.int, core.int, core.int, core.int]),
>+  [_getImageData_1]: dart.fnType(dart.dynamic, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic]),
>+  [_getLineDash]: dart.fnType(core.List$(core.num), []),
>+  [$isContextLost]: dart.fnType(core.bool, []),
>+  [$isPointInPath]: dart.fnType(core.bool, [dart.dynamic, core.num], [dart.dynamic, core.String]),
>+  [$isPointInStroke]: dart.fnType(core.bool, [dart.dynamic, core.num], [core.num]),
>+  [$measureText]: dart.fnType(html$.TextMetrics, [core.String]),
>+  [$putImageData]: dart.fnType(dart.void, [html$.ImageData, core.int, core.int], [core.int, core.int, core.int, core.int]),
>+  [_putImageData_1]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic]),
>+  [_putImageData_2]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic]),
>+  [$removeHitRegion]: dart.fnType(dart.void, [core.String]),
>+  [$resetTransform]: dart.fnType(dart.void, []),
>+  [$restore]: dart.fnType(dart.void, []),
>+  [$rotate]: dart.fnType(dart.void, [core.num]),
>+  [$save]: dart.fnType(dart.void, []),
>+  [$scale]: dart.fnType(dart.void, [core.num, core.num]),
>+  [$scrollPathIntoView]: dart.fnType(dart.void, [], [html$.Path2D]),
>+  [$setTransform]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num, core.num, core.num]),
>+  [$stroke]: dart.fnType(dart.void, [], [html$.Path2D]),
>+  [$strokeRect]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num]),
>+  [$strokeText]: dart.fnType(dart.void, [core.String, core.num, core.num], [core.num]),
>+  [$transform]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num, core.num, core.num]),
>+  [$translate]: dart.fnType(dart.void, [core.num, core.num]),
>+  [_arc]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num, core.num, core.bool]),
>+  [$arcTo]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num, core.num]),
>+  [$bezierCurveTo]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num, core.num, core.num]),
>+  [$closePath]: dart.fnType(dart.void, []),
>+  [$ellipse]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num, core.num, core.num, core.num, core.bool]),
>+  [$lineTo]: dart.fnType(dart.void, [core.num, core.num]),
>+  [$moveTo]: dart.fnType(dart.void, [core.num, core.num]),
>+  [$quadraticCurveTo]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num]),
>+  [$rect]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num]),
>+  [$createImageDataFromImageData]: dart.fnType(html$.ImageData, [html$.ImageData]),
>+  [$setFillColorRgb]: dart.fnType(dart.void, [core.int, core.int, core.int], [core.num]),
>+  [$setFillColorHsl]: dart.fnType(dart.void, [core.int, core.num, core.num], [core.num]),
>+  [$setStrokeColorRgb]: dart.fnType(dart.void, [core.int, core.int, core.int], [core.num]),
>+  [$setStrokeColorHsl]: dart.fnType(dart.void, [core.int, core.num, core.num], [core.num]),
>+  [$arc]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num, core.num], [core.bool]),
>+  [$createPatternFromImage]: dart.fnType(html$.CanvasPattern, [html$.ImageElement, core.String]),
>+  [$drawImageToRect]: dart.fnType(dart.void, [html$.CanvasImageSource, math.Rectangle$(core.num)], {sourceRect: math.Rectangle$(core.num)}),
>+  [$drawImage]: dart.fnType(dart.void, [html$.CanvasImageSource, core.num, core.num]),
>+  [$drawImageScaled]: dart.fnType(dart.void, [html$.CanvasImageSource, core.num, core.num, core.num, core.num]),
>+  [$drawImageScaledFromSource]: dart.fnType(dart.void, [html$.CanvasImageSource, core.num, core.num, core.num, core.num, core.num, core.num, core.num, core.num]),
>+  [$getLineDash]: dart.fnType(core.List$(core.num), []),
>+  [$setLineDash]: dart.fnType(dart.void, [core.List$(core.num)]),
>+  [$fillText]: dart.fnType(dart.void, [core.String, core.num, core.num], [core.num])
>+}));
>+dart.setGetterSignature(html$.CanvasRenderingContext2D, () => ({
>+  __proto__: dart.getGetters(html$.CanvasRenderingContext2D.__proto__),
>+  [$lineDashOffset]: core.num,
>+  [$backingStorePixelRatio]: core.double
>+}));
>+dart.setSetterSignature(html$.CanvasRenderingContext2D, () => ({
>+  __proto__: dart.getSetters(html$.CanvasRenderingContext2D.__proto__),
>+  [$lineDashOffset]: core.num
>+}));
>+dart.setLibraryUri(html$.CanvasRenderingContext2D, "dart:html");
>+dart.setFieldSignature(html$.CanvasRenderingContext2D, () => ({
>+  __proto__: dart.getFields(html$.CanvasRenderingContext2D.__proto__),
>+  [$canvas]: dart.finalFieldType(html$.CanvasElement),
>+  [$currentTransform]: dart.fieldType(svg$.Matrix),
>+  [$direction]: dart.fieldType(core.String),
>+  [$fillStyle]: dart.fieldType(core.Object),
>+  [$filter]: dart.fieldType(core.String),
>+  [$font]: dart.fieldType(core.String),
>+  [$globalAlpha]: dart.fieldType(core.num),
>+  [$globalCompositeOperation]: dart.fieldType(core.String),
>+  [$imageSmoothingEnabled]: dart.fieldType(core.bool),
>+  [$imageSmoothingQuality]: dart.fieldType(core.String),
>+  [$lineCap]: dart.fieldType(core.String),
>+  [$lineJoin]: dart.fieldType(core.String),
>+  [$lineWidth]: dart.fieldType(core.num),
>+  [$miterLimit]: dart.fieldType(core.num),
>+  [$shadowBlur]: dart.fieldType(core.num),
>+  [$shadowColor]: dart.fieldType(core.String),
>+  [$shadowOffsetX]: dart.fieldType(core.num),
>+  [$shadowOffsetY]: dart.fieldType(core.num),
>+  [$strokeStyle]: dart.fieldType(core.Object),
>+  [$textAlign]: dart.fieldType(core.String),
>+  [$textBaseline]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("CanvasRenderingContext2D", html$.CanvasRenderingContext2D);
>+html$.ChildNode = class ChildNode extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$.ChildNode);
>+dart.setLibraryUri(html$.ChildNode, "dart:html");
>+html$.Client = class Client extends _interceptors.Interceptor {
>+  get [$frameType]() {
>+    return this.frameType;
>+  }
>+  get [$id]() {
>+    return this.id;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  get [$url]() {
>+    return this.url;
>+  }
>+  [$postMessage](...args) {
>+    return this.postMessage.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.Client);
>+const frameType = Symbol("Client.frameType");
>+const id$4 = Symbol("Client.id");
>+const type$6 = Symbol("Client.type");
>+const url$ = Symbol("Client.url");
>+dart.setMethodSignature(html$.Client, () => ({
>+  __proto__: dart.getMethods(html$.Client.__proto__),
>+  [$postMessage]: dart.fnType(dart.void, [core.Object], [core.List$(core.Object)])
>+}));
>+dart.setLibraryUri(html$.Client, "dart:html");
>+dart.setFieldSignature(html$.Client, () => ({
>+  __proto__: dart.getFields(html$.Client.__proto__),
>+  [$frameType]: dart.finalFieldType(core.String),
>+  [$id]: dart.finalFieldType(core.String),
>+  [$type]: dart.finalFieldType(core.String),
>+  [$url]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("Client", html$.Client);
>+html$.Clients = class Clients extends _interceptors.Interceptor {
>+  [$claim]() {
>+    return html$.promiseToFuture(dart.dynamic, this.claim());
>+  }
>+  [$get](id) {
>+    return html$.promiseToFuture(dart.dynamic, this.get(id));
>+  }
>+  [$matchAll](options) {
>+    if (options === void 0) options = null;
>+    let options_dict = null;
>+    if (options != null) {
>+      options_dict = html_common.convertDartToNative_Dictionary(options);
>+    }
>+    return html$.promiseToFuture(ListOfClient(), this.matchAll(options_dict));
>+  }
>+  [$openWindow](url) {
>+    return html$.promiseToFuture(html$.WindowClient, this.openWindow(url));
>+  }
>+};
>+dart.addTypeTests(html$.Clients);
>+dart.setMethodSignature(html$.Clients, () => ({
>+  __proto__: dart.getMethods(html$.Clients.__proto__),
>+  [$claim]: dart.fnType(async.Future, []),
>+  [$get]: dart.fnType(async.Future, [core.String]),
>+  [$matchAll]: dart.fnType(async.Future$(core.List$(html$.Client)), [], [core.Map]),
>+  [$openWindow]: dart.fnType(async.Future$(html$.WindowClient), [core.String])
>+}));
>+dart.setLibraryUri(html$.Clients, "dart:html");
>+dart.registerExtension("Clients", html$.Clients);
>+html$.ClipboardEvent = class ClipboardEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.ClipboardEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.ClipboardEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new ClipboardEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new ClipboardEvent(type);
>+  }
>+  get [$clipboardData]() {
>+    return this.clipboardData;
>+  }
>+};
>+dart.addTypeTests(html$.ClipboardEvent);
>+const clipboardData = Symbol("ClipboardEvent.clipboardData");
>+dart.setLibraryUri(html$.ClipboardEvent, "dart:html");
>+dart.setFieldSignature(html$.ClipboardEvent, () => ({
>+  __proto__: dart.getFields(html$.ClipboardEvent.__proto__),
>+  [$clipboardData]: dart.finalFieldType(html$.DataTransfer)
>+}));
>+dart.registerExtension("ClipboardEvent", html$.ClipboardEvent);
>+html$.CloseEvent = class CloseEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.CloseEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.CloseEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new CloseEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new CloseEvent(type);
>+  }
>+  get [$code]() {
>+    return this.code;
>+  }
>+  get [$reason]() {
>+    return this.reason;
>+  }
>+  get [$wasClean]() {
>+    return this.wasClean;
>+  }
>+};
>+dart.addTypeTests(html$.CloseEvent);
>+const code = Symbol("CloseEvent.code");
>+const reason$ = Symbol("CloseEvent.reason");
>+const wasClean = Symbol("CloseEvent.wasClean");
>+dart.setLibraryUri(html$.CloseEvent, "dart:html");
>+dart.setFieldSignature(html$.CloseEvent, () => ({
>+  __proto__: dart.getFields(html$.CloseEvent.__proto__),
>+  [$code]: dart.finalFieldType(core.int),
>+  [$reason]: dart.finalFieldType(core.String),
>+  [$wasClean]: dart.finalFieldType(core.bool)
>+}));
>+dart.registerExtension("CloseEvent", html$.CloseEvent);
>+html$.Comment = class Comment extends html$.CharacterData {
>+  static new(data) {
>+    if (data === void 0) data = null;
>+    return html$.document.createComment(data == null ? "" : data);
>+  }
>+};
>+dart.addTypeTests(html$.Comment);
>+dart.setLibraryUri(html$.Comment, "dart:html");
>+dart.registerExtension("Comment", html$.Comment);
>+const _initCompositionEvent = dart.privateName(html$, "_initCompositionEvent");
>+const _initUIEvent = dart.privateName(html$, "_initUIEvent");
>+const _get_view = dart.privateName(html$, "_get_view");
>+const _which = dart.privateName(html$, "_which");
>+html$.UIEvent = class UIEvent$ extends html$.Event {
>+  static new(type, opts) {
>+    let view = opts && 'view' in opts ? opts.view : null;
>+    let detail = opts && 'detail' in opts ? opts.detail : 0;
>+    let canBubble = opts && 'canBubble' in opts ? opts.canBubble : true;
>+    let cancelable = opts && 'cancelable' in opts ? opts.cancelable : true;
>+    if (view == null) {
>+      view = html$.window;
>+    }
>+    let e = html$.UIEvent._check(html$.document[_createEvent]("UIEvent"));
>+    e[_initUIEvent](type, canBubble, cancelable, view, detail);
>+    return e;
>+  }
>+  static __(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.UIEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.UIEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new UIEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new UIEvent(type);
>+  }
>+  get [$detail]() {
>+    return this.detail;
>+  }
>+  get [$sourceCapabilities]() {
>+    return this.sourceCapabilities;
>+  }
>+  get [$view]() {
>+    return html$._convertNativeToDart_Window(this[_get_view]);
>+  }
>+  get [_get_view]() {
>+    return this.view;
>+  }
>+  get [_which]() {
>+    return this.which;
>+  }
>+  [_initUIEvent](...args) {
>+    return this.initUIEvent.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.UIEvent);
>+const detail = Symbol("UIEvent.detail");
>+const sourceCapabilities = Symbol("UIEvent.sourceCapabilities");
>+dart.setMethodSignature(html$.UIEvent, () => ({
>+  __proto__: dart.getMethods(html$.UIEvent.__proto__),
>+  [_initUIEvent]: dart.fnType(dart.void, [core.String, core.bool, core.bool, html$.Window, core.int])
>+}));
>+dart.setGetterSignature(html$.UIEvent, () => ({
>+  __proto__: dart.getGetters(html$.UIEvent.__proto__),
>+  [$view]: html$.WindowBase
>+}));
>+dart.setLibraryUri(html$.UIEvent, "dart:html");
>+dart.setFieldSignature(html$.UIEvent, () => ({
>+  __proto__: dart.getFields(html$.UIEvent.__proto__),
>+  [$detail]: dart.finalFieldType(core.int),
>+  [$sourceCapabilities]: dart.finalFieldType(html$.InputDeviceCapabilities),
>+  [_get_view]: dart.finalFieldType(dart.dynamic),
>+  [_which]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("UIEvent", html$.UIEvent);
>+html$.CompositionEvent = class CompositionEvent$ extends html$.UIEvent {
>+  static new(type, opts) {
>+    let canBubble = opts && 'canBubble' in opts ? opts.canBubble : false;
>+    let cancelable = opts && 'cancelable' in opts ? opts.cancelable : false;
>+    let view = opts && 'view' in opts ? opts.view : null;
>+    let data = opts && 'data' in opts ? opts.data : null;
>+    let locale = opts && 'locale' in opts ? opts.locale : null;
>+    if (view == null) {
>+      view = html$.window;
>+    }
>+    let e = html$.CompositionEvent._check(html$.document[_createEvent]("CompositionEvent"));
>+    if (dart.test(html_common.Device.isFirefox)) {
>+      e.initCompositionEvent(type, canBubble, cancelable, view, data, locale);
>+    } else {
>+      e[_initCompositionEvent](type, canBubble, cancelable, view, data);
>+    }
>+    return e;
>+  }
>+  static __(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.CompositionEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.CompositionEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new CompositionEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new CompositionEvent(type);
>+  }
>+  get [$data]() {
>+    return this.data;
>+  }
>+  [_initCompositionEvent](...args) {
>+    return this.initCompositionEvent.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.CompositionEvent);
>+const data$1 = Symbol("CompositionEvent.data");
>+dart.setMethodSignature(html$.CompositionEvent, () => ({
>+  __proto__: dart.getMethods(html$.CompositionEvent.__proto__),
>+  [_initCompositionEvent]: dart.fnType(dart.void, [core.String, core.bool, core.bool, html$.Window, core.String])
>+}));
>+dart.setLibraryUri(html$.CompositionEvent, "dart:html");
>+dart.setFieldSignature(html$.CompositionEvent, () => ({
>+  __proto__: dart.getFields(html$.CompositionEvent.__proto__),
>+  [$data]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("CompositionEvent", html$.CompositionEvent);
>+html$.ContentElement = class ContentElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.ContentElement._check(html$.document[$createElement]("content"));
>+  }
>+  static get supported() {
>+    return html$.Element.isTagSupported("content");
>+  }
>+  get [$select]() {
>+    return this.select;
>+  }
>+  set [$select](value) {
>+    this.select = value;
>+  }
>+  [$getDistributedNodes](...args) {
>+    return this.getDistributedNodes.apply(this, args);
>+  }
>+};
>+(html$.ContentElement.created = function() {
>+  this[select] = null;
>+  html$.ContentElement.__proto__.created.call(this);
>+}).prototype = html$.ContentElement.prototype;
>+dart.addTypeTests(html$.ContentElement);
>+const select = Symbol("ContentElement.select");
>+dart.setMethodSignature(html$.ContentElement, () => ({
>+  __proto__: dart.getMethods(html$.ContentElement.__proto__),
>+  [$getDistributedNodes]: dart.fnType(core.List$(html$.Node), [])
>+}));
>+dart.setLibraryUri(html$.ContentElement, "dart:html");
>+dart.setFieldSignature(html$.ContentElement, () => ({
>+  __proto__: dart.getFields(html$.ContentElement.__proto__),
>+  [$select]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("HTMLContentElement", html$.ContentElement);
>+html$.CookieStore = class CookieStore extends _interceptors.Interceptor {
>+  [$getAll](options) {
>+    if (options === void 0) options = null;
>+    let options_dict = null;
>+    if (options != null) {
>+      options_dict = html_common.convertDartToNative_Dictionary(options);
>+    }
>+    return html$.promiseToFuture(dart.dynamic, this.getAll(options_dict));
>+  }
>+  [$set](name, value, options) {
>+    if (options === void 0) options = null;
>+    let options_dict = null;
>+    if (options != null) {
>+      options_dict = html_common.convertDartToNative_Dictionary(options);
>+    }
>+    return html$.promiseToFuture(dart.dynamic, this.set(name, value, options_dict));
>+  }
>+};
>+dart.addTypeTests(html$.CookieStore);
>+dart.setMethodSignature(html$.CookieStore, () => ({
>+  __proto__: dart.getMethods(html$.CookieStore.__proto__),
>+  [$getAll]: dart.fnType(async.Future, [], [core.Map]),
>+  [$set]: dart.fnType(async.Future, [core.String, core.String], [core.Map])
>+}));
>+dart.setLibraryUri(html$.CookieStore, "dart:html");
>+dart.registerExtension("CookieStore", html$.CookieStore);
>+html$.Coordinates = class Coordinates extends _interceptors.Interceptor {
>+  get [$accuracy]() {
>+    return this.accuracy;
>+  }
>+  get [$altitude]() {
>+    return this.altitude;
>+  }
>+  get [$altitudeAccuracy]() {
>+    return this.altitudeAccuracy;
>+  }
>+  get [$heading]() {
>+    return this.heading;
>+  }
>+  get [$latitude]() {
>+    return this.latitude;
>+  }
>+  get [$longitude]() {
>+    return this.longitude;
>+  }
>+  get [$speed]() {
>+    return this.speed;
>+  }
>+};
>+dart.addTypeTests(html$.Coordinates);
>+const accuracy = Symbol("Coordinates.accuracy");
>+const altitude = Symbol("Coordinates.altitude");
>+const altitudeAccuracy = Symbol("Coordinates.altitudeAccuracy");
>+const heading = Symbol("Coordinates.heading");
>+const latitude = Symbol("Coordinates.latitude");
>+const longitude = Symbol("Coordinates.longitude");
>+const speed = Symbol("Coordinates.speed");
>+dart.setLibraryUri(html$.Coordinates, "dart:html");
>+dart.setFieldSignature(html$.Coordinates, () => ({
>+  __proto__: dart.getFields(html$.Coordinates.__proto__),
>+  [$accuracy]: dart.finalFieldType(core.num),
>+  [$altitude]: dart.finalFieldType(core.num),
>+  [$altitudeAccuracy]: dart.finalFieldType(core.num),
>+  [$heading]: dart.finalFieldType(core.num),
>+  [$latitude]: dart.finalFieldType(core.num),
>+  [$longitude]: dart.finalFieldType(core.num),
>+  [$speed]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("Coordinates", html$.Coordinates);
>+html$.Credential = class Credential extends _interceptors.Interceptor {
>+  get [$id]() {
>+    return this.id;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+};
>+dart.addTypeTests(html$.Credential);
>+const id$5 = Symbol("Credential.id");
>+const type$7 = Symbol("Credential.type");
>+dart.setLibraryUri(html$.Credential, "dart:html");
>+dart.setFieldSignature(html$.Credential, () => ({
>+  __proto__: dart.getFields(html$.Credential.__proto__),
>+  [$id]: dart.finalFieldType(core.String),
>+  [$type]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("Credential", html$.Credential);
>+html$.CredentialUserData = class CredentialUserData extends _interceptors.Interceptor {
>+  get [$iconUrl]() {
>+    return this.iconURL;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+};
>+dart.addTypeTests(html$.CredentialUserData);
>+const iconUrl = Symbol("CredentialUserData.iconUrl");
>+const name$8 = Symbol("CredentialUserData.name");
>+dart.setLibraryUri(html$.CredentialUserData, "dart:html");
>+dart.setFieldSignature(html$.CredentialUserData, () => ({
>+  __proto__: dart.getFields(html$.CredentialUserData.__proto__),
>+  [$iconUrl]: dart.finalFieldType(core.String),
>+  [$name]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("CredentialUserData", html$.CredentialUserData);
>+html$.CredentialsContainer = class CredentialsContainer extends _interceptors.Interceptor {
>+  [$create](options) {
>+    if (options === void 0) options = null;
>+    let options_dict = null;
>+    if (options != null) {
>+      options_dict = html_common.convertDartToNative_Dictionary(options);
>+    }
>+    return html$.promiseToFuture(dart.dynamic, this.create(options_dict));
>+  }
>+  [$get](options) {
>+    if (options === void 0) options = null;
>+    let options_dict = null;
>+    if (options != null) {
>+      options_dict = html_common.convertDartToNative_Dictionary(options);
>+    }
>+    return html$.promiseToFuture(dart.dynamic, this.get(options_dict));
>+  }
>+  [$preventSilentAccess]() {
>+    return html$.promiseToFuture(dart.dynamic, this.preventSilentAccess());
>+  }
>+  [$requireUserMediation]() {
>+    return html$.promiseToFuture(dart.dynamic, this.requireUserMediation());
>+  }
>+  [$store](credential) {
>+    return html$.promiseToFuture(dart.dynamic, this.store(credential));
>+  }
>+};
>+dart.addTypeTests(html$.CredentialsContainer);
>+dart.setMethodSignature(html$.CredentialsContainer, () => ({
>+  __proto__: dart.getMethods(html$.CredentialsContainer.__proto__),
>+  [$create]: dart.fnType(async.Future, [], [core.Map]),
>+  [$get]: dart.fnType(async.Future, [], [core.Map]),
>+  [$preventSilentAccess]: dart.fnType(async.Future, []),
>+  [$requireUserMediation]: dart.fnType(async.Future, []),
>+  [$store]: dart.fnType(async.Future, [html$.Credential])
>+}));
>+dart.setLibraryUri(html$.CredentialsContainer, "dart:html");
>+dart.registerExtension("CredentialsContainer", html$.CredentialsContainer);
>+const _getRandomValues = dart.privateName(html$, "_getRandomValues");
>+html$.Crypto = class Crypto extends _interceptors.Interceptor {
>+  [$getRandomValues](array) {
>+    return this[_getRandomValues](array);
>+  }
>+  static get supported() {
>+    return !!(window.crypto && window.crypto.getRandomValues);
>+  }
>+  get [$subtle]() {
>+    return this.subtle;
>+  }
>+  [_getRandomValues](...args) {
>+    return this.getRandomValues.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.Crypto);
>+const subtle = Symbol("Crypto.subtle");
>+dart.setMethodSignature(html$.Crypto, () => ({
>+  __proto__: dart.getMethods(html$.Crypto.__proto__),
>+  [$getRandomValues]: dart.fnType(typed_data.TypedData, [typed_data.TypedData]),
>+  [_getRandomValues]: dart.fnType(typed_data.TypedData, [typed_data.TypedData])
>+}));
>+dart.setLibraryUri(html$.Crypto, "dart:html");
>+dart.setFieldSignature(html$.Crypto, () => ({
>+  __proto__: dart.getFields(html$.Crypto.__proto__),
>+  [$subtle]: dart.finalFieldType(html$._SubtleCrypto)
>+}));
>+dart.registerExtension("Crypto", html$.Crypto);
>+html$.CryptoKey = class CryptoKey extends _interceptors.Interceptor {
>+  get [$algorithm]() {
>+    return this.algorithm;
>+  }
>+  get [$extractable]() {
>+    return this.extractable;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  get [$usages]() {
>+    return this.usages;
>+  }
>+};
>+dart.addTypeTests(html$.CryptoKey);
>+const algorithm = Symbol("CryptoKey.algorithm");
>+const extractable = Symbol("CryptoKey.extractable");
>+const type$8 = Symbol("CryptoKey.type");
>+const usages = Symbol("CryptoKey.usages");
>+dart.setLibraryUri(html$.CryptoKey, "dart:html");
>+dart.setFieldSignature(html$.CryptoKey, () => ({
>+  __proto__: dart.getFields(html$.CryptoKey.__proto__),
>+  [$algorithm]: dart.finalFieldType(core.Object),
>+  [$extractable]: dart.finalFieldType(core.bool),
>+  [$type]: dart.finalFieldType(core.String),
>+  [$usages]: dart.finalFieldType(core.Object)
>+}));
>+dart.registerExtension("CryptoKey", html$.CryptoKey);
>+html$.Css = class Css extends _interceptors.Interceptor {
>+  static registerProperty(descriptor) {
>+    let descriptor_1 = html_common.convertDartToNative_Dictionary(descriptor);
>+    dart.global.CSS.registerProperty(descriptor_1);
>+    return;
>+  }
>+};
>+dart.addTypeTests(html$.Css);
>+dart.setLibraryUri(html$.Css, "dart:html");
>+dart.defineLazy(html$.Css, {
>+  /*html$.Css.paintWorklet*/get paintWorklet() {
>+    return null;
>+  }
>+});
>+dart.registerExtension("CSS", html$.Css);
>+html$.CssRule = class CssRule extends _interceptors.Interceptor {
>+  get [$cssText]() {
>+    return this.cssText;
>+  }
>+  set [$cssText](value) {
>+    this.cssText = value;
>+  }
>+  get [$parentRule]() {
>+    return this.parentRule;
>+  }
>+  get [$parentStyleSheet]() {
>+    return this.parentStyleSheet;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+};
>+dart.addTypeTests(html$.CssRule);
>+const cssText = Symbol("CssRule.cssText");
>+const parentRule = Symbol("CssRule.parentRule");
>+const parentStyleSheet = Symbol("CssRule.parentStyleSheet");
>+const type$9 = Symbol("CssRule.type");
>+dart.setLibraryUri(html$.CssRule, "dart:html");
>+dart.setFieldSignature(html$.CssRule, () => ({
>+  __proto__: dart.getFields(html$.CssRule.__proto__),
>+  [$cssText]: dart.fieldType(core.String),
>+  [$parentRule]: dart.finalFieldType(html$.CssRule),
>+  [$parentStyleSheet]: dart.finalFieldType(html$.CssStyleSheet),
>+  [$type]: dart.finalFieldType(core.int)
>+}));
>+dart.defineLazy(html$.CssRule, {
>+  /*html$.CssRule.CHARSET_RULE*/get CHARSET_RULE() {
>+    return 2;
>+  },
>+  /*html$.CssRule.FONT_FACE_RULE*/get FONT_FACE_RULE() {
>+    return 5;
>+  },
>+  /*html$.CssRule.IMPORT_RULE*/get IMPORT_RULE() {
>+    return 3;
>+  },
>+  /*html$.CssRule.KEYFRAMES_RULE*/get KEYFRAMES_RULE() {
>+    return 7;
>+  },
>+  /*html$.CssRule.KEYFRAME_RULE*/get KEYFRAME_RULE() {
>+    return 8;
>+  },
>+  /*html$.CssRule.MEDIA_RULE*/get MEDIA_RULE() {
>+    return 4;
>+  },
>+  /*html$.CssRule.NAMESPACE_RULE*/get NAMESPACE_RULE() {
>+    return 10;
>+  },
>+  /*html$.CssRule.PAGE_RULE*/get PAGE_RULE() {
>+    return 6;
>+  },
>+  /*html$.CssRule.STYLE_RULE*/get STYLE_RULE() {
>+    return 1;
>+  },
>+  /*html$.CssRule.SUPPORTS_RULE*/get SUPPORTS_RULE() {
>+    return 12;
>+  },
>+  /*html$.CssRule.VIEWPORT_RULE*/get VIEWPORT_RULE() {
>+    return 15;
>+  }
>+});
>+dart.registerExtension("CSSRule", html$.CssRule);
>+html$.CssCharsetRule = class CssCharsetRule extends html$.CssRule {
>+  get [$encoding]() {
>+    return this.encoding;
>+  }
>+  set [$encoding](value) {
>+    this.encoding = value;
>+  }
>+};
>+dart.addTypeTests(html$.CssCharsetRule);
>+const encoding$ = Symbol("CssCharsetRule.encoding");
>+dart.setLibraryUri(html$.CssCharsetRule, "dart:html");
>+dart.setFieldSignature(html$.CssCharsetRule, () => ({
>+  __proto__: dart.getFields(html$.CssCharsetRule.__proto__),
>+  [$encoding]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("CSSCharsetRule", html$.CssCharsetRule);
>+html$.CssGroupingRule = class CssGroupingRule extends html$.CssRule {
>+  get [$cssRules]() {
>+    return this.cssRules;
>+  }
>+  [$deleteRule](...args) {
>+    return this.deleteRule.apply(this, args);
>+  }
>+  [$insertRule](...args) {
>+    return this.insertRule.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.CssGroupingRule);
>+const cssRules = Symbol("CssGroupingRule.cssRules");
>+dart.setMethodSignature(html$.CssGroupingRule, () => ({
>+  __proto__: dart.getMethods(html$.CssGroupingRule.__proto__),
>+  [$deleteRule]: dart.fnType(dart.void, [core.int]),
>+  [$insertRule]: dart.fnType(core.int, [core.String, core.int])
>+}));
>+dart.setLibraryUri(html$.CssGroupingRule, "dart:html");
>+dart.setFieldSignature(html$.CssGroupingRule, () => ({
>+  __proto__: dart.getFields(html$.CssGroupingRule.__proto__),
>+  [$cssRules]: dart.finalFieldType(ListOfCssRule())
>+}));
>+dart.registerExtension("CSSGroupingRule", html$.CssGroupingRule);
>+html$.CssConditionRule = class CssConditionRule extends html$.CssGroupingRule {
>+  get [$conditionText]() {
>+    return this.conditionText;
>+  }
>+};
>+dart.addTypeTests(html$.CssConditionRule);
>+const conditionText = Symbol("CssConditionRule.conditionText");
>+dart.setLibraryUri(html$.CssConditionRule, "dart:html");
>+dart.setFieldSignature(html$.CssConditionRule, () => ({
>+  __proto__: dart.getFields(html$.CssConditionRule.__proto__),
>+  [$conditionText]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("CSSConditionRule", html$.CssConditionRule);
>+html$.CssFontFaceRule = class CssFontFaceRule extends html$.CssRule {
>+  get [$style]() {
>+    return this.style;
>+  }
>+};
>+dart.addTypeTests(html$.CssFontFaceRule);
>+const style$ = Symbol("CssFontFaceRule.style");
>+dart.setLibraryUri(html$.CssFontFaceRule, "dart:html");
>+dart.setFieldSignature(html$.CssFontFaceRule, () => ({
>+  __proto__: dart.getFields(html$.CssFontFaceRule.__proto__),
>+  [$style]: dart.finalFieldType(html$.CssStyleDeclaration)
>+}));
>+dart.registerExtension("CSSFontFaceRule", html$.CssFontFaceRule);
>+html$.CssStyleValue = class CssStyleValue extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$.CssStyleValue);
>+dart.setLibraryUri(html$.CssStyleValue, "dart:html");
>+dart.registerExtension("CSSStyleValue", html$.CssStyleValue);
>+html$.CssResourceValue = class CssResourceValue extends html$.CssStyleValue {
>+  get [$state]() {
>+    return this.state;
>+  }
>+};
>+dart.addTypeTests(html$.CssResourceValue);
>+const state$ = Symbol("CssResourceValue.state");
>+dart.setLibraryUri(html$.CssResourceValue, "dart:html");
>+dart.setFieldSignature(html$.CssResourceValue, () => ({
>+  __proto__: dart.getFields(html$.CssResourceValue.__proto__),
>+  [$state]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("CSSResourceValue", html$.CssResourceValue);
>+html$.CssImageValue = class CssImageValue extends html$.CssResourceValue {
>+  get [$intrinsicHeight]() {
>+    return this.intrinsicHeight;
>+  }
>+  get [$intrinsicRatio]() {
>+    return this.intrinsicRatio;
>+  }
>+  get [$intrinsicWidth]() {
>+    return this.intrinsicWidth;
>+  }
>+};
>+dart.addTypeTests(html$.CssImageValue);
>+const intrinsicHeight = Symbol("CssImageValue.intrinsicHeight");
>+const intrinsicRatio = Symbol("CssImageValue.intrinsicRatio");
>+const intrinsicWidth = Symbol("CssImageValue.intrinsicWidth");
>+dart.setLibraryUri(html$.CssImageValue, "dart:html");
>+dart.setFieldSignature(html$.CssImageValue, () => ({
>+  __proto__: dart.getFields(html$.CssImageValue.__proto__),
>+  [$intrinsicHeight]: dart.finalFieldType(core.num),
>+  [$intrinsicRatio]: dart.finalFieldType(core.num),
>+  [$intrinsicWidth]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("CSSImageValue", html$.CssImageValue);
>+html$.CssImportRule = class CssImportRule extends html$.CssRule {
>+  get [$href]() {
>+    return this.href;
>+  }
>+  get [$media]() {
>+    return this.media;
>+  }
>+  get [$styleSheet]() {
>+    return this.styleSheet;
>+  }
>+};
>+dart.addTypeTests(html$.CssImportRule);
>+const href$1 = Symbol("CssImportRule.href");
>+const media = Symbol("CssImportRule.media");
>+const styleSheet = Symbol("CssImportRule.styleSheet");
>+dart.setLibraryUri(html$.CssImportRule, "dart:html");
>+dart.setFieldSignature(html$.CssImportRule, () => ({
>+  __proto__: dart.getFields(html$.CssImportRule.__proto__),
>+  [$href]: dart.finalFieldType(core.String),
>+  [$media]: dart.finalFieldType(html$.MediaList),
>+  [$styleSheet]: dart.finalFieldType(html$.CssStyleSheet)
>+}));
>+dart.registerExtension("CSSImportRule", html$.CssImportRule);
>+html$.CssKeyframeRule = class CssKeyframeRule extends html$.CssRule {
>+  get [$keyText]() {
>+    return this.keyText;
>+  }
>+  set [$keyText](value) {
>+    this.keyText = value;
>+  }
>+  get [$style]() {
>+    return this.style;
>+  }
>+};
>+dart.addTypeTests(html$.CssKeyframeRule);
>+const keyText = Symbol("CssKeyframeRule.keyText");
>+const style$0 = Symbol("CssKeyframeRule.style");
>+dart.setLibraryUri(html$.CssKeyframeRule, "dart:html");
>+dart.setFieldSignature(html$.CssKeyframeRule, () => ({
>+  __proto__: dart.getFields(html$.CssKeyframeRule.__proto__),
>+  [$keyText]: dart.fieldType(core.String),
>+  [$style]: dart.finalFieldType(html$.CssStyleDeclaration)
>+}));
>+dart.registerExtension("CSSKeyframeRule", html$.CssKeyframeRule);
>+dart.registerExtension("MozCSSKeyframeRule", html$.CssKeyframeRule);
>+dart.registerExtension("WebKitCSSKeyframeRule", html$.CssKeyframeRule);
>+const __getter__ = dart.privateName(html$, "__getter__");
>+html$.CssKeyframesRule = class CssKeyframesRule extends html$.CssRule {
>+  get [$cssRules]() {
>+    return this.cssRules;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+  set [$name](value) {
>+    this.name = value;
>+  }
>+  [__getter__](...args) {
>+    return this.__getter__.apply(this, args);
>+  }
>+  [$appendRule](...args) {
>+    return this.appendRule.apply(this, args);
>+  }
>+  [$deleteRule](...args) {
>+    return this.deleteRule.apply(this, args);
>+  }
>+  [$findRule](...args) {
>+    return this.findRule.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.CssKeyframesRule);
>+const cssRules$ = Symbol("CssKeyframesRule.cssRules");
>+const name$9 = Symbol("CssKeyframesRule.name");
>+dart.setMethodSignature(html$.CssKeyframesRule, () => ({
>+  __proto__: dart.getMethods(html$.CssKeyframesRule.__proto__),
>+  [__getter__]: dart.fnType(html$.CssKeyframeRule, [core.int]),
>+  [$appendRule]: dart.fnType(dart.void, [core.String]),
>+  [$deleteRule]: dart.fnType(dart.void, [core.String]),
>+  [$findRule]: dart.fnType(html$.CssKeyframeRule, [core.String])
>+}));
>+dart.setLibraryUri(html$.CssKeyframesRule, "dart:html");
>+dart.setFieldSignature(html$.CssKeyframesRule, () => ({
>+  __proto__: dart.getFields(html$.CssKeyframesRule.__proto__),
>+  [$cssRules]: dart.finalFieldType(ListOfCssRule()),
>+  [$name]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("CSSKeyframesRule", html$.CssKeyframesRule);
>+dart.registerExtension("MozCSSKeyframesRule", html$.CssKeyframesRule);
>+dart.registerExtension("WebKitCSSKeyframesRule", html$.CssKeyframesRule);
>+html$.CssKeywordValue = class CssKeywordValue extends html$.CssStyleValue {
>+  static new(keyword) {
>+    return html$.CssKeywordValue._create_1(keyword);
>+  }
>+  static _create_1(keyword) {
>+    return new CSSKeywordValue(keyword);
>+  }
>+  get [$value]() {
>+    return this.value;
>+  }
>+  set [$value](value) {
>+    this.value = value;
>+  }
>+};
>+dart.addTypeTests(html$.CssKeywordValue);
>+const value$2 = Symbol("CssKeywordValue.value");
>+dart.setLibraryUri(html$.CssKeywordValue, "dart:html");
>+dart.setFieldSignature(html$.CssKeywordValue, () => ({
>+  __proto__: dart.getFields(html$.CssKeywordValue.__proto__),
>+  [$value]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("CSSKeywordValue", html$.CssKeywordValue);
>+html$.CssTransformComponent = class CssTransformComponent extends _interceptors.Interceptor {
>+  get [$is2D]() {
>+    return this.is2D;
>+  }
>+  set [$is2D](value) {
>+    this.is2D = value;
>+  }
>+};
>+dart.addTypeTests(html$.CssTransformComponent);
>+const is2D = Symbol("CssTransformComponent.is2D");
>+dart.setLibraryUri(html$.CssTransformComponent, "dart:html");
>+dart.setFieldSignature(html$.CssTransformComponent, () => ({
>+  __proto__: dart.getFields(html$.CssTransformComponent.__proto__),
>+  [$is2D]: dart.fieldType(core.bool)
>+}));
>+dart.registerExtension("CSSTransformComponent", html$.CssTransformComponent);
>+html$.CssMatrixComponent = class CssMatrixComponent extends html$.CssTransformComponent {
>+  static new(matrix, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      return html$.CssMatrixComponent._create_1(matrix, options_1);
>+    }
>+    return html$.CssMatrixComponent._create_2(matrix);
>+  }
>+  static _create_1(matrix, options) {
>+    return new CSSMatrixComponent(matrix, options);
>+  }
>+  static _create_2(matrix) {
>+    return new CSSMatrixComponent(matrix);
>+  }
>+  get [$matrix]() {
>+    return this.matrix;
>+  }
>+  set [$matrix](value) {
>+    this.matrix = value;
>+  }
>+};
>+dart.addTypeTests(html$.CssMatrixComponent);
>+const matrix = Symbol("CssMatrixComponent.matrix");
>+dart.setLibraryUri(html$.CssMatrixComponent, "dart:html");
>+dart.setFieldSignature(html$.CssMatrixComponent, () => ({
>+  __proto__: dart.getFields(html$.CssMatrixComponent.__proto__),
>+  [$matrix]: dart.fieldType(html$.DomMatrix)
>+}));
>+dart.registerExtension("CSSMatrixComponent", html$.CssMatrixComponent);
>+html$.CssMediaRule = class CssMediaRule extends html$.CssConditionRule {
>+  get [$media]() {
>+    return this.media;
>+  }
>+};
>+dart.addTypeTests(html$.CssMediaRule);
>+const media$ = Symbol("CssMediaRule.media");
>+dart.setLibraryUri(html$.CssMediaRule, "dart:html");
>+dart.setFieldSignature(html$.CssMediaRule, () => ({
>+  __proto__: dart.getFields(html$.CssMediaRule.__proto__),
>+  [$media]: dart.finalFieldType(html$.MediaList)
>+}));
>+dart.registerExtension("CSSMediaRule", html$.CssMediaRule);
>+html$.CssNamespaceRule = class CssNamespaceRule extends html$.CssRule {
>+  get [$namespaceUri]() {
>+    return this.namespaceURI;
>+  }
>+  get [$prefix]() {
>+    return this.prefix;
>+  }
>+};
>+dart.addTypeTests(html$.CssNamespaceRule);
>+const namespaceUri = Symbol("CssNamespaceRule.namespaceUri");
>+const prefix = Symbol("CssNamespaceRule.prefix");
>+dart.setLibraryUri(html$.CssNamespaceRule, "dart:html");
>+dart.setFieldSignature(html$.CssNamespaceRule, () => ({
>+  __proto__: dart.getFields(html$.CssNamespaceRule.__proto__),
>+  [$namespaceUri]: dart.finalFieldType(core.String),
>+  [$prefix]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("CSSNamespaceRule", html$.CssNamespaceRule);
>+html$.CssNumericValue = class CssNumericValue extends html$.CssStyleValue {
>+  [$add](...args) {
>+    return this.add.apply(this, args);
>+  }
>+  [$div](...args) {
>+    return this.div.apply(this, args);
>+  }
>+  [$mul](...args) {
>+    return this.mul.apply(this, args);
>+  }
>+  [$sub](...args) {
>+    return this.sub.apply(this, args);
>+  }
>+  [$to](...args) {
>+    return this.to.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.CssNumericValue);
>+dart.setMethodSignature(html$.CssNumericValue, () => ({
>+  __proto__: dart.getMethods(html$.CssNumericValue.__proto__),
>+  [$add]: dart.fnType(html$.CssNumericValue, [html$.CssNumericValue]),
>+  [$div]: dart.fnType(html$.CssNumericValue, [core.num]),
>+  [$mul]: dart.fnType(html$.CssNumericValue, [core.num]),
>+  [$sub]: dart.fnType(html$.CssNumericValue, [html$.CssNumericValue]),
>+  [$to]: dart.fnType(html$.CssNumericValue, [core.String])
>+}));
>+dart.setLibraryUri(html$.CssNumericValue, "dart:html");
>+dart.registerExtension("CSSNumericValue", html$.CssNumericValue);
>+html$.CssPageRule = class CssPageRule extends html$.CssRule {
>+  get [$selectorText]() {
>+    return this.selectorText;
>+  }
>+  set [$selectorText](value) {
>+    this.selectorText = value;
>+  }
>+  get [$style]() {
>+    return this.style;
>+  }
>+};
>+dart.addTypeTests(html$.CssPageRule);
>+const selectorText = Symbol("CssPageRule.selectorText");
>+const style$1 = Symbol("CssPageRule.style");
>+dart.setLibraryUri(html$.CssPageRule, "dart:html");
>+dart.setFieldSignature(html$.CssPageRule, () => ({
>+  __proto__: dart.getFields(html$.CssPageRule.__proto__),
>+  [$selectorText]: dart.fieldType(core.String),
>+  [$style]: dart.finalFieldType(html$.CssStyleDeclaration)
>+}));
>+dart.registerExtension("CSSPageRule", html$.CssPageRule);
>+html$.CssPerspective = class CssPerspective extends html$.CssTransformComponent {
>+  static new(length) {
>+    return html$.CssPerspective._create_1(length);
>+  }
>+  static _create_1(length) {
>+    return new CSSPerspective(length);
>+  }
>+  get [$length]() {
>+    return this.length;
>+  }
>+  set [$length](value) {
>+    this.length = value;
>+  }
>+};
>+dart.addTypeTests(html$.CssPerspective);
>+const length$1 = Symbol("CssPerspective.length");
>+dart.setLibraryUri(html$.CssPerspective, "dart:html");
>+dart.setFieldSignature(html$.CssPerspective, () => ({
>+  __proto__: dart.getFields(html$.CssPerspective.__proto__),
>+  [$length]: dart.fieldType(html$.CssNumericValue)
>+}));
>+dart.registerExtension("CSSPerspective", html$.CssPerspective);
>+html$.CssPositionValue = class CssPositionValue extends html$.CssStyleValue {
>+  static new(x, y) {
>+    return html$.CssPositionValue._create_1(x, y);
>+  }
>+  static _create_1(x, y) {
>+    return new CSSPositionValue(x, y);
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  set [$x](value) {
>+    this.x = value;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+  set [$y](value) {
>+    this.y = value;
>+  }
>+};
>+dart.addTypeTests(html$.CssPositionValue);
>+const x$ = Symbol("CssPositionValue.x");
>+const y$ = Symbol("CssPositionValue.y");
>+dart.setLibraryUri(html$.CssPositionValue, "dart:html");
>+dart.setFieldSignature(html$.CssPositionValue, () => ({
>+  __proto__: dart.getFields(html$.CssPositionValue.__proto__),
>+  [$x]: dart.fieldType(html$.CssNumericValue),
>+  [$y]: dart.fieldType(html$.CssNumericValue)
>+}));
>+dart.registerExtension("CSSPositionValue", html$.CssPositionValue);
>+html$.CssRotation = class CssRotation extends html$.CssTransformComponent {
>+  static new(angleValue_OR_x, y, z, angle) {
>+    if (y === void 0) y = null;
>+    if (z === void 0) z = null;
>+    if (angle === void 0) angle = null;
>+    if (html$.CssNumericValue.is(angleValue_OR_x) && y == null && z == null && angle == null) {
>+      return html$.CssRotation._create_1(angleValue_OR_x);
>+    }
>+    if (html$.CssNumericValue.is(angle) && typeof z == 'number' && typeof y == 'number' && typeof angleValue_OR_x == 'number') {
>+      return html$.CssRotation._create_2(angleValue_OR_x, y, z, angle);
>+    }
>+    dart.throw(new core.ArgumentError.new("Incorrect number or type of arguments"));
>+  }
>+  static _create_1(angleValue_OR_x) {
>+    return new CSSRotation(angleValue_OR_x);
>+  }
>+  static _create_2(angleValue_OR_x, y, z, angle) {
>+    return new CSSRotation(angleValue_OR_x, y, z, angle);
>+  }
>+  get [$angle]() {
>+    return this.angle;
>+  }
>+  set [$angle](value) {
>+    this.angle = value;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  set [$x](value) {
>+    this.x = value;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+  set [$y](value) {
>+    this.y = value;
>+  }
>+  get [$z]() {
>+    return this.z;
>+  }
>+  set [$z](value) {
>+    this.z = value;
>+  }
>+};
>+dart.addTypeTests(html$.CssRotation);
>+const angle = Symbol("CssRotation.angle");
>+const x$0 = Symbol("CssRotation.x");
>+const y$0 = Symbol("CssRotation.y");
>+const z$ = Symbol("CssRotation.z");
>+dart.setLibraryUri(html$.CssRotation, "dart:html");
>+dart.setFieldSignature(html$.CssRotation, () => ({
>+  __proto__: dart.getFields(html$.CssRotation.__proto__),
>+  [$angle]: dart.fieldType(html$.CssNumericValue),
>+  [$x]: dart.fieldType(core.num),
>+  [$y]: dart.fieldType(core.num),
>+  [$z]: dart.fieldType(core.num)
>+}));
>+dart.registerExtension("CSSRotation", html$.CssRotation);
>+html$.CssScale = class CssScale extends html$.CssTransformComponent {
>+  static new(x, y, z) {
>+    if (z === void 0) z = null;
>+    if (typeof y == 'number' && typeof x == 'number' && z == null) {
>+      return html$.CssScale._create_1(x, y);
>+    }
>+    if (typeof z == 'number' && typeof y == 'number' && typeof x == 'number') {
>+      return html$.CssScale._create_2(x, y, z);
>+    }
>+    dart.throw(new core.ArgumentError.new("Incorrect number or type of arguments"));
>+  }
>+  static _create_1(x, y) {
>+    return new CSSScale(x, y);
>+  }
>+  static _create_2(x, y, z) {
>+    return new CSSScale(x, y, z);
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  set [$x](value) {
>+    this.x = value;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+  set [$y](value) {
>+    this.y = value;
>+  }
>+  get [$z]() {
>+    return this.z;
>+  }
>+  set [$z](value) {
>+    this.z = value;
>+  }
>+};
>+dart.addTypeTests(html$.CssScale);
>+const x$1 = Symbol("CssScale.x");
>+const y$1 = Symbol("CssScale.y");
>+const z$0 = Symbol("CssScale.z");
>+dart.setLibraryUri(html$.CssScale, "dart:html");
>+dart.setFieldSignature(html$.CssScale, () => ({
>+  __proto__: dart.getFields(html$.CssScale.__proto__),
>+  [$x]: dart.fieldType(core.num),
>+  [$y]: dart.fieldType(core.num),
>+  [$z]: dart.fieldType(core.num)
>+}));
>+dart.registerExtension("CSSScale", html$.CssScale);
>+html$.CssSkew = class CssSkew extends html$.CssTransformComponent {
>+  static new(ax, ay) {
>+    return html$.CssSkew._create_1(ax, ay);
>+  }
>+  static _create_1(ax, ay) {
>+    return new CSSSkew(ax, ay);
>+  }
>+  get [$ax]() {
>+    return this.ax;
>+  }
>+  set [$ax](value) {
>+    this.ax = value;
>+  }
>+  get [$ay]() {
>+    return this.ay;
>+  }
>+  set [$ay](value) {
>+    this.ay = value;
>+  }
>+};
>+dart.addTypeTests(html$.CssSkew);
>+const ax = Symbol("CssSkew.ax");
>+const ay = Symbol("CssSkew.ay");
>+dart.setLibraryUri(html$.CssSkew, "dart:html");
>+dart.setFieldSignature(html$.CssSkew, () => ({
>+  __proto__: dart.getFields(html$.CssSkew.__proto__),
>+  [$ax]: dart.fieldType(html$.CssNumericValue),
>+  [$ay]: dart.fieldType(html$.CssNumericValue)
>+}));
>+dart.registerExtension("CSSSkew", html$.CssSkew);
>+const _getPropertyValueHelper = dart.privateName(html$, "_getPropertyValueHelper");
>+const _browserPropertyName = dart.privateName(html$, "_browserPropertyName");
>+const _getPropertyValue = dart.privateName(html$, "_getPropertyValue");
>+const _supportsProperty = dart.privateName(html$, "_supportsProperty");
>+const _setPropertyHelper = dart.privateName(html$, "_setPropertyHelper");
>+const _supportedBrowserPropertyName = dart.privateName(html$, "_supportedBrowserPropertyName");
>+const _background = dart.privateName(html$, "_background");
>+const _backgroundAttachment = dart.privateName(html$, "_backgroundAttachment");
>+const _backgroundColor = dart.privateName(html$, "_backgroundColor");
>+const _backgroundImage = dart.privateName(html$, "_backgroundImage");
>+const _backgroundPosition = dart.privateName(html$, "_backgroundPosition");
>+const _backgroundRepeat = dart.privateName(html$, "_backgroundRepeat");
>+const _border = dart.privateName(html$, "_border");
>+const _borderBottom = dart.privateName(html$, "_borderBottom");
>+const _borderBottomColor = dart.privateName(html$, "_borderBottomColor");
>+const _borderBottomStyle = dart.privateName(html$, "_borderBottomStyle");
>+const _borderBottomWidth = dart.privateName(html$, "_borderBottomWidth");
>+const _borderCollapse = dart.privateName(html$, "_borderCollapse");
>+const _borderColor = dart.privateName(html$, "_borderColor");
>+const _borderLeft = dart.privateName(html$, "_borderLeft");
>+const _borderLeftColor = dart.privateName(html$, "_borderLeftColor");
>+const _borderLeftStyle = dart.privateName(html$, "_borderLeftStyle");
>+const _borderLeftWidth = dart.privateName(html$, "_borderLeftWidth");
>+const _borderRight = dart.privateName(html$, "_borderRight");
>+const _borderRightColor = dart.privateName(html$, "_borderRightColor");
>+const _borderRightStyle = dart.privateName(html$, "_borderRightStyle");
>+const _borderRightWidth = dart.privateName(html$, "_borderRightWidth");
>+const _borderSpacing = dart.privateName(html$, "_borderSpacing");
>+const _borderStyle = dart.privateName(html$, "_borderStyle");
>+const _borderTop = dart.privateName(html$, "_borderTop");
>+const _borderTopColor = dart.privateName(html$, "_borderTopColor");
>+const _borderTopStyle = dart.privateName(html$, "_borderTopStyle");
>+const _borderTopWidth = dart.privateName(html$, "_borderTopWidth");
>+const _borderWidth = dart.privateName(html$, "_borderWidth");
>+const _bottom = dart.privateName(html$, "_bottom");
>+const _captionSide = dart.privateName(html$, "_captionSide");
>+const _clear$0 = dart.privateName(html$, "_clear");
>+const _clip = dart.privateName(html$, "_clip");
>+const _color = dart.privateName(html$, "_color");
>+const _content = dart.privateName(html$, "_content");
>+const _cursor = dart.privateName(html$, "_cursor");
>+const _direction = dart.privateName(html$, "_direction");
>+const _display = dart.privateName(html$, "_display");
>+const _emptyCells = dart.privateName(html$, "_emptyCells");
>+const _font = dart.privateName(html$, "_font");
>+const _fontFamily = dart.privateName(html$, "_fontFamily");
>+const _fontSize = dart.privateName(html$, "_fontSize");
>+const _fontStyle = dart.privateName(html$, "_fontStyle");
>+const _fontVariant = dart.privateName(html$, "_fontVariant");
>+const _fontWeight = dart.privateName(html$, "_fontWeight");
>+const _height$ = dart.privateName(html$, "_height");
>+const _left = dart.privateName(html$, "_left");
>+const _letterSpacing = dart.privateName(html$, "_letterSpacing");
>+const _lineHeight = dart.privateName(html$, "_lineHeight");
>+const _listStyle = dart.privateName(html$, "_listStyle");
>+const _listStyleImage = dart.privateName(html$, "_listStyleImage");
>+const _listStylePosition = dart.privateName(html$, "_listStylePosition");
>+const _listStyleType = dart.privateName(html$, "_listStyleType");
>+const _margin = dart.privateName(html$, "_margin");
>+const _marginBottom = dart.privateName(html$, "_marginBottom");
>+const _marginLeft = dart.privateName(html$, "_marginLeft");
>+const _marginRight = dart.privateName(html$, "_marginRight");
>+const _marginTop = dart.privateName(html$, "_marginTop");
>+const _maxHeight = dart.privateName(html$, "_maxHeight");
>+const _maxWidth = dart.privateName(html$, "_maxWidth");
>+const _minHeight = dart.privateName(html$, "_minHeight");
>+const _minWidth = dart.privateName(html$, "_minWidth");
>+const _outline = dart.privateName(html$, "_outline");
>+const _outlineColor = dart.privateName(html$, "_outlineColor");
>+const _outlineStyle = dart.privateName(html$, "_outlineStyle");
>+const _outlineWidth = dart.privateName(html$, "_outlineWidth");
>+const _overflow = dart.privateName(html$, "_overflow");
>+const _padding = dart.privateName(html$, "_padding");
>+const _paddingBottom = dart.privateName(html$, "_paddingBottom");
>+const _paddingLeft = dart.privateName(html$, "_paddingLeft");
>+const _paddingRight = dart.privateName(html$, "_paddingRight");
>+const _paddingTop = dart.privateName(html$, "_paddingTop");
>+const _pageBreakAfter = dart.privateName(html$, "_pageBreakAfter");
>+const _pageBreakBefore = dart.privateName(html$, "_pageBreakBefore");
>+const _pageBreakInside = dart.privateName(html$, "_pageBreakInside");
>+const _position$1 = dart.privateName(html$, "_position");
>+const _quotes = dart.privateName(html$, "_quotes");
>+const _right = dart.privateName(html$, "_right");
>+const _tableLayout = dart.privateName(html$, "_tableLayout");
>+const _textAlign = dart.privateName(html$, "_textAlign");
>+const _textDecoration = dart.privateName(html$, "_textDecoration");
>+const _textIndent = dart.privateName(html$, "_textIndent");
>+const _textTransform = dart.privateName(html$, "_textTransform");
>+const _top = dart.privateName(html$, "_top");
>+const _unicodeBidi = dart.privateName(html$, "_unicodeBidi");
>+const _verticalAlign = dart.privateName(html$, "_verticalAlign");
>+const _visibility = dart.privateName(html$, "_visibility");
>+const _whiteSpace = dart.privateName(html$, "_whiteSpace");
>+const _width$ = dart.privateName(html$, "_width");
>+const _wordSpacing = dart.privateName(html$, "_wordSpacing");
>+const _zIndex = dart.privateName(html$, "_zIndex");
>+html$.CssStyleDeclarationBase = class CssStyleDeclarationBase extends core.Object {
>+  get alignContent() {
>+    return this[$getPropertyValue]("align-content");
>+  }
>+  set alignContent(value) {
>+    this[$setProperty]("align-content", value, "");
>+  }
>+  get alignItems() {
>+    return this[$getPropertyValue]("align-items");
>+  }
>+  set alignItems(value) {
>+    this[$setProperty]("align-items", value, "");
>+  }
>+  get alignSelf() {
>+    return this[$getPropertyValue]("align-self");
>+  }
>+  set alignSelf(value) {
>+    this[$setProperty]("align-self", value, "");
>+  }
>+  get animation() {
>+    return this[$getPropertyValue]("animation");
>+  }
>+  set animation(value) {
>+    this[$setProperty]("animation", value, "");
>+  }
>+  get animationDelay() {
>+    return this[$getPropertyValue]("animation-delay");
>+  }
>+  set animationDelay(value) {
>+    this[$setProperty]("animation-delay", value, "");
>+  }
>+  get animationDirection() {
>+    return this[$getPropertyValue]("animation-direction");
>+  }
>+  set animationDirection(value) {
>+    this[$setProperty]("animation-direction", value, "");
>+  }
>+  get animationDuration() {
>+    return this[$getPropertyValue]("animation-duration");
>+  }
>+  set animationDuration(value) {
>+    this[$setProperty]("animation-duration", value, "");
>+  }
>+  get animationFillMode() {
>+    return this[$getPropertyValue]("animation-fill-mode");
>+  }
>+  set animationFillMode(value) {
>+    this[$setProperty]("animation-fill-mode", value, "");
>+  }
>+  get animationIterationCount() {
>+    return this[$getPropertyValue]("animation-iteration-count");
>+  }
>+  set animationIterationCount(value) {
>+    this[$setProperty]("animation-iteration-count", value, "");
>+  }
>+  get animationName() {
>+    return this[$getPropertyValue]("animation-name");
>+  }
>+  set animationName(value) {
>+    this[$setProperty]("animation-name", value, "");
>+  }
>+  get animationPlayState() {
>+    return this[$getPropertyValue]("animation-play-state");
>+  }
>+  set animationPlayState(value) {
>+    this[$setProperty]("animation-play-state", value, "");
>+  }
>+  get animationTimingFunction() {
>+    return this[$getPropertyValue]("animation-timing-function");
>+  }
>+  set animationTimingFunction(value) {
>+    this[$setProperty]("animation-timing-function", value, "");
>+  }
>+  get appRegion() {
>+    return this[$getPropertyValue]("app-region");
>+  }
>+  set appRegion(value) {
>+    this[$setProperty]("app-region", value, "");
>+  }
>+  get appearance() {
>+    return this[$getPropertyValue]("appearance");
>+  }
>+  set appearance(value) {
>+    this[$setProperty]("appearance", value, "");
>+  }
>+  get aspectRatio() {
>+    return this[$getPropertyValue]("aspect-ratio");
>+  }
>+  set aspectRatio(value) {
>+    this[$setProperty]("aspect-ratio", value, "");
>+  }
>+  get backfaceVisibility() {
>+    return this[$getPropertyValue]("backface-visibility");
>+  }
>+  set backfaceVisibility(value) {
>+    this[$setProperty]("backface-visibility", value, "");
>+  }
>+  get background() {
>+    return this[$getPropertyValue]("background");
>+  }
>+  set background(value) {
>+    this[$setProperty]("background", value, "");
>+  }
>+  get backgroundAttachment() {
>+    return this[$getPropertyValue]("background-attachment");
>+  }
>+  set backgroundAttachment(value) {
>+    this[$setProperty]("background-attachment", value, "");
>+  }
>+  get backgroundBlendMode() {
>+    return this[$getPropertyValue]("background-blend-mode");
>+  }
>+  set backgroundBlendMode(value) {
>+    this[$setProperty]("background-blend-mode", value, "");
>+  }
>+  get backgroundClip() {
>+    return this[$getPropertyValue]("background-clip");
>+  }
>+  set backgroundClip(value) {
>+    this[$setProperty]("background-clip", value, "");
>+  }
>+  get backgroundColor() {
>+    return this[$getPropertyValue]("background-color");
>+  }
>+  set backgroundColor(value) {
>+    this[$setProperty]("background-color", value, "");
>+  }
>+  get backgroundComposite() {
>+    return this[$getPropertyValue]("background-composite");
>+  }
>+  set backgroundComposite(value) {
>+    this[$setProperty]("background-composite", value, "");
>+  }
>+  get backgroundImage() {
>+    return this[$getPropertyValue]("background-image");
>+  }
>+  set backgroundImage(value) {
>+    this[$setProperty]("background-image", value, "");
>+  }
>+  get backgroundOrigin() {
>+    return this[$getPropertyValue]("background-origin");
>+  }
>+  set backgroundOrigin(value) {
>+    this[$setProperty]("background-origin", value, "");
>+  }
>+  get backgroundPosition() {
>+    return this[$getPropertyValue]("background-position");
>+  }
>+  set backgroundPosition(value) {
>+    this[$setProperty]("background-position", value, "");
>+  }
>+  get backgroundPositionX() {
>+    return this[$getPropertyValue]("background-position-x");
>+  }
>+  set backgroundPositionX(value) {
>+    this[$setProperty]("background-position-x", value, "");
>+  }
>+  get backgroundPositionY() {
>+    return this[$getPropertyValue]("background-position-y");
>+  }
>+  set backgroundPositionY(value) {
>+    this[$setProperty]("background-position-y", value, "");
>+  }
>+  get backgroundRepeat() {
>+    return this[$getPropertyValue]("background-repeat");
>+  }
>+  set backgroundRepeat(value) {
>+    this[$setProperty]("background-repeat", value, "");
>+  }
>+  get backgroundRepeatX() {
>+    return this[$getPropertyValue]("background-repeat-x");
>+  }
>+  set backgroundRepeatX(value) {
>+    this[$setProperty]("background-repeat-x", value, "");
>+  }
>+  get backgroundRepeatY() {
>+    return this[$getPropertyValue]("background-repeat-y");
>+  }
>+  set backgroundRepeatY(value) {
>+    this[$setProperty]("background-repeat-y", value, "");
>+  }
>+  get backgroundSize() {
>+    return this[$getPropertyValue]("background-size");
>+  }
>+  set backgroundSize(value) {
>+    this[$setProperty]("background-size", value, "");
>+  }
>+  get border() {
>+    return this[$getPropertyValue]("border");
>+  }
>+  set border(value) {
>+    this[$setProperty]("border", value, "");
>+  }
>+  get borderAfter() {
>+    return this[$getPropertyValue]("border-after");
>+  }
>+  set borderAfter(value) {
>+    this[$setProperty]("border-after", value, "");
>+  }
>+  get borderAfterColor() {
>+    return this[$getPropertyValue]("border-after-color");
>+  }
>+  set borderAfterColor(value) {
>+    this[$setProperty]("border-after-color", value, "");
>+  }
>+  get borderAfterStyle() {
>+    return this[$getPropertyValue]("border-after-style");
>+  }
>+  set borderAfterStyle(value) {
>+    this[$setProperty]("border-after-style", value, "");
>+  }
>+  get borderAfterWidth() {
>+    return this[$getPropertyValue]("border-after-width");
>+  }
>+  set borderAfterWidth(value) {
>+    this[$setProperty]("border-after-width", value, "");
>+  }
>+  get borderBefore() {
>+    return this[$getPropertyValue]("border-before");
>+  }
>+  set borderBefore(value) {
>+    this[$setProperty]("border-before", value, "");
>+  }
>+  get borderBeforeColor() {
>+    return this[$getPropertyValue]("border-before-color");
>+  }
>+  set borderBeforeColor(value) {
>+    this[$setProperty]("border-before-color", value, "");
>+  }
>+  get borderBeforeStyle() {
>+    return this[$getPropertyValue]("border-before-style");
>+  }
>+  set borderBeforeStyle(value) {
>+    this[$setProperty]("border-before-style", value, "");
>+  }
>+  get borderBeforeWidth() {
>+    return this[$getPropertyValue]("border-before-width");
>+  }
>+  set borderBeforeWidth(value) {
>+    this[$setProperty]("border-before-width", value, "");
>+  }
>+  get borderBottom() {
>+    return this[$getPropertyValue]("border-bottom");
>+  }
>+  set borderBottom(value) {
>+    this[$setProperty]("border-bottom", value, "");
>+  }
>+  get borderBottomColor() {
>+    return this[$getPropertyValue]("border-bottom-color");
>+  }
>+  set borderBottomColor(value) {
>+    this[$setProperty]("border-bottom-color", value, "");
>+  }
>+  get borderBottomLeftRadius() {
>+    return this[$getPropertyValue]("border-bottom-left-radius");
>+  }
>+  set borderBottomLeftRadius(value) {
>+    this[$setProperty]("border-bottom-left-radius", value, "");
>+  }
>+  get borderBottomRightRadius() {
>+    return this[$getPropertyValue]("border-bottom-right-radius");
>+  }
>+  set borderBottomRightRadius(value) {
>+    this[$setProperty]("border-bottom-right-radius", value, "");
>+  }
>+  get borderBottomStyle() {
>+    return this[$getPropertyValue]("border-bottom-style");
>+  }
>+  set borderBottomStyle(value) {
>+    this[$setProperty]("border-bottom-style", value, "");
>+  }
>+  get borderBottomWidth() {
>+    return this[$getPropertyValue]("border-bottom-width");
>+  }
>+  set borderBottomWidth(value) {
>+    this[$setProperty]("border-bottom-width", value, "");
>+  }
>+  get borderCollapse() {
>+    return this[$getPropertyValue]("border-collapse");
>+  }
>+  set borderCollapse(value) {
>+    this[$setProperty]("border-collapse", value, "");
>+  }
>+  get borderColor() {
>+    return this[$getPropertyValue]("border-color");
>+  }
>+  set borderColor(value) {
>+    this[$setProperty]("border-color", value, "");
>+  }
>+  get borderEnd() {
>+    return this[$getPropertyValue]("border-end");
>+  }
>+  set borderEnd(value) {
>+    this[$setProperty]("border-end", value, "");
>+  }
>+  get borderEndColor() {
>+    return this[$getPropertyValue]("border-end-color");
>+  }
>+  set borderEndColor(value) {
>+    this[$setProperty]("border-end-color", value, "");
>+  }
>+  get borderEndStyle() {
>+    return this[$getPropertyValue]("border-end-style");
>+  }
>+  set borderEndStyle(value) {
>+    this[$setProperty]("border-end-style", value, "");
>+  }
>+  get borderEndWidth() {
>+    return this[$getPropertyValue]("border-end-width");
>+  }
>+  set borderEndWidth(value) {
>+    this[$setProperty]("border-end-width", value, "");
>+  }
>+  get borderFit() {
>+    return this[$getPropertyValue]("border-fit");
>+  }
>+  set borderFit(value) {
>+    this[$setProperty]("border-fit", value, "");
>+  }
>+  get borderHorizontalSpacing() {
>+    return this[$getPropertyValue]("border-horizontal-spacing");
>+  }
>+  set borderHorizontalSpacing(value) {
>+    this[$setProperty]("border-horizontal-spacing", value, "");
>+  }
>+  get borderImage() {
>+    return this[$getPropertyValue]("border-image");
>+  }
>+  set borderImage(value) {
>+    this[$setProperty]("border-image", value, "");
>+  }
>+  get borderImageOutset() {
>+    return this[$getPropertyValue]("border-image-outset");
>+  }
>+  set borderImageOutset(value) {
>+    this[$setProperty]("border-image-outset", value, "");
>+  }
>+  get borderImageRepeat() {
>+    return this[$getPropertyValue]("border-image-repeat");
>+  }
>+  set borderImageRepeat(value) {
>+    this[$setProperty]("border-image-repeat", value, "");
>+  }
>+  get borderImageSlice() {
>+    return this[$getPropertyValue]("border-image-slice");
>+  }
>+  set borderImageSlice(value) {
>+    this[$setProperty]("border-image-slice", value, "");
>+  }
>+  get borderImageSource() {
>+    return this[$getPropertyValue]("border-image-source");
>+  }
>+  set borderImageSource(value) {
>+    this[$setProperty]("border-image-source", value, "");
>+  }
>+  get borderImageWidth() {
>+    return this[$getPropertyValue]("border-image-width");
>+  }
>+  set borderImageWidth(value) {
>+    this[$setProperty]("border-image-width", value, "");
>+  }
>+  get borderLeft() {
>+    return this[$getPropertyValue]("border-left");
>+  }
>+  set borderLeft(value) {
>+    this[$setProperty]("border-left", value, "");
>+  }
>+  get borderLeftColor() {
>+    return this[$getPropertyValue]("border-left-color");
>+  }
>+  set borderLeftColor(value) {
>+    this[$setProperty]("border-left-color", value, "");
>+  }
>+  get borderLeftStyle() {
>+    return this[$getPropertyValue]("border-left-style");
>+  }
>+  set borderLeftStyle(value) {
>+    this[$setProperty]("border-left-style", value, "");
>+  }
>+  get borderLeftWidth() {
>+    return this[$getPropertyValue]("border-left-width");
>+  }
>+  set borderLeftWidth(value) {
>+    this[$setProperty]("border-left-width", value, "");
>+  }
>+  get borderRadius() {
>+    return this[$getPropertyValue]("border-radius");
>+  }
>+  set borderRadius(value) {
>+    this[$setProperty]("border-radius", value, "");
>+  }
>+  get borderRight() {
>+    return this[$getPropertyValue]("border-right");
>+  }
>+  set borderRight(value) {
>+    this[$setProperty]("border-right", value, "");
>+  }
>+  get borderRightColor() {
>+    return this[$getPropertyValue]("border-right-color");
>+  }
>+  set borderRightColor(value) {
>+    this[$setProperty]("border-right-color", value, "");
>+  }
>+  get borderRightStyle() {
>+    return this[$getPropertyValue]("border-right-style");
>+  }
>+  set borderRightStyle(value) {
>+    this[$setProperty]("border-right-style", value, "");
>+  }
>+  get borderRightWidth() {
>+    return this[$getPropertyValue]("border-right-width");
>+  }
>+  set borderRightWidth(value) {
>+    this[$setProperty]("border-right-width", value, "");
>+  }
>+  get borderSpacing() {
>+    return this[$getPropertyValue]("border-spacing");
>+  }
>+  set borderSpacing(value) {
>+    this[$setProperty]("border-spacing", value, "");
>+  }
>+  get borderStart() {
>+    return this[$getPropertyValue]("border-start");
>+  }
>+  set borderStart(value) {
>+    this[$setProperty]("border-start", value, "");
>+  }
>+  get borderStartColor() {
>+    return this[$getPropertyValue]("border-start-color");
>+  }
>+  set borderStartColor(value) {
>+    this[$setProperty]("border-start-color", value, "");
>+  }
>+  get borderStartStyle() {
>+    return this[$getPropertyValue]("border-start-style");
>+  }
>+  set borderStartStyle(value) {
>+    this[$setProperty]("border-start-style", value, "");
>+  }
>+  get borderStartWidth() {
>+    return this[$getPropertyValue]("border-start-width");
>+  }
>+  set borderStartWidth(value) {
>+    this[$setProperty]("border-start-width", value, "");
>+  }
>+  get borderStyle() {
>+    return this[$getPropertyValue]("border-style");
>+  }
>+  set borderStyle(value) {
>+    this[$setProperty]("border-style", value, "");
>+  }
>+  get borderTop() {
>+    return this[$getPropertyValue]("border-top");
>+  }
>+  set borderTop(value) {
>+    this[$setProperty]("border-top", value, "");
>+  }
>+  get borderTopColor() {
>+    return this[$getPropertyValue]("border-top-color");
>+  }
>+  set borderTopColor(value) {
>+    this[$setProperty]("border-top-color", value, "");
>+  }
>+  get borderTopLeftRadius() {
>+    return this[$getPropertyValue]("border-top-left-radius");
>+  }
>+  set borderTopLeftRadius(value) {
>+    this[$setProperty]("border-top-left-radius", value, "");
>+  }
>+  get borderTopRightRadius() {
>+    return this[$getPropertyValue]("border-top-right-radius");
>+  }
>+  set borderTopRightRadius(value) {
>+    this[$setProperty]("border-top-right-radius", value, "");
>+  }
>+  get borderTopStyle() {
>+    return this[$getPropertyValue]("border-top-style");
>+  }
>+  set borderTopStyle(value) {
>+    this[$setProperty]("border-top-style", value, "");
>+  }
>+  get borderTopWidth() {
>+    return this[$getPropertyValue]("border-top-width");
>+  }
>+  set borderTopWidth(value) {
>+    this[$setProperty]("border-top-width", value, "");
>+  }
>+  get borderVerticalSpacing() {
>+    return this[$getPropertyValue]("border-vertical-spacing");
>+  }
>+  set borderVerticalSpacing(value) {
>+    this[$setProperty]("border-vertical-spacing", value, "");
>+  }
>+  get borderWidth() {
>+    return this[$getPropertyValue]("border-width");
>+  }
>+  set borderWidth(value) {
>+    this[$setProperty]("border-width", value, "");
>+  }
>+  get bottom() {
>+    return this[$getPropertyValue]("bottom");
>+  }
>+  set bottom(value) {
>+    this[$setProperty]("bottom", value, "");
>+  }
>+  get boxAlign() {
>+    return this[$getPropertyValue]("box-align");
>+  }
>+  set boxAlign(value) {
>+    this[$setProperty]("box-align", value, "");
>+  }
>+  get boxDecorationBreak() {
>+    return this[$getPropertyValue]("box-decoration-break");
>+  }
>+  set boxDecorationBreak(value) {
>+    this[$setProperty]("box-decoration-break", value, "");
>+  }
>+  get boxDirection() {
>+    return this[$getPropertyValue]("box-direction");
>+  }
>+  set boxDirection(value) {
>+    this[$setProperty]("box-direction", value, "");
>+  }
>+  get boxFlex() {
>+    return this[$getPropertyValue]("box-flex");
>+  }
>+  set boxFlex(value) {
>+    this[$setProperty]("box-flex", value, "");
>+  }
>+  get boxFlexGroup() {
>+    return this[$getPropertyValue]("box-flex-group");
>+  }
>+  set boxFlexGroup(value) {
>+    this[$setProperty]("box-flex-group", value, "");
>+  }
>+  get boxLines() {
>+    return this[$getPropertyValue]("box-lines");
>+  }
>+  set boxLines(value) {
>+    this[$setProperty]("box-lines", value, "");
>+  }
>+  get boxOrdinalGroup() {
>+    return this[$getPropertyValue]("box-ordinal-group");
>+  }
>+  set boxOrdinalGroup(value) {
>+    this[$setProperty]("box-ordinal-group", value, "");
>+  }
>+  get boxOrient() {
>+    return this[$getPropertyValue]("box-orient");
>+  }
>+  set boxOrient(value) {
>+    this[$setProperty]("box-orient", value, "");
>+  }
>+  get boxPack() {
>+    return this[$getPropertyValue]("box-pack");
>+  }
>+  set boxPack(value) {
>+    this[$setProperty]("box-pack", value, "");
>+  }
>+  get boxReflect() {
>+    return this[$getPropertyValue]("box-reflect");
>+  }
>+  set boxReflect(value) {
>+    this[$setProperty]("box-reflect", value, "");
>+  }
>+  get boxShadow() {
>+    return this[$getPropertyValue]("box-shadow");
>+  }
>+  set boxShadow(value) {
>+    this[$setProperty]("box-shadow", value, "");
>+  }
>+  get boxSizing() {
>+    return this[$getPropertyValue]("box-sizing");
>+  }
>+  set boxSizing(value) {
>+    this[$setProperty]("box-sizing", value, "");
>+  }
>+  get captionSide() {
>+    return this[$getPropertyValue]("caption-side");
>+  }
>+  set captionSide(value) {
>+    this[$setProperty]("caption-side", value, "");
>+  }
>+  get clear() {
>+    return this[$getPropertyValue]("clear");
>+  }
>+  set clear(value) {
>+    this[$setProperty]("clear", value, "");
>+  }
>+  get clip() {
>+    return this[$getPropertyValue]("clip");
>+  }
>+  set clip(value) {
>+    this[$setProperty]("clip", value, "");
>+  }
>+  get clipPath() {
>+    return this[$getPropertyValue]("clip-path");
>+  }
>+  set clipPath(value) {
>+    this[$setProperty]("clip-path", value, "");
>+  }
>+  get color() {
>+    return this[$getPropertyValue]("color");
>+  }
>+  set color(value) {
>+    this[$setProperty]("color", value, "");
>+  }
>+  get columnBreakAfter() {
>+    return this[$getPropertyValue]("column-break-after");
>+  }
>+  set columnBreakAfter(value) {
>+    this[$setProperty]("column-break-after", value, "");
>+  }
>+  get columnBreakBefore() {
>+    return this[$getPropertyValue]("column-break-before");
>+  }
>+  set columnBreakBefore(value) {
>+    this[$setProperty]("column-break-before", value, "");
>+  }
>+  get columnBreakInside() {
>+    return this[$getPropertyValue]("column-break-inside");
>+  }
>+  set columnBreakInside(value) {
>+    this[$setProperty]("column-break-inside", value, "");
>+  }
>+  get columnCount() {
>+    return this[$getPropertyValue]("column-count");
>+  }
>+  set columnCount(value) {
>+    this[$setProperty]("column-count", value, "");
>+  }
>+  get columnFill() {
>+    return this[$getPropertyValue]("column-fill");
>+  }
>+  set columnFill(value) {
>+    this[$setProperty]("column-fill", value, "");
>+  }
>+  get columnGap() {
>+    return this[$getPropertyValue]("column-gap");
>+  }
>+  set columnGap(value) {
>+    this[$setProperty]("column-gap", value, "");
>+  }
>+  get columnRule() {
>+    return this[$getPropertyValue]("column-rule");
>+  }
>+  set columnRule(value) {
>+    this[$setProperty]("column-rule", value, "");
>+  }
>+  get columnRuleColor() {
>+    return this[$getPropertyValue]("column-rule-color");
>+  }
>+  set columnRuleColor(value) {
>+    this[$setProperty]("column-rule-color", value, "");
>+  }
>+  get columnRuleStyle() {
>+    return this[$getPropertyValue]("column-rule-style");
>+  }
>+  set columnRuleStyle(value) {
>+    this[$setProperty]("column-rule-style", value, "");
>+  }
>+  get columnRuleWidth() {
>+    return this[$getPropertyValue]("column-rule-width");
>+  }
>+  set columnRuleWidth(value) {
>+    this[$setProperty]("column-rule-width", value, "");
>+  }
>+  get columnSpan() {
>+    return this[$getPropertyValue]("column-span");
>+  }
>+  set columnSpan(value) {
>+    this[$setProperty]("column-span", value, "");
>+  }
>+  get columnWidth() {
>+    return this[$getPropertyValue]("column-width");
>+  }
>+  set columnWidth(value) {
>+    this[$setProperty]("column-width", value, "");
>+  }
>+  get columns() {
>+    return this[$getPropertyValue]("columns");
>+  }
>+  set columns(value) {
>+    this[$setProperty]("columns", value, "");
>+  }
>+  get content() {
>+    return this[$getPropertyValue]("content");
>+  }
>+  set content(value) {
>+    this[$setProperty]("content", value, "");
>+  }
>+  get counterIncrement() {
>+    return this[$getPropertyValue]("counter-increment");
>+  }
>+  set counterIncrement(value) {
>+    this[$setProperty]("counter-increment", value, "");
>+  }
>+  get counterReset() {
>+    return this[$getPropertyValue]("counter-reset");
>+  }
>+  set counterReset(value) {
>+    this[$setProperty]("counter-reset", value, "");
>+  }
>+  get cursor() {
>+    return this[$getPropertyValue]("cursor");
>+  }
>+  set cursor(value) {
>+    this[$setProperty]("cursor", value, "");
>+  }
>+  get direction() {
>+    return this[$getPropertyValue]("direction");
>+  }
>+  set direction(value) {
>+    this[$setProperty]("direction", value, "");
>+  }
>+  get display() {
>+    return this[$getPropertyValue]("display");
>+  }
>+  set display(value) {
>+    this[$setProperty]("display", value, "");
>+  }
>+  get emptyCells() {
>+    return this[$getPropertyValue]("empty-cells");
>+  }
>+  set emptyCells(value) {
>+    this[$setProperty]("empty-cells", value, "");
>+  }
>+  get filter() {
>+    return this[$getPropertyValue]("filter");
>+  }
>+  set filter(value) {
>+    this[$setProperty]("filter", value, "");
>+  }
>+  get flex() {
>+    return this[$getPropertyValue]("flex");
>+  }
>+  set flex(value) {
>+    this[$setProperty]("flex", value, "");
>+  }
>+  get flexBasis() {
>+    return this[$getPropertyValue]("flex-basis");
>+  }
>+  set flexBasis(value) {
>+    this[$setProperty]("flex-basis", value, "");
>+  }
>+  get flexDirection() {
>+    return this[$getPropertyValue]("flex-direction");
>+  }
>+  set flexDirection(value) {
>+    this[$setProperty]("flex-direction", value, "");
>+  }
>+  get flexFlow() {
>+    return this[$getPropertyValue]("flex-flow");
>+  }
>+  set flexFlow(value) {
>+    this[$setProperty]("flex-flow", value, "");
>+  }
>+  get flexGrow() {
>+    return this[$getPropertyValue]("flex-grow");
>+  }
>+  set flexGrow(value) {
>+    this[$setProperty]("flex-grow", value, "");
>+  }
>+  get flexShrink() {
>+    return this[$getPropertyValue]("flex-shrink");
>+  }
>+  set flexShrink(value) {
>+    this[$setProperty]("flex-shrink", value, "");
>+  }
>+  get flexWrap() {
>+    return this[$getPropertyValue]("flex-wrap");
>+  }
>+  set flexWrap(value) {
>+    this[$setProperty]("flex-wrap", value, "");
>+  }
>+  get float() {
>+    return this[$getPropertyValue]("float");
>+  }
>+  set float(value) {
>+    this[$setProperty]("float", value, "");
>+  }
>+  get font() {
>+    return this[$getPropertyValue]("font");
>+  }
>+  set font(value) {
>+    this[$setProperty]("font", value, "");
>+  }
>+  get fontFamily() {
>+    return this[$getPropertyValue]("font-family");
>+  }
>+  set fontFamily(value) {
>+    this[$setProperty]("font-family", value, "");
>+  }
>+  get fontFeatureSettings() {
>+    return this[$getPropertyValue]("font-feature-settings");
>+  }
>+  set fontFeatureSettings(value) {
>+    this[$setProperty]("font-feature-settings", value, "");
>+  }
>+  get fontKerning() {
>+    return this[$getPropertyValue]("font-kerning");
>+  }
>+  set fontKerning(value) {
>+    this[$setProperty]("font-kerning", value, "");
>+  }
>+  get fontSize() {
>+    return this[$getPropertyValue]("font-size");
>+  }
>+  set fontSize(value) {
>+    this[$setProperty]("font-size", value, "");
>+  }
>+  get fontSizeDelta() {
>+    return this[$getPropertyValue]("font-size-delta");
>+  }
>+  set fontSizeDelta(value) {
>+    this[$setProperty]("font-size-delta", value, "");
>+  }
>+  get fontSmoothing() {
>+    return this[$getPropertyValue]("font-smoothing");
>+  }
>+  set fontSmoothing(value) {
>+    this[$setProperty]("font-smoothing", value, "");
>+  }
>+  get fontStretch() {
>+    return this[$getPropertyValue]("font-stretch");
>+  }
>+  set fontStretch(value) {
>+    this[$setProperty]("font-stretch", value, "");
>+  }
>+  get fontStyle() {
>+    return this[$getPropertyValue]("font-style");
>+  }
>+  set fontStyle(value) {
>+    this[$setProperty]("font-style", value, "");
>+  }
>+  get fontVariant() {
>+    return this[$getPropertyValue]("font-variant");
>+  }
>+  set fontVariant(value) {
>+    this[$setProperty]("font-variant", value, "");
>+  }
>+  get fontVariantLigatures() {
>+    return this[$getPropertyValue]("font-variant-ligatures");
>+  }
>+  set fontVariantLigatures(value) {
>+    this[$setProperty]("font-variant-ligatures", value, "");
>+  }
>+  get fontWeight() {
>+    return this[$getPropertyValue]("font-weight");
>+  }
>+  set fontWeight(value) {
>+    this[$setProperty]("font-weight", value, "");
>+  }
>+  get grid() {
>+    return this[$getPropertyValue]("grid");
>+  }
>+  set grid(value) {
>+    this[$setProperty]("grid", value, "");
>+  }
>+  get gridArea() {
>+    return this[$getPropertyValue]("grid-area");
>+  }
>+  set gridArea(value) {
>+    this[$setProperty]("grid-area", value, "");
>+  }
>+  get gridAutoColumns() {
>+    return this[$getPropertyValue]("grid-auto-columns");
>+  }
>+  set gridAutoColumns(value) {
>+    this[$setProperty]("grid-auto-columns", value, "");
>+  }
>+  get gridAutoFlow() {
>+    return this[$getPropertyValue]("grid-auto-flow");
>+  }
>+  set gridAutoFlow(value) {
>+    this[$setProperty]("grid-auto-flow", value, "");
>+  }
>+  get gridAutoRows() {
>+    return this[$getPropertyValue]("grid-auto-rows");
>+  }
>+  set gridAutoRows(value) {
>+    this[$setProperty]("grid-auto-rows", value, "");
>+  }
>+  get gridColumn() {
>+    return this[$getPropertyValue]("grid-column");
>+  }
>+  set gridColumn(value) {
>+    this[$setProperty]("grid-column", value, "");
>+  }
>+  get gridColumnEnd() {
>+    return this[$getPropertyValue]("grid-column-end");
>+  }
>+  set gridColumnEnd(value) {
>+    this[$setProperty]("grid-column-end", value, "");
>+  }
>+  get gridColumnStart() {
>+    return this[$getPropertyValue]("grid-column-start");
>+  }
>+  set gridColumnStart(value) {
>+    this[$setProperty]("grid-column-start", value, "");
>+  }
>+  get gridRow() {
>+    return this[$getPropertyValue]("grid-row");
>+  }
>+  set gridRow(value) {
>+    this[$setProperty]("grid-row", value, "");
>+  }
>+  get gridRowEnd() {
>+    return this[$getPropertyValue]("grid-row-end");
>+  }
>+  set gridRowEnd(value) {
>+    this[$setProperty]("grid-row-end", value, "");
>+  }
>+  get gridRowStart() {
>+    return this[$getPropertyValue]("grid-row-start");
>+  }
>+  set gridRowStart(value) {
>+    this[$setProperty]("grid-row-start", value, "");
>+  }
>+  get gridTemplate() {
>+    return this[$getPropertyValue]("grid-template");
>+  }
>+  set gridTemplate(value) {
>+    this[$setProperty]("grid-template", value, "");
>+  }
>+  get gridTemplateAreas() {
>+    return this[$getPropertyValue]("grid-template-areas");
>+  }
>+  set gridTemplateAreas(value) {
>+    this[$setProperty]("grid-template-areas", value, "");
>+  }
>+  get gridTemplateColumns() {
>+    return this[$getPropertyValue]("grid-template-columns");
>+  }
>+  set gridTemplateColumns(value) {
>+    this[$setProperty]("grid-template-columns", value, "");
>+  }
>+  get gridTemplateRows() {
>+    return this[$getPropertyValue]("grid-template-rows");
>+  }
>+  set gridTemplateRows(value) {
>+    this[$setProperty]("grid-template-rows", value, "");
>+  }
>+  get height() {
>+    return this[$getPropertyValue]("height");
>+  }
>+  set height(value) {
>+    this[$setProperty]("height", value, "");
>+  }
>+  get highlight() {
>+    return this[$getPropertyValue]("highlight");
>+  }
>+  set highlight(value) {
>+    this[$setProperty]("highlight", value, "");
>+  }
>+  get hyphenateCharacter() {
>+    return this[$getPropertyValue]("hyphenate-character");
>+  }
>+  set hyphenateCharacter(value) {
>+    this[$setProperty]("hyphenate-character", value, "");
>+  }
>+  get imageRendering() {
>+    return this[$getPropertyValue]("image-rendering");
>+  }
>+  set imageRendering(value) {
>+    this[$setProperty]("image-rendering", value, "");
>+  }
>+  get isolation() {
>+    return this[$getPropertyValue]("isolation");
>+  }
>+  set isolation(value) {
>+    this[$setProperty]("isolation", value, "");
>+  }
>+  get justifyContent() {
>+    return this[$getPropertyValue]("justify-content");
>+  }
>+  set justifyContent(value) {
>+    this[$setProperty]("justify-content", value, "");
>+  }
>+  get justifySelf() {
>+    return this[$getPropertyValue]("justify-self");
>+  }
>+  set justifySelf(value) {
>+    this[$setProperty]("justify-self", value, "");
>+  }
>+  get left() {
>+    return this[$getPropertyValue]("left");
>+  }
>+  set left(value) {
>+    this[$setProperty]("left", value, "");
>+  }
>+  get letterSpacing() {
>+    return this[$getPropertyValue]("letter-spacing");
>+  }
>+  set letterSpacing(value) {
>+    this[$setProperty]("letter-spacing", value, "");
>+  }
>+  get lineBoxContain() {
>+    return this[$getPropertyValue]("line-box-contain");
>+  }
>+  set lineBoxContain(value) {
>+    this[$setProperty]("line-box-contain", value, "");
>+  }
>+  get lineBreak() {
>+    return this[$getPropertyValue]("line-break");
>+  }
>+  set lineBreak(value) {
>+    this[$setProperty]("line-break", value, "");
>+  }
>+  get lineClamp() {
>+    return this[$getPropertyValue]("line-clamp");
>+  }
>+  set lineClamp(value) {
>+    this[$setProperty]("line-clamp", value, "");
>+  }
>+  get lineHeight() {
>+    return this[$getPropertyValue]("line-height");
>+  }
>+  set lineHeight(value) {
>+    this[$setProperty]("line-height", value, "");
>+  }
>+  get listStyle() {
>+    return this[$getPropertyValue]("list-style");
>+  }
>+  set listStyle(value) {
>+    this[$setProperty]("list-style", value, "");
>+  }
>+  get listStyleImage() {
>+    return this[$getPropertyValue]("list-style-image");
>+  }
>+  set listStyleImage(value) {
>+    this[$setProperty]("list-style-image", value, "");
>+  }
>+  get listStylePosition() {
>+    return this[$getPropertyValue]("list-style-position");
>+  }
>+  set listStylePosition(value) {
>+    this[$setProperty]("list-style-position", value, "");
>+  }
>+  get listStyleType() {
>+    return this[$getPropertyValue]("list-style-type");
>+  }
>+  set listStyleType(value) {
>+    this[$setProperty]("list-style-type", value, "");
>+  }
>+  get locale() {
>+    return this[$getPropertyValue]("locale");
>+  }
>+  set locale(value) {
>+    this[$setProperty]("locale", value, "");
>+  }
>+  get logicalHeight() {
>+    return this[$getPropertyValue]("logical-height");
>+  }
>+  set logicalHeight(value) {
>+    this[$setProperty]("logical-height", value, "");
>+  }
>+  get logicalWidth() {
>+    return this[$getPropertyValue]("logical-width");
>+  }
>+  set logicalWidth(value) {
>+    this[$setProperty]("logical-width", value, "");
>+  }
>+  get margin() {
>+    return this[$getPropertyValue]("margin");
>+  }
>+  set margin(value) {
>+    this[$setProperty]("margin", value, "");
>+  }
>+  get marginAfter() {
>+    return this[$getPropertyValue]("margin-after");
>+  }
>+  set marginAfter(value) {
>+    this[$setProperty]("margin-after", value, "");
>+  }
>+  get marginAfterCollapse() {
>+    return this[$getPropertyValue]("margin-after-collapse");
>+  }
>+  set marginAfterCollapse(value) {
>+    this[$setProperty]("margin-after-collapse", value, "");
>+  }
>+  get marginBefore() {
>+    return this[$getPropertyValue]("margin-before");
>+  }
>+  set marginBefore(value) {
>+    this[$setProperty]("margin-before", value, "");
>+  }
>+  get marginBeforeCollapse() {
>+    return this[$getPropertyValue]("margin-before-collapse");
>+  }
>+  set marginBeforeCollapse(value) {
>+    this[$setProperty]("margin-before-collapse", value, "");
>+  }
>+  get marginBottom() {
>+    return this[$getPropertyValue]("margin-bottom");
>+  }
>+  set marginBottom(value) {
>+    this[$setProperty]("margin-bottom", value, "");
>+  }
>+  get marginBottomCollapse() {
>+    return this[$getPropertyValue]("margin-bottom-collapse");
>+  }
>+  set marginBottomCollapse(value) {
>+    this[$setProperty]("margin-bottom-collapse", value, "");
>+  }
>+  get marginCollapse() {
>+    return this[$getPropertyValue]("margin-collapse");
>+  }
>+  set marginCollapse(value) {
>+    this[$setProperty]("margin-collapse", value, "");
>+  }
>+  get marginEnd() {
>+    return this[$getPropertyValue]("margin-end");
>+  }
>+  set marginEnd(value) {
>+    this[$setProperty]("margin-end", value, "");
>+  }
>+  get marginLeft() {
>+    return this[$getPropertyValue]("margin-left");
>+  }
>+  set marginLeft(value) {
>+    this[$setProperty]("margin-left", value, "");
>+  }
>+  get marginRight() {
>+    return this[$getPropertyValue]("margin-right");
>+  }
>+  set marginRight(value) {
>+    this[$setProperty]("margin-right", value, "");
>+  }
>+  get marginStart() {
>+    return this[$getPropertyValue]("margin-start");
>+  }
>+  set marginStart(value) {
>+    this[$setProperty]("margin-start", value, "");
>+  }
>+  get marginTop() {
>+    return this[$getPropertyValue]("margin-top");
>+  }
>+  set marginTop(value) {
>+    this[$setProperty]("margin-top", value, "");
>+  }
>+  get marginTopCollapse() {
>+    return this[$getPropertyValue]("margin-top-collapse");
>+  }
>+  set marginTopCollapse(value) {
>+    this[$setProperty]("margin-top-collapse", value, "");
>+  }
>+  get mask() {
>+    return this[$getPropertyValue]("mask");
>+  }
>+  set mask(value) {
>+    this[$setProperty]("mask", value, "");
>+  }
>+  get maskBoxImage() {
>+    return this[$getPropertyValue]("mask-box-image");
>+  }
>+  set maskBoxImage(value) {
>+    this[$setProperty]("mask-box-image", value, "");
>+  }
>+  get maskBoxImageOutset() {
>+    return this[$getPropertyValue]("mask-box-image-outset");
>+  }
>+  set maskBoxImageOutset(value) {
>+    this[$setProperty]("mask-box-image-outset", value, "");
>+  }
>+  get maskBoxImageRepeat() {
>+    return this[$getPropertyValue]("mask-box-image-repeat");
>+  }
>+  set maskBoxImageRepeat(value) {
>+    this[$setProperty]("mask-box-image-repeat", value, "");
>+  }
>+  get maskBoxImageSlice() {
>+    return this[$getPropertyValue]("mask-box-image-slice");
>+  }
>+  set maskBoxImageSlice(value) {
>+    this[$setProperty]("mask-box-image-slice", value, "");
>+  }
>+  get maskBoxImageSource() {
>+    return this[$getPropertyValue]("mask-box-image-source");
>+  }
>+  set maskBoxImageSource(value) {
>+    this[$setProperty]("mask-box-image-source", value, "");
>+  }
>+  get maskBoxImageWidth() {
>+    return this[$getPropertyValue]("mask-box-image-width");
>+  }
>+  set maskBoxImageWidth(value) {
>+    this[$setProperty]("mask-box-image-width", value, "");
>+  }
>+  get maskClip() {
>+    return this[$getPropertyValue]("mask-clip");
>+  }
>+  set maskClip(value) {
>+    this[$setProperty]("mask-clip", value, "");
>+  }
>+  get maskComposite() {
>+    return this[$getPropertyValue]("mask-composite");
>+  }
>+  set maskComposite(value) {
>+    this[$setProperty]("mask-composite", value, "");
>+  }
>+  get maskImage() {
>+    return this[$getPropertyValue]("mask-image");
>+  }
>+  set maskImage(value) {
>+    this[$setProperty]("mask-image", value, "");
>+  }
>+  get maskOrigin() {
>+    return this[$getPropertyValue]("mask-origin");
>+  }
>+  set maskOrigin(value) {
>+    this[$setProperty]("mask-origin", value, "");
>+  }
>+  get maskPosition() {
>+    return this[$getPropertyValue]("mask-position");
>+  }
>+  set maskPosition(value) {
>+    this[$setProperty]("mask-position", value, "");
>+  }
>+  get maskPositionX() {
>+    return this[$getPropertyValue]("mask-position-x");
>+  }
>+  set maskPositionX(value) {
>+    this[$setProperty]("mask-position-x", value, "");
>+  }
>+  get maskPositionY() {
>+    return this[$getPropertyValue]("mask-position-y");
>+  }
>+  set maskPositionY(value) {
>+    this[$setProperty]("mask-position-y", value, "");
>+  }
>+  get maskRepeat() {
>+    return this[$getPropertyValue]("mask-repeat");
>+  }
>+  set maskRepeat(value) {
>+    this[$setProperty]("mask-repeat", value, "");
>+  }
>+  get maskRepeatX() {
>+    return this[$getPropertyValue]("mask-repeat-x");
>+  }
>+  set maskRepeatX(value) {
>+    this[$setProperty]("mask-repeat-x", value, "");
>+  }
>+  get maskRepeatY() {
>+    return this[$getPropertyValue]("mask-repeat-y");
>+  }
>+  set maskRepeatY(value) {
>+    this[$setProperty]("mask-repeat-y", value, "");
>+  }
>+  get maskSize() {
>+    return this[$getPropertyValue]("mask-size");
>+  }
>+  set maskSize(value) {
>+    this[$setProperty]("mask-size", value, "");
>+  }
>+  get maskSourceType() {
>+    return this[$getPropertyValue]("mask-source-type");
>+  }
>+  set maskSourceType(value) {
>+    this[$setProperty]("mask-source-type", value, "");
>+  }
>+  get maxHeight() {
>+    return this[$getPropertyValue]("max-height");
>+  }
>+  set maxHeight(value) {
>+    this[$setProperty]("max-height", value, "");
>+  }
>+  get maxLogicalHeight() {
>+    return this[$getPropertyValue]("max-logical-height");
>+  }
>+  set maxLogicalHeight(value) {
>+    this[$setProperty]("max-logical-height", value, "");
>+  }
>+  get maxLogicalWidth() {
>+    return this[$getPropertyValue]("max-logical-width");
>+  }
>+  set maxLogicalWidth(value) {
>+    this[$setProperty]("max-logical-width", value, "");
>+  }
>+  get maxWidth() {
>+    return this[$getPropertyValue]("max-width");
>+  }
>+  set maxWidth(value) {
>+    this[$setProperty]("max-width", value, "");
>+  }
>+  get maxZoom() {
>+    return this[$getPropertyValue]("max-zoom");
>+  }
>+  set maxZoom(value) {
>+    this[$setProperty]("max-zoom", value, "");
>+  }
>+  get minHeight() {
>+    return this[$getPropertyValue]("min-height");
>+  }
>+  set minHeight(value) {
>+    this[$setProperty]("min-height", value, "");
>+  }
>+  get minLogicalHeight() {
>+    return this[$getPropertyValue]("min-logical-height");
>+  }
>+  set minLogicalHeight(value) {
>+    this[$setProperty]("min-logical-height", value, "");
>+  }
>+  get minLogicalWidth() {
>+    return this[$getPropertyValue]("min-logical-width");
>+  }
>+  set minLogicalWidth(value) {
>+    this[$setProperty]("min-logical-width", value, "");
>+  }
>+  get minWidth() {
>+    return this[$getPropertyValue]("min-width");
>+  }
>+  set minWidth(value) {
>+    this[$setProperty]("min-width", value, "");
>+  }
>+  get minZoom() {
>+    return this[$getPropertyValue]("min-zoom");
>+  }
>+  set minZoom(value) {
>+    this[$setProperty]("min-zoom", value, "");
>+  }
>+  get mixBlendMode() {
>+    return this[$getPropertyValue]("mix-blend-mode");
>+  }
>+  set mixBlendMode(value) {
>+    this[$setProperty]("mix-blend-mode", value, "");
>+  }
>+  get objectFit() {
>+    return this[$getPropertyValue]("object-fit");
>+  }
>+  set objectFit(value) {
>+    this[$setProperty]("object-fit", value, "");
>+  }
>+  get objectPosition() {
>+    return this[$getPropertyValue]("object-position");
>+  }
>+  set objectPosition(value) {
>+    this[$setProperty]("object-position", value, "");
>+  }
>+  get opacity() {
>+    return this[$getPropertyValue]("opacity");
>+  }
>+  set opacity(value) {
>+    this[$setProperty]("opacity", value, "");
>+  }
>+  get order() {
>+    return this[$getPropertyValue]("order");
>+  }
>+  set order(value) {
>+    this[$setProperty]("order", value, "");
>+  }
>+  get orientation() {
>+    return this[$getPropertyValue]("orientation");
>+  }
>+  set orientation(value) {
>+    this[$setProperty]("orientation", value, "");
>+  }
>+  get orphans() {
>+    return this[$getPropertyValue]("orphans");
>+  }
>+  set orphans(value) {
>+    this[$setProperty]("orphans", value, "");
>+  }
>+  get outline() {
>+    return this[$getPropertyValue]("outline");
>+  }
>+  set outline(value) {
>+    this[$setProperty]("outline", value, "");
>+  }
>+  get outlineColor() {
>+    return this[$getPropertyValue]("outline-color");
>+  }
>+  set outlineColor(value) {
>+    this[$setProperty]("outline-color", value, "");
>+  }
>+  get outlineOffset() {
>+    return this[$getPropertyValue]("outline-offset");
>+  }
>+  set outlineOffset(value) {
>+    this[$setProperty]("outline-offset", value, "");
>+  }
>+  get outlineStyle() {
>+    return this[$getPropertyValue]("outline-style");
>+  }
>+  set outlineStyle(value) {
>+    this[$setProperty]("outline-style", value, "");
>+  }
>+  get outlineWidth() {
>+    return this[$getPropertyValue]("outline-width");
>+  }
>+  set outlineWidth(value) {
>+    this[$setProperty]("outline-width", value, "");
>+  }
>+  get overflow() {
>+    return this[$getPropertyValue]("overflow");
>+  }
>+  set overflow(value) {
>+    this[$setProperty]("overflow", value, "");
>+  }
>+  get overflowWrap() {
>+    return this[$getPropertyValue]("overflow-wrap");
>+  }
>+  set overflowWrap(value) {
>+    this[$setProperty]("overflow-wrap", value, "");
>+  }
>+  get overflowX() {
>+    return this[$getPropertyValue]("overflow-x");
>+  }
>+  set overflowX(value) {
>+    this[$setProperty]("overflow-x", value, "");
>+  }
>+  get overflowY() {
>+    return this[$getPropertyValue]("overflow-y");
>+  }
>+  set overflowY(value) {
>+    this[$setProperty]("overflow-y", value, "");
>+  }
>+  get padding() {
>+    return this[$getPropertyValue]("padding");
>+  }
>+  set padding(value) {
>+    this[$setProperty]("padding", value, "");
>+  }
>+  get paddingAfter() {
>+    return this[$getPropertyValue]("padding-after");
>+  }
>+  set paddingAfter(value) {
>+    this[$setProperty]("padding-after", value, "");
>+  }
>+  get paddingBefore() {
>+    return this[$getPropertyValue]("padding-before");
>+  }
>+  set paddingBefore(value) {
>+    this[$setProperty]("padding-before", value, "");
>+  }
>+  get paddingBottom() {
>+    return this[$getPropertyValue]("padding-bottom");
>+  }
>+  set paddingBottom(value) {
>+    this[$setProperty]("padding-bottom", value, "");
>+  }
>+  get paddingEnd() {
>+    return this[$getPropertyValue]("padding-end");
>+  }
>+  set paddingEnd(value) {
>+    this[$setProperty]("padding-end", value, "");
>+  }
>+  get paddingLeft() {
>+    return this[$getPropertyValue]("padding-left");
>+  }
>+  set paddingLeft(value) {
>+    this[$setProperty]("padding-left", value, "");
>+  }
>+  get paddingRight() {
>+    return this[$getPropertyValue]("padding-right");
>+  }
>+  set paddingRight(value) {
>+    this[$setProperty]("padding-right", value, "");
>+  }
>+  get paddingStart() {
>+    return this[$getPropertyValue]("padding-start");
>+  }
>+  set paddingStart(value) {
>+    this[$setProperty]("padding-start", value, "");
>+  }
>+  get paddingTop() {
>+    return this[$getPropertyValue]("padding-top");
>+  }
>+  set paddingTop(value) {
>+    this[$setProperty]("padding-top", value, "");
>+  }
>+  get page() {
>+    return this[$getPropertyValue]("page");
>+  }
>+  set page(value) {
>+    this[$setProperty]("page", value, "");
>+  }
>+  get pageBreakAfter() {
>+    return this[$getPropertyValue]("page-break-after");
>+  }
>+  set pageBreakAfter(value) {
>+    this[$setProperty]("page-break-after", value, "");
>+  }
>+  get pageBreakBefore() {
>+    return this[$getPropertyValue]("page-break-before");
>+  }
>+  set pageBreakBefore(value) {
>+    this[$setProperty]("page-break-before", value, "");
>+  }
>+  get pageBreakInside() {
>+    return this[$getPropertyValue]("page-break-inside");
>+  }
>+  set pageBreakInside(value) {
>+    this[$setProperty]("page-break-inside", value, "");
>+  }
>+  get perspective() {
>+    return this[$getPropertyValue]("perspective");
>+  }
>+  set perspective(value) {
>+    this[$setProperty]("perspective", value, "");
>+  }
>+  get perspectiveOrigin() {
>+    return this[$getPropertyValue]("perspective-origin");
>+  }
>+  set perspectiveOrigin(value) {
>+    this[$setProperty]("perspective-origin", value, "");
>+  }
>+  get perspectiveOriginX() {
>+    return this[$getPropertyValue]("perspective-origin-x");
>+  }
>+  set perspectiveOriginX(value) {
>+    this[$setProperty]("perspective-origin-x", value, "");
>+  }
>+  get perspectiveOriginY() {
>+    return this[$getPropertyValue]("perspective-origin-y");
>+  }
>+  set perspectiveOriginY(value) {
>+    this[$setProperty]("perspective-origin-y", value, "");
>+  }
>+  get pointerEvents() {
>+    return this[$getPropertyValue]("pointer-events");
>+  }
>+  set pointerEvents(value) {
>+    this[$setProperty]("pointer-events", value, "");
>+  }
>+  get position() {
>+    return this[$getPropertyValue]("position");
>+  }
>+  set position(value) {
>+    this[$setProperty]("position", value, "");
>+  }
>+  get printColorAdjust() {
>+    return this[$getPropertyValue]("print-color-adjust");
>+  }
>+  set printColorAdjust(value) {
>+    this[$setProperty]("print-color-adjust", value, "");
>+  }
>+  get quotes() {
>+    return this[$getPropertyValue]("quotes");
>+  }
>+  set quotes(value) {
>+    this[$setProperty]("quotes", value, "");
>+  }
>+  get resize() {
>+    return this[$getPropertyValue]("resize");
>+  }
>+  set resize(value) {
>+    this[$setProperty]("resize", value, "");
>+  }
>+  get right() {
>+    return this[$getPropertyValue]("right");
>+  }
>+  set right(value) {
>+    this[$setProperty]("right", value, "");
>+  }
>+  get rtlOrdering() {
>+    return this[$getPropertyValue]("rtl-ordering");
>+  }
>+  set rtlOrdering(value) {
>+    this[$setProperty]("rtl-ordering", value, "");
>+  }
>+  get rubyPosition() {
>+    return this[$getPropertyValue]("ruby-position");
>+  }
>+  set rubyPosition(value) {
>+    this[$setProperty]("ruby-position", value, "");
>+  }
>+  get scrollBehavior() {
>+    return this[$getPropertyValue]("scroll-behavior");
>+  }
>+  set scrollBehavior(value) {
>+    this[$setProperty]("scroll-behavior", value, "");
>+  }
>+  get shapeImageThreshold() {
>+    return this[$getPropertyValue]("shape-image-threshold");
>+  }
>+  set shapeImageThreshold(value) {
>+    this[$setProperty]("shape-image-threshold", value, "");
>+  }
>+  get shapeMargin() {
>+    return this[$getPropertyValue]("shape-margin");
>+  }
>+  set shapeMargin(value) {
>+    this[$setProperty]("shape-margin", value, "");
>+  }
>+  get shapeOutside() {
>+    return this[$getPropertyValue]("shape-outside");
>+  }
>+  set shapeOutside(value) {
>+    this[$setProperty]("shape-outside", value, "");
>+  }
>+  get size() {
>+    return this[$getPropertyValue]("size");
>+  }
>+  set size(value) {
>+    this[$setProperty]("size", value, "");
>+  }
>+  get speak() {
>+    return this[$getPropertyValue]("speak");
>+  }
>+  set speak(value) {
>+    this[$setProperty]("speak", value, "");
>+  }
>+  get src() {
>+    return this[$getPropertyValue]("src");
>+  }
>+  set src(value) {
>+    this[$setProperty]("src", value, "");
>+  }
>+  get tabSize() {
>+    return this[$getPropertyValue]("tab-size");
>+  }
>+  set tabSize(value) {
>+    this[$setProperty]("tab-size", value, "");
>+  }
>+  get tableLayout() {
>+    return this[$getPropertyValue]("table-layout");
>+  }
>+  set tableLayout(value) {
>+    this[$setProperty]("table-layout", value, "");
>+  }
>+  get tapHighlightColor() {
>+    return this[$getPropertyValue]("tap-highlight-color");
>+  }
>+  set tapHighlightColor(value) {
>+    this[$setProperty]("tap-highlight-color", value, "");
>+  }
>+  get textAlign() {
>+    return this[$getPropertyValue]("text-align");
>+  }
>+  set textAlign(value) {
>+    this[$setProperty]("text-align", value, "");
>+  }
>+  get textAlignLast() {
>+    return this[$getPropertyValue]("text-align-last");
>+  }
>+  set textAlignLast(value) {
>+    this[$setProperty]("text-align-last", value, "");
>+  }
>+  get textCombine() {
>+    return this[$getPropertyValue]("text-combine");
>+  }
>+  set textCombine(value) {
>+    this[$setProperty]("text-combine", value, "");
>+  }
>+  get textDecoration() {
>+    return this[$getPropertyValue]("text-decoration");
>+  }
>+  set textDecoration(value) {
>+    this[$setProperty]("text-decoration", value, "");
>+  }
>+  get textDecorationColor() {
>+    return this[$getPropertyValue]("text-decoration-color");
>+  }
>+  set textDecorationColor(value) {
>+    this[$setProperty]("text-decoration-color", value, "");
>+  }
>+  get textDecorationLine() {
>+    return this[$getPropertyValue]("text-decoration-line");
>+  }
>+  set textDecorationLine(value) {
>+    this[$setProperty]("text-decoration-line", value, "");
>+  }
>+  get textDecorationStyle() {
>+    return this[$getPropertyValue]("text-decoration-style");
>+  }
>+  set textDecorationStyle(value) {
>+    this[$setProperty]("text-decoration-style", value, "");
>+  }
>+  get textDecorationsInEffect() {
>+    return this[$getPropertyValue]("text-decorations-in-effect");
>+  }
>+  set textDecorationsInEffect(value) {
>+    this[$setProperty]("text-decorations-in-effect", value, "");
>+  }
>+  get textEmphasis() {
>+    return this[$getPropertyValue]("text-emphasis");
>+  }
>+  set textEmphasis(value) {
>+    this[$setProperty]("text-emphasis", value, "");
>+  }
>+  get textEmphasisColor() {
>+    return this[$getPropertyValue]("text-emphasis-color");
>+  }
>+  set textEmphasisColor(value) {
>+    this[$setProperty]("text-emphasis-color", value, "");
>+  }
>+  get textEmphasisPosition() {
>+    return this[$getPropertyValue]("text-emphasis-position");
>+  }
>+  set textEmphasisPosition(value) {
>+    this[$setProperty]("text-emphasis-position", value, "");
>+  }
>+  get textEmphasisStyle() {
>+    return this[$getPropertyValue]("text-emphasis-style");
>+  }
>+  set textEmphasisStyle(value) {
>+    this[$setProperty]("text-emphasis-style", value, "");
>+  }
>+  get textFillColor() {
>+    return this[$getPropertyValue]("text-fill-color");
>+  }
>+  set textFillColor(value) {
>+    this[$setProperty]("text-fill-color", value, "");
>+  }
>+  get textIndent() {
>+    return this[$getPropertyValue]("text-indent");
>+  }
>+  set textIndent(value) {
>+    this[$setProperty]("text-indent", value, "");
>+  }
>+  get textJustify() {
>+    return this[$getPropertyValue]("text-justify");
>+  }
>+  set textJustify(value) {
>+    this[$setProperty]("text-justify", value, "");
>+  }
>+  get textLineThroughColor() {
>+    return this[$getPropertyValue]("text-line-through-color");
>+  }
>+  set textLineThroughColor(value) {
>+    this[$setProperty]("text-line-through-color", value, "");
>+  }
>+  get textLineThroughMode() {
>+    return this[$getPropertyValue]("text-line-through-mode");
>+  }
>+  set textLineThroughMode(value) {
>+    this[$setProperty]("text-line-through-mode", value, "");
>+  }
>+  get textLineThroughStyle() {
>+    return this[$getPropertyValue]("text-line-through-style");
>+  }
>+  set textLineThroughStyle(value) {
>+    this[$setProperty]("text-line-through-style", value, "");
>+  }
>+  get textLineThroughWidth() {
>+    return this[$getPropertyValue]("text-line-through-width");
>+  }
>+  set textLineThroughWidth(value) {
>+    this[$setProperty]("text-line-through-width", value, "");
>+  }
>+  get textOrientation() {
>+    return this[$getPropertyValue]("text-orientation");
>+  }
>+  set textOrientation(value) {
>+    this[$setProperty]("text-orientation", value, "");
>+  }
>+  get textOverflow() {
>+    return this[$getPropertyValue]("text-overflow");
>+  }
>+  set textOverflow(value) {
>+    this[$setProperty]("text-overflow", value, "");
>+  }
>+  get textOverlineColor() {
>+    return this[$getPropertyValue]("text-overline-color");
>+  }
>+  set textOverlineColor(value) {
>+    this[$setProperty]("text-overline-color", value, "");
>+  }
>+  get textOverlineMode() {
>+    return this[$getPropertyValue]("text-overline-mode");
>+  }
>+  set textOverlineMode(value) {
>+    this[$setProperty]("text-overline-mode", value, "");
>+  }
>+  get textOverlineStyle() {
>+    return this[$getPropertyValue]("text-overline-style");
>+  }
>+  set textOverlineStyle(value) {
>+    this[$setProperty]("text-overline-style", value, "");
>+  }
>+  get textOverlineWidth() {
>+    return this[$getPropertyValue]("text-overline-width");
>+  }
>+  set textOverlineWidth(value) {
>+    this[$setProperty]("text-overline-width", value, "");
>+  }
>+  get textRendering() {
>+    return this[$getPropertyValue]("text-rendering");
>+  }
>+  set textRendering(value) {
>+    this[$setProperty]("text-rendering", value, "");
>+  }
>+  get textSecurity() {
>+    return this[$getPropertyValue]("text-security");
>+  }
>+  set textSecurity(value) {
>+    this[$setProperty]("text-security", value, "");
>+  }
>+  get textShadow() {
>+    return this[$getPropertyValue]("text-shadow");
>+  }
>+  set textShadow(value) {
>+    this[$setProperty]("text-shadow", value, "");
>+  }
>+  get textStroke() {
>+    return this[$getPropertyValue]("text-stroke");
>+  }
>+  set textStroke(value) {
>+    this[$setProperty]("text-stroke", value, "");
>+  }
>+  get textStrokeColor() {
>+    return this[$getPropertyValue]("text-stroke-color");
>+  }
>+  set textStrokeColor(value) {
>+    this[$setProperty]("text-stroke-color", value, "");
>+  }
>+  get textStrokeWidth() {
>+    return this[$getPropertyValue]("text-stroke-width");
>+  }
>+  set textStrokeWidth(value) {
>+    this[$setProperty]("text-stroke-width", value, "");
>+  }
>+  get textTransform() {
>+    return this[$getPropertyValue]("text-transform");
>+  }
>+  set textTransform(value) {
>+    this[$setProperty]("text-transform", value, "");
>+  }
>+  get textUnderlineColor() {
>+    return this[$getPropertyValue]("text-underline-color");
>+  }
>+  set textUnderlineColor(value) {
>+    this[$setProperty]("text-underline-color", value, "");
>+  }
>+  get textUnderlineMode() {
>+    return this[$getPropertyValue]("text-underline-mode");
>+  }
>+  set textUnderlineMode(value) {
>+    this[$setProperty]("text-underline-mode", value, "");
>+  }
>+  get textUnderlinePosition() {
>+    return this[$getPropertyValue]("text-underline-position");
>+  }
>+  set textUnderlinePosition(value) {
>+    this[$setProperty]("text-underline-position", value, "");
>+  }
>+  get textUnderlineStyle() {
>+    return this[$getPropertyValue]("text-underline-style");
>+  }
>+  set textUnderlineStyle(value) {
>+    this[$setProperty]("text-underline-style", value, "");
>+  }
>+  get textUnderlineWidth() {
>+    return this[$getPropertyValue]("text-underline-width");
>+  }
>+  set textUnderlineWidth(value) {
>+    this[$setProperty]("text-underline-width", value, "");
>+  }
>+  get top() {
>+    return this[$getPropertyValue]("top");
>+  }
>+  set top(value) {
>+    this[$setProperty]("top", value, "");
>+  }
>+  get touchAction() {
>+    return this[$getPropertyValue]("touch-action");
>+  }
>+  set touchAction(value) {
>+    this[$setProperty]("touch-action", value, "");
>+  }
>+  get touchActionDelay() {
>+    return this[$getPropertyValue]("touch-action-delay");
>+  }
>+  set touchActionDelay(value) {
>+    this[$setProperty]("touch-action-delay", value, "");
>+  }
>+  get transform() {
>+    return this[$getPropertyValue]("transform");
>+  }
>+  set transform(value) {
>+    this[$setProperty]("transform", value, "");
>+  }
>+  get transformOrigin() {
>+    return this[$getPropertyValue]("transform-origin");
>+  }
>+  set transformOrigin(value) {
>+    this[$setProperty]("transform-origin", value, "");
>+  }
>+  get transformOriginX() {
>+    return this[$getPropertyValue]("transform-origin-x");
>+  }
>+  set transformOriginX(value) {
>+    this[$setProperty]("transform-origin-x", value, "");
>+  }
>+  get transformOriginY() {
>+    return this[$getPropertyValue]("transform-origin-y");
>+  }
>+  set transformOriginY(value) {
>+    this[$setProperty]("transform-origin-y", value, "");
>+  }
>+  get transformOriginZ() {
>+    return this[$getPropertyValue]("transform-origin-z");
>+  }
>+  set transformOriginZ(value) {
>+    this[$setProperty]("transform-origin-z", value, "");
>+  }
>+  get transformStyle() {
>+    return this[$getPropertyValue]("transform-style");
>+  }
>+  set transformStyle(value) {
>+    this[$setProperty]("transform-style", value, "");
>+  }
>+  get transition() {
>+    return this[$getPropertyValue]("transition");
>+  }
>+  set transition(value) {
>+    this[$setProperty]("transition", value, "");
>+  }
>+  get transitionDelay() {
>+    return this[$getPropertyValue]("transition-delay");
>+  }
>+  set transitionDelay(value) {
>+    this[$setProperty]("transition-delay", value, "");
>+  }
>+  get transitionDuration() {
>+    return this[$getPropertyValue]("transition-duration");
>+  }
>+  set transitionDuration(value) {
>+    this[$setProperty]("transition-duration", value, "");
>+  }
>+  get transitionProperty() {
>+    return this[$getPropertyValue]("transition-property");
>+  }
>+  set transitionProperty(value) {
>+    this[$setProperty]("transition-property", value, "");
>+  }
>+  get transitionTimingFunction() {
>+    return this[$getPropertyValue]("transition-timing-function");
>+  }
>+  set transitionTimingFunction(value) {
>+    this[$setProperty]("transition-timing-function", value, "");
>+  }
>+  get unicodeBidi() {
>+    return this[$getPropertyValue]("unicode-bidi");
>+  }
>+  set unicodeBidi(value) {
>+    this[$setProperty]("unicode-bidi", value, "");
>+  }
>+  get unicodeRange() {
>+    return this[$getPropertyValue]("unicode-range");
>+  }
>+  set unicodeRange(value) {
>+    this[$setProperty]("unicode-range", value, "");
>+  }
>+  get userDrag() {
>+    return this[$getPropertyValue]("user-drag");
>+  }
>+  set userDrag(value) {
>+    this[$setProperty]("user-drag", value, "");
>+  }
>+  get userModify() {
>+    return this[$getPropertyValue]("user-modify");
>+  }
>+  set userModify(value) {
>+    this[$setProperty]("user-modify", value, "");
>+  }
>+  get userSelect() {
>+    return this[$getPropertyValue]("user-select");
>+  }
>+  set userSelect(value) {
>+    this[$setProperty]("user-select", value, "");
>+  }
>+  get userZoom() {
>+    return this[$getPropertyValue]("user-zoom");
>+  }
>+  set userZoom(value) {
>+    this[$setProperty]("user-zoom", value, "");
>+  }
>+  get verticalAlign() {
>+    return this[$getPropertyValue]("vertical-align");
>+  }
>+  set verticalAlign(value) {
>+    this[$setProperty]("vertical-align", value, "");
>+  }
>+  get visibility() {
>+    return this[$getPropertyValue]("visibility");
>+  }
>+  set visibility(value) {
>+    this[$setProperty]("visibility", value, "");
>+  }
>+  get whiteSpace() {
>+    return this[$getPropertyValue]("white-space");
>+  }
>+  set whiteSpace(value) {
>+    this[$setProperty]("white-space", value, "");
>+  }
>+  get widows() {
>+    return this[$getPropertyValue]("widows");
>+  }
>+  set widows(value) {
>+    this[$setProperty]("widows", value, "");
>+  }
>+  get width() {
>+    return this[$getPropertyValue]("width");
>+  }
>+  set width(value) {
>+    this[$setProperty]("width", value, "");
>+  }
>+  get willChange() {
>+    return this[$getPropertyValue]("will-change");
>+  }
>+  set willChange(value) {
>+    this[$setProperty]("will-change", value, "");
>+  }
>+  get wordBreak() {
>+    return this[$getPropertyValue]("word-break");
>+  }
>+  set wordBreak(value) {
>+    this[$setProperty]("word-break", value, "");
>+  }
>+  get wordSpacing() {
>+    return this[$getPropertyValue]("word-spacing");
>+  }
>+  set wordSpacing(value) {
>+    this[$setProperty]("word-spacing", value, "");
>+  }
>+  get wordWrap() {
>+    return this[$getPropertyValue]("word-wrap");
>+  }
>+  set wordWrap(value) {
>+    this[$setProperty]("word-wrap", value, "");
>+  }
>+  get wrapFlow() {
>+    return this[$getPropertyValue]("wrap-flow");
>+  }
>+  set wrapFlow(value) {
>+    this[$setProperty]("wrap-flow", value, "");
>+  }
>+  get wrapThrough() {
>+    return this[$getPropertyValue]("wrap-through");
>+  }
>+  set wrapThrough(value) {
>+    this[$setProperty]("wrap-through", value, "");
>+  }
>+  get writingMode() {
>+    return this[$getPropertyValue]("writing-mode");
>+  }
>+  set writingMode(value) {
>+    this[$setProperty]("writing-mode", value, "");
>+  }
>+  get zIndex() {
>+    return this[$getPropertyValue]("z-index");
>+  }
>+  set zIndex(value) {
>+    this[$setProperty]("z-index", value, "");
>+  }
>+  get zoom() {
>+    return this[$getPropertyValue]("zoom");
>+  }
>+  set zoom(value) {
>+    this[$setProperty]("zoom", value, "");
>+  }
>+};
>+(html$.CssStyleDeclarationBase.new = function() {
>+}).prototype = html$.CssStyleDeclarationBase.prototype;
>+dart.addTypeTests(html$.CssStyleDeclarationBase);
>+dart.setGetterSignature(html$.CssStyleDeclarationBase, () => ({
>+  __proto__: dart.getGetters(html$.CssStyleDeclarationBase.__proto__),
>+  alignContent: core.String,
>+  [$alignContent]: core.String,
>+  alignItems: core.String,
>+  [$alignItems]: core.String,
>+  alignSelf: core.String,
>+  [$alignSelf]: core.String,
>+  animation: core.String,
>+  [$animation]: core.String,
>+  animationDelay: core.String,
>+  [$animationDelay]: core.String,
>+  animationDirection: core.String,
>+  [$animationDirection]: core.String,
>+  animationDuration: core.String,
>+  [$animationDuration]: core.String,
>+  animationFillMode: core.String,
>+  [$animationFillMode]: core.String,
>+  animationIterationCount: core.String,
>+  [$animationIterationCount]: core.String,
>+  animationName: core.String,
>+  [$animationName]: core.String,
>+  animationPlayState: core.String,
>+  [$animationPlayState]: core.String,
>+  animationTimingFunction: core.String,
>+  [$animationTimingFunction]: core.String,
>+  appRegion: core.String,
>+  [$appRegion]: core.String,
>+  appearance: core.String,
>+  [$appearance]: core.String,
>+  aspectRatio: core.String,
>+  [$aspectRatio]: core.String,
>+  backfaceVisibility: core.String,
>+  [$backfaceVisibility]: core.String,
>+  background: core.String,
>+  [$background]: core.String,
>+  backgroundAttachment: core.String,
>+  [$backgroundAttachment]: core.String,
>+  backgroundBlendMode: core.String,
>+  [$backgroundBlendMode]: core.String,
>+  backgroundClip: core.String,
>+  [$backgroundClip]: core.String,
>+  backgroundColor: core.String,
>+  [$backgroundColor]: core.String,
>+  backgroundComposite: core.String,
>+  [$backgroundComposite]: core.String,
>+  backgroundImage: core.String,
>+  [$backgroundImage]: core.String,
>+  backgroundOrigin: core.String,
>+  [$backgroundOrigin]: core.String,
>+  backgroundPosition: core.String,
>+  [$backgroundPosition]: core.String,
>+  backgroundPositionX: core.String,
>+  [$backgroundPositionX]: core.String,
>+  backgroundPositionY: core.String,
>+  [$backgroundPositionY]: core.String,
>+  backgroundRepeat: core.String,
>+  [$backgroundRepeat]: core.String,
>+  backgroundRepeatX: core.String,
>+  [$backgroundRepeatX]: core.String,
>+  backgroundRepeatY: core.String,
>+  [$backgroundRepeatY]: core.String,
>+  backgroundSize: core.String,
>+  [$backgroundSize]: core.String,
>+  border: core.String,
>+  [$border]: core.String,
>+  borderAfter: core.String,
>+  [$borderAfter]: core.String,
>+  borderAfterColor: core.String,
>+  [$borderAfterColor]: core.String,
>+  borderAfterStyle: core.String,
>+  [$borderAfterStyle]: core.String,
>+  borderAfterWidth: core.String,
>+  [$borderAfterWidth]: core.String,
>+  borderBefore: core.String,
>+  [$borderBefore]: core.String,
>+  borderBeforeColor: core.String,
>+  [$borderBeforeColor]: core.String,
>+  borderBeforeStyle: core.String,
>+  [$borderBeforeStyle]: core.String,
>+  borderBeforeWidth: core.String,
>+  [$borderBeforeWidth]: core.String,
>+  borderBottom: core.String,
>+  [$borderBottom]: core.String,
>+  borderBottomColor: core.String,
>+  [$borderBottomColor]: core.String,
>+  borderBottomLeftRadius: core.String,
>+  [$borderBottomLeftRadius]: core.String,
>+  borderBottomRightRadius: core.String,
>+  [$borderBottomRightRadius]: core.String,
>+  borderBottomStyle: core.String,
>+  [$borderBottomStyle]: core.String,
>+  borderBottomWidth: core.String,
>+  [$borderBottomWidth]: core.String,
>+  borderCollapse: core.String,
>+  [$borderCollapse]: core.String,
>+  borderColor: core.String,
>+  [$borderColor]: core.String,
>+  borderEnd: core.String,
>+  [$borderEnd]: core.String,
>+  borderEndColor: core.String,
>+  [$borderEndColor]: core.String,
>+  borderEndStyle: core.String,
>+  [$borderEndStyle]: core.String,
>+  borderEndWidth: core.String,
>+  [$borderEndWidth]: core.String,
>+  borderFit: core.String,
>+  [$borderFit]: core.String,
>+  borderHorizontalSpacing: core.String,
>+  [$borderHorizontalSpacing]: core.String,
>+  borderImage: core.String,
>+  [$borderImage]: core.String,
>+  borderImageOutset: core.String,
>+  [$borderImageOutset]: core.String,
>+  borderImageRepeat: core.String,
>+  [$borderImageRepeat]: core.String,
>+  borderImageSlice: core.String,
>+  [$borderImageSlice]: core.String,
>+  borderImageSource: core.String,
>+  [$borderImageSource]: core.String,
>+  borderImageWidth: core.String,
>+  [$borderImageWidth]: core.String,
>+  borderLeft: core.String,
>+  [$borderLeft]: core.String,
>+  borderLeftColor: core.String,
>+  [$borderLeftColor]: core.String,
>+  borderLeftStyle: core.String,
>+  [$borderLeftStyle]: core.String,
>+  borderLeftWidth: core.String,
>+  [$borderLeftWidth]: core.String,
>+  borderRadius: core.String,
>+  [$borderRadius]: core.String,
>+  borderRight: core.String,
>+  [$borderRight]: core.String,
>+  borderRightColor: core.String,
>+  [$borderRightColor]: core.String,
>+  borderRightStyle: core.String,
>+  [$borderRightStyle]: core.String,
>+  borderRightWidth: core.String,
>+  [$borderRightWidth]: core.String,
>+  borderSpacing: core.String,
>+  [$borderSpacing]: core.String,
>+  borderStart: core.String,
>+  [$borderStart]: core.String,
>+  borderStartColor: core.String,
>+  [$borderStartColor]: core.String,
>+  borderStartStyle: core.String,
>+  [$borderStartStyle]: core.String,
>+  borderStartWidth: core.String,
>+  [$borderStartWidth]: core.String,
>+  borderStyle: core.String,
>+  [$borderStyle]: core.String,
>+  borderTop: core.String,
>+  [$borderTop]: core.String,
>+  borderTopColor: core.String,
>+  [$borderTopColor]: core.String,
>+  borderTopLeftRadius: core.String,
>+  [$borderTopLeftRadius]: core.String,
>+  borderTopRightRadius: core.String,
>+  [$borderTopRightRadius]: core.String,
>+  borderTopStyle: core.String,
>+  [$borderTopStyle]: core.String,
>+  borderTopWidth: core.String,
>+  [$borderTopWidth]: core.String,
>+  borderVerticalSpacing: core.String,
>+  [$borderVerticalSpacing]: core.String,
>+  borderWidth: core.String,
>+  [$borderWidth]: core.String,
>+  bottom: core.String,
>+  [$bottom]: core.String,
>+  boxAlign: core.String,
>+  [$boxAlign]: core.String,
>+  boxDecorationBreak: core.String,
>+  [$boxDecorationBreak]: core.String,
>+  boxDirection: core.String,
>+  [$boxDirection]: core.String,
>+  boxFlex: core.String,
>+  [$boxFlex]: core.String,
>+  boxFlexGroup: core.String,
>+  [$boxFlexGroup]: core.String,
>+  boxLines: core.String,
>+  [$boxLines]: core.String,
>+  boxOrdinalGroup: core.String,
>+  [$boxOrdinalGroup]: core.String,
>+  boxOrient: core.String,
>+  [$boxOrient]: core.String,
>+  boxPack: core.String,
>+  [$boxPack]: core.String,
>+  boxReflect: core.String,
>+  [$boxReflect]: core.String,
>+  boxShadow: core.String,
>+  [$boxShadow]: core.String,
>+  boxSizing: core.String,
>+  [$boxSizing]: core.String,
>+  captionSide: core.String,
>+  [$captionSide]: core.String,
>+  clear: core.String,
>+  [$clear]: core.String,
>+  clip: core.String,
>+  [$clip]: core.String,
>+  clipPath: core.String,
>+  [$clipPath]: core.String,
>+  color: core.String,
>+  [$color]: core.String,
>+  columnBreakAfter: core.String,
>+  [$columnBreakAfter]: core.String,
>+  columnBreakBefore: core.String,
>+  [$columnBreakBefore]: core.String,
>+  columnBreakInside: core.String,
>+  [$columnBreakInside]: core.String,
>+  columnCount: core.String,
>+  [$columnCount]: core.String,
>+  columnFill: core.String,
>+  [$columnFill]: core.String,
>+  columnGap: core.String,
>+  [$columnGap]: core.String,
>+  columnRule: core.String,
>+  [$columnRule]: core.String,
>+  columnRuleColor: core.String,
>+  [$columnRuleColor]: core.String,
>+  columnRuleStyle: core.String,
>+  [$columnRuleStyle]: core.String,
>+  columnRuleWidth: core.String,
>+  [$columnRuleWidth]: core.String,
>+  columnSpan: core.String,
>+  [$columnSpan]: core.String,
>+  columnWidth: core.String,
>+  [$columnWidth]: core.String,
>+  columns: core.String,
>+  [$columns]: core.String,
>+  content: core.String,
>+  [$content]: core.String,
>+  counterIncrement: core.String,
>+  [$counterIncrement]: core.String,
>+  counterReset: core.String,
>+  [$counterReset]: core.String,
>+  cursor: core.String,
>+  [$cursor]: core.String,
>+  direction: core.String,
>+  [$direction]: core.String,
>+  display: core.String,
>+  [$display]: core.String,
>+  emptyCells: core.String,
>+  [$emptyCells]: core.String,
>+  filter: core.String,
>+  [$filter]: core.String,
>+  flex: core.String,
>+  [$flex]: core.String,
>+  flexBasis: core.String,
>+  [$flexBasis]: core.String,
>+  flexDirection: core.String,
>+  [$flexDirection]: core.String,
>+  flexFlow: core.String,
>+  [$flexFlow]: core.String,
>+  flexGrow: core.String,
>+  [$flexGrow]: core.String,
>+  flexShrink: core.String,
>+  [$flexShrink]: core.String,
>+  flexWrap: core.String,
>+  [$flexWrap]: core.String,
>+  float: core.String,
>+  [$float]: core.String,
>+  font: core.String,
>+  [$font]: core.String,
>+  fontFamily: core.String,
>+  [$fontFamily]: core.String,
>+  fontFeatureSettings: core.String,
>+  [$fontFeatureSettings]: core.String,
>+  fontKerning: core.String,
>+  [$fontKerning]: core.String,
>+  fontSize: core.String,
>+  [$fontSize]: core.String,
>+  fontSizeDelta: core.String,
>+  [$fontSizeDelta]: core.String,
>+  fontSmoothing: core.String,
>+  [$fontSmoothing]: core.String,
>+  fontStretch: core.String,
>+  [$fontStretch]: core.String,
>+  fontStyle: core.String,
>+  [$fontStyle]: core.String,
>+  fontVariant: core.String,
>+  [$fontVariant]: core.String,
>+  fontVariantLigatures: core.String,
>+  [$fontVariantLigatures]: core.String,
>+  fontWeight: core.String,
>+  [$fontWeight]: core.String,
>+  grid: core.String,
>+  [$grid]: core.String,
>+  gridArea: core.String,
>+  [$gridArea]: core.String,
>+  gridAutoColumns: core.String,
>+  [$gridAutoColumns]: core.String,
>+  gridAutoFlow: core.String,
>+  [$gridAutoFlow]: core.String,
>+  gridAutoRows: core.String,
>+  [$gridAutoRows]: core.String,
>+  gridColumn: core.String,
>+  [$gridColumn]: core.String,
>+  gridColumnEnd: core.String,
>+  [$gridColumnEnd]: core.String,
>+  gridColumnStart: core.String,
>+  [$gridColumnStart]: core.String,
>+  gridRow: core.String,
>+  [$gridRow]: core.String,
>+  gridRowEnd: core.String,
>+  [$gridRowEnd]: core.String,
>+  gridRowStart: core.String,
>+  [$gridRowStart]: core.String,
>+  gridTemplate: core.String,
>+  [$gridTemplate]: core.String,
>+  gridTemplateAreas: core.String,
>+  [$gridTemplateAreas]: core.String,
>+  gridTemplateColumns: core.String,
>+  [$gridTemplateColumns]: core.String,
>+  gridTemplateRows: core.String,
>+  [$gridTemplateRows]: core.String,
>+  height: core.String,
>+  [$height]: core.String,
>+  highlight: core.String,
>+  [$highlight]: core.String,
>+  hyphenateCharacter: core.String,
>+  [$hyphenateCharacter]: core.String,
>+  imageRendering: core.String,
>+  [$imageRendering]: core.String,
>+  isolation: core.String,
>+  [$isolation]: core.String,
>+  justifyContent: core.String,
>+  [$justifyContent]: core.String,
>+  justifySelf: core.String,
>+  [$justifySelf]: core.String,
>+  left: core.String,
>+  [$left]: core.String,
>+  letterSpacing: core.String,
>+  [$letterSpacing]: core.String,
>+  lineBoxContain: core.String,
>+  [$lineBoxContain]: core.String,
>+  lineBreak: core.String,
>+  [$lineBreak]: core.String,
>+  lineClamp: core.String,
>+  [$lineClamp]: core.String,
>+  lineHeight: core.String,
>+  [$lineHeight]: core.String,
>+  listStyle: core.String,
>+  [$listStyle]: core.String,
>+  listStyleImage: core.String,
>+  [$listStyleImage]: core.String,
>+  listStylePosition: core.String,
>+  [$listStylePosition]: core.String,
>+  listStyleType: core.String,
>+  [$listStyleType]: core.String,
>+  locale: core.String,
>+  [$locale]: core.String,
>+  logicalHeight: core.String,
>+  [$logicalHeight]: core.String,
>+  logicalWidth: core.String,
>+  [$logicalWidth]: core.String,
>+  margin: core.String,
>+  [$margin]: core.String,
>+  marginAfter: core.String,
>+  [$marginAfter]: core.String,
>+  marginAfterCollapse: core.String,
>+  [$marginAfterCollapse]: core.String,
>+  marginBefore: core.String,
>+  [$marginBefore]: core.String,
>+  marginBeforeCollapse: core.String,
>+  [$marginBeforeCollapse]: core.String,
>+  marginBottom: core.String,
>+  [$marginBottom]: core.String,
>+  marginBottomCollapse: core.String,
>+  [$marginBottomCollapse]: core.String,
>+  marginCollapse: core.String,
>+  [$marginCollapse]: core.String,
>+  marginEnd: core.String,
>+  [$marginEnd]: core.String,
>+  marginLeft: core.String,
>+  [$marginLeft]: core.String,
>+  marginRight: core.String,
>+  [$marginRight]: core.String,
>+  marginStart: core.String,
>+  [$marginStart]: core.String,
>+  marginTop: core.String,
>+  [$marginTop]: core.String,
>+  marginTopCollapse: core.String,
>+  [$marginTopCollapse]: core.String,
>+  mask: core.String,
>+  [$mask]: core.String,
>+  maskBoxImage: core.String,
>+  [$maskBoxImage]: core.String,
>+  maskBoxImageOutset: core.String,
>+  [$maskBoxImageOutset]: core.String,
>+  maskBoxImageRepeat: core.String,
>+  [$maskBoxImageRepeat]: core.String,
>+  maskBoxImageSlice: core.String,
>+  [$maskBoxImageSlice]: core.String,
>+  maskBoxImageSource: core.String,
>+  [$maskBoxImageSource]: core.String,
>+  maskBoxImageWidth: core.String,
>+  [$maskBoxImageWidth]: core.String,
>+  maskClip: core.String,
>+  [$maskClip]: core.String,
>+  maskComposite: core.String,
>+  [$maskComposite]: core.String,
>+  maskImage: core.String,
>+  [$maskImage]: core.String,
>+  maskOrigin: core.String,
>+  [$maskOrigin]: core.String,
>+  maskPosition: core.String,
>+  [$maskPosition]: core.String,
>+  maskPositionX: core.String,
>+  [$maskPositionX]: core.String,
>+  maskPositionY: core.String,
>+  [$maskPositionY]: core.String,
>+  maskRepeat: core.String,
>+  [$maskRepeat]: core.String,
>+  maskRepeatX: core.String,
>+  [$maskRepeatX]: core.String,
>+  maskRepeatY: core.String,
>+  [$maskRepeatY]: core.String,
>+  maskSize: core.String,
>+  [$maskSize]: core.String,
>+  maskSourceType: core.String,
>+  [$maskSourceType]: core.String,
>+  maxHeight: core.String,
>+  [$maxHeight]: core.String,
>+  maxLogicalHeight: core.String,
>+  [$maxLogicalHeight]: core.String,
>+  maxLogicalWidth: core.String,
>+  [$maxLogicalWidth]: core.String,
>+  maxWidth: core.String,
>+  [$maxWidth]: core.String,
>+  maxZoom: core.String,
>+  [$maxZoom]: core.String,
>+  minHeight: core.String,
>+  [$minHeight]: core.String,
>+  minLogicalHeight: core.String,
>+  [$minLogicalHeight]: core.String,
>+  minLogicalWidth: core.String,
>+  [$minLogicalWidth]: core.String,
>+  minWidth: core.String,
>+  [$minWidth]: core.String,
>+  minZoom: core.String,
>+  [$minZoom]: core.String,
>+  mixBlendMode: core.String,
>+  [$mixBlendMode]: core.String,
>+  objectFit: core.String,
>+  [$objectFit]: core.String,
>+  objectPosition: core.String,
>+  [$objectPosition]: core.String,
>+  opacity: core.String,
>+  [$opacity]: core.String,
>+  order: core.String,
>+  [$order]: core.String,
>+  orientation: core.String,
>+  [$orientation]: core.String,
>+  orphans: core.String,
>+  [$orphans]: core.String,
>+  outline: core.String,
>+  [$outline]: core.String,
>+  outlineColor: core.String,
>+  [$outlineColor]: core.String,
>+  outlineOffset: core.String,
>+  [$outlineOffset]: core.String,
>+  outlineStyle: core.String,
>+  [$outlineStyle]: core.String,
>+  outlineWidth: core.String,
>+  [$outlineWidth]: core.String,
>+  overflow: core.String,
>+  [$overflow]: core.String,
>+  overflowWrap: core.String,
>+  [$overflowWrap]: core.String,
>+  overflowX: core.String,
>+  [$overflowX]: core.String,
>+  overflowY: core.String,
>+  [$overflowY]: core.String,
>+  padding: core.String,
>+  [$padding]: core.String,
>+  paddingAfter: core.String,
>+  [$paddingAfter]: core.String,
>+  paddingBefore: core.String,
>+  [$paddingBefore]: core.String,
>+  paddingBottom: core.String,
>+  [$paddingBottom]: core.String,
>+  paddingEnd: core.String,
>+  [$paddingEnd]: core.String,
>+  paddingLeft: core.String,
>+  [$paddingLeft]: core.String,
>+  paddingRight: core.String,
>+  [$paddingRight]: core.String,
>+  paddingStart: core.String,
>+  [$paddingStart]: core.String,
>+  paddingTop: core.String,
>+  [$paddingTop]: core.String,
>+  page: core.String,
>+  [$page]: core.String,
>+  pageBreakAfter: core.String,
>+  [$pageBreakAfter]: core.String,
>+  pageBreakBefore: core.String,
>+  [$pageBreakBefore]: core.String,
>+  pageBreakInside: core.String,
>+  [$pageBreakInside]: core.String,
>+  perspective: core.String,
>+  [$perspective]: core.String,
>+  perspectiveOrigin: core.String,
>+  [$perspectiveOrigin]: core.String,
>+  perspectiveOriginX: core.String,
>+  [$perspectiveOriginX]: core.String,
>+  perspectiveOriginY: core.String,
>+  [$perspectiveOriginY]: core.String,
>+  pointerEvents: core.String,
>+  [$pointerEvents]: core.String,
>+  position: core.String,
>+  [$position]: core.String,
>+  printColorAdjust: core.String,
>+  [$printColorAdjust]: core.String,
>+  quotes: core.String,
>+  [$quotes]: core.String,
>+  resize: core.String,
>+  [$resize]: core.String,
>+  right: core.String,
>+  [$right]: core.String,
>+  rtlOrdering: core.String,
>+  [$rtlOrdering]: core.String,
>+  rubyPosition: core.String,
>+  [$rubyPosition]: core.String,
>+  scrollBehavior: core.String,
>+  [$scrollBehavior]: core.String,
>+  shapeImageThreshold: core.String,
>+  [$shapeImageThreshold]: core.String,
>+  shapeMargin: core.String,
>+  [$shapeMargin]: core.String,
>+  shapeOutside: core.String,
>+  [$shapeOutside]: core.String,
>+  size: core.String,
>+  [$size]: core.String,
>+  speak: core.String,
>+  [$speak]: core.String,
>+  src: core.String,
>+  [$src]: core.String,
>+  tabSize: core.String,
>+  [$tabSize]: core.String,
>+  tableLayout: core.String,
>+  [$tableLayout]: core.String,
>+  tapHighlightColor: core.String,
>+  [$tapHighlightColor]: core.String,
>+  textAlign: core.String,
>+  [$textAlign]: core.String,
>+  textAlignLast: core.String,
>+  [$textAlignLast]: core.String,
>+  textCombine: core.String,
>+  [$textCombine]: core.String,
>+  textDecoration: core.String,
>+  [$textDecoration]: core.String,
>+  textDecorationColor: core.String,
>+  [$textDecorationColor]: core.String,
>+  textDecorationLine: core.String,
>+  [$textDecorationLine]: core.String,
>+  textDecorationStyle: core.String,
>+  [$textDecorationStyle]: core.String,
>+  textDecorationsInEffect: core.String,
>+  [$textDecorationsInEffect]: core.String,
>+  textEmphasis: core.String,
>+  [$textEmphasis]: core.String,
>+  textEmphasisColor: core.String,
>+  [$textEmphasisColor]: core.String,
>+  textEmphasisPosition: core.String,
>+  [$textEmphasisPosition]: core.String,
>+  textEmphasisStyle: core.String,
>+  [$textEmphasisStyle]: core.String,
>+  textFillColor: core.String,
>+  [$textFillColor]: core.String,
>+  textIndent: core.String,
>+  [$textIndent]: core.String,
>+  textJustify: core.String,
>+  [$textJustify]: core.String,
>+  textLineThroughColor: core.String,
>+  [$textLineThroughColor]: core.String,
>+  textLineThroughMode: core.String,
>+  [$textLineThroughMode]: core.String,
>+  textLineThroughStyle: core.String,
>+  [$textLineThroughStyle]: core.String,
>+  textLineThroughWidth: core.String,
>+  [$textLineThroughWidth]: core.String,
>+  textOrientation: core.String,
>+  [$textOrientation]: core.String,
>+  textOverflow: core.String,
>+  [$textOverflow]: core.String,
>+  textOverlineColor: core.String,
>+  [$textOverlineColor]: core.String,
>+  textOverlineMode: core.String,
>+  [$textOverlineMode]: core.String,
>+  textOverlineStyle: core.String,
>+  [$textOverlineStyle]: core.String,
>+  textOverlineWidth: core.String,
>+  [$textOverlineWidth]: core.String,
>+  textRendering: core.String,
>+  [$textRendering]: core.String,
>+  textSecurity: core.String,
>+  [$textSecurity]: core.String,
>+  textShadow: core.String,
>+  [$textShadow]: core.String,
>+  textStroke: core.String,
>+  [$textStroke]: core.String,
>+  textStrokeColor: core.String,
>+  [$textStrokeColor]: core.String,
>+  textStrokeWidth: core.String,
>+  [$textStrokeWidth]: core.String,
>+  textTransform: core.String,
>+  [$textTransform]: core.String,
>+  textUnderlineColor: core.String,
>+  [$textUnderlineColor]: core.String,
>+  textUnderlineMode: core.String,
>+  [$textUnderlineMode]: core.String,
>+  textUnderlinePosition: core.String,
>+  [$textUnderlinePosition]: core.String,
>+  textUnderlineStyle: core.String,
>+  [$textUnderlineStyle]: core.String,
>+  textUnderlineWidth: core.String,
>+  [$textUnderlineWidth]: core.String,
>+  top: core.String,
>+  [$top]: core.String,
>+  touchAction: core.String,
>+  [$touchAction]: core.String,
>+  touchActionDelay: core.String,
>+  [$touchActionDelay]: core.String,
>+  transform: core.String,
>+  [$transform]: core.String,
>+  transformOrigin: core.String,
>+  [$transformOrigin]: core.String,
>+  transformOriginX: core.String,
>+  [$transformOriginX]: core.String,
>+  transformOriginY: core.String,
>+  [$transformOriginY]: core.String,
>+  transformOriginZ: core.String,
>+  [$transformOriginZ]: core.String,
>+  transformStyle: core.String,
>+  [$transformStyle]: core.String,
>+  transition: core.String,
>+  [$transition]: core.String,
>+  transitionDelay: core.String,
>+  [$transitionDelay]: core.String,
>+  transitionDuration: core.String,
>+  [$transitionDuration]: core.String,
>+  transitionProperty: core.String,
>+  [$transitionProperty]: core.String,
>+  transitionTimingFunction: core.String,
>+  [$transitionTimingFunction]: core.String,
>+  unicodeBidi: core.String,
>+  [$unicodeBidi]: core.String,
>+  unicodeRange: core.String,
>+  [$unicodeRange]: core.String,
>+  userDrag: core.String,
>+  [$userDrag]: core.String,
>+  userModify: core.String,
>+  [$userModify]: core.String,
>+  userSelect: core.String,
>+  [$userSelect]: core.String,
>+  userZoom: core.String,
>+  [$userZoom]: core.String,
>+  verticalAlign: core.String,
>+  [$verticalAlign]: core.String,
>+  visibility: core.String,
>+  [$visibility]: core.String,
>+  whiteSpace: core.String,
>+  [$whiteSpace]: core.String,
>+  widows: core.String,
>+  [$widows]: core.String,
>+  width: core.String,
>+  [$width]: core.String,
>+  willChange: core.String,
>+  [$willChange]: core.String,
>+  wordBreak: core.String,
>+  [$wordBreak]: core.String,
>+  wordSpacing: core.String,
>+  [$wordSpacing]: core.String,
>+  wordWrap: core.String,
>+  [$wordWrap]: core.String,
>+  wrapFlow: core.String,
>+  [$wrapFlow]: core.String,
>+  wrapThrough: core.String,
>+  [$wrapThrough]: core.String,
>+  writingMode: core.String,
>+  [$writingMode]: core.String,
>+  zIndex: core.String,
>+  [$zIndex]: core.String,
>+  zoom: core.String,
>+  [$zoom]: core.String
>+}));
>+dart.setSetterSignature(html$.CssStyleDeclarationBase, () => ({
>+  __proto__: dart.getSetters(html$.CssStyleDeclarationBase.__proto__),
>+  alignContent: core.String,
>+  [$alignContent]: core.String,
>+  alignItems: core.String,
>+  [$alignItems]: core.String,
>+  alignSelf: core.String,
>+  [$alignSelf]: core.String,
>+  animation: core.String,
>+  [$animation]: core.String,
>+  animationDelay: core.String,
>+  [$animationDelay]: core.String,
>+  animationDirection: core.String,
>+  [$animationDirection]: core.String,
>+  animationDuration: core.String,
>+  [$animationDuration]: core.String,
>+  animationFillMode: core.String,
>+  [$animationFillMode]: core.String,
>+  animationIterationCount: core.String,
>+  [$animationIterationCount]: core.String,
>+  animationName: core.String,
>+  [$animationName]: core.String,
>+  animationPlayState: core.String,
>+  [$animationPlayState]: core.String,
>+  animationTimingFunction: core.String,
>+  [$animationTimingFunction]: core.String,
>+  appRegion: core.String,
>+  [$appRegion]: core.String,
>+  appearance: core.String,
>+  [$appearance]: core.String,
>+  aspectRatio: core.String,
>+  [$aspectRatio]: core.String,
>+  backfaceVisibility: core.String,
>+  [$backfaceVisibility]: core.String,
>+  background: core.String,
>+  [$background]: core.String,
>+  backgroundAttachment: core.String,
>+  [$backgroundAttachment]: core.String,
>+  backgroundBlendMode: core.String,
>+  [$backgroundBlendMode]: core.String,
>+  backgroundClip: core.String,
>+  [$backgroundClip]: core.String,
>+  backgroundColor: core.String,
>+  [$backgroundColor]: core.String,
>+  backgroundComposite: core.String,
>+  [$backgroundComposite]: core.String,
>+  backgroundImage: core.String,
>+  [$backgroundImage]: core.String,
>+  backgroundOrigin: core.String,
>+  [$backgroundOrigin]: core.String,
>+  backgroundPosition: core.String,
>+  [$backgroundPosition]: core.String,
>+  backgroundPositionX: core.String,
>+  [$backgroundPositionX]: core.String,
>+  backgroundPositionY: core.String,
>+  [$backgroundPositionY]: core.String,
>+  backgroundRepeat: core.String,
>+  [$backgroundRepeat]: core.String,
>+  backgroundRepeatX: core.String,
>+  [$backgroundRepeatX]: core.String,
>+  backgroundRepeatY: core.String,
>+  [$backgroundRepeatY]: core.String,
>+  backgroundSize: core.String,
>+  [$backgroundSize]: core.String,
>+  border: core.String,
>+  [$border]: core.String,
>+  borderAfter: core.String,
>+  [$borderAfter]: core.String,
>+  borderAfterColor: core.String,
>+  [$borderAfterColor]: core.String,
>+  borderAfterStyle: core.String,
>+  [$borderAfterStyle]: core.String,
>+  borderAfterWidth: core.String,
>+  [$borderAfterWidth]: core.String,
>+  borderBefore: core.String,
>+  [$borderBefore]: core.String,
>+  borderBeforeColor: core.String,
>+  [$borderBeforeColor]: core.String,
>+  borderBeforeStyle: core.String,
>+  [$borderBeforeStyle]: core.String,
>+  borderBeforeWidth: core.String,
>+  [$borderBeforeWidth]: core.String,
>+  borderBottom: core.String,
>+  [$borderBottom]: core.String,
>+  borderBottomColor: core.String,
>+  [$borderBottomColor]: core.String,
>+  borderBottomLeftRadius: core.String,
>+  [$borderBottomLeftRadius]: core.String,
>+  borderBottomRightRadius: core.String,
>+  [$borderBottomRightRadius]: core.String,
>+  borderBottomStyle: core.String,
>+  [$borderBottomStyle]: core.String,
>+  borderBottomWidth: core.String,
>+  [$borderBottomWidth]: core.String,
>+  borderCollapse: core.String,
>+  [$borderCollapse]: core.String,
>+  borderColor: core.String,
>+  [$borderColor]: core.String,
>+  borderEnd: core.String,
>+  [$borderEnd]: core.String,
>+  borderEndColor: core.String,
>+  [$borderEndColor]: core.String,
>+  borderEndStyle: core.String,
>+  [$borderEndStyle]: core.String,
>+  borderEndWidth: core.String,
>+  [$borderEndWidth]: core.String,
>+  borderFit: core.String,
>+  [$borderFit]: core.String,
>+  borderHorizontalSpacing: core.String,
>+  [$borderHorizontalSpacing]: core.String,
>+  borderImage: core.String,
>+  [$borderImage]: core.String,
>+  borderImageOutset: core.String,
>+  [$borderImageOutset]: core.String,
>+  borderImageRepeat: core.String,
>+  [$borderImageRepeat]: core.String,
>+  borderImageSlice: core.String,
>+  [$borderImageSlice]: core.String,
>+  borderImageSource: core.String,
>+  [$borderImageSource]: core.String,
>+  borderImageWidth: core.String,
>+  [$borderImageWidth]: core.String,
>+  borderLeft: core.String,
>+  [$borderLeft]: core.String,
>+  borderLeftColor: core.String,
>+  [$borderLeftColor]: core.String,
>+  borderLeftStyle: core.String,
>+  [$borderLeftStyle]: core.String,
>+  borderLeftWidth: core.String,
>+  [$borderLeftWidth]: core.String,
>+  borderRadius: core.String,
>+  [$borderRadius]: core.String,
>+  borderRight: core.String,
>+  [$borderRight]: core.String,
>+  borderRightColor: core.String,
>+  [$borderRightColor]: core.String,
>+  borderRightStyle: core.String,
>+  [$borderRightStyle]: core.String,
>+  borderRightWidth: core.String,
>+  [$borderRightWidth]: core.String,
>+  borderSpacing: core.String,
>+  [$borderSpacing]: core.String,
>+  borderStart: core.String,
>+  [$borderStart]: core.String,
>+  borderStartColor: core.String,
>+  [$borderStartColor]: core.String,
>+  borderStartStyle: core.String,
>+  [$borderStartStyle]: core.String,
>+  borderStartWidth: core.String,
>+  [$borderStartWidth]: core.String,
>+  borderStyle: core.String,
>+  [$borderStyle]: core.String,
>+  borderTop: core.String,
>+  [$borderTop]: core.String,
>+  borderTopColor: core.String,
>+  [$borderTopColor]: core.String,
>+  borderTopLeftRadius: core.String,
>+  [$borderTopLeftRadius]: core.String,
>+  borderTopRightRadius: core.String,
>+  [$borderTopRightRadius]: core.String,
>+  borderTopStyle: core.String,
>+  [$borderTopStyle]: core.String,
>+  borderTopWidth: core.String,
>+  [$borderTopWidth]: core.String,
>+  borderVerticalSpacing: core.String,
>+  [$borderVerticalSpacing]: core.String,
>+  borderWidth: core.String,
>+  [$borderWidth]: core.String,
>+  bottom: core.String,
>+  [$bottom]: core.String,
>+  boxAlign: core.String,
>+  [$boxAlign]: core.String,
>+  boxDecorationBreak: core.String,
>+  [$boxDecorationBreak]: core.String,
>+  boxDirection: core.String,
>+  [$boxDirection]: core.String,
>+  boxFlex: core.String,
>+  [$boxFlex]: core.String,
>+  boxFlexGroup: core.String,
>+  [$boxFlexGroup]: core.String,
>+  boxLines: core.String,
>+  [$boxLines]: core.String,
>+  boxOrdinalGroup: core.String,
>+  [$boxOrdinalGroup]: core.String,
>+  boxOrient: core.String,
>+  [$boxOrient]: core.String,
>+  boxPack: core.String,
>+  [$boxPack]: core.String,
>+  boxReflect: core.String,
>+  [$boxReflect]: core.String,
>+  boxShadow: core.String,
>+  [$boxShadow]: core.String,
>+  boxSizing: core.String,
>+  [$boxSizing]: core.String,
>+  captionSide: core.String,
>+  [$captionSide]: core.String,
>+  clear: core.String,
>+  [$clear]: core.String,
>+  clip: core.String,
>+  [$clip]: core.String,
>+  clipPath: core.String,
>+  [$clipPath]: core.String,
>+  color: core.String,
>+  [$color]: core.String,
>+  columnBreakAfter: core.String,
>+  [$columnBreakAfter]: core.String,
>+  columnBreakBefore: core.String,
>+  [$columnBreakBefore]: core.String,
>+  columnBreakInside: core.String,
>+  [$columnBreakInside]: core.String,
>+  columnCount: core.String,
>+  [$columnCount]: core.String,
>+  columnFill: core.String,
>+  [$columnFill]: core.String,
>+  columnGap: core.String,
>+  [$columnGap]: core.String,
>+  columnRule: core.String,
>+  [$columnRule]: core.String,
>+  columnRuleColor: core.String,
>+  [$columnRuleColor]: core.String,
>+  columnRuleStyle: core.String,
>+  [$columnRuleStyle]: core.String,
>+  columnRuleWidth: core.String,
>+  [$columnRuleWidth]: core.String,
>+  columnSpan: core.String,
>+  [$columnSpan]: core.String,
>+  columnWidth: core.String,
>+  [$columnWidth]: core.String,
>+  columns: core.String,
>+  [$columns]: core.String,
>+  content: core.String,
>+  [$content]: core.String,
>+  counterIncrement: core.String,
>+  [$counterIncrement]: core.String,
>+  counterReset: core.String,
>+  [$counterReset]: core.String,
>+  cursor: core.String,
>+  [$cursor]: core.String,
>+  direction: core.String,
>+  [$direction]: core.String,
>+  display: core.String,
>+  [$display]: core.String,
>+  emptyCells: core.String,
>+  [$emptyCells]: core.String,
>+  filter: core.String,
>+  [$filter]: core.String,
>+  flex: core.String,
>+  [$flex]: core.String,
>+  flexBasis: core.String,
>+  [$flexBasis]: core.String,
>+  flexDirection: core.String,
>+  [$flexDirection]: core.String,
>+  flexFlow: core.String,
>+  [$flexFlow]: core.String,
>+  flexGrow: core.String,
>+  [$flexGrow]: core.String,
>+  flexShrink: core.String,
>+  [$flexShrink]: core.String,
>+  flexWrap: core.String,
>+  [$flexWrap]: core.String,
>+  float: core.String,
>+  [$float]: core.String,
>+  font: core.String,
>+  [$font]: core.String,
>+  fontFamily: core.String,
>+  [$fontFamily]: core.String,
>+  fontFeatureSettings: core.String,
>+  [$fontFeatureSettings]: core.String,
>+  fontKerning: core.String,
>+  [$fontKerning]: core.String,
>+  fontSize: core.String,
>+  [$fontSize]: core.String,
>+  fontSizeDelta: core.String,
>+  [$fontSizeDelta]: core.String,
>+  fontSmoothing: core.String,
>+  [$fontSmoothing]: core.String,
>+  fontStretch: core.String,
>+  [$fontStretch]: core.String,
>+  fontStyle: core.String,
>+  [$fontStyle]: core.String,
>+  fontVariant: core.String,
>+  [$fontVariant]: core.String,
>+  fontVariantLigatures: core.String,
>+  [$fontVariantLigatures]: core.String,
>+  fontWeight: core.String,
>+  [$fontWeight]: core.String,
>+  grid: core.String,
>+  [$grid]: core.String,
>+  gridArea: core.String,
>+  [$gridArea]: core.String,
>+  gridAutoColumns: core.String,
>+  [$gridAutoColumns]: core.String,
>+  gridAutoFlow: core.String,
>+  [$gridAutoFlow]: core.String,
>+  gridAutoRows: core.String,
>+  [$gridAutoRows]: core.String,
>+  gridColumn: core.String,
>+  [$gridColumn]: core.String,
>+  gridColumnEnd: core.String,
>+  [$gridColumnEnd]: core.String,
>+  gridColumnStart: core.String,
>+  [$gridColumnStart]: core.String,
>+  gridRow: core.String,
>+  [$gridRow]: core.String,
>+  gridRowEnd: core.String,
>+  [$gridRowEnd]: core.String,
>+  gridRowStart: core.String,
>+  [$gridRowStart]: core.String,
>+  gridTemplate: core.String,
>+  [$gridTemplate]: core.String,
>+  gridTemplateAreas: core.String,
>+  [$gridTemplateAreas]: core.String,
>+  gridTemplateColumns: core.String,
>+  [$gridTemplateColumns]: core.String,
>+  gridTemplateRows: core.String,
>+  [$gridTemplateRows]: core.String,
>+  height: core.String,
>+  [$height]: core.String,
>+  highlight: core.String,
>+  [$highlight]: core.String,
>+  hyphenateCharacter: core.String,
>+  [$hyphenateCharacter]: core.String,
>+  imageRendering: core.String,
>+  [$imageRendering]: core.String,
>+  isolation: core.String,
>+  [$isolation]: core.String,
>+  justifyContent: core.String,
>+  [$justifyContent]: core.String,
>+  justifySelf: core.String,
>+  [$justifySelf]: core.String,
>+  left: core.String,
>+  [$left]: core.String,
>+  letterSpacing: core.String,
>+  [$letterSpacing]: core.String,
>+  lineBoxContain: core.String,
>+  [$lineBoxContain]: core.String,
>+  lineBreak: core.String,
>+  [$lineBreak]: core.String,
>+  lineClamp: core.String,
>+  [$lineClamp]: core.String,
>+  lineHeight: core.String,
>+  [$lineHeight]: core.String,
>+  listStyle: core.String,
>+  [$listStyle]: core.String,
>+  listStyleImage: core.String,
>+  [$listStyleImage]: core.String,
>+  listStylePosition: core.String,
>+  [$listStylePosition]: core.String,
>+  listStyleType: core.String,
>+  [$listStyleType]: core.String,
>+  locale: core.String,
>+  [$locale]: core.String,
>+  logicalHeight: core.String,
>+  [$logicalHeight]: core.String,
>+  logicalWidth: core.String,
>+  [$logicalWidth]: core.String,
>+  margin: core.String,
>+  [$margin]: core.String,
>+  marginAfter: core.String,
>+  [$marginAfter]: core.String,
>+  marginAfterCollapse: core.String,
>+  [$marginAfterCollapse]: core.String,
>+  marginBefore: core.String,
>+  [$marginBefore]: core.String,
>+  marginBeforeCollapse: core.String,
>+  [$marginBeforeCollapse]: core.String,
>+  marginBottom: core.String,
>+  [$marginBottom]: core.String,
>+  marginBottomCollapse: core.String,
>+  [$marginBottomCollapse]: core.String,
>+  marginCollapse: core.String,
>+  [$marginCollapse]: core.String,
>+  marginEnd: core.String,
>+  [$marginEnd]: core.String,
>+  marginLeft: core.String,
>+  [$marginLeft]: core.String,
>+  marginRight: core.String,
>+  [$marginRight]: core.String,
>+  marginStart: core.String,
>+  [$marginStart]: core.String,
>+  marginTop: core.String,
>+  [$marginTop]: core.String,
>+  marginTopCollapse: core.String,
>+  [$marginTopCollapse]: core.String,
>+  mask: core.String,
>+  [$mask]: core.String,
>+  maskBoxImage: core.String,
>+  [$maskBoxImage]: core.String,
>+  maskBoxImageOutset: core.String,
>+  [$maskBoxImageOutset]: core.String,
>+  maskBoxImageRepeat: core.String,
>+  [$maskBoxImageRepeat]: core.String,
>+  maskBoxImageSlice: core.String,
>+  [$maskBoxImageSlice]: core.String,
>+  maskBoxImageSource: core.String,
>+  [$maskBoxImageSource]: core.String,
>+  maskBoxImageWidth: core.String,
>+  [$maskBoxImageWidth]: core.String,
>+  maskClip: core.String,
>+  [$maskClip]: core.String,
>+  maskComposite: core.String,
>+  [$maskComposite]: core.String,
>+  maskImage: core.String,
>+  [$maskImage]: core.String,
>+  maskOrigin: core.String,
>+  [$maskOrigin]: core.String,
>+  maskPosition: core.String,
>+  [$maskPosition]: core.String,
>+  maskPositionX: core.String,
>+  [$maskPositionX]: core.String,
>+  maskPositionY: core.String,
>+  [$maskPositionY]: core.String,
>+  maskRepeat: core.String,
>+  [$maskRepeat]: core.String,
>+  maskRepeatX: core.String,
>+  [$maskRepeatX]: core.String,
>+  maskRepeatY: core.String,
>+  [$maskRepeatY]: core.String,
>+  maskSize: core.String,
>+  [$maskSize]: core.String,
>+  maskSourceType: core.String,
>+  [$maskSourceType]: core.String,
>+  maxHeight: core.String,
>+  [$maxHeight]: core.String,
>+  maxLogicalHeight: core.String,
>+  [$maxLogicalHeight]: core.String,
>+  maxLogicalWidth: core.String,
>+  [$maxLogicalWidth]: core.String,
>+  maxWidth: core.String,
>+  [$maxWidth]: core.String,
>+  maxZoom: core.String,
>+  [$maxZoom]: core.String,
>+  minHeight: core.String,
>+  [$minHeight]: core.String,
>+  minLogicalHeight: core.String,
>+  [$minLogicalHeight]: core.String,
>+  minLogicalWidth: core.String,
>+  [$minLogicalWidth]: core.String,
>+  minWidth: core.String,
>+  [$minWidth]: core.String,
>+  minZoom: core.String,
>+  [$minZoom]: core.String,
>+  mixBlendMode: core.String,
>+  [$mixBlendMode]: core.String,
>+  objectFit: core.String,
>+  [$objectFit]: core.String,
>+  objectPosition: core.String,
>+  [$objectPosition]: core.String,
>+  opacity: core.String,
>+  [$opacity]: core.String,
>+  order: core.String,
>+  [$order]: core.String,
>+  orientation: core.String,
>+  [$orientation]: core.String,
>+  orphans: core.String,
>+  [$orphans]: core.String,
>+  outline: core.String,
>+  [$outline]: core.String,
>+  outlineColor: core.String,
>+  [$outlineColor]: core.String,
>+  outlineOffset: core.String,
>+  [$outlineOffset]: core.String,
>+  outlineStyle: core.String,
>+  [$outlineStyle]: core.String,
>+  outlineWidth: core.String,
>+  [$outlineWidth]: core.String,
>+  overflow: core.String,
>+  [$overflow]: core.String,
>+  overflowWrap: core.String,
>+  [$overflowWrap]: core.String,
>+  overflowX: core.String,
>+  [$overflowX]: core.String,
>+  overflowY: core.String,
>+  [$overflowY]: core.String,
>+  padding: core.String,
>+  [$padding]: core.String,
>+  paddingAfter: core.String,
>+  [$paddingAfter]: core.String,
>+  paddingBefore: core.String,
>+  [$paddingBefore]: core.String,
>+  paddingBottom: core.String,
>+  [$paddingBottom]: core.String,
>+  paddingEnd: core.String,
>+  [$paddingEnd]: core.String,
>+  paddingLeft: core.String,
>+  [$paddingLeft]: core.String,
>+  paddingRight: core.String,
>+  [$paddingRight]: core.String,
>+  paddingStart: core.String,
>+  [$paddingStart]: core.String,
>+  paddingTop: core.String,
>+  [$paddingTop]: core.String,
>+  page: core.String,
>+  [$page]: core.String,
>+  pageBreakAfter: core.String,
>+  [$pageBreakAfter]: core.String,
>+  pageBreakBefore: core.String,
>+  [$pageBreakBefore]: core.String,
>+  pageBreakInside: core.String,
>+  [$pageBreakInside]: core.String,
>+  perspective: core.String,
>+  [$perspective]: core.String,
>+  perspectiveOrigin: core.String,
>+  [$perspectiveOrigin]: core.String,
>+  perspectiveOriginX: core.String,
>+  [$perspectiveOriginX]: core.String,
>+  perspectiveOriginY: core.String,
>+  [$perspectiveOriginY]: core.String,
>+  pointerEvents: core.String,
>+  [$pointerEvents]: core.String,
>+  position: core.String,
>+  [$position]: core.String,
>+  printColorAdjust: core.String,
>+  [$printColorAdjust]: core.String,
>+  quotes: core.String,
>+  [$quotes]: core.String,
>+  resize: core.String,
>+  [$resize]: core.String,
>+  right: core.String,
>+  [$right]: core.String,
>+  rtlOrdering: core.String,
>+  [$rtlOrdering]: core.String,
>+  rubyPosition: core.String,
>+  [$rubyPosition]: core.String,
>+  scrollBehavior: core.String,
>+  [$scrollBehavior]: core.String,
>+  shapeImageThreshold: core.String,
>+  [$shapeImageThreshold]: core.String,
>+  shapeMargin: core.String,
>+  [$shapeMargin]: core.String,
>+  shapeOutside: core.String,
>+  [$shapeOutside]: core.String,
>+  size: core.String,
>+  [$size]: core.String,
>+  speak: core.String,
>+  [$speak]: core.String,
>+  src: core.String,
>+  [$src]: core.String,
>+  tabSize: core.String,
>+  [$tabSize]: core.String,
>+  tableLayout: core.String,
>+  [$tableLayout]: core.String,
>+  tapHighlightColor: core.String,
>+  [$tapHighlightColor]: core.String,
>+  textAlign: core.String,
>+  [$textAlign]: core.String,
>+  textAlignLast: core.String,
>+  [$textAlignLast]: core.String,
>+  textCombine: core.String,
>+  [$textCombine]: core.String,
>+  textDecoration: core.String,
>+  [$textDecoration]: core.String,
>+  textDecorationColor: core.String,
>+  [$textDecorationColor]: core.String,
>+  textDecorationLine: core.String,
>+  [$textDecorationLine]: core.String,
>+  textDecorationStyle: core.String,
>+  [$textDecorationStyle]: core.String,
>+  textDecorationsInEffect: core.String,
>+  [$textDecorationsInEffect]: core.String,
>+  textEmphasis: core.String,
>+  [$textEmphasis]: core.String,
>+  textEmphasisColor: core.String,
>+  [$textEmphasisColor]: core.String,
>+  textEmphasisPosition: core.String,
>+  [$textEmphasisPosition]: core.String,
>+  textEmphasisStyle: core.String,
>+  [$textEmphasisStyle]: core.String,
>+  textFillColor: core.String,
>+  [$textFillColor]: core.String,
>+  textIndent: core.String,
>+  [$textIndent]: core.String,
>+  textJustify: core.String,
>+  [$textJustify]: core.String,
>+  textLineThroughColor: core.String,
>+  [$textLineThroughColor]: core.String,
>+  textLineThroughMode: core.String,
>+  [$textLineThroughMode]: core.String,
>+  textLineThroughStyle: core.String,
>+  [$textLineThroughStyle]: core.String,
>+  textLineThroughWidth: core.String,
>+  [$textLineThroughWidth]: core.String,
>+  textOrientation: core.String,
>+  [$textOrientation]: core.String,
>+  textOverflow: core.String,
>+  [$textOverflow]: core.String,
>+  textOverlineColor: core.String,
>+  [$textOverlineColor]: core.String,
>+  textOverlineMode: core.String,
>+  [$textOverlineMode]: core.String,
>+  textOverlineStyle: core.String,
>+  [$textOverlineStyle]: core.String,
>+  textOverlineWidth: core.String,
>+  [$textOverlineWidth]: core.String,
>+  textRendering: core.String,
>+  [$textRendering]: core.String,
>+  textSecurity: core.String,
>+  [$textSecurity]: core.String,
>+  textShadow: core.String,
>+  [$textShadow]: core.String,
>+  textStroke: core.String,
>+  [$textStroke]: core.String,
>+  textStrokeColor: core.String,
>+  [$textStrokeColor]: core.String,
>+  textStrokeWidth: core.String,
>+  [$textStrokeWidth]: core.String,
>+  textTransform: core.String,
>+  [$textTransform]: core.String,
>+  textUnderlineColor: core.String,
>+  [$textUnderlineColor]: core.String,
>+  textUnderlineMode: core.String,
>+  [$textUnderlineMode]: core.String,
>+  textUnderlinePosition: core.String,
>+  [$textUnderlinePosition]: core.String,
>+  textUnderlineStyle: core.String,
>+  [$textUnderlineStyle]: core.String,
>+  textUnderlineWidth: core.String,
>+  [$textUnderlineWidth]: core.String,
>+  top: core.String,
>+  [$top]: core.String,
>+  touchAction: core.String,
>+  [$touchAction]: core.String,
>+  touchActionDelay: core.String,
>+  [$touchActionDelay]: core.String,
>+  transform: core.String,
>+  [$transform]: core.String,
>+  transformOrigin: core.String,
>+  [$transformOrigin]: core.String,
>+  transformOriginX: core.String,
>+  [$transformOriginX]: core.String,
>+  transformOriginY: core.String,
>+  [$transformOriginY]: core.String,
>+  transformOriginZ: core.String,
>+  [$transformOriginZ]: core.String,
>+  transformStyle: core.String,
>+  [$transformStyle]: core.String,
>+  transition: core.String,
>+  [$transition]: core.String,
>+  transitionDelay: core.String,
>+  [$transitionDelay]: core.String,
>+  transitionDuration: core.String,
>+  [$transitionDuration]: core.String,
>+  transitionProperty: core.String,
>+  [$transitionProperty]: core.String,
>+  transitionTimingFunction: core.String,
>+  [$transitionTimingFunction]: core.String,
>+  unicodeBidi: core.String,
>+  [$unicodeBidi]: core.String,
>+  unicodeRange: core.String,
>+  [$unicodeRange]: core.String,
>+  userDrag: core.String,
>+  [$userDrag]: core.String,
>+  userModify: core.String,
>+  [$userModify]: core.String,
>+  userSelect: core.String,
>+  [$userSelect]: core.String,
>+  userZoom: core.String,
>+  [$userZoom]: core.String,
>+  verticalAlign: core.String,
>+  [$verticalAlign]: core.String,
>+  visibility: core.String,
>+  [$visibility]: core.String,
>+  whiteSpace: core.String,
>+  [$whiteSpace]: core.String,
>+  widows: core.String,
>+  [$widows]: core.String,
>+  width: core.String,
>+  [$width]: core.String,
>+  willChange: core.String,
>+  [$willChange]: core.String,
>+  wordBreak: core.String,
>+  [$wordBreak]: core.String,
>+  wordSpacing: core.String,
>+  [$wordSpacing]: core.String,
>+  wordWrap: core.String,
>+  [$wordWrap]: core.String,
>+  wrapFlow: core.String,
>+  [$wrapFlow]: core.String,
>+  wrapThrough: core.String,
>+  [$wrapThrough]: core.String,
>+  writingMode: core.String,
>+  [$writingMode]: core.String,
>+  zIndex: core.String,
>+  [$zIndex]: core.String,
>+  zoom: core.String,
>+  [$zoom]: core.String
>+}));
>+dart.setLibraryUri(html$.CssStyleDeclarationBase, "dart:html");
>+dart.defineExtensionAccessors(html$.CssStyleDeclarationBase, [
>+  'alignContent',
>+  'alignItems',
>+  'alignSelf',
>+  'animation',
>+  'animationDelay',
>+  'animationDirection',
>+  'animationDuration',
>+  'animationFillMode',
>+  'animationIterationCount',
>+  'animationName',
>+  'animationPlayState',
>+  'animationTimingFunction',
>+  'appRegion',
>+  'appearance',
>+  'aspectRatio',
>+  'backfaceVisibility',
>+  'background',
>+  'backgroundAttachment',
>+  'backgroundBlendMode',
>+  'backgroundClip',
>+  'backgroundColor',
>+  'backgroundComposite',
>+  'backgroundImage',
>+  'backgroundOrigin',
>+  'backgroundPosition',
>+  'backgroundPositionX',
>+  'backgroundPositionY',
>+  'backgroundRepeat',
>+  'backgroundRepeatX',
>+  'backgroundRepeatY',
>+  'backgroundSize',
>+  'border',
>+  'borderAfter',
>+  'borderAfterColor',
>+  'borderAfterStyle',
>+  'borderAfterWidth',
>+  'borderBefore',
>+  'borderBeforeColor',
>+  'borderBeforeStyle',
>+  'borderBeforeWidth',
>+  'borderBottom',
>+  'borderBottomColor',
>+  'borderBottomLeftRadius',
>+  'borderBottomRightRadius',
>+  'borderBottomStyle',
>+  'borderBottomWidth',
>+  'borderCollapse',
>+  'borderColor',
>+  'borderEnd',
>+  'borderEndColor',
>+  'borderEndStyle',
>+  'borderEndWidth',
>+  'borderFit',
>+  'borderHorizontalSpacing',
>+  'borderImage',
>+  'borderImageOutset',
>+  'borderImageRepeat',
>+  'borderImageSlice',
>+  'borderImageSource',
>+  'borderImageWidth',
>+  'borderLeft',
>+  'borderLeftColor',
>+  'borderLeftStyle',
>+  'borderLeftWidth',
>+  'borderRadius',
>+  'borderRight',
>+  'borderRightColor',
>+  'borderRightStyle',
>+  'borderRightWidth',
>+  'borderSpacing',
>+  'borderStart',
>+  'borderStartColor',
>+  'borderStartStyle',
>+  'borderStartWidth',
>+  'borderStyle',
>+  'borderTop',
>+  'borderTopColor',
>+  'borderTopLeftRadius',
>+  'borderTopRightRadius',
>+  'borderTopStyle',
>+  'borderTopWidth',
>+  'borderVerticalSpacing',
>+  'borderWidth',
>+  'bottom',
>+  'boxAlign',
>+  'boxDecorationBreak',
>+  'boxDirection',
>+  'boxFlex',
>+  'boxFlexGroup',
>+  'boxLines',
>+  'boxOrdinalGroup',
>+  'boxOrient',
>+  'boxPack',
>+  'boxReflect',
>+  'boxShadow',
>+  'boxSizing',
>+  'captionSide',
>+  'clear',
>+  'clip',
>+  'clipPath',
>+  'color',
>+  'columnBreakAfter',
>+  'columnBreakBefore',
>+  'columnBreakInside',
>+  'columnCount',
>+  'columnFill',
>+  'columnGap',
>+  'columnRule',
>+  'columnRuleColor',
>+  'columnRuleStyle',
>+  'columnRuleWidth',
>+  'columnSpan',
>+  'columnWidth',
>+  'columns',
>+  'content',
>+  'counterIncrement',
>+  'counterReset',
>+  'cursor',
>+  'direction',
>+  'display',
>+  'emptyCells',
>+  'filter',
>+  'flex',
>+  'flexBasis',
>+  'flexDirection',
>+  'flexFlow',
>+  'flexGrow',
>+  'flexShrink',
>+  'flexWrap',
>+  'float',
>+  'font',
>+  'fontFamily',
>+  'fontFeatureSettings',
>+  'fontKerning',
>+  'fontSize',
>+  'fontSizeDelta',
>+  'fontSmoothing',
>+  'fontStretch',
>+  'fontStyle',
>+  'fontVariant',
>+  'fontVariantLigatures',
>+  'fontWeight',
>+  'grid',
>+  'gridArea',
>+  'gridAutoColumns',
>+  'gridAutoFlow',
>+  'gridAutoRows',
>+  'gridColumn',
>+  'gridColumnEnd',
>+  'gridColumnStart',
>+  'gridRow',
>+  'gridRowEnd',
>+  'gridRowStart',
>+  'gridTemplate',
>+  'gridTemplateAreas',
>+  'gridTemplateColumns',
>+  'gridTemplateRows',
>+  'height',
>+  'highlight',
>+  'hyphenateCharacter',
>+  'imageRendering',
>+  'isolation',
>+  'justifyContent',
>+  'justifySelf',
>+  'left',
>+  'letterSpacing',
>+  'lineBoxContain',
>+  'lineBreak',
>+  'lineClamp',
>+  'lineHeight',
>+  'listStyle',
>+  'listStyleImage',
>+  'listStylePosition',
>+  'listStyleType',
>+  'locale',
>+  'logicalHeight',
>+  'logicalWidth',
>+  'margin',
>+  'marginAfter',
>+  'marginAfterCollapse',
>+  'marginBefore',
>+  'marginBeforeCollapse',
>+  'marginBottom',
>+  'marginBottomCollapse',
>+  'marginCollapse',
>+  'marginEnd',
>+  'marginLeft',
>+  'marginRight',
>+  'marginStart',
>+  'marginTop',
>+  'marginTopCollapse',
>+  'mask',
>+  'maskBoxImage',
>+  'maskBoxImageOutset',
>+  'maskBoxImageRepeat',
>+  'maskBoxImageSlice',
>+  'maskBoxImageSource',
>+  'maskBoxImageWidth',
>+  'maskClip',
>+  'maskComposite',
>+  'maskImage',
>+  'maskOrigin',
>+  'maskPosition',
>+  'maskPositionX',
>+  'maskPositionY',
>+  'maskRepeat',
>+  'maskRepeatX',
>+  'maskRepeatY',
>+  'maskSize',
>+  'maskSourceType',
>+  'maxHeight',
>+  'maxLogicalHeight',
>+  'maxLogicalWidth',
>+  'maxWidth',
>+  'maxZoom',
>+  'minHeight',
>+  'minLogicalHeight',
>+  'minLogicalWidth',
>+  'minWidth',
>+  'minZoom',
>+  'mixBlendMode',
>+  'objectFit',
>+  'objectPosition',
>+  'opacity',
>+  'order',
>+  'orientation',
>+  'orphans',
>+  'outline',
>+  'outlineColor',
>+  'outlineOffset',
>+  'outlineStyle',
>+  'outlineWidth',
>+  'overflow',
>+  'overflowWrap',
>+  'overflowX',
>+  'overflowY',
>+  'padding',
>+  'paddingAfter',
>+  'paddingBefore',
>+  'paddingBottom',
>+  'paddingEnd',
>+  'paddingLeft',
>+  'paddingRight',
>+  'paddingStart',
>+  'paddingTop',
>+  'page',
>+  'pageBreakAfter',
>+  'pageBreakBefore',
>+  'pageBreakInside',
>+  'perspective',
>+  'perspectiveOrigin',
>+  'perspectiveOriginX',
>+  'perspectiveOriginY',
>+  'pointerEvents',
>+  'position',
>+  'printColorAdjust',
>+  'quotes',
>+  'resize',
>+  'right',
>+  'rtlOrdering',
>+  'rubyPosition',
>+  'scrollBehavior',
>+  'shapeImageThreshold',
>+  'shapeMargin',
>+  'shapeOutside',
>+  'size',
>+  'speak',
>+  'src',
>+  'tabSize',
>+  'tableLayout',
>+  'tapHighlightColor',
>+  'textAlign',
>+  'textAlignLast',
>+  'textCombine',
>+  'textDecoration',
>+  'textDecorationColor',
>+  'textDecorationLine',
>+  'textDecorationStyle',
>+  'textDecorationsInEffect',
>+  'textEmphasis',
>+  'textEmphasisColor',
>+  'textEmphasisPosition',
>+  'textEmphasisStyle',
>+  'textFillColor',
>+  'textIndent',
>+  'textJustify',
>+  'textLineThroughColor',
>+  'textLineThroughMode',
>+  'textLineThroughStyle',
>+  'textLineThroughWidth',
>+  'textOrientation',
>+  'textOverflow',
>+  'textOverlineColor',
>+  'textOverlineMode',
>+  'textOverlineStyle',
>+  'textOverlineWidth',
>+  'textRendering',
>+  'textSecurity',
>+  'textShadow',
>+  'textStroke',
>+  'textStrokeColor',
>+  'textStrokeWidth',
>+  'textTransform',
>+  'textUnderlineColor',
>+  'textUnderlineMode',
>+  'textUnderlinePosition',
>+  'textUnderlineStyle',
>+  'textUnderlineWidth',
>+  'top',
>+  'touchAction',
>+  'touchActionDelay',
>+  'transform',
>+  'transformOrigin',
>+  'transformOriginX',
>+  'transformOriginY',
>+  'transformOriginZ',
>+  'transformStyle',
>+  'transition',
>+  'transitionDelay',
>+  'transitionDuration',
>+  'transitionProperty',
>+  'transitionTimingFunction',
>+  'unicodeBidi',
>+  'unicodeRange',
>+  'userDrag',
>+  'userModify',
>+  'userSelect',
>+  'userZoom',
>+  'verticalAlign',
>+  'visibility',
>+  'whiteSpace',
>+  'widows',
>+  'width',
>+  'willChange',
>+  'wordBreak',
>+  'wordSpacing',
>+  'wordWrap',
>+  'wrapFlow',
>+  'wrapThrough',
>+  'writingMode',
>+  'zIndex',
>+  'zoom'
>+]);
>+const Interceptor_CssStyleDeclarationBase$ = class Interceptor_CssStyleDeclarationBase extends _interceptors.Interceptor {};
>+(Interceptor_CssStyleDeclarationBase$.new = function() {
>+  Interceptor_CssStyleDeclarationBase$.__proto__.new.call(this);
>+}).prototype = Interceptor_CssStyleDeclarationBase$.prototype;
>+dart.applyMixin(Interceptor_CssStyleDeclarationBase$, html$.CssStyleDeclarationBase);
>+html$.CssStyleDeclaration = class CssStyleDeclaration extends Interceptor_CssStyleDeclarationBase$ {
>+  static new() {
>+    return html$.CssStyleDeclaration.css("");
>+  }
>+  static css(css) {
>+    let style = html$.DivElement.new().style;
>+    style.cssText = css;
>+    return style;
>+  }
>+  [$getPropertyValue](propertyName) {
>+    let propValue = this[_getPropertyValueHelper](propertyName);
>+    return propValue != null ? propValue : "";
>+  }
>+  [_getPropertyValueHelper](propertyName) {
>+    return this[_getPropertyValue](this[_browserPropertyName](propertyName));
>+  }
>+  [$supportsProperty](propertyName) {
>+    return dart.test(this[_supportsProperty](propertyName)) || dart.test(this[_supportsProperty](html$.CssStyleDeclaration._camelCase(dart.str(html_common.Device.cssPrefix) + dart.str(propertyName))));
>+  }
>+  [_supportsProperty](propertyName) {
>+    return propertyName in this;
>+  }
>+  [$setProperty](propertyName, value, priority) {
>+    if (priority === void 0) priority = null;
>+    return this[_setPropertyHelper](this[_browserPropertyName](propertyName), value, priority);
>+  }
>+  [_browserPropertyName](propertyName) {
>+    let name = html$.CssStyleDeclaration._readCache(propertyName);
>+    if (typeof name == 'string') return name;
>+    name = this[_supportedBrowserPropertyName](propertyName);
>+    html$.CssStyleDeclaration._writeCache(propertyName, name);
>+    return name;
>+  }
>+  [_supportedBrowserPropertyName](propertyName) {
>+    if (dart.test(this[_supportsProperty](html$.CssStyleDeclaration._camelCase(propertyName)))) {
>+      return propertyName;
>+    }
>+    let prefixed = dart.str(html_common.Device.cssPrefix) + dart.str(propertyName);
>+    if (dart.test(this[_supportsProperty](prefixed))) {
>+      return prefixed;
>+    }
>+    return propertyName;
>+  }
>+  static _readCache(key) {
>+    return html$.CssStyleDeclaration._propertyCache[key];
>+  }
>+  static _writeCache(key, value) {
>+    html$.CssStyleDeclaration._propertyCache[key] = value;
>+  }
>+  static _camelCase(hyphenated) {
>+    let replacedMs = hyphenated.replace(/^-ms-/, "ms-");
>+    return replacedMs.replace(/-([\da-z])/ig, function(_, letter) {
>+      return letter.toUpperCase();
>+    });
>+  }
>+  [_setPropertyHelper](propertyName, value, priority) {
>+    if (priority === void 0) priority = null;
>+    if (value == null) value = "";
>+    if (priority == null) priority = "";
>+    this.setProperty(propertyName, value, priority);
>+  }
>+  static get supportsTransitions() {
>+    return html$.document.body.style[$supportsProperty]("transition");
>+  }
>+  get [$cssFloat]() {
>+    return this.cssFloat;
>+  }
>+  set [$cssFloat](value) {
>+    this.cssFloat = value;
>+  }
>+  get [$cssText]() {
>+    return this.cssText;
>+  }
>+  set [$cssText](value) {
>+    this.cssText = value;
>+  }
>+  get [$length]() {
>+    return this.length;
>+  }
>+  get [$parentRule]() {
>+    return this.parentRule;
>+  }
>+  [$getPropertyPriority](...args) {
>+    return this.getPropertyPriority.apply(this, args);
>+  }
>+  [_getPropertyValue](...args) {
>+    return this.getPropertyValue.apply(this, args);
>+  }
>+  [$item](...args) {
>+    return this.item.apply(this, args);
>+  }
>+  [$removeProperty](...args) {
>+    return this.removeProperty.apply(this, args);
>+  }
>+  get [$background]() {
>+    return this[_background];
>+  }
>+  set [$background](value) {
>+    this[_background] = value == null ? "" : value;
>+  }
>+  get [_background]() {
>+    return this.background;
>+  }
>+  set [_background](value) {
>+    this.background = value;
>+  }
>+  get [$backgroundAttachment]() {
>+    return this[_backgroundAttachment];
>+  }
>+  set [$backgroundAttachment](value) {
>+    this[_backgroundAttachment] = value == null ? "" : value;
>+  }
>+  get [_backgroundAttachment]() {
>+    return this.backgroundAttachment;
>+  }
>+  set [_backgroundAttachment](value) {
>+    this.backgroundAttachment = value;
>+  }
>+  get [$backgroundColor]() {
>+    return this[_backgroundColor];
>+  }
>+  set [$backgroundColor](value) {
>+    this[_backgroundColor] = value == null ? "" : value;
>+  }
>+  get [_backgroundColor]() {
>+    return this.backgroundColor;
>+  }
>+  set [_backgroundColor](value) {
>+    this.backgroundColor = value;
>+  }
>+  get [$backgroundImage]() {
>+    return this[_backgroundImage];
>+  }
>+  set [$backgroundImage](value) {
>+    this[_backgroundImage] = value == null ? "" : value;
>+  }
>+  get [_backgroundImage]() {
>+    return this.backgroundImage;
>+  }
>+  set [_backgroundImage](value) {
>+    this.backgroundImage = value;
>+  }
>+  get [$backgroundPosition]() {
>+    return this[_backgroundPosition];
>+  }
>+  set [$backgroundPosition](value) {
>+    this[_backgroundPosition] = value == null ? "" : value;
>+  }
>+  get [_backgroundPosition]() {
>+    return this.backgroundPosition;
>+  }
>+  set [_backgroundPosition](value) {
>+    this.backgroundPosition = value;
>+  }
>+  get [$backgroundRepeat]() {
>+    return this[_backgroundRepeat];
>+  }
>+  set [$backgroundRepeat](value) {
>+    this[_backgroundRepeat] = value == null ? "" : value;
>+  }
>+  get [_backgroundRepeat]() {
>+    return this.backgroundRepeat;
>+  }
>+  set [_backgroundRepeat](value) {
>+    this.backgroundRepeat = value;
>+  }
>+  get [$border]() {
>+    return this[_border];
>+  }
>+  set [$border](value) {
>+    this[_border] = value == null ? "" : value;
>+  }
>+  get [_border]() {
>+    return this.border;
>+  }
>+  set [_border](value) {
>+    this.border = value;
>+  }
>+  get [$borderBottom]() {
>+    return this[_borderBottom];
>+  }
>+  set [$borderBottom](value) {
>+    this[_borderBottom] = value == null ? "" : value;
>+  }
>+  get [_borderBottom]() {
>+    return this.borderBottom;
>+  }
>+  set [_borderBottom](value) {
>+    this.borderBottom = value;
>+  }
>+  get [$borderBottomColor]() {
>+    return this[_borderBottomColor];
>+  }
>+  set [$borderBottomColor](value) {
>+    this[_borderBottomColor] = value == null ? "" : value;
>+  }
>+  get [_borderBottomColor]() {
>+    return this.borderBottomColor;
>+  }
>+  set [_borderBottomColor](value) {
>+    this.borderBottomColor = value;
>+  }
>+  get [$borderBottomStyle]() {
>+    return this[_borderBottomStyle];
>+  }
>+  set [$borderBottomStyle](value) {
>+    this[_borderBottomStyle] = value == null ? "" : value;
>+  }
>+  get [_borderBottomStyle]() {
>+    return this.borderBottomStyle;
>+  }
>+  set [_borderBottomStyle](value) {
>+    this.borderBottomStyle = value;
>+  }
>+  get [$borderBottomWidth]() {
>+    return this[_borderBottomWidth];
>+  }
>+  set [$borderBottomWidth](value) {
>+    this[_borderBottomWidth] = value == null ? "" : value;
>+  }
>+  get [_borderBottomWidth]() {
>+    return this.borderBottomWidth;
>+  }
>+  set [_borderBottomWidth](value) {
>+    this.borderBottomWidth = value;
>+  }
>+  get [$borderCollapse]() {
>+    return this[_borderCollapse];
>+  }
>+  set [$borderCollapse](value) {
>+    this[_borderCollapse] = value == null ? "" : value;
>+  }
>+  get [_borderCollapse]() {
>+    return this.borderCollapse;
>+  }
>+  set [_borderCollapse](value) {
>+    this.borderCollapse = value;
>+  }
>+  get [$borderColor]() {
>+    return this[_borderColor];
>+  }
>+  set [$borderColor](value) {
>+    this[_borderColor] = value == null ? "" : value;
>+  }
>+  get [_borderColor]() {
>+    return this.borderColor;
>+  }
>+  set [_borderColor](value) {
>+    this.borderColor = value;
>+  }
>+  get [$borderLeft]() {
>+    return this[_borderLeft];
>+  }
>+  set [$borderLeft](value) {
>+    this[_borderLeft] = value == null ? "" : value;
>+  }
>+  get [_borderLeft]() {
>+    return this.borderLeft;
>+  }
>+  set [_borderLeft](value) {
>+    this.borderLeft = value;
>+  }
>+  get [$borderLeftColor]() {
>+    return this[_borderLeftColor];
>+  }
>+  set [$borderLeftColor](value) {
>+    this[_borderLeftColor] = value == null ? "" : value;
>+  }
>+  get [_borderLeftColor]() {
>+    return this.borderLeftColor;
>+  }
>+  set [_borderLeftColor](value) {
>+    this.borderLeftColor = value;
>+  }
>+  get [$borderLeftStyle]() {
>+    return this[_borderLeftStyle];
>+  }
>+  set [$borderLeftStyle](value) {
>+    this[_borderLeftStyle] = value == null ? "" : value;
>+  }
>+  get [_borderLeftStyle]() {
>+    return this.borderLeftStyle;
>+  }
>+  set [_borderLeftStyle](value) {
>+    this.borderLeftStyle = value;
>+  }
>+  get [$borderLeftWidth]() {
>+    return this[_borderLeftWidth];
>+  }
>+  set [$borderLeftWidth](value) {
>+    this[_borderLeftWidth] = value == null ? "" : value;
>+  }
>+  get [_borderLeftWidth]() {
>+    return this.borderLeftWidth;
>+  }
>+  set [_borderLeftWidth](value) {
>+    this.borderLeftWidth = value;
>+  }
>+  get [$borderRight]() {
>+    return this[_borderRight];
>+  }
>+  set [$borderRight](value) {
>+    this[_borderRight] = value == null ? "" : value;
>+  }
>+  get [_borderRight]() {
>+    return this.borderRight;
>+  }
>+  set [_borderRight](value) {
>+    this.borderRight = value;
>+  }
>+  get [$borderRightColor]() {
>+    return this[_borderRightColor];
>+  }
>+  set [$borderRightColor](value) {
>+    this[_borderRightColor] = value == null ? "" : value;
>+  }
>+  get [_borderRightColor]() {
>+    return this.borderRightColor;
>+  }
>+  set [_borderRightColor](value) {
>+    this.borderRightColor = value;
>+  }
>+  get [$borderRightStyle]() {
>+    return this[_borderRightStyle];
>+  }
>+  set [$borderRightStyle](value) {
>+    this[_borderRightStyle] = value == null ? "" : value;
>+  }
>+  get [_borderRightStyle]() {
>+    return this.borderRightStyle;
>+  }
>+  set [_borderRightStyle](value) {
>+    this.borderRightStyle = value;
>+  }
>+  get [$borderRightWidth]() {
>+    return this[_borderRightWidth];
>+  }
>+  set [$borderRightWidth](value) {
>+    this[_borderRightWidth] = value == null ? "" : value;
>+  }
>+  get [_borderRightWidth]() {
>+    return this.borderRightWidth;
>+  }
>+  set [_borderRightWidth](value) {
>+    this.borderRightWidth = value;
>+  }
>+  get [$borderSpacing]() {
>+    return this[_borderSpacing];
>+  }
>+  set [$borderSpacing](value) {
>+    this[_borderSpacing] = value == null ? "" : value;
>+  }
>+  get [_borderSpacing]() {
>+    return this.borderSpacing;
>+  }
>+  set [_borderSpacing](value) {
>+    this.borderSpacing = value;
>+  }
>+  get [$borderStyle]() {
>+    return this[_borderStyle];
>+  }
>+  set [$borderStyle](value) {
>+    this[_borderStyle] = value == null ? "" : value;
>+  }
>+  get [_borderStyle]() {
>+    return this.borderStyle;
>+  }
>+  set [_borderStyle](value) {
>+    this.borderStyle = value;
>+  }
>+  get [$borderTop]() {
>+    return this[_borderTop];
>+  }
>+  set [$borderTop](value) {
>+    this[_borderTop] = value == null ? "" : value;
>+  }
>+  get [_borderTop]() {
>+    return this.borderTop;
>+  }
>+  set [_borderTop](value) {
>+    this.borderTop = value;
>+  }
>+  get [$borderTopColor]() {
>+    return this[_borderTopColor];
>+  }
>+  set [$borderTopColor](value) {
>+    this[_borderTopColor] = value == null ? "" : value;
>+  }
>+  get [_borderTopColor]() {
>+    return this.borderTopColor;
>+  }
>+  set [_borderTopColor](value) {
>+    this.borderTopColor = value;
>+  }
>+  get [$borderTopStyle]() {
>+    return this[_borderTopStyle];
>+  }
>+  set [$borderTopStyle](value) {
>+    this[_borderTopStyle] = value == null ? "" : value;
>+  }
>+  get [_borderTopStyle]() {
>+    return this.borderTopStyle;
>+  }
>+  set [_borderTopStyle](value) {
>+    this.borderTopStyle = value;
>+  }
>+  get [$borderTopWidth]() {
>+    return this[_borderTopWidth];
>+  }
>+  set [$borderTopWidth](value) {
>+    this[_borderTopWidth] = value == null ? "" : value;
>+  }
>+  get [_borderTopWidth]() {
>+    return this.borderTopWidth;
>+  }
>+  set [_borderTopWidth](value) {
>+    this.borderTopWidth = value;
>+  }
>+  get [$borderWidth]() {
>+    return this[_borderWidth];
>+  }
>+  set [$borderWidth](value) {
>+    this[_borderWidth] = value == null ? "" : value;
>+  }
>+  get [_borderWidth]() {
>+    return this.borderWidth;
>+  }
>+  set [_borderWidth](value) {
>+    this.borderWidth = value;
>+  }
>+  get [$bottom]() {
>+    return this[_bottom];
>+  }
>+  set [$bottom](value) {
>+    this[_bottom] = value == null ? "" : value;
>+  }
>+  get [_bottom]() {
>+    return this.bottom;
>+  }
>+  set [_bottom](value) {
>+    this.bottom = value;
>+  }
>+  get [$captionSide]() {
>+    return this[_captionSide];
>+  }
>+  set [$captionSide](value) {
>+    this[_captionSide] = value == null ? "" : value;
>+  }
>+  get [_captionSide]() {
>+    return this.captionSide;
>+  }
>+  set [_captionSide](value) {
>+    this.captionSide = value;
>+  }
>+  get [$clear]() {
>+    return this[_clear$0];
>+  }
>+  set [$clear](value) {
>+    this[_clear$0] = value == null ? "" : value;
>+  }
>+  get [_clear$0]() {
>+    return this.clear;
>+  }
>+  set [_clear$0](value) {
>+    this.clear = value;
>+  }
>+  get [$clip]() {
>+    return this[_clip];
>+  }
>+  set [$clip](value) {
>+    this[_clip] = value == null ? "" : value;
>+  }
>+  get [_clip]() {
>+    return this.clip;
>+  }
>+  set [_clip](value) {
>+    this.clip = value;
>+  }
>+  get [$color]() {
>+    return this[_color];
>+  }
>+  set [$color](value) {
>+    this[_color] = value == null ? "" : value;
>+  }
>+  get [_color]() {
>+    return this.color;
>+  }
>+  set [_color](value) {
>+    this.color = value;
>+  }
>+  get [$content]() {
>+    return this[_content];
>+  }
>+  set [$content](value) {
>+    this[_content] = value == null ? "" : value;
>+  }
>+  get [_content]() {
>+    return this.content;
>+  }
>+  set [_content](value) {
>+    this.content = value;
>+  }
>+  get [$cursor]() {
>+    return this[_cursor];
>+  }
>+  set [$cursor](value) {
>+    this[_cursor] = value == null ? "" : value;
>+  }
>+  get [_cursor]() {
>+    return this.cursor;
>+  }
>+  set [_cursor](value) {
>+    this.cursor = value;
>+  }
>+  get [$direction]() {
>+    return this[_direction];
>+  }
>+  set [$direction](value) {
>+    this[_direction] = value == null ? "" : value;
>+  }
>+  get [_direction]() {
>+    return this.direction;
>+  }
>+  set [_direction](value) {
>+    this.direction = value;
>+  }
>+  get [$display]() {
>+    return this[_display];
>+  }
>+  set [$display](value) {
>+    this[_display] = value == null ? "" : value;
>+  }
>+  get [_display]() {
>+    return this.display;
>+  }
>+  set [_display](value) {
>+    this.display = value;
>+  }
>+  get [$emptyCells]() {
>+    return this[_emptyCells];
>+  }
>+  set [$emptyCells](value) {
>+    this[_emptyCells] = value == null ? "" : value;
>+  }
>+  get [_emptyCells]() {
>+    return this.emptyCells;
>+  }
>+  set [_emptyCells](value) {
>+    this.emptyCells = value;
>+  }
>+  get [$font]() {
>+    return this[_font];
>+  }
>+  set [$font](value) {
>+    this[_font] = value == null ? "" : value;
>+  }
>+  get [_font]() {
>+    return this.font;
>+  }
>+  set [_font](value) {
>+    this.font = value;
>+  }
>+  get [$fontFamily]() {
>+    return this[_fontFamily];
>+  }
>+  set [$fontFamily](value) {
>+    this[_fontFamily] = value == null ? "" : value;
>+  }
>+  get [_fontFamily]() {
>+    return this.fontFamily;
>+  }
>+  set [_fontFamily](value) {
>+    this.fontFamily = value;
>+  }
>+  get [$fontSize]() {
>+    return this[_fontSize];
>+  }
>+  set [$fontSize](value) {
>+    this[_fontSize] = value == null ? "" : value;
>+  }
>+  get [_fontSize]() {
>+    return this.fontSize;
>+  }
>+  set [_fontSize](value) {
>+    this.fontSize = value;
>+  }
>+  get [$fontStyle]() {
>+    return this[_fontStyle];
>+  }
>+  set [$fontStyle](value) {
>+    this[_fontStyle] = value == null ? "" : value;
>+  }
>+  get [_fontStyle]() {
>+    return this.fontStyle;
>+  }
>+  set [_fontStyle](value) {
>+    this.fontStyle = value;
>+  }
>+  get [$fontVariant]() {
>+    return this[_fontVariant];
>+  }
>+  set [$fontVariant](value) {
>+    this[_fontVariant] = value == null ? "" : value;
>+  }
>+  get [_fontVariant]() {
>+    return this.fontVariant;
>+  }
>+  set [_fontVariant](value) {
>+    this.fontVariant = value;
>+  }
>+  get [$fontWeight]() {
>+    return this[_fontWeight];
>+  }
>+  set [$fontWeight](value) {
>+    this[_fontWeight] = value == null ? "" : value;
>+  }
>+  get [_fontWeight]() {
>+    return this.fontWeight;
>+  }
>+  set [_fontWeight](value) {
>+    this.fontWeight = value;
>+  }
>+  get [$height]() {
>+    return this[_height$];
>+  }
>+  set [$height](value) {
>+    this[_height$] = value == null ? "" : value;
>+  }
>+  get [_height$]() {
>+    return this.height;
>+  }
>+  set [_height$](value) {
>+    this.height = value;
>+  }
>+  get [$left]() {
>+    return this[_left];
>+  }
>+  set [$left](value) {
>+    this[_left] = value == null ? "" : value;
>+  }
>+  get [_left]() {
>+    return this.left;
>+  }
>+  set [_left](value) {
>+    this.left = value;
>+  }
>+  get [$letterSpacing]() {
>+    return this[_letterSpacing];
>+  }
>+  set [$letterSpacing](value) {
>+    this[_letterSpacing] = value == null ? "" : value;
>+  }
>+  get [_letterSpacing]() {
>+    return this.letterSpacing;
>+  }
>+  set [_letterSpacing](value) {
>+    this.letterSpacing = value;
>+  }
>+  get [$lineHeight]() {
>+    return this[_lineHeight];
>+  }
>+  set [$lineHeight](value) {
>+    this[_lineHeight] = value == null ? "" : value;
>+  }
>+  get [_lineHeight]() {
>+    return this.lineHeight;
>+  }
>+  set [_lineHeight](value) {
>+    this.lineHeight = value;
>+  }
>+  get [$listStyle]() {
>+    return this[_listStyle];
>+  }
>+  set [$listStyle](value) {
>+    this[_listStyle] = value == null ? "" : value;
>+  }
>+  get [_listStyle]() {
>+    return this.listStyle;
>+  }
>+  set [_listStyle](value) {
>+    this.listStyle = value;
>+  }
>+  get [$listStyleImage]() {
>+    return this[_listStyleImage];
>+  }
>+  set [$listStyleImage](value) {
>+    this[_listStyleImage] = value == null ? "" : value;
>+  }
>+  get [_listStyleImage]() {
>+    return this.listStyleImage;
>+  }
>+  set [_listStyleImage](value) {
>+    this.listStyleImage = value;
>+  }
>+  get [$listStylePosition]() {
>+    return this[_listStylePosition];
>+  }
>+  set [$listStylePosition](value) {
>+    this[_listStylePosition] = value == null ? "" : value;
>+  }
>+  get [_listStylePosition]() {
>+    return this.listStylePosition;
>+  }
>+  set [_listStylePosition](value) {
>+    this.listStylePosition = value;
>+  }
>+  get [$listStyleType]() {
>+    return this[_listStyleType];
>+  }
>+  set [$listStyleType](value) {
>+    this[_listStyleType] = value == null ? "" : value;
>+  }
>+  get [_listStyleType]() {
>+    return this.listStyleType;
>+  }
>+  set [_listStyleType](value) {
>+    this.listStyleType = value;
>+  }
>+  get [$margin]() {
>+    return this[_margin];
>+  }
>+  set [$margin](value) {
>+    this[_margin] = value == null ? "" : value;
>+  }
>+  get [_margin]() {
>+    return this.margin;
>+  }
>+  set [_margin](value) {
>+    this.margin = value;
>+  }
>+  get [$marginBottom]() {
>+    return this[_marginBottom];
>+  }
>+  set [$marginBottom](value) {
>+    this[_marginBottom] = value == null ? "" : value;
>+  }
>+  get [_marginBottom]() {
>+    return this.marginBottom;
>+  }
>+  set [_marginBottom](value) {
>+    this.marginBottom = value;
>+  }
>+  get [$marginLeft]() {
>+    return this[_marginLeft];
>+  }
>+  set [$marginLeft](value) {
>+    this[_marginLeft] = value == null ? "" : value;
>+  }
>+  get [_marginLeft]() {
>+    return this.marginLeft;
>+  }
>+  set [_marginLeft](value) {
>+    this.marginLeft = value;
>+  }
>+  get [$marginRight]() {
>+    return this[_marginRight];
>+  }
>+  set [$marginRight](value) {
>+    this[_marginRight] = value == null ? "" : value;
>+  }
>+  get [_marginRight]() {
>+    return this.marginRight;
>+  }
>+  set [_marginRight](value) {
>+    this.marginRight = value;
>+  }
>+  get [$marginTop]() {
>+    return this[_marginTop];
>+  }
>+  set [$marginTop](value) {
>+    this[_marginTop] = value == null ? "" : value;
>+  }
>+  get [_marginTop]() {
>+    return this.marginTop;
>+  }
>+  set [_marginTop](value) {
>+    this.marginTop = value;
>+  }
>+  get [$maxHeight]() {
>+    return this[_maxHeight];
>+  }
>+  set [$maxHeight](value) {
>+    this[_maxHeight] = value == null ? "" : value;
>+  }
>+  get [_maxHeight]() {
>+    return this.maxHeight;
>+  }
>+  set [_maxHeight](value) {
>+    this.maxHeight = value;
>+  }
>+  get [$maxWidth]() {
>+    return this[_maxWidth];
>+  }
>+  set [$maxWidth](value) {
>+    this[_maxWidth] = value == null ? "" : value;
>+  }
>+  get [_maxWidth]() {
>+    return this.maxWidth;
>+  }
>+  set [_maxWidth](value) {
>+    this.maxWidth = value;
>+  }
>+  get [$minHeight]() {
>+    return this[_minHeight];
>+  }
>+  set [$minHeight](value) {
>+    this[_minHeight] = value == null ? "" : value;
>+  }
>+  get [_minHeight]() {
>+    return this.minHeight;
>+  }
>+  set [_minHeight](value) {
>+    this.minHeight = value;
>+  }
>+  get [$minWidth]() {
>+    return this[_minWidth];
>+  }
>+  set [$minWidth](value) {
>+    this[_minWidth] = value == null ? "" : value;
>+  }
>+  get [_minWidth]() {
>+    return this.minWidth;
>+  }
>+  set [_minWidth](value) {
>+    this.minWidth = value;
>+  }
>+  get [$outline]() {
>+    return this[_outline];
>+  }
>+  set [$outline](value) {
>+    this[_outline] = value == null ? "" : value;
>+  }
>+  get [_outline]() {
>+    return this.outline;
>+  }
>+  set [_outline](value) {
>+    this.outline = value;
>+  }
>+  get [$outlineColor]() {
>+    return this[_outlineColor];
>+  }
>+  set [$outlineColor](value) {
>+    this[_outlineColor] = value == null ? "" : value;
>+  }
>+  get [_outlineColor]() {
>+    return this.outlineColor;
>+  }
>+  set [_outlineColor](value) {
>+    this.outlineColor = value;
>+  }
>+  get [$outlineStyle]() {
>+    return this[_outlineStyle];
>+  }
>+  set [$outlineStyle](value) {
>+    this[_outlineStyle] = value == null ? "" : value;
>+  }
>+  get [_outlineStyle]() {
>+    return this.outlineStyle;
>+  }
>+  set [_outlineStyle](value) {
>+    this.outlineStyle = value;
>+  }
>+  get [$outlineWidth]() {
>+    return this[_outlineWidth];
>+  }
>+  set [$outlineWidth](value) {
>+    this[_outlineWidth] = value == null ? "" : value;
>+  }
>+  get [_outlineWidth]() {
>+    return this.outlineWidth;
>+  }
>+  set [_outlineWidth](value) {
>+    this.outlineWidth = value;
>+  }
>+  get [$overflow]() {
>+    return this[_overflow];
>+  }
>+  set [$overflow](value) {
>+    this[_overflow] = value == null ? "" : value;
>+  }
>+  get [_overflow]() {
>+    return this.overflow;
>+  }
>+  set [_overflow](value) {
>+    this.overflow = value;
>+  }
>+  get [$padding]() {
>+    return this[_padding];
>+  }
>+  set [$padding](value) {
>+    this[_padding] = value == null ? "" : value;
>+  }
>+  get [_padding]() {
>+    return this.padding;
>+  }
>+  set [_padding](value) {
>+    this.padding = value;
>+  }
>+  get [$paddingBottom]() {
>+    return this[_paddingBottom];
>+  }
>+  set [$paddingBottom](value) {
>+    this[_paddingBottom] = value == null ? "" : value;
>+  }
>+  get [_paddingBottom]() {
>+    return this.paddingBottom;
>+  }
>+  set [_paddingBottom](value) {
>+    this.paddingBottom = value;
>+  }
>+  get [$paddingLeft]() {
>+    return this[_paddingLeft];
>+  }
>+  set [$paddingLeft](value) {
>+    this[_paddingLeft] = value == null ? "" : value;
>+  }
>+  get [_paddingLeft]() {
>+    return this.paddingLeft;
>+  }
>+  set [_paddingLeft](value) {
>+    this.paddingLeft = value;
>+  }
>+  get [$paddingRight]() {
>+    return this[_paddingRight];
>+  }
>+  set [$paddingRight](value) {
>+    this[_paddingRight] = value == null ? "" : value;
>+  }
>+  get [_paddingRight]() {
>+    return this.paddingRight;
>+  }
>+  set [_paddingRight](value) {
>+    this.paddingRight = value;
>+  }
>+  get [$paddingTop]() {
>+    return this[_paddingTop];
>+  }
>+  set [$paddingTop](value) {
>+    this[_paddingTop] = value == null ? "" : value;
>+  }
>+  get [_paddingTop]() {
>+    return this.paddingTop;
>+  }
>+  set [_paddingTop](value) {
>+    this.paddingTop = value;
>+  }
>+  get [$pageBreakAfter]() {
>+    return this[_pageBreakAfter];
>+  }
>+  set [$pageBreakAfter](value) {
>+    this[_pageBreakAfter] = value == null ? "" : value;
>+  }
>+  get [_pageBreakAfter]() {
>+    return this.pageBreakAfter;
>+  }
>+  set [_pageBreakAfter](value) {
>+    this.pageBreakAfter = value;
>+  }
>+  get [$pageBreakBefore]() {
>+    return this[_pageBreakBefore];
>+  }
>+  set [$pageBreakBefore](value) {
>+    this[_pageBreakBefore] = value == null ? "" : value;
>+  }
>+  get [_pageBreakBefore]() {
>+    return this.pageBreakBefore;
>+  }
>+  set [_pageBreakBefore](value) {
>+    this.pageBreakBefore = value;
>+  }
>+  get [$pageBreakInside]() {
>+    return this[_pageBreakInside];
>+  }
>+  set [$pageBreakInside](value) {
>+    this[_pageBreakInside] = value == null ? "" : value;
>+  }
>+  get [_pageBreakInside]() {
>+    return this.pageBreakInside;
>+  }
>+  set [_pageBreakInside](value) {
>+    this.pageBreakInside = value;
>+  }
>+  get [$position]() {
>+    return this[_position$1];
>+  }
>+  set [$position](value) {
>+    this[_position$1] = value == null ? "" : value;
>+  }
>+  get [_position$1]() {
>+    return this.position;
>+  }
>+  set [_position$1](value) {
>+    this.position = value;
>+  }
>+  get [$quotes]() {
>+    return this[_quotes];
>+  }
>+  set [$quotes](value) {
>+    this[_quotes] = value == null ? "" : value;
>+  }
>+  get [_quotes]() {
>+    return this.quotes;
>+  }
>+  set [_quotes](value) {
>+    this.quotes = value;
>+  }
>+  get [$right]() {
>+    return this[_right];
>+  }
>+  set [$right](value) {
>+    this[_right] = value == null ? "" : value;
>+  }
>+  get [_right]() {
>+    return this.right;
>+  }
>+  set [_right](value) {
>+    this.right = value;
>+  }
>+  get [$tableLayout]() {
>+    return this[_tableLayout];
>+  }
>+  set [$tableLayout](value) {
>+    this[_tableLayout] = value == null ? "" : value;
>+  }
>+  get [_tableLayout]() {
>+    return this.tableLayout;
>+  }
>+  set [_tableLayout](value) {
>+    this.tableLayout = value;
>+  }
>+  get [$textAlign]() {
>+    return this[_textAlign];
>+  }
>+  set [$textAlign](value) {
>+    this[_textAlign] = value == null ? "" : value;
>+  }
>+  get [_textAlign]() {
>+    return this.textAlign;
>+  }
>+  set [_textAlign](value) {
>+    this.textAlign = value;
>+  }
>+  get [$textDecoration]() {
>+    return this[_textDecoration];
>+  }
>+  set [$textDecoration](value) {
>+    this[_textDecoration] = value == null ? "" : value;
>+  }
>+  get [_textDecoration]() {
>+    return this.textDecoration;
>+  }
>+  set [_textDecoration](value) {
>+    this.textDecoration = value;
>+  }
>+  get [$textIndent]() {
>+    return this[_textIndent];
>+  }
>+  set [$textIndent](value) {
>+    this[_textIndent] = value == null ? "" : value;
>+  }
>+  get [_textIndent]() {
>+    return this.textIndent;
>+  }
>+  set [_textIndent](value) {
>+    this.textIndent = value;
>+  }
>+  get [$textTransform]() {
>+    return this[_textTransform];
>+  }
>+  set [$textTransform](value) {
>+    this[_textTransform] = value == null ? "" : value;
>+  }
>+  get [_textTransform]() {
>+    return this.textTransform;
>+  }
>+  set [_textTransform](value) {
>+    this.textTransform = value;
>+  }
>+  get [$top]() {
>+    return this[_top];
>+  }
>+  set [$top](value) {
>+    this[_top] = value == null ? "" : value;
>+  }
>+  get [_top]() {
>+    return this.top;
>+  }
>+  set [_top](value) {
>+    this.top = value;
>+  }
>+  get [$unicodeBidi]() {
>+    return this[_unicodeBidi];
>+  }
>+  set [$unicodeBidi](value) {
>+    this[_unicodeBidi] = value == null ? "" : value;
>+  }
>+  get [_unicodeBidi]() {
>+    return this.unicodeBidi;
>+  }
>+  set [_unicodeBidi](value) {
>+    this.unicodeBidi = value;
>+  }
>+  get [$verticalAlign]() {
>+    return this[_verticalAlign];
>+  }
>+  set [$verticalAlign](value) {
>+    this[_verticalAlign] = value == null ? "" : value;
>+  }
>+  get [_verticalAlign]() {
>+    return this.verticalAlign;
>+  }
>+  set [_verticalAlign](value) {
>+    this.verticalAlign = value;
>+  }
>+  get [$visibility]() {
>+    return this[_visibility];
>+  }
>+  set [$visibility](value) {
>+    this[_visibility] = value == null ? "" : value;
>+  }
>+  get [_visibility]() {
>+    return this.visibility;
>+  }
>+  set [_visibility](value) {
>+    this.visibility = value;
>+  }
>+  get [$whiteSpace]() {
>+    return this[_whiteSpace];
>+  }
>+  set [$whiteSpace](value) {
>+    this[_whiteSpace] = value == null ? "" : value;
>+  }
>+  get [_whiteSpace]() {
>+    return this.whiteSpace;
>+  }
>+  set [_whiteSpace](value) {
>+    this.whiteSpace = value;
>+  }
>+  get [$width]() {
>+    return this[_width$];
>+  }
>+  set [$width](value) {
>+    this[_width$] = value == null ? "" : value;
>+  }
>+  get [_width$]() {
>+    return this.width;
>+  }
>+  set [_width$](value) {
>+    this.width = value;
>+  }
>+  get [$wordSpacing]() {
>+    return this[_wordSpacing];
>+  }
>+  set [$wordSpacing](value) {
>+    this[_wordSpacing] = value == null ? "" : value;
>+  }
>+  get [_wordSpacing]() {
>+    return this.wordSpacing;
>+  }
>+  set [_wordSpacing](value) {
>+    this.wordSpacing = value;
>+  }
>+  get [$zIndex]() {
>+    return this[_zIndex];
>+  }
>+  set [$zIndex](value) {
>+    this[_zIndex] = value == null ? "" : value;
>+  }
>+  get [_zIndex]() {
>+    return this.zIndex;
>+  }
>+  set [_zIndex](value) {
>+    this.zIndex = value;
>+  }
>+};
>+dart.addTypeTests(html$.CssStyleDeclaration);
>+const cssFloat = Symbol("CssStyleDeclaration.cssFloat");
>+const cssText$ = Symbol("CssStyleDeclaration.cssText");
>+const length$2 = Symbol("CssStyleDeclaration.length");
>+const parentRule$ = Symbol("CssStyleDeclaration.parentRule");
>+dart.setMethodSignature(html$.CssStyleDeclaration, () => ({
>+  __proto__: dart.getMethods(html$.CssStyleDeclaration.__proto__),
>+  [$getPropertyValue]: dart.fnType(core.String, [core.String]),
>+  [_getPropertyValueHelper]: dart.fnType(core.String, [core.String]),
>+  [$supportsProperty]: dart.fnType(core.bool, [core.String]),
>+  [_supportsProperty]: dart.fnType(core.bool, [core.String]),
>+  [$setProperty]: dart.fnType(dart.void, [core.String, core.String], [core.String]),
>+  [_browserPropertyName]: dart.fnType(core.String, [core.String]),
>+  [_supportedBrowserPropertyName]: dart.fnType(core.String, [core.String]),
>+  [_setPropertyHelper]: dart.fnType(dart.void, [core.String, core.String], [core.String]),
>+  [$getPropertyPriority]: dart.fnType(core.String, [core.String]),
>+  [_getPropertyValue]: dart.fnType(core.String, [core.String]),
>+  [$item]: dart.fnType(core.String, [core.int]),
>+  [$removeProperty]: dart.fnType(core.String, [core.String])
>+}));
>+dart.setLibraryUri(html$.CssStyleDeclaration, "dart:html");
>+dart.setFieldSignature(html$.CssStyleDeclaration, () => ({
>+  __proto__: dart.getFields(html$.CssStyleDeclaration.__proto__),
>+  [$cssFloat]: dart.fieldType(core.String),
>+  [$cssText]: dart.fieldType(core.String),
>+  [$length]: dart.finalFieldType(core.int),
>+  [$parentRule]: dart.finalFieldType(html$.CssRule),
>+  [_background]: dart.fieldType(core.String),
>+  [_backgroundAttachment]: dart.fieldType(core.String),
>+  [_backgroundColor]: dart.fieldType(core.String),
>+  [_backgroundImage]: dart.fieldType(core.String),
>+  [_backgroundPosition]: dart.fieldType(core.String),
>+  [_backgroundRepeat]: dart.fieldType(core.String),
>+  [_border]: dart.fieldType(core.String),
>+  [_borderBottom]: dart.fieldType(core.String),
>+  [_borderBottomColor]: dart.fieldType(core.String),
>+  [_borderBottomStyle]: dart.fieldType(core.String),
>+  [_borderBottomWidth]: dart.fieldType(core.String),
>+  [_borderCollapse]: dart.fieldType(core.String),
>+  [_borderColor]: dart.fieldType(core.String),
>+  [_borderLeft]: dart.fieldType(core.String),
>+  [_borderLeftColor]: dart.fieldType(core.String),
>+  [_borderLeftStyle]: dart.fieldType(core.String),
>+  [_borderLeftWidth]: dart.fieldType(core.String),
>+  [_borderRight]: dart.fieldType(core.String),
>+  [_borderRightColor]: dart.fieldType(core.String),
>+  [_borderRightStyle]: dart.fieldType(core.String),
>+  [_borderRightWidth]: dart.fieldType(core.String),
>+  [_borderSpacing]: dart.fieldType(core.String),
>+  [_borderStyle]: dart.fieldType(core.String),
>+  [_borderTop]: dart.fieldType(core.String),
>+  [_borderTopColor]: dart.fieldType(core.String),
>+  [_borderTopStyle]: dart.fieldType(core.String),
>+  [_borderTopWidth]: dart.fieldType(core.String),
>+  [_borderWidth]: dart.fieldType(core.String),
>+  [_bottom]: dart.fieldType(core.String),
>+  [_captionSide]: dart.fieldType(core.String),
>+  [_clear$0]: dart.fieldType(core.String),
>+  [_clip]: dart.fieldType(core.String),
>+  [_color]: dart.fieldType(core.String),
>+  [_content]: dart.fieldType(core.String),
>+  [_cursor]: dart.fieldType(core.String),
>+  [_direction]: dart.fieldType(core.String),
>+  [_display]: dart.fieldType(core.String),
>+  [_emptyCells]: dart.fieldType(core.String),
>+  [_font]: dart.fieldType(core.String),
>+  [_fontFamily]: dart.fieldType(core.String),
>+  [_fontSize]: dart.fieldType(core.String),
>+  [_fontStyle]: dart.fieldType(core.String),
>+  [_fontVariant]: dart.fieldType(core.String),
>+  [_fontWeight]: dart.fieldType(core.String),
>+  [_height$]: dart.fieldType(core.String),
>+  [_left]: dart.fieldType(core.String),
>+  [_letterSpacing]: dart.fieldType(core.String),
>+  [_lineHeight]: dart.fieldType(core.String),
>+  [_listStyle]: dart.fieldType(core.String),
>+  [_listStyleImage]: dart.fieldType(core.String),
>+  [_listStylePosition]: dart.fieldType(core.String),
>+  [_listStyleType]: dart.fieldType(core.String),
>+  [_margin]: dart.fieldType(core.String),
>+  [_marginBottom]: dart.fieldType(core.String),
>+  [_marginLeft]: dart.fieldType(core.String),
>+  [_marginRight]: dart.fieldType(core.String),
>+  [_marginTop]: dart.fieldType(core.String),
>+  [_maxHeight]: dart.fieldType(core.String),
>+  [_maxWidth]: dart.fieldType(core.String),
>+  [_minHeight]: dart.fieldType(core.String),
>+  [_minWidth]: dart.fieldType(core.String),
>+  [_outline]: dart.fieldType(core.String),
>+  [_outlineColor]: dart.fieldType(core.String),
>+  [_outlineStyle]: dart.fieldType(core.String),
>+  [_outlineWidth]: dart.fieldType(core.String),
>+  [_overflow]: dart.fieldType(core.String),
>+  [_padding]: dart.fieldType(core.String),
>+  [_paddingBottom]: dart.fieldType(core.String),
>+  [_paddingLeft]: dart.fieldType(core.String),
>+  [_paddingRight]: dart.fieldType(core.String),
>+  [_paddingTop]: dart.fieldType(core.String),
>+  [_pageBreakAfter]: dart.fieldType(core.String),
>+  [_pageBreakBefore]: dart.fieldType(core.String),
>+  [_pageBreakInside]: dart.fieldType(core.String),
>+  [_position$1]: dart.fieldType(core.String),
>+  [_quotes]: dart.fieldType(core.String),
>+  [_right]: dart.fieldType(core.String),
>+  [_tableLayout]: dart.fieldType(core.String),
>+  [_textAlign]: dart.fieldType(core.String),
>+  [_textDecoration]: dart.fieldType(core.String),
>+  [_textIndent]: dart.fieldType(core.String),
>+  [_textTransform]: dart.fieldType(core.String),
>+  [_top]: dart.fieldType(core.String),
>+  [_unicodeBidi]: dart.fieldType(core.String),
>+  [_verticalAlign]: dart.fieldType(core.String),
>+  [_visibility]: dart.fieldType(core.String),
>+  [_whiteSpace]: dart.fieldType(core.String),
>+  [_width$]: dart.fieldType(core.String),
>+  [_wordSpacing]: dart.fieldType(core.String),
>+  [_zIndex]: dart.fieldType(core.String)
>+}));
>+dart.defineLazy(html$.CssStyleDeclaration, {
>+  /*html$.CssStyleDeclaration._propertyCache*/get _propertyCache() {
>+    return {};
>+  }
>+});
>+dart.registerExtension("CSSStyleDeclaration", html$.CssStyleDeclaration);
>+dart.registerExtension("MSStyleCSSProperties", html$.CssStyleDeclaration);
>+dart.registerExtension("CSS2Properties", html$.CssStyleDeclaration);
>+const _elementIterable = dart.privateName(html$, "_elementIterable");
>+const _elementCssStyleDeclarationSetIterable = dart.privateName(html$, "_elementCssStyleDeclarationSetIterable");
>+const _setAll = dart.privateName(html$, "_setAll");
>+const Object_CssStyleDeclarationBase$ = class Object_CssStyleDeclarationBase extends core.Object {};
>+(Object_CssStyleDeclarationBase$.new = function() {
>+}).prototype = Object_CssStyleDeclarationBase$.prototype;
>+dart.applyMixin(Object_CssStyleDeclarationBase$, html$.CssStyleDeclarationBase);
>+html$._CssStyleDeclarationSet = class _CssStyleDeclarationSet extends Object_CssStyleDeclarationBase$ {
>+  getPropertyValue(propertyName) {
>+    return this[_elementCssStyleDeclarationSetIterable][$first][$getPropertyValue](propertyName);
>+  }
>+  setProperty(propertyName, value, priority) {
>+    if (priority === void 0) priority = null;
>+    this[_elementCssStyleDeclarationSetIterable][$forEach](dart.fn(e => e[$setProperty](propertyName, value, priority), CssStyleDeclarationTovoid()));
>+  }
>+  [_setAll](propertyName, value) {
>+    value = value == null ? "" : value;
>+    for (let element of this[_elementIterable]) {
>+      element.style[propertyName] = value;
>+    }
>+  }
>+  set background(value) {
>+    this[_setAll]("background", value);
>+  }
>+  get background() {
>+    return super.background;
>+  }
>+  set backgroundAttachment(value) {
>+    this[_setAll]("backgroundAttachment", value);
>+  }
>+  get backgroundAttachment() {
>+    return super.backgroundAttachment;
>+  }
>+  set backgroundColor(value) {
>+    this[_setAll]("backgroundColor", value);
>+  }
>+  get backgroundColor() {
>+    return super.backgroundColor;
>+  }
>+  set backgroundImage(value) {
>+    this[_setAll]("backgroundImage", value);
>+  }
>+  get backgroundImage() {
>+    return super.backgroundImage;
>+  }
>+  set backgroundPosition(value) {
>+    this[_setAll]("backgroundPosition", value);
>+  }
>+  get backgroundPosition() {
>+    return super.backgroundPosition;
>+  }
>+  set backgroundRepeat(value) {
>+    this[_setAll]("backgroundRepeat", value);
>+  }
>+  get backgroundRepeat() {
>+    return super.backgroundRepeat;
>+  }
>+  set border(value) {
>+    this[_setAll]("border", value);
>+  }
>+  get border() {
>+    return super.border;
>+  }
>+  set borderBottom(value) {
>+    this[_setAll]("borderBottom", value);
>+  }
>+  get borderBottom() {
>+    return super.borderBottom;
>+  }
>+  set borderBottomColor(value) {
>+    this[_setAll]("borderBottomColor", value);
>+  }
>+  get borderBottomColor() {
>+    return super.borderBottomColor;
>+  }
>+  set borderBottomStyle(value) {
>+    this[_setAll]("borderBottomStyle", value);
>+  }
>+  get borderBottomStyle() {
>+    return super.borderBottomStyle;
>+  }
>+  set borderBottomWidth(value) {
>+    this[_setAll]("borderBottomWidth", value);
>+  }
>+  get borderBottomWidth() {
>+    return super.borderBottomWidth;
>+  }
>+  set borderCollapse(value) {
>+    this[_setAll]("borderCollapse", value);
>+  }
>+  get borderCollapse() {
>+    return super.borderCollapse;
>+  }
>+  set borderColor(value) {
>+    this[_setAll]("borderColor", value);
>+  }
>+  get borderColor() {
>+    return super.borderColor;
>+  }
>+  set borderLeft(value) {
>+    this[_setAll]("borderLeft", value);
>+  }
>+  get borderLeft() {
>+    return super.borderLeft;
>+  }
>+  set borderLeftColor(value) {
>+    this[_setAll]("borderLeftColor", value);
>+  }
>+  get borderLeftColor() {
>+    return super.borderLeftColor;
>+  }
>+  set borderLeftStyle(value) {
>+    this[_setAll]("borderLeftStyle", value);
>+  }
>+  get borderLeftStyle() {
>+    return super.borderLeftStyle;
>+  }
>+  set borderLeftWidth(value) {
>+    this[_setAll]("borderLeftWidth", value);
>+  }
>+  get borderLeftWidth() {
>+    return super.borderLeftWidth;
>+  }
>+  set borderRight(value) {
>+    this[_setAll]("borderRight", value);
>+  }
>+  get borderRight() {
>+    return super.borderRight;
>+  }
>+  set borderRightColor(value) {
>+    this[_setAll]("borderRightColor", value);
>+  }
>+  get borderRightColor() {
>+    return super.borderRightColor;
>+  }
>+  set borderRightStyle(value) {
>+    this[_setAll]("borderRightStyle", value);
>+  }
>+  get borderRightStyle() {
>+    return super.borderRightStyle;
>+  }
>+  set borderRightWidth(value) {
>+    this[_setAll]("borderRightWidth", value);
>+  }
>+  get borderRightWidth() {
>+    return super.borderRightWidth;
>+  }
>+  set borderSpacing(value) {
>+    this[_setAll]("borderSpacing", value);
>+  }
>+  get borderSpacing() {
>+    return super.borderSpacing;
>+  }
>+  set borderStyle(value) {
>+    this[_setAll]("borderStyle", value);
>+  }
>+  get borderStyle() {
>+    return super.borderStyle;
>+  }
>+  set borderTop(value) {
>+    this[_setAll]("borderTop", value);
>+  }
>+  get borderTop() {
>+    return super.borderTop;
>+  }
>+  set borderTopColor(value) {
>+    this[_setAll]("borderTopColor", value);
>+  }
>+  get borderTopColor() {
>+    return super.borderTopColor;
>+  }
>+  set borderTopStyle(value) {
>+    this[_setAll]("borderTopStyle", value);
>+  }
>+  get borderTopStyle() {
>+    return super.borderTopStyle;
>+  }
>+  set borderTopWidth(value) {
>+    this[_setAll]("borderTopWidth", value);
>+  }
>+  get borderTopWidth() {
>+    return super.borderTopWidth;
>+  }
>+  set borderWidth(value) {
>+    this[_setAll]("borderWidth", value);
>+  }
>+  get borderWidth() {
>+    return super.borderWidth;
>+  }
>+  set bottom(value) {
>+    this[_setAll]("bottom", value);
>+  }
>+  get bottom() {
>+    return super.bottom;
>+  }
>+  set captionSide(value) {
>+    this[_setAll]("captionSide", value);
>+  }
>+  get captionSide() {
>+    return super.captionSide;
>+  }
>+  set clear(value) {
>+    this[_setAll]("clear", value);
>+  }
>+  get clear() {
>+    return super.clear;
>+  }
>+  set clip(value) {
>+    this[_setAll]("clip", value);
>+  }
>+  get clip() {
>+    return super.clip;
>+  }
>+  set color(value) {
>+    this[_setAll]("color", value);
>+  }
>+  get color() {
>+    return super.color;
>+  }
>+  set content(value) {
>+    this[_setAll]("content", value);
>+  }
>+  get content() {
>+    return super.content;
>+  }
>+  set cursor(value) {
>+    this[_setAll]("cursor", value);
>+  }
>+  get cursor() {
>+    return super.cursor;
>+  }
>+  set direction(value) {
>+    this[_setAll]("direction", value);
>+  }
>+  get direction() {
>+    return super.direction;
>+  }
>+  set display(value) {
>+    this[_setAll]("display", value);
>+  }
>+  get display() {
>+    return super.display;
>+  }
>+  set emptyCells(value) {
>+    this[_setAll]("emptyCells", value);
>+  }
>+  get emptyCells() {
>+    return super.emptyCells;
>+  }
>+  set font(value) {
>+    this[_setAll]("font", value);
>+  }
>+  get font() {
>+    return super.font;
>+  }
>+  set fontFamily(value) {
>+    this[_setAll]("fontFamily", value);
>+  }
>+  get fontFamily() {
>+    return super.fontFamily;
>+  }
>+  set fontSize(value) {
>+    this[_setAll]("fontSize", value);
>+  }
>+  get fontSize() {
>+    return super.fontSize;
>+  }
>+  set fontStyle(value) {
>+    this[_setAll]("fontStyle", value);
>+  }
>+  get fontStyle() {
>+    return super.fontStyle;
>+  }
>+  set fontVariant(value) {
>+    this[_setAll]("fontVariant", value);
>+  }
>+  get fontVariant() {
>+    return super.fontVariant;
>+  }
>+  set fontWeight(value) {
>+    this[_setAll]("fontWeight", value);
>+  }
>+  get fontWeight() {
>+    return super.fontWeight;
>+  }
>+  set height(value) {
>+    this[_setAll]("height", value);
>+  }
>+  get height() {
>+    return super.height;
>+  }
>+  set left(value) {
>+    this[_setAll]("left", value);
>+  }
>+  get left() {
>+    return super.left;
>+  }
>+  set letterSpacing(value) {
>+    this[_setAll]("letterSpacing", value);
>+  }
>+  get letterSpacing() {
>+    return super.letterSpacing;
>+  }
>+  set lineHeight(value) {
>+    this[_setAll]("lineHeight", value);
>+  }
>+  get lineHeight() {
>+    return super.lineHeight;
>+  }
>+  set listStyle(value) {
>+    this[_setAll]("listStyle", value);
>+  }
>+  get listStyle() {
>+    return super.listStyle;
>+  }
>+  set listStyleImage(value) {
>+    this[_setAll]("listStyleImage", value);
>+  }
>+  get listStyleImage() {
>+    return super.listStyleImage;
>+  }
>+  set listStylePosition(value) {
>+    this[_setAll]("listStylePosition", value);
>+  }
>+  get listStylePosition() {
>+    return super.listStylePosition;
>+  }
>+  set listStyleType(value) {
>+    this[_setAll]("listStyleType", value);
>+  }
>+  get listStyleType() {
>+    return super.listStyleType;
>+  }
>+  set margin(value) {
>+    this[_setAll]("margin", value);
>+  }
>+  get margin() {
>+    return super.margin;
>+  }
>+  set marginBottom(value) {
>+    this[_setAll]("marginBottom", value);
>+  }
>+  get marginBottom() {
>+    return super.marginBottom;
>+  }
>+  set marginLeft(value) {
>+    this[_setAll]("marginLeft", value);
>+  }
>+  get marginLeft() {
>+    return super.marginLeft;
>+  }
>+  set marginRight(value) {
>+    this[_setAll]("marginRight", value);
>+  }
>+  get marginRight() {
>+    return super.marginRight;
>+  }
>+  set marginTop(value) {
>+    this[_setAll]("marginTop", value);
>+  }
>+  get marginTop() {
>+    return super.marginTop;
>+  }
>+  set maxHeight(value) {
>+    this[_setAll]("maxHeight", value);
>+  }
>+  get maxHeight() {
>+    return super.maxHeight;
>+  }
>+  set maxWidth(value) {
>+    this[_setAll]("maxWidth", value);
>+  }
>+  get maxWidth() {
>+    return super.maxWidth;
>+  }
>+  set minHeight(value) {
>+    this[_setAll]("minHeight", value);
>+  }
>+  get minHeight() {
>+    return super.minHeight;
>+  }
>+  set minWidth(value) {
>+    this[_setAll]("minWidth", value);
>+  }
>+  get minWidth() {
>+    return super.minWidth;
>+  }
>+  set outline(value) {
>+    this[_setAll]("outline", value);
>+  }
>+  get outline() {
>+    return super.outline;
>+  }
>+  set outlineColor(value) {
>+    this[_setAll]("outlineColor", value);
>+  }
>+  get outlineColor() {
>+    return super.outlineColor;
>+  }
>+  set outlineStyle(value) {
>+    this[_setAll]("outlineStyle", value);
>+  }
>+  get outlineStyle() {
>+    return super.outlineStyle;
>+  }
>+  set outlineWidth(value) {
>+    this[_setAll]("outlineWidth", value);
>+  }
>+  get outlineWidth() {
>+    return super.outlineWidth;
>+  }
>+  set overflow(value) {
>+    this[_setAll]("overflow", value);
>+  }
>+  get overflow() {
>+    return super.overflow;
>+  }
>+  set padding(value) {
>+    this[_setAll]("padding", value);
>+  }
>+  get padding() {
>+    return super.padding;
>+  }
>+  set paddingBottom(value) {
>+    this[_setAll]("paddingBottom", value);
>+  }
>+  get paddingBottom() {
>+    return super.paddingBottom;
>+  }
>+  set paddingLeft(value) {
>+    this[_setAll]("paddingLeft", value);
>+  }
>+  get paddingLeft() {
>+    return super.paddingLeft;
>+  }
>+  set paddingRight(value) {
>+    this[_setAll]("paddingRight", value);
>+  }
>+  get paddingRight() {
>+    return super.paddingRight;
>+  }
>+  set paddingTop(value) {
>+    this[_setAll]("paddingTop", value);
>+  }
>+  get paddingTop() {
>+    return super.paddingTop;
>+  }
>+  set pageBreakAfter(value) {
>+    this[_setAll]("pageBreakAfter", value);
>+  }
>+  get pageBreakAfter() {
>+    return super.pageBreakAfter;
>+  }
>+  set pageBreakBefore(value) {
>+    this[_setAll]("pageBreakBefore", value);
>+  }
>+  get pageBreakBefore() {
>+    return super.pageBreakBefore;
>+  }
>+  set pageBreakInside(value) {
>+    this[_setAll]("pageBreakInside", value);
>+  }
>+  get pageBreakInside() {
>+    return super.pageBreakInside;
>+  }
>+  set position(value) {
>+    this[_setAll]("position", value);
>+  }
>+  get position() {
>+    return super.position;
>+  }
>+  set quotes(value) {
>+    this[_setAll]("quotes", value);
>+  }
>+  get quotes() {
>+    return super.quotes;
>+  }
>+  set right(value) {
>+    this[_setAll]("right", value);
>+  }
>+  get right() {
>+    return super.right;
>+  }
>+  set tableLayout(value) {
>+    this[_setAll]("tableLayout", value);
>+  }
>+  get tableLayout() {
>+    return super.tableLayout;
>+  }
>+  set textAlign(value) {
>+    this[_setAll]("textAlign", value);
>+  }
>+  get textAlign() {
>+    return super.textAlign;
>+  }
>+  set textDecoration(value) {
>+    this[_setAll]("textDecoration", value);
>+  }
>+  get textDecoration() {
>+    return super.textDecoration;
>+  }
>+  set textIndent(value) {
>+    this[_setAll]("textIndent", value);
>+  }
>+  get textIndent() {
>+    return super.textIndent;
>+  }
>+  set textTransform(value) {
>+    this[_setAll]("textTransform", value);
>+  }
>+  get textTransform() {
>+    return super.textTransform;
>+  }
>+  set top(value) {
>+    this[_setAll]("top", value);
>+  }
>+  get top() {
>+    return super.top;
>+  }
>+  set unicodeBidi(value) {
>+    this[_setAll]("unicodeBidi", value);
>+  }
>+  get unicodeBidi() {
>+    return super.unicodeBidi;
>+  }
>+  set verticalAlign(value) {
>+    this[_setAll]("verticalAlign", value);
>+  }
>+  get verticalAlign() {
>+    return super.verticalAlign;
>+  }
>+  set visibility(value) {
>+    this[_setAll]("visibility", value);
>+  }
>+  get visibility() {
>+    return super.visibility;
>+  }
>+  set whiteSpace(value) {
>+    this[_setAll]("whiteSpace", value);
>+  }
>+  get whiteSpace() {
>+    return super.whiteSpace;
>+  }
>+  set width(value) {
>+    this[_setAll]("width", value);
>+  }
>+  get width() {
>+    return super.width;
>+  }
>+  set wordSpacing(value) {
>+    this[_setAll]("wordSpacing", value);
>+  }
>+  get wordSpacing() {
>+    return super.wordSpacing;
>+  }
>+  set zIndex(value) {
>+    this[_setAll]("zIndex", value);
>+  }
>+  get zIndex() {
>+    return super.zIndex;
>+  }
>+};
>+(html$._CssStyleDeclarationSet.new = function(elementIterable) {
>+  this[_elementCssStyleDeclarationSetIterable] = null;
>+  this[_elementIterable] = elementIterable;
>+  this[_elementCssStyleDeclarationSetIterable] = IterableOfCssStyleDeclaration()._check(core.List.from(this[_elementIterable])[$map](html$.CssStyleDeclaration, dart.fn(e => html$.CssStyleDeclaration._check(dart.dload(e, 'style')), dynamicToCssStyleDeclaration())));
>+}).prototype = html$._CssStyleDeclarationSet.prototype;
>+dart.addTypeTests(html$._CssStyleDeclarationSet);
>+dart.setMethodSignature(html$._CssStyleDeclarationSet, () => ({
>+  __proto__: dart.getMethods(html$._CssStyleDeclarationSet.__proto__),
>+  getPropertyValue: dart.fnType(core.String, [core.String]),
>+  [$getPropertyValue]: dart.fnType(core.String, [core.String]),
>+  setProperty: dart.fnType(dart.void, [core.String, core.String], [core.String]),
>+  [$setProperty]: dart.fnType(dart.void, [core.String, core.String], [core.String]),
>+  [_setAll]: dart.fnType(dart.void, [core.String, core.String])
>+}));
>+dart.setLibraryUri(html$._CssStyleDeclarationSet, "dart:html");
>+dart.setFieldSignature(html$._CssStyleDeclarationSet, () => ({
>+  __proto__: dart.getFields(html$._CssStyleDeclarationSet.__proto__),
>+  [_elementIterable]: dart.finalFieldType(IterableOfElement()),
>+  [_elementCssStyleDeclarationSetIterable]: dart.fieldType(IterableOfCssStyleDeclaration())
>+}));
>+dart.defineExtensionMethods(html$._CssStyleDeclarationSet, ['getPropertyValue', 'setProperty']);
>+dart.defineExtensionAccessors(html$._CssStyleDeclarationSet, [
>+  'background',
>+  'backgroundAttachment',
>+  'backgroundColor',
>+  'backgroundImage',
>+  'backgroundPosition',
>+  'backgroundRepeat',
>+  'border',
>+  'borderBottom',
>+  'borderBottomColor',
>+  'borderBottomStyle',
>+  'borderBottomWidth',
>+  'borderCollapse',
>+  'borderColor',
>+  'borderLeft',
>+  'borderLeftColor',
>+  'borderLeftStyle',
>+  'borderLeftWidth',
>+  'borderRight',
>+  'borderRightColor',
>+  'borderRightStyle',
>+  'borderRightWidth',
>+  'borderSpacing',
>+  'borderStyle',
>+  'borderTop',
>+  'borderTopColor',
>+  'borderTopStyle',
>+  'borderTopWidth',
>+  'borderWidth',
>+  'bottom',
>+  'captionSide',
>+  'clear',
>+  'clip',
>+  'color',
>+  'content',
>+  'cursor',
>+  'direction',
>+  'display',
>+  'emptyCells',
>+  'font',
>+  'fontFamily',
>+  'fontSize',
>+  'fontStyle',
>+  'fontVariant',
>+  'fontWeight',
>+  'height',
>+  'left',
>+  'letterSpacing',
>+  'lineHeight',
>+  'listStyle',
>+  'listStyleImage',
>+  'listStylePosition',
>+  'listStyleType',
>+  'margin',
>+  'marginBottom',
>+  'marginLeft',
>+  'marginRight',
>+  'marginTop',
>+  'maxHeight',
>+  'maxWidth',
>+  'minHeight',
>+  'minWidth',
>+  'outline',
>+  'outlineColor',
>+  'outlineStyle',
>+  'outlineWidth',
>+  'overflow',
>+  'padding',
>+  'paddingBottom',
>+  'paddingLeft',
>+  'paddingRight',
>+  'paddingTop',
>+  'pageBreakAfter',
>+  'pageBreakBefore',
>+  'pageBreakInside',
>+  'position',
>+  'quotes',
>+  'right',
>+  'tableLayout',
>+  'textAlign',
>+  'textDecoration',
>+  'textIndent',
>+  'textTransform',
>+  'top',
>+  'unicodeBidi',
>+  'verticalAlign',
>+  'visibility',
>+  'whiteSpace',
>+  'width',
>+  'wordSpacing',
>+  'zIndex'
>+]);
>+html$.CssStyleRule = class CssStyleRule extends html$.CssRule {
>+  get [$selectorText]() {
>+    return this.selectorText;
>+  }
>+  set [$selectorText](value) {
>+    this.selectorText = value;
>+  }
>+  get [$style]() {
>+    return this.style;
>+  }
>+};
>+dart.addTypeTests(html$.CssStyleRule);
>+const selectorText$ = Symbol("CssStyleRule.selectorText");
>+const style$2 = Symbol("CssStyleRule.style");
>+dart.setLibraryUri(html$.CssStyleRule, "dart:html");
>+dart.setFieldSignature(html$.CssStyleRule, () => ({
>+  __proto__: dart.getFields(html$.CssStyleRule.__proto__),
>+  [$selectorText]: dart.fieldType(core.String),
>+  [$style]: dart.finalFieldType(html$.CssStyleDeclaration)
>+}));
>+dart.registerExtension("CSSStyleRule", html$.CssStyleRule);
>+html$.StyleSheet = class StyleSheet extends _interceptors.Interceptor {
>+  get [$disabled]() {
>+    return this.disabled;
>+  }
>+  set [$disabled](value) {
>+    this.disabled = value;
>+  }
>+  get [$href]() {
>+    return this.href;
>+  }
>+  get [$media]() {
>+    return this.media;
>+  }
>+  get [$ownerNode]() {
>+    return this.ownerNode;
>+  }
>+  get [$parentStyleSheet]() {
>+    return this.parentStyleSheet;
>+  }
>+  get [$title]() {
>+    return this.title;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+};
>+dart.addTypeTests(html$.StyleSheet);
>+const disabled$0 = Symbol("StyleSheet.disabled");
>+const href$2 = Symbol("StyleSheet.href");
>+const media$0 = Symbol("StyleSheet.media");
>+const ownerNode = Symbol("StyleSheet.ownerNode");
>+const parentStyleSheet$ = Symbol("StyleSheet.parentStyleSheet");
>+const title$0 = Symbol("StyleSheet.title");
>+const type$10 = Symbol("StyleSheet.type");
>+dart.setLibraryUri(html$.StyleSheet, "dart:html");
>+dart.setFieldSignature(html$.StyleSheet, () => ({
>+  __proto__: dart.getFields(html$.StyleSheet.__proto__),
>+  [$disabled]: dart.fieldType(core.bool),
>+  [$href]: dart.finalFieldType(core.String),
>+  [$media]: dart.finalFieldType(html$.MediaList),
>+  [$ownerNode]: dart.finalFieldType(html$.Node),
>+  [$parentStyleSheet]: dart.finalFieldType(html$.StyleSheet),
>+  [$title]: dart.finalFieldType(core.String),
>+  [$type]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("StyleSheet", html$.StyleSheet);
>+html$.CssStyleSheet = class CssStyleSheet extends html$.StyleSheet {
>+  get [$cssRules]() {
>+    return this.cssRules;
>+  }
>+  get [$ownerRule]() {
>+    return this.ownerRule;
>+  }
>+  get [$rules]() {
>+    return this.rules;
>+  }
>+  [$addRule](...args) {
>+    return this.addRule.apply(this, args);
>+  }
>+  [$deleteRule](...args) {
>+    return this.deleteRule.apply(this, args);
>+  }
>+  [$insertRule](...args) {
>+    return this.insertRule.apply(this, args);
>+  }
>+  [$removeRule](...args) {
>+    return this.removeRule.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.CssStyleSheet);
>+const cssRules$0 = Symbol("CssStyleSheet.cssRules");
>+const ownerRule = Symbol("CssStyleSheet.ownerRule");
>+const rules = Symbol("CssStyleSheet.rules");
>+dart.setMethodSignature(html$.CssStyleSheet, () => ({
>+  __proto__: dart.getMethods(html$.CssStyleSheet.__proto__),
>+  [$addRule]: dart.fnType(core.int, [core.String, core.String], [core.int]),
>+  [$deleteRule]: dart.fnType(dart.void, [core.int]),
>+  [$insertRule]: dart.fnType(core.int, [core.String], [core.int]),
>+  [$removeRule]: dart.fnType(dart.void, [core.int])
>+}));
>+dart.setLibraryUri(html$.CssStyleSheet, "dart:html");
>+dart.setFieldSignature(html$.CssStyleSheet, () => ({
>+  __proto__: dart.getFields(html$.CssStyleSheet.__proto__),
>+  [$cssRules]: dart.finalFieldType(ListOfCssRule()),
>+  [$ownerRule]: dart.finalFieldType(html$.CssRule),
>+  [$rules]: dart.finalFieldType(ListOfCssRule())
>+}));
>+dart.registerExtension("CSSStyleSheet", html$.CssStyleSheet);
>+html$.CssSupportsRule = class CssSupportsRule extends html$.CssConditionRule {};
>+dart.addTypeTests(html$.CssSupportsRule);
>+dart.setLibraryUri(html$.CssSupportsRule, "dart:html");
>+dart.registerExtension("CSSSupportsRule", html$.CssSupportsRule);
>+html$.CssTransformValue = class CssTransformValue extends html$.CssStyleValue {
>+  static new(transformComponents) {
>+    if (transformComponents === void 0) transformComponents = null;
>+    if (transformComponents == null) {
>+      return html$.CssTransformValue._create_1();
>+    }
>+    if (ListOfCssTransformComponent().is(transformComponents)) {
>+      return html$.CssTransformValue._create_2(transformComponents);
>+    }
>+    dart.throw(new core.ArgumentError.new("Incorrect number or type of arguments"));
>+  }
>+  static _create_1() {
>+    return new CSSTransformValue();
>+  }
>+  static _create_2(transformComponents) {
>+    return new CSSTransformValue(transformComponents);
>+  }
>+  get [$is2D]() {
>+    return this.is2D;
>+  }
>+  get [$length]() {
>+    return this.length;
>+  }
>+  [$componentAtIndex](...args) {
>+    return this.componentAtIndex.apply(this, args);
>+  }
>+  [$toMatrix](...args) {
>+    return this.toMatrix.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.CssTransformValue);
>+const is2D$ = Symbol("CssTransformValue.is2D");
>+const length$3 = Symbol("CssTransformValue.length");
>+dart.setMethodSignature(html$.CssTransformValue, () => ({
>+  __proto__: dart.getMethods(html$.CssTransformValue.__proto__),
>+  [$componentAtIndex]: dart.fnType(html$.CssTransformComponent, [core.int]),
>+  [$toMatrix]: dart.fnType(html$.DomMatrix, [])
>+}));
>+dart.setLibraryUri(html$.CssTransformValue, "dart:html");
>+dart.setFieldSignature(html$.CssTransformValue, () => ({
>+  __proto__: dart.getFields(html$.CssTransformValue.__proto__),
>+  [$is2D]: dart.finalFieldType(core.bool),
>+  [$length]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("CSSTransformValue", html$.CssTransformValue);
>+html$.CssTranslation = class CssTranslation extends html$.CssTransformComponent {
>+  static new(x, y, z) {
>+    if (z === void 0) z = null;
>+    if (html$.CssNumericValue.is(y) && html$.CssNumericValue.is(x) && z == null) {
>+      return html$.CssTranslation._create_1(x, y);
>+    }
>+    if (html$.CssNumericValue.is(z) && html$.CssNumericValue.is(y) && html$.CssNumericValue.is(x)) {
>+      return html$.CssTranslation._create_2(x, y, z);
>+    }
>+    dart.throw(new core.ArgumentError.new("Incorrect number or type of arguments"));
>+  }
>+  static _create_1(x, y) {
>+    return new CSSTranslation(x, y);
>+  }
>+  static _create_2(x, y, z) {
>+    return new CSSTranslation(x, y, z);
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  set [$x](value) {
>+    this.x = value;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+  set [$y](value) {
>+    this.y = value;
>+  }
>+  get [$z]() {
>+    return this.z;
>+  }
>+  set [$z](value) {
>+    this.z = value;
>+  }
>+};
>+dart.addTypeTests(html$.CssTranslation);
>+const x$2 = Symbol("CssTranslation.x");
>+const y$2 = Symbol("CssTranslation.y");
>+const z$1 = Symbol("CssTranslation.z");
>+dart.setLibraryUri(html$.CssTranslation, "dart:html");
>+dart.setFieldSignature(html$.CssTranslation, () => ({
>+  __proto__: dart.getFields(html$.CssTranslation.__proto__),
>+  [$x]: dart.fieldType(html$.CssNumericValue),
>+  [$y]: dart.fieldType(html$.CssNumericValue),
>+  [$z]: dart.fieldType(html$.CssNumericValue)
>+}));
>+dart.registerExtension("CSSTranslation", html$.CssTranslation);
>+html$.CssUnitValue = class CssUnitValue extends html$.CssNumericValue {
>+  static new(value, unit) {
>+    return html$.CssUnitValue._create_1(value, unit);
>+  }
>+  static _create_1(value, unit) {
>+    return new CSSUnitValue(value, unit);
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  get [$unit]() {
>+    return this.unit;
>+  }
>+  set [$unit](value) {
>+    this.unit = value;
>+  }
>+  get [$value]() {
>+    return this.value;
>+  }
>+  set [$value](value) {
>+    this.value = value;
>+  }
>+};
>+dart.addTypeTests(html$.CssUnitValue);
>+const type$11 = Symbol("CssUnitValue.type");
>+const unit = Symbol("CssUnitValue.unit");
>+const value$3 = Symbol("CssUnitValue.value");
>+dart.setLibraryUri(html$.CssUnitValue, "dart:html");
>+dart.setFieldSignature(html$.CssUnitValue, () => ({
>+  __proto__: dart.getFields(html$.CssUnitValue.__proto__),
>+  [$type]: dart.finalFieldType(core.String),
>+  [$unit]: dart.fieldType(core.String),
>+  [$value]: dart.fieldType(core.num)
>+}));
>+dart.registerExtension("CSSUnitValue", html$.CssUnitValue);
>+html$.CssUnparsedValue = class CssUnparsedValue extends html$.CssStyleValue {
>+  get [$length]() {
>+    return this.length;
>+  }
>+  [$fragmentAtIndex](...args) {
>+    return this.fragmentAtIndex.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.CssUnparsedValue);
>+const length$4 = Symbol("CssUnparsedValue.length");
>+dart.setMethodSignature(html$.CssUnparsedValue, () => ({
>+  __proto__: dart.getMethods(html$.CssUnparsedValue.__proto__),
>+  [$fragmentAtIndex]: dart.fnType(core.Object, [core.int])
>+}));
>+dart.setLibraryUri(html$.CssUnparsedValue, "dart:html");
>+dart.setFieldSignature(html$.CssUnparsedValue, () => ({
>+  __proto__: dart.getFields(html$.CssUnparsedValue.__proto__),
>+  [$length]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("CSSUnparsedValue", html$.CssUnparsedValue);
>+html$.CssVariableReferenceValue = class CssVariableReferenceValue extends _interceptors.Interceptor {
>+  get [$fallback]() {
>+    return this.fallback;
>+  }
>+  get [$variable]() {
>+    return this.variable;
>+  }
>+};
>+dart.addTypeTests(html$.CssVariableReferenceValue);
>+const fallback = Symbol("CssVariableReferenceValue.fallback");
>+const variable = Symbol("CssVariableReferenceValue.variable");
>+dart.setLibraryUri(html$.CssVariableReferenceValue, "dart:html");
>+dart.setFieldSignature(html$.CssVariableReferenceValue, () => ({
>+  __proto__: dart.getFields(html$.CssVariableReferenceValue.__proto__),
>+  [$fallback]: dart.finalFieldType(html$.CssUnparsedValue),
>+  [$variable]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("CSSVariableReferenceValue", html$.CssVariableReferenceValue);
>+html$.CssViewportRule = class CssViewportRule extends html$.CssRule {
>+  get [$style]() {
>+    return this.style;
>+  }
>+};
>+dart.addTypeTests(html$.CssViewportRule);
>+const style$3 = Symbol("CssViewportRule.style");
>+dart.setLibraryUri(html$.CssViewportRule, "dart:html");
>+dart.setFieldSignature(html$.CssViewportRule, () => ({
>+  __proto__: dart.getFields(html$.CssViewportRule.__proto__),
>+  [$style]: dart.finalFieldType(html$.CssStyleDeclaration)
>+}));
>+dart.registerExtension("CSSViewportRule", html$.CssViewportRule);
>+html$.CssurlImageValue = class CssurlImageValue extends html$.CssImageValue {
>+  static new(url) {
>+    return html$.CssurlImageValue._create_1(url);
>+  }
>+  static _create_1(url) {
>+    return new CSSURLImageValue(url);
>+  }
>+  get [$url]() {
>+    return this.url;
>+  }
>+};
>+dart.addTypeTests(html$.CssurlImageValue);
>+const url$0 = Symbol("CssurlImageValue.url");
>+dart.setLibraryUri(html$.CssurlImageValue, "dart:html");
>+dart.setFieldSignature(html$.CssurlImageValue, () => ({
>+  __proto__: dart.getFields(html$.CssurlImageValue.__proto__),
>+  [$url]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("CSSURLImageValue", html$.CssurlImageValue);
>+const _define_1 = dart.privateName(html$, "_define_1");
>+const _define_2 = dart.privateName(html$, "_define_2");
>+html$.CustomElementRegistry = class CustomElementRegistry extends _interceptors.Interceptor {
>+  [$define](name, constructor, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      this[_define_1](name, constructor, options_1);
>+      return;
>+    }
>+    this[_define_2](name, constructor);
>+    return;
>+  }
>+  [_define_1](...args) {
>+    return this.define.apply(this, args);
>+  }
>+  [_define_2](...args) {
>+    return this.define.apply(this, args);
>+  }
>+  [$get](...args) {
>+    return this.get.apply(this, args);
>+  }
>+  [$whenDefined](name) {
>+    return html$.promiseToFuture(dart.dynamic, this.whenDefined(name));
>+  }
>+};
>+dart.addTypeTests(html$.CustomElementRegistry);
>+dart.setMethodSignature(html$.CustomElementRegistry, () => ({
>+  __proto__: dart.getMethods(html$.CustomElementRegistry.__proto__),
>+  [$define]: dart.fnType(dart.void, [core.String, core.Object], [core.Map]),
>+  [_define_1]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic]),
>+  [_define_2]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic]),
>+  [$get]: dart.fnType(core.Object, [core.String]),
>+  [$whenDefined]: dart.fnType(async.Future, [core.String])
>+}));
>+dart.setLibraryUri(html$.CustomElementRegistry, "dart:html");
>+dart.registerExtension("CustomElementRegistry", html$.CustomElementRegistry);
>+const _dartDetail = dart.privateName(html$, "_dartDetail");
>+const _initCustomEvent = dart.privateName(html$, "_initCustomEvent");
>+const _detail = dart.privateName(html$, "_detail");
>+const _get__detail = dart.privateName(html$, "_get__detail");
>+html$.CustomEvent = class CustomEvent$ extends html$.Event {
>+  get [_dartDetail]() {
>+    return this._dartDetail;
>+  }
>+  set [_dartDetail](value) {
>+    this._dartDetail = value;
>+  }
>+  static new(type, opts) {
>+    let canBubble = opts && 'canBubble' in opts ? opts.canBubble : true;
>+    let cancelable = opts && 'cancelable' in opts ? opts.cancelable : true;
>+    let detail = opts && 'detail' in opts ? opts.detail : null;
>+    let e = html$.CustomEvent._check(html$.document[_createEvent]("CustomEvent"));
>+    e[_dartDetail] = detail;
>+    if (core.List.is(detail) || core.Map.is(detail) || typeof detail == 'string' || typeof detail == 'number') {
>+      try {
>+        detail = html_common.convertDartToNative_SerializedScriptValue(detail);
>+        e[_initCustomEvent](type, canBubble, cancelable, detail);
>+      } catch (e$) {
>+        let _ = dart.getThrown(e$);
>+        e[_initCustomEvent](type, canBubble, cancelable, null);
>+      }
>+    } else {
>+      e[_initCustomEvent](type, canBubble, cancelable, null);
>+    }
>+    return e;
>+  }
>+  get [$detail]() {
>+    if (this[_dartDetail] != null) {
>+      return this[_dartDetail];
>+    }
>+    return this[_detail];
>+  }
>+  static __(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.CustomEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.CustomEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new CustomEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new CustomEvent(type);
>+  }
>+  get [_detail]() {
>+    return html_common.convertNativeToDart_SerializedScriptValue(this[_get__detail]);
>+  }
>+  get [_get__detail]() {
>+    return this.detail;
>+  }
>+  [_initCustomEvent](...args) {
>+    return this.initCustomEvent.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.CustomEvent);
>+dart.setMethodSignature(html$.CustomEvent, () => ({
>+  __proto__: dart.getMethods(html$.CustomEvent.__proto__),
>+  [_initCustomEvent]: dart.fnType(dart.void, [core.String], [core.bool, core.bool, core.Object])
>+}));
>+dart.setGetterSignature(html$.CustomEvent, () => ({
>+  __proto__: dart.getGetters(html$.CustomEvent.__proto__),
>+  [$detail]: dart.dynamic,
>+  [_detail]: dart.dynamic
>+}));
>+dart.setLibraryUri(html$.CustomEvent, "dart:html");
>+dart.setFieldSignature(html$.CustomEvent, () => ({
>+  __proto__: dart.getFields(html$.CustomEvent.__proto__),
>+  [_dartDetail]: dart.fieldType(dart.dynamic),
>+  [_get__detail]: dart.finalFieldType(dart.dynamic)
>+}));
>+dart.registerExtension("CustomEvent", html$.CustomEvent);
>+html$.DListElement = class DListElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("dl");
>+  }
>+};
>+(html$.DListElement.created = function() {
>+  html$.DListElement.__proto__.created.call(this);
>+}).prototype = html$.DListElement.prototype;
>+dart.addTypeTests(html$.DListElement);
>+dart.setLibraryUri(html$.DListElement, "dart:html");
>+dart.registerExtension("HTMLDListElement", html$.DListElement);
>+html$.DataElement = class DataElement extends html$.HtmlElement {
>+  get [$value]() {
>+    return this.value;
>+  }
>+  set [$value](value) {
>+    this.value = value;
>+  }
>+};
>+(html$.DataElement.created = function() {
>+  this[value$4] = null;
>+  html$.DataElement.__proto__.created.call(this);
>+}).prototype = html$.DataElement.prototype;
>+dart.addTypeTests(html$.DataElement);
>+const value$4 = Symbol("DataElement.value");
>+dart.setLibraryUri(html$.DataElement, "dart:html");
>+dart.setFieldSignature(html$.DataElement, () => ({
>+  __proto__: dart.getFields(html$.DataElement.__proto__),
>+  [$value]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("HTMLDataElement", html$.DataElement);
>+html$.DataListElement = class DataListElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.DataListElement._check(html$.document[$createElement]("datalist"));
>+  }
>+  static get supported() {
>+    return html$.Element.isTagSupported("datalist");
>+  }
>+  get [$options]() {
>+    return this.options;
>+  }
>+};
>+(html$.DataListElement.created = function() {
>+  this[options] = null;
>+  html$.DataListElement.__proto__.created.call(this);
>+}).prototype = html$.DataListElement.prototype;
>+dart.addTypeTests(html$.DataListElement);
>+const options = Symbol("DataListElement.options");
>+dart.setLibraryUri(html$.DataListElement, "dart:html");
>+dart.setFieldSignature(html$.DataListElement, () => ({
>+  __proto__: dart.getFields(html$.DataListElement.__proto__),
>+  [$options]: dart.finalFieldType(ListOfNode())
>+}));
>+dart.registerExtension("HTMLDataListElement", html$.DataListElement);
>+html$.DataTransfer = class DataTransfer$ extends _interceptors.Interceptor {
>+  static new() {
>+    return html$.DataTransfer._create_1();
>+  }
>+  static _create_1() {
>+    return new DataTransfer();
>+  }
>+  get [$dropEffect]() {
>+    return this.dropEffect;
>+  }
>+  set [$dropEffect](value) {
>+    this.dropEffect = value;
>+  }
>+  get [$effectAllowed]() {
>+    return this.effectAllowed;
>+  }
>+  set [$effectAllowed](value) {
>+    this.effectAllowed = value;
>+  }
>+  get [$files]() {
>+    return this.files;
>+  }
>+  get [$items]() {
>+    return this.items;
>+  }
>+  get [$types]() {
>+    return this.types;
>+  }
>+  [$clearData](...args) {
>+    return this.clearData.apply(this, args);
>+  }
>+  [$getData](...args) {
>+    return this.getData.apply(this, args);
>+  }
>+  [$setData](...args) {
>+    return this.setData.apply(this, args);
>+  }
>+  [$setDragImage](...args) {
>+    return this.setDragImage.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.DataTransfer);
>+const dropEffect = Symbol("DataTransfer.dropEffect");
>+const effectAllowed = Symbol("DataTransfer.effectAllowed");
>+const files = Symbol("DataTransfer.files");
>+const items = Symbol("DataTransfer.items");
>+const types = Symbol("DataTransfer.types");
>+dart.setMethodSignature(html$.DataTransfer, () => ({
>+  __proto__: dart.getMethods(html$.DataTransfer.__proto__),
>+  [$clearData]: dart.fnType(dart.void, [], [core.String]),
>+  [$getData]: dart.fnType(core.String, [core.String]),
>+  [$setData]: dart.fnType(dart.void, [core.String, core.String]),
>+  [$setDragImage]: dart.fnType(dart.void, [html$.Element, core.int, core.int])
>+}));
>+dart.setLibraryUri(html$.DataTransfer, "dart:html");
>+dart.setFieldSignature(html$.DataTransfer, () => ({
>+  __proto__: dart.getFields(html$.DataTransfer.__proto__),
>+  [$dropEffect]: dart.fieldType(core.String),
>+  [$effectAllowed]: dart.fieldType(core.String),
>+  [$files]: dart.finalFieldType(ListOfFile()),
>+  [$items]: dart.finalFieldType(html$.DataTransferItemList),
>+  [$types]: dart.finalFieldType(ListOfString())
>+}));
>+dart.registerExtension("DataTransfer", html$.DataTransfer);
>+const _webkitGetAsEntry = dart.privateName(html$, "_webkitGetAsEntry");
>+html$.DataTransferItem = class DataTransferItem extends _interceptors.Interceptor {
>+  [$getAsEntry]() {
>+    let entry = this[_webkitGetAsEntry]();
>+    if (dart.test(entry.isFile))
>+      _js_helper.applyExtension("FileEntry", entry);
>+    else if (dart.test(entry.isDirectory))
>+      _js_helper.applyExtension("DirectoryEntry", entry);
>+    else
>+      _js_helper.applyExtension("Entry", entry);
>+    return entry;
>+  }
>+  get [$kind]() {
>+    return this.kind;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  [$getAsFile](...args) {
>+    return this.getAsFile.apply(this, args);
>+  }
>+  [_webkitGetAsEntry](...args) {
>+    return this.webkitGetAsEntry.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.DataTransferItem);
>+const kind$ = Symbol("DataTransferItem.kind");
>+const type$12 = Symbol("DataTransferItem.type");
>+dart.setMethodSignature(html$.DataTransferItem, () => ({
>+  __proto__: dart.getMethods(html$.DataTransferItem.__proto__),
>+  [$getAsEntry]: dart.fnType(html$.Entry, []),
>+  [$getAsFile]: dart.fnType(html$.File, []),
>+  [_webkitGetAsEntry]: dart.fnType(html$.Entry, [])
>+}));
>+dart.setLibraryUri(html$.DataTransferItem, "dart:html");
>+dart.setFieldSignature(html$.DataTransferItem, () => ({
>+  __proto__: dart.getFields(html$.DataTransferItem.__proto__),
>+  [$kind]: dart.finalFieldType(core.String),
>+  [$type]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("DataTransferItem", html$.DataTransferItem);
>+html$.DataTransferItemList = class DataTransferItemList extends _interceptors.Interceptor {
>+  get [$length]() {
>+    return this.length;
>+  }
>+  [$add](...args) {
>+    return this.add.apply(this, args);
>+  }
>+  [$addData](...args) {
>+    return this.add.apply(this, args);
>+  }
>+  [$addFile](...args) {
>+    return this.add.apply(this, args);
>+  }
>+  [$clear](...args) {
>+    return this.clear.apply(this, args);
>+  }
>+  [$item](...args) {
>+    return this.item.apply(this, args);
>+  }
>+  [$remove](...args) {
>+    return this.remove.apply(this, args);
>+  }
>+  [$_get](index) {
>+    return this[index];
>+  }
>+};
>+dart.addTypeTests(html$.DataTransferItemList);
>+const length$5 = Symbol("DataTransferItemList.length");
>+dart.setMethodSignature(html$.DataTransferItemList, () => ({
>+  __proto__: dart.getMethods(html$.DataTransferItemList.__proto__),
>+  [$add]: dart.fnType(html$.DataTransferItem, [dart.dynamic], [core.String]),
>+  [$addData]: dart.fnType(html$.DataTransferItem, [core.String, core.String]),
>+  [$addFile]: dart.fnType(html$.DataTransferItem, [html$.File]),
>+  [$clear]: dart.fnType(dart.void, []),
>+  [$item]: dart.fnType(html$.DataTransferItem, [core.int]),
>+  [$remove]: dart.fnType(dart.void, [core.int]),
>+  [$_get]: dart.fnType(html$.DataTransferItem, [core.int])
>+}));
>+dart.setLibraryUri(html$.DataTransferItemList, "dart:html");
>+dart.setFieldSignature(html$.DataTransferItemList, () => ({
>+  __proto__: dart.getFields(html$.DataTransferItemList.__proto__),
>+  [$length]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("DataTransferItemList", html$.DataTransferItemList);
>+const _postMessage_1 = dart.privateName(html$, "_postMessage_1");
>+const _postMessage_2 = dart.privateName(html$, "_postMessage_2");
>+const _webkitRequestFileSystem = dart.privateName(html$, "_webkitRequestFileSystem");
>+const _webkitResolveLocalFileSystemUrl = dart.privateName(html$, "_webkitResolveLocalFileSystemUrl");
>+const _setInterval_String = dart.privateName(html$, "_setInterval_String");
>+const _setTimeout_String = dart.privateName(html$, "_setTimeout_String");
>+const _clearInterval = dart.privateName(html$, "_clearInterval");
>+const _clearTimeout = dart.privateName(html$, "_clearTimeout");
>+const _setInterval = dart.privateName(html$, "_setInterval");
>+const _setTimeout = dart.privateName(html$, "_setTimeout");
>+html$.WorkerGlobalScope = class WorkerGlobalScope extends html$.EventTarget {
>+  get [$addressSpace]() {
>+    return this.addressSpace;
>+  }
>+  get [$caches]() {
>+    return this.caches;
>+  }
>+  get [$crypto]() {
>+    return this.crypto;
>+  }
>+  get [$indexedDB]() {
>+    return this.indexedDB;
>+  }
>+  get [$isSecureContext]() {
>+    return this.isSecureContext;
>+  }
>+  get [$location]() {
>+    return this.location;
>+  }
>+  get [$navigator]() {
>+    return this.navigator;
>+  }
>+  get [$origin]() {
>+    return this.origin;
>+  }
>+  get [$performance]() {
>+    return this.performance;
>+  }
>+  get [$self]() {
>+    return this.self;
>+  }
>+  [$fetch](input, init) {
>+    if (init === void 0) init = null;
>+    let init_dict = null;
>+    if (init != null) {
>+      init_dict = html_common.convertDartToNative_Dictionary(init);
>+    }
>+    return html$.promiseToFuture(dart.dynamic, this.fetch(input, init_dict));
>+  }
>+  [$importScripts](...args) {
>+    return this.importScripts.apply(this, args);
>+  }
>+  [$atob](...args) {
>+    return this.atob.apply(this, args);
>+  }
>+  [$btoa](...args) {
>+    return this.btoa.apply(this, args);
>+  }
>+  [_setInterval_String](...args) {
>+    return this.setInterval.apply(this, args);
>+  }
>+  [_setTimeout_String](...args) {
>+    return this.setTimeout.apply(this, args);
>+  }
>+  [_clearInterval](...args) {
>+    return this.clearInterval.apply(this, args);
>+  }
>+  [_clearTimeout](...args) {
>+    return this.clearTimeout.apply(this, args);
>+  }
>+  [_setInterval](...args) {
>+    return this.setInterval.apply(this, args);
>+  }
>+  [_setTimeout](...args) {
>+    return this.setTimeout.apply(this, args);
>+  }
>+  get [$onError]() {
>+    return html$.WorkerGlobalScope.errorEvent.forTarget(this);
>+  }
>+  static get instance() {
>+    return html$._workerSelf;
>+  }
>+};
>+dart.addTypeTests(html$.WorkerGlobalScope);
>+const addressSpace = Symbol("WorkerGlobalScope.addressSpace");
>+const caches = Symbol("WorkerGlobalScope.caches");
>+const crypto$ = Symbol("WorkerGlobalScope.crypto");
>+const indexedDB = Symbol("WorkerGlobalScope.indexedDB");
>+const isSecureContext = Symbol("WorkerGlobalScope.isSecureContext");
>+const navigator = Symbol("WorkerGlobalScope.navigator");
>+const origin$0 = Symbol("WorkerGlobalScope.origin");
>+const performance = Symbol("WorkerGlobalScope.performance");
>+const self$ = Symbol("WorkerGlobalScope.self");
>+html$.WorkerGlobalScope[dart.implements] = () => [html$._WindowTimers, html$.WindowBase64];
>+dart.setMethodSignature(html$.WorkerGlobalScope, () => ({
>+  __proto__: dart.getMethods(html$.WorkerGlobalScope.__proto__),
>+  [$fetch]: dart.fnType(async.Future, [dart.dynamic], [core.Map]),
>+  [$importScripts]: dart.fnType(dart.void, [core.String]),
>+  [$atob]: dart.fnType(core.String, [core.String]),
>+  [$btoa]: dart.fnType(core.String, [core.String]),
>+  [_setInterval_String]: dart.fnType(core.int, [core.String], [core.int, core.Object]),
>+  [_setTimeout_String]: dart.fnType(core.int, [core.String], [core.int, core.Object]),
>+  [_clearInterval]: dart.fnType(dart.void, [], [core.int]),
>+  [_clearTimeout]: dart.fnType(dart.void, [], [core.int]),
>+  [_setInterval]: dart.fnType(core.int, [core.Object], [core.int]),
>+  [_setTimeout]: dart.fnType(core.int, [core.Object], [core.int])
>+}));
>+dart.setGetterSignature(html$.WorkerGlobalScope, () => ({
>+  __proto__: dart.getGetters(html$.WorkerGlobalScope.__proto__),
>+  [$onError]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.WorkerGlobalScope, "dart:html");
>+dart.setFieldSignature(html$.WorkerGlobalScope, () => ({
>+  __proto__: dart.getFields(html$.WorkerGlobalScope.__proto__),
>+  [$addressSpace]: dart.finalFieldType(core.String),
>+  [$caches]: dart.finalFieldType(html$.CacheStorage),
>+  [$crypto]: dart.finalFieldType(html$.Crypto),
>+  [$indexedDB]: dart.finalFieldType(indexed_db.IdbFactory),
>+  [$isSecureContext]: dart.finalFieldType(core.bool),
>+  [$location]: dart.finalFieldType(html$._WorkerLocation),
>+  [$navigator]: dart.finalFieldType(html$._WorkerNavigator),
>+  [$origin]: dart.finalFieldType(core.String),
>+  [$performance]: dart.finalFieldType(html$.WorkerPerformance),
>+  [$self]: dart.finalFieldType(html$.WorkerGlobalScope)
>+}));
>+dart.defineLazy(html$.WorkerGlobalScope, {
>+  /*html$.WorkerGlobalScope.errorEvent*/get errorEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("error"));
>+  }
>+});
>+dart.registerExtension("WorkerGlobalScope", html$.WorkerGlobalScope);
>+html$.DedicatedWorkerGlobalScope = class DedicatedWorkerGlobalScope extends html$.WorkerGlobalScope {
>+  [$close](...args) {
>+    return this.close.apply(this, args);
>+  }
>+  [$postMessage](message, transfer) {
>+    if (transfer === void 0) transfer = null;
>+    if (transfer != null) {
>+      let message_1 = html_common.convertDartToNative_SerializedScriptValue(message);
>+      this[_postMessage_1](message_1, transfer);
>+      return;
>+    }
>+    let message_1 = html_common.convertDartToNative_SerializedScriptValue(message);
>+    this[_postMessage_2](message_1);
>+    return;
>+  }
>+  [_postMessage_1](...args) {
>+    return this.postMessage.apply(this, args);
>+  }
>+  [_postMessage_2](...args) {
>+    return this.postMessage.apply(this, args);
>+  }
>+  [_webkitRequestFileSystem](...args) {
>+    return this.webkitRequestFileSystem.apply(this, args);
>+  }
>+  [$requestFileSystemSync](...args) {
>+    return this.webkitRequestFileSystemSync.apply(this, args);
>+  }
>+  [$resolveLocalFileSystemSyncUrl](...args) {
>+    return this.webkitResolveLocalFileSystemSyncURL.apply(this, args);
>+  }
>+  [_webkitResolveLocalFileSystemUrl](...args) {
>+    return this.webkitResolveLocalFileSystemURL.apply(this, args);
>+  }
>+  get [$onMessage]() {
>+    return html$.DedicatedWorkerGlobalScope.messageEvent.forTarget(this);
>+  }
>+  static get instance() {
>+    return html$.DedicatedWorkerGlobalScope.as(html$._workerSelf);
>+  }
>+};
>+dart.addTypeTests(html$.DedicatedWorkerGlobalScope);
>+dart.setMethodSignature(html$.DedicatedWorkerGlobalScope, () => ({
>+  __proto__: dart.getMethods(html$.DedicatedWorkerGlobalScope.__proto__),
>+  [$close]: dart.fnType(dart.void, []),
>+  [$postMessage]: dart.fnType(dart.void, [dart.dynamic], [core.List$(core.Object)]),
>+  [_postMessage_1]: dart.fnType(dart.void, [dart.dynamic, core.List$(core.Object)]),
>+  [_postMessage_2]: dart.fnType(dart.void, [dart.dynamic]),
>+  [_webkitRequestFileSystem]: dart.fnType(dart.void, [core.int, core.int], [dart.fnType(dart.void, [html$.FileSystem]), dart.fnType(dart.void, [html$.DomException])]),
>+  [$requestFileSystemSync]: dart.fnType(html$._DOMFileSystemSync, [core.int, core.int]),
>+  [$resolveLocalFileSystemSyncUrl]: dart.fnType(html$._EntrySync, [core.String]),
>+  [_webkitResolveLocalFileSystemUrl]: dart.fnType(dart.void, [core.String, dart.fnType(dart.void, [html$.Entry])], [dart.fnType(dart.void, [html$.DomException])])
>+}));
>+dart.setGetterSignature(html$.DedicatedWorkerGlobalScope, () => ({
>+  __proto__: dart.getGetters(html$.DedicatedWorkerGlobalScope.__proto__),
>+  [$onMessage]: async.Stream$(html$.MessageEvent)
>+}));
>+dart.setLibraryUri(html$.DedicatedWorkerGlobalScope, "dart:html");
>+dart.defineLazy(html$.DedicatedWorkerGlobalScope, {
>+  /*html$.DedicatedWorkerGlobalScope.messageEvent*/get messageEvent() {
>+    return dart.const(new (EventStreamProviderOfMessageEvent()).new("message"));
>+  },
>+  /*html$.DedicatedWorkerGlobalScope.PERSISTENT*/get PERSISTENT() {
>+    return 1;
>+  },
>+  /*html$.DedicatedWorkerGlobalScope.TEMPORARY*/get TEMPORARY() {
>+    return 0;
>+  }
>+});
>+dart.registerExtension("DedicatedWorkerGlobalScope", html$.DedicatedWorkerGlobalScope);
>+html$.DeprecatedStorageInfo = class DeprecatedStorageInfo extends _interceptors.Interceptor {
>+  [$queryUsageAndQuota](...args) {
>+    return this.queryUsageAndQuota.apply(this, args);
>+  }
>+  [$requestQuota](...args) {
>+    return this.requestQuota.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.DeprecatedStorageInfo);
>+dart.setMethodSignature(html$.DeprecatedStorageInfo, () => ({
>+  __proto__: dart.getMethods(html$.DeprecatedStorageInfo.__proto__),
>+  [$queryUsageAndQuota]: dart.fnType(dart.void, [core.int], [dart.fnType(dart.void, [core.int, core.int]), dart.fnType(dart.void, [html$.DomError])]),
>+  [$requestQuota]: dart.fnType(dart.void, [core.int, core.int], [dart.fnType(dart.void, [core.int]), dart.fnType(dart.void, [html$.DomError])])
>+}));
>+dart.setLibraryUri(html$.DeprecatedStorageInfo, "dart:html");
>+dart.defineLazy(html$.DeprecatedStorageInfo, {
>+  /*html$.DeprecatedStorageInfo.PERSISTENT*/get PERSISTENT() {
>+    return 1;
>+  },
>+  /*html$.DeprecatedStorageInfo.TEMPORARY*/get TEMPORARY() {
>+    return 0;
>+  }
>+});
>+dart.registerExtension("DeprecatedStorageInfo", html$.DeprecatedStorageInfo);
>+html$.DeprecatedStorageQuota = class DeprecatedStorageQuota extends _interceptors.Interceptor {
>+  [$queryUsageAndQuota](...args) {
>+    return this.queryUsageAndQuota.apply(this, args);
>+  }
>+  [$requestQuota](...args) {
>+    return this.requestQuota.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.DeprecatedStorageQuota);
>+dart.setMethodSignature(html$.DeprecatedStorageQuota, () => ({
>+  __proto__: dart.getMethods(html$.DeprecatedStorageQuota.__proto__),
>+  [$queryUsageAndQuota]: dart.fnType(dart.void, [dart.fnType(dart.void, [core.int, core.int])], [dart.fnType(dart.void, [html$.DomError])]),
>+  [$requestQuota]: dart.fnType(dart.void, [core.int], [dart.fnType(dart.void, [core.int]), dart.fnType(dart.void, [html$.DomError])])
>+}));
>+dart.setLibraryUri(html$.DeprecatedStorageQuota, "dart:html");
>+dart.registerExtension("DeprecatedStorageQuota", html$.DeprecatedStorageQuota);
>+html$.ReportBody = class ReportBody extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$.ReportBody);
>+dart.setLibraryUri(html$.ReportBody, "dart:html");
>+dart.registerExtension("ReportBody", html$.ReportBody);
>+html$.DeprecationReport = class DeprecationReport extends html$.ReportBody {
>+  get [$lineNumber]() {
>+    return this.lineNumber;
>+  }
>+  get [$message]() {
>+    return this.message;
>+  }
>+  get [$sourceFile]() {
>+    return this.sourceFile;
>+  }
>+};
>+dart.addTypeTests(html$.DeprecationReport);
>+const lineNumber = Symbol("DeprecationReport.lineNumber");
>+const message$16 = Symbol("DeprecationReport.message");
>+const sourceFile = Symbol("DeprecationReport.sourceFile");
>+dart.setLibraryUri(html$.DeprecationReport, "dart:html");
>+dart.setFieldSignature(html$.DeprecationReport, () => ({
>+  __proto__: dart.getFields(html$.DeprecationReport.__proto__),
>+  [$lineNumber]: dart.finalFieldType(core.int),
>+  [$message]: dart.finalFieldType(core.String),
>+  [$sourceFile]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("DeprecationReport", html$.DeprecationReport);
>+html$.DetailsElement = class DetailsElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.DetailsElement._check(html$.document[$createElement]("details"));
>+  }
>+  static get supported() {
>+    return html$.Element.isTagSupported("details");
>+  }
>+  get [$open]() {
>+    return this.open;
>+  }
>+  set [$open](value) {
>+    this.open = value;
>+  }
>+};
>+(html$.DetailsElement.created = function() {
>+  this[open] = null;
>+  html$.DetailsElement.__proto__.created.call(this);
>+}).prototype = html$.DetailsElement.prototype;
>+dart.addTypeTests(html$.DetailsElement);
>+const open = Symbol("DetailsElement.open");
>+dart.setLibraryUri(html$.DetailsElement, "dart:html");
>+dart.setFieldSignature(html$.DetailsElement, () => ({
>+  __proto__: dart.getFields(html$.DetailsElement.__proto__),
>+  [$open]: dart.fieldType(core.bool)
>+}));
>+dart.registerExtension("HTMLDetailsElement", html$.DetailsElement);
>+html$.DetectedBarcode = class DetectedBarcode$ extends _interceptors.Interceptor {
>+  static new() {
>+    return html$.DetectedBarcode._create_1();
>+  }
>+  static _create_1() {
>+    return new DetectedBarcode();
>+  }
>+  get [$boundingBox]() {
>+    return this.boundingBox;
>+  }
>+  get [$cornerPoints]() {
>+    return this.cornerPoints;
>+  }
>+  get [$rawValue]() {
>+    return this.rawValue;
>+  }
>+};
>+dart.addTypeTests(html$.DetectedBarcode);
>+const boundingBox = Symbol("DetectedBarcode.boundingBox");
>+const cornerPoints = Symbol("DetectedBarcode.cornerPoints");
>+const rawValue = Symbol("DetectedBarcode.rawValue");
>+dart.setLibraryUri(html$.DetectedBarcode, "dart:html");
>+dart.setFieldSignature(html$.DetectedBarcode, () => ({
>+  __proto__: dart.getFields(html$.DetectedBarcode.__proto__),
>+  [$boundingBox]: dart.finalFieldType(RectangleOfnum()),
>+  [$cornerPoints]: dart.finalFieldType(core.List),
>+  [$rawValue]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("DetectedBarcode", html$.DetectedBarcode);
>+html$.DetectedFace = class DetectedFace$ extends _interceptors.Interceptor {
>+  static new() {
>+    return html$.DetectedFace._create_1();
>+  }
>+  static _create_1() {
>+    return new DetectedFace();
>+  }
>+  get [$boundingBox]() {
>+    return this.boundingBox;
>+  }
>+  get [$landmarks]() {
>+    return this.landmarks;
>+  }
>+};
>+dart.addTypeTests(html$.DetectedFace);
>+const boundingBox$ = Symbol("DetectedFace.boundingBox");
>+const landmarks = Symbol("DetectedFace.landmarks");
>+dart.setLibraryUri(html$.DetectedFace, "dart:html");
>+dart.setFieldSignature(html$.DetectedFace, () => ({
>+  __proto__: dart.getFields(html$.DetectedFace.__proto__),
>+  [$boundingBox]: dart.finalFieldType(RectangleOfnum()),
>+  [$landmarks]: dart.finalFieldType(core.List)
>+}));
>+dart.registerExtension("DetectedFace", html$.DetectedFace);
>+html$.DetectedText = class DetectedText$ extends _interceptors.Interceptor {
>+  static new() {
>+    return html$.DetectedText._create_1();
>+  }
>+  static _create_1() {
>+    return new DetectedText();
>+  }
>+  get [$boundingBox]() {
>+    return this.boundingBox;
>+  }
>+  get [$cornerPoints]() {
>+    return this.cornerPoints;
>+  }
>+  get [$rawValue]() {
>+    return this.rawValue;
>+  }
>+};
>+dart.addTypeTests(html$.DetectedText);
>+const boundingBox$0 = Symbol("DetectedText.boundingBox");
>+const cornerPoints$ = Symbol("DetectedText.cornerPoints");
>+const rawValue$ = Symbol("DetectedText.rawValue");
>+dart.setLibraryUri(html$.DetectedText, "dart:html");
>+dart.setFieldSignature(html$.DetectedText, () => ({
>+  __proto__: dart.getFields(html$.DetectedText.__proto__),
>+  [$boundingBox]: dart.finalFieldType(RectangleOfnum()),
>+  [$cornerPoints]: dart.finalFieldType(core.List),
>+  [$rawValue]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("DetectedText", html$.DetectedText);
>+html$.DeviceAcceleration = class DeviceAcceleration extends _interceptors.Interceptor {
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+  get [$z]() {
>+    return this.z;
>+  }
>+};
>+dart.addTypeTests(html$.DeviceAcceleration);
>+const x$3 = Symbol("DeviceAcceleration.x");
>+const y$3 = Symbol("DeviceAcceleration.y");
>+const z$2 = Symbol("DeviceAcceleration.z");
>+dart.setLibraryUri(html$.DeviceAcceleration, "dart:html");
>+dart.setFieldSignature(html$.DeviceAcceleration, () => ({
>+  __proto__: dart.getFields(html$.DeviceAcceleration.__proto__),
>+  [$x]: dart.finalFieldType(core.num),
>+  [$y]: dart.finalFieldType(core.num),
>+  [$z]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("DeviceAcceleration", html$.DeviceAcceleration);
>+html$.DeviceMotionEvent = class DeviceMotionEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.DeviceMotionEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.DeviceMotionEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new DeviceMotionEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new DeviceMotionEvent(type);
>+  }
>+  get [$acceleration]() {
>+    return this.acceleration;
>+  }
>+  get [$accelerationIncludingGravity]() {
>+    return this.accelerationIncludingGravity;
>+  }
>+  get [$interval]() {
>+    return this.interval;
>+  }
>+  get [$rotationRate]() {
>+    return this.rotationRate;
>+  }
>+};
>+dart.addTypeTests(html$.DeviceMotionEvent);
>+const acceleration = Symbol("DeviceMotionEvent.acceleration");
>+const accelerationIncludingGravity = Symbol("DeviceMotionEvent.accelerationIncludingGravity");
>+const interval = Symbol("DeviceMotionEvent.interval");
>+const rotationRate = Symbol("DeviceMotionEvent.rotationRate");
>+dart.setLibraryUri(html$.DeviceMotionEvent, "dart:html");
>+dart.setFieldSignature(html$.DeviceMotionEvent, () => ({
>+  __proto__: dart.getFields(html$.DeviceMotionEvent.__proto__),
>+  [$acceleration]: dart.finalFieldType(html$.DeviceAcceleration),
>+  [$accelerationIncludingGravity]: dart.finalFieldType(html$.DeviceAcceleration),
>+  [$interval]: dart.finalFieldType(core.num),
>+  [$rotationRate]: dart.finalFieldType(html$.DeviceRotationRate)
>+}));
>+dart.registerExtension("DeviceMotionEvent", html$.DeviceMotionEvent);
>+html$.DeviceOrientationEvent = class DeviceOrientationEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.DeviceOrientationEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.DeviceOrientationEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new DeviceOrientationEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new DeviceOrientationEvent(type);
>+  }
>+  get [$absolute]() {
>+    return this.absolute;
>+  }
>+  get [$alpha]() {
>+    return this.alpha;
>+  }
>+  get [$beta]() {
>+    return this.beta;
>+  }
>+  get [$gamma]() {
>+    return this.gamma;
>+  }
>+};
>+dart.addTypeTests(html$.DeviceOrientationEvent);
>+const absolute = Symbol("DeviceOrientationEvent.absolute");
>+const alpha = Symbol("DeviceOrientationEvent.alpha");
>+const beta = Symbol("DeviceOrientationEvent.beta");
>+const gamma = Symbol("DeviceOrientationEvent.gamma");
>+dart.setLibraryUri(html$.DeviceOrientationEvent, "dart:html");
>+dart.setFieldSignature(html$.DeviceOrientationEvent, () => ({
>+  __proto__: dart.getFields(html$.DeviceOrientationEvent.__proto__),
>+  [$absolute]: dart.finalFieldType(core.bool),
>+  [$alpha]: dart.finalFieldType(core.num),
>+  [$beta]: dart.finalFieldType(core.num),
>+  [$gamma]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("DeviceOrientationEvent", html$.DeviceOrientationEvent);
>+html$.DeviceRotationRate = class DeviceRotationRate extends _interceptors.Interceptor {
>+  get [$alpha]() {
>+    return this.alpha;
>+  }
>+  get [$beta]() {
>+    return this.beta;
>+  }
>+  get [$gamma]() {
>+    return this.gamma;
>+  }
>+};
>+dart.addTypeTests(html$.DeviceRotationRate);
>+const alpha$ = Symbol("DeviceRotationRate.alpha");
>+const beta$ = Symbol("DeviceRotationRate.beta");
>+const gamma$ = Symbol("DeviceRotationRate.gamma");
>+dart.setLibraryUri(html$.DeviceRotationRate, "dart:html");
>+dart.setFieldSignature(html$.DeviceRotationRate, () => ({
>+  __proto__: dart.getFields(html$.DeviceRotationRate.__proto__),
>+  [$alpha]: dart.finalFieldType(core.num),
>+  [$beta]: dart.finalFieldType(core.num),
>+  [$gamma]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("DeviceRotationRate", html$.DeviceRotationRate);
>+html$.DialogElement = class DialogElement extends html$.HtmlElement {
>+  get [$open]() {
>+    return this.open;
>+  }
>+  set [$open](value) {
>+    this.open = value;
>+  }
>+  get [$returnValue]() {
>+    return this.returnValue;
>+  }
>+  set [$returnValue](value) {
>+    this.returnValue = value;
>+  }
>+  [$close](...args) {
>+    return this.close.apply(this, args);
>+  }
>+  [$show](...args) {
>+    return this.show.apply(this, args);
>+  }
>+  [$showModal](...args) {
>+    return this.showModal.apply(this, args);
>+  }
>+};
>+(html$.DialogElement.created = function() {
>+  this[open$] = null;
>+  this[returnValue] = null;
>+  html$.DialogElement.__proto__.created.call(this);
>+}).prototype = html$.DialogElement.prototype;
>+dart.addTypeTests(html$.DialogElement);
>+const open$ = Symbol("DialogElement.open");
>+const returnValue = Symbol("DialogElement.returnValue");
>+dart.setMethodSignature(html$.DialogElement, () => ({
>+  __proto__: dart.getMethods(html$.DialogElement.__proto__),
>+  [$close]: dart.fnType(dart.void, [], [core.String]),
>+  [$show]: dart.fnType(dart.void, []),
>+  [$showModal]: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(html$.DialogElement, "dart:html");
>+dart.setFieldSignature(html$.DialogElement, () => ({
>+  __proto__: dart.getFields(html$.DialogElement.__proto__),
>+  [$open]: dart.fieldType(core.bool),
>+  [$returnValue]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("HTMLDialogElement", html$.DialogElement);
>+const _getDirectory = dart.privateName(html$, "_getDirectory");
>+const _createReader = dart.privateName(html$, "_createReader");
>+const _getFile = dart.privateName(html$, "_getFile");
>+const __getDirectory_1 = dart.privateName(html$, "__getDirectory_1");
>+const __getDirectory_2 = dart.privateName(html$, "__getDirectory_2");
>+const __getDirectory_3 = dart.privateName(html$, "__getDirectory_3");
>+const __getDirectory_4 = dart.privateName(html$, "__getDirectory_4");
>+const __getDirectory = dart.privateName(html$, "__getDirectory");
>+const __getFile_1 = dart.privateName(html$, "__getFile_1");
>+const __getFile_2 = dart.privateName(html$, "__getFile_2");
>+const __getFile_3 = dart.privateName(html$, "__getFile_3");
>+const __getFile_4 = dart.privateName(html$, "__getFile_4");
>+const __getFile = dart.privateName(html$, "__getFile");
>+const _removeRecursively = dart.privateName(html$, "_removeRecursively");
>+const _copyTo = dart.privateName(html$, "_copyTo");
>+const _getMetadata = dart.privateName(html$, "_getMetadata");
>+const _getParent = dart.privateName(html$, "_getParent");
>+const _moveTo = dart.privateName(html$, "_moveTo");
>+const _remove$ = dart.privateName(html$, "_remove");
>+html$.Entry = class Entry extends _interceptors.Interceptor {
>+  get [$filesystem]() {
>+    return this.filesystem;
>+  }
>+  get [$fullPath]() {
>+    return this.fullPath;
>+  }
>+  get [$isDirectory]() {
>+    return this.isDirectory;
>+  }
>+  get [$isFile]() {
>+    return this.isFile;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+  [_copyTo](...args) {
>+    return this.copyTo.apply(this, args);
>+  }
>+  [$copyTo](parent, opts) {
>+    let name = opts && 'name' in opts ? opts.name : null;
>+    let completer = CompleterOfEntry().new();
>+    this[_copyTo](parent, name, dart.fn(value => {
>+      completer.complete(value);
>+    }, EntryToNull()), dart.fn(error => {
>+      completer.completeError(error);
>+    }, DomExceptionToNull()));
>+    return completer.future;
>+  }
>+  [_getMetadata](...args) {
>+    return this.getMetadata.apply(this, args);
>+  }
>+  [$getMetadata]() {
>+    let completer = CompleterOfMetadata().new();
>+    this[_getMetadata](dart.fn(value => {
>+      _js_helper.applyExtension("Metadata", value);
>+      completer.complete(value);
>+    }, MetadataToNull()), dart.fn(error => {
>+      completer.completeError(error);
>+    }, DomExceptionToNull()));
>+    return completer.future;
>+  }
>+  [_getParent](...args) {
>+    return this.getParent.apply(this, args);
>+  }
>+  [$getParent]() {
>+    let completer = CompleterOfEntry().new();
>+    this[_getParent](dart.fn(value => {
>+      _js_helper.applyExtension("Entry", value);
>+      completer.complete(value);
>+    }, EntryToNull()), dart.fn(error => {
>+      completer.completeError(error);
>+    }, DomExceptionToNull()));
>+    return completer.future;
>+  }
>+  [_moveTo](...args) {
>+    return this.moveTo.apply(this, args);
>+  }
>+  [$moveTo](parent, opts) {
>+    let name = opts && 'name' in opts ? opts.name : null;
>+    let completer = CompleterOfEntry().new();
>+    this[_moveTo](parent, name, dart.fn(value => {
>+      completer.complete(value);
>+    }, EntryToNull()), dart.fn(error => {
>+      completer.completeError(error);
>+    }, DomExceptionToNull()));
>+    return completer.future;
>+  }
>+  [_remove$](...args) {
>+    return this.remove.apply(this, args);
>+  }
>+  [$remove]() {
>+    let completer = async.Completer.new();
>+    this[_remove$](dart.fn(() => {
>+      completer.complete();
>+    }, VoidToNull()), dart.fn(error => {
>+      completer.completeError(error);
>+    }, DomExceptionToNull()));
>+    return completer.future;
>+  }
>+  [$toUrl](...args) {
>+    return this.toURL.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.Entry);
>+const filesystem = Symbol("Entry.filesystem");
>+const fullPath = Symbol("Entry.fullPath");
>+const isDirectory = Symbol("Entry.isDirectory");
>+const isFile = Symbol("Entry.isFile");
>+const name$10 = Symbol("Entry.name");
>+dart.setMethodSignature(html$.Entry, () => ({
>+  __proto__: dart.getMethods(html$.Entry.__proto__),
>+  [_copyTo]: dart.fnType(dart.void, [html$.DirectoryEntry], [core.String, dart.fnType(dart.void, [html$.Entry]), dart.fnType(dart.void, [html$.DomException])]),
>+  [$copyTo]: dart.fnType(async.Future$(html$.Entry), [html$.DirectoryEntry], {name: core.String}),
>+  [_getMetadata]: dart.fnType(dart.void, [dart.fnType(dart.void, [html$.Metadata])], [dart.fnType(dart.void, [html$.DomException])]),
>+  [$getMetadata]: dart.fnType(async.Future$(html$.Metadata), []),
>+  [_getParent]: dart.fnType(dart.void, [], [dart.fnType(dart.void, [html$.Entry]), dart.fnType(dart.void, [html$.DomException])]),
>+  [$getParent]: dart.fnType(async.Future$(html$.Entry), []),
>+  [_moveTo]: dart.fnType(dart.void, [html$.DirectoryEntry], [core.String, dart.fnType(dart.void, [html$.Entry]), dart.fnType(dart.void, [html$.DomException])]),
>+  [$moveTo]: dart.fnType(async.Future$(html$.Entry), [html$.DirectoryEntry], {name: core.String}),
>+  [_remove$]: dart.fnType(dart.void, [dart.fnType(dart.void, [])], [dart.fnType(dart.void, [html$.DomException])]),
>+  [$remove]: dart.fnType(async.Future, []),
>+  [$toUrl]: dart.fnType(core.String, [])
>+}));
>+dart.setLibraryUri(html$.Entry, "dart:html");
>+dart.setFieldSignature(html$.Entry, () => ({
>+  __proto__: dart.getFields(html$.Entry.__proto__),
>+  [$filesystem]: dart.finalFieldType(html$.FileSystem),
>+  [$fullPath]: dart.finalFieldType(core.String),
>+  [$isDirectory]: dart.finalFieldType(core.bool),
>+  [$isFile]: dart.finalFieldType(core.bool),
>+  [$name]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("Entry", html$.Entry);
>+html$.DirectoryEntry = class DirectoryEntry extends html$.Entry {
>+  [$createDirectory](path, opts) {
>+    let exclusive = opts && 'exclusive' in opts ? opts.exclusive : false;
>+    return this[_getDirectory](path, {options: new _js_helper.LinkedMap.from(["create", true, "exclusive", exclusive])});
>+  }
>+  [$createReader]() {
>+    let reader = this[_createReader]();
>+    _js_helper.applyExtension("DirectoryReader", reader);
>+    return reader;
>+  }
>+  [$getDirectory](path) {
>+    return this[_getDirectory](path);
>+  }
>+  [$createFile](path, opts) {
>+    let exclusive = opts && 'exclusive' in opts ? opts.exclusive : false;
>+    return this[_getFile](path, {options: new _js_helper.LinkedMap.from(["create", true, "exclusive", exclusive])});
>+  }
>+  [$getFile](path) {
>+    return this[_getFile](path);
>+  }
>+  [_createReader](...args) {
>+    return this.createReader.apply(this, args);
>+  }
>+  [__getDirectory](path, options, successCallback, errorCallback) {
>+    if (options === void 0) options = null;
>+    if (successCallback === void 0) successCallback = null;
>+    if (errorCallback === void 0) errorCallback = null;
>+    if (errorCallback != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      this[__getDirectory_1](path, options_1, successCallback, errorCallback);
>+      return;
>+    }
>+    if (successCallback != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      this[__getDirectory_2](path, options_1, successCallback);
>+      return;
>+    }
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      this[__getDirectory_3](path, options_1);
>+      return;
>+    }
>+    this[__getDirectory_4](path);
>+    return;
>+  }
>+  [__getDirectory_1](...args) {
>+    return this.getDirectory.apply(this, args);
>+  }
>+  [__getDirectory_2](...args) {
>+    return this.getDirectory.apply(this, args);
>+  }
>+  [__getDirectory_3](...args) {
>+    return this.getDirectory.apply(this, args);
>+  }
>+  [__getDirectory_4](...args) {
>+    return this.getDirectory.apply(this, args);
>+  }
>+  [_getDirectory](path, opts) {
>+    let options = opts && 'options' in opts ? opts.options : null;
>+    let completer = CompleterOfEntry().new();
>+    this[__getDirectory](path, options, dart.fn(value => {
>+      completer.complete(value);
>+    }, EntryToNull()), dart.fn(error => {
>+      completer.completeError(error);
>+    }, DomExceptionToNull()));
>+    return completer.future;
>+  }
>+  [__getFile](path, options, successCallback, errorCallback) {
>+    if (options === void 0) options = null;
>+    if (successCallback === void 0) successCallback = null;
>+    if (errorCallback === void 0) errorCallback = null;
>+    if (errorCallback != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      this[__getFile_1](path, options_1, successCallback, errorCallback);
>+      return;
>+    }
>+    if (successCallback != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      this[__getFile_2](path, options_1, successCallback);
>+      return;
>+    }
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      this[__getFile_3](path, options_1);
>+      return;
>+    }
>+    this[__getFile_4](path);
>+    return;
>+  }
>+  [__getFile_1](...args) {
>+    return this.getFile.apply(this, args);
>+  }
>+  [__getFile_2](...args) {
>+    return this.getFile.apply(this, args);
>+  }
>+  [__getFile_3](...args) {
>+    return this.getFile.apply(this, args);
>+  }
>+  [__getFile_4](...args) {
>+    return this.getFile.apply(this, args);
>+  }
>+  [_getFile](path, opts) {
>+    let options = opts && 'options' in opts ? opts.options : null;
>+    let completer = CompleterOfEntry().new();
>+    this[__getFile](path, options, dart.fn(value => {
>+      _js_helper.applyExtension("FileEntry", value);
>+      completer.complete(value);
>+    }, EntryToNull()), dart.fn(error => {
>+      completer.completeError(error);
>+    }, DomExceptionToNull()));
>+    return completer.future;
>+  }
>+  [_removeRecursively](...args) {
>+    return this.removeRecursively.apply(this, args);
>+  }
>+  [$removeRecursively]() {
>+    let completer = async.Completer.new();
>+    this[_removeRecursively](dart.fn(() => {
>+      completer.complete();
>+    }, VoidToNull()), dart.fn(error => {
>+      completer.completeError(error);
>+    }, DomExceptionToNull()));
>+    return completer.future;
>+  }
>+};
>+dart.addTypeTests(html$.DirectoryEntry);
>+dart.setMethodSignature(html$.DirectoryEntry, () => ({
>+  __proto__: dart.getMethods(html$.DirectoryEntry.__proto__),
>+  [$createDirectory]: dart.fnType(async.Future$(html$.Entry), [core.String], {exclusive: core.bool}),
>+  [$createReader]: dart.fnType(html$.DirectoryReader, []),
>+  [$getDirectory]: dart.fnType(async.Future$(html$.Entry), [core.String]),
>+  [$createFile]: dart.fnType(async.Future$(html$.Entry), [core.String], {exclusive: core.bool}),
>+  [$getFile]: dart.fnType(async.Future$(html$.Entry), [core.String]),
>+  [_createReader]: dart.fnType(html$.DirectoryReader, []),
>+  [__getDirectory]: dart.fnType(dart.void, [core.String], [core.Map, dart.fnType(dart.void, [html$.Entry]), dart.fnType(dart.void, [html$.DomException])]),
>+  [__getDirectory_1]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.fnType(dart.void, [html$.Entry]), dart.fnType(dart.void, [html$.DomException])]),
>+  [__getDirectory_2]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.fnType(dart.void, [html$.Entry])]),
>+  [__getDirectory_3]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic]),
>+  [__getDirectory_4]: dart.fnType(dart.void, [dart.dynamic]),
>+  [_getDirectory]: dart.fnType(async.Future$(html$.Entry), [core.String], {options: core.Map}),
>+  [__getFile]: dart.fnType(dart.void, [core.String], [core.Map, dart.fnType(dart.void, [html$.Entry]), dart.fnType(dart.void, [html$.DomException])]),
>+  [__getFile_1]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.fnType(dart.void, [html$.Entry]), dart.fnType(dart.void, [html$.DomException])]),
>+  [__getFile_2]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.fnType(dart.void, [html$.Entry])]),
>+  [__getFile_3]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic]),
>+  [__getFile_4]: dart.fnType(dart.void, [dart.dynamic]),
>+  [_getFile]: dart.fnType(async.Future$(html$.Entry), [core.String], {options: core.Map}),
>+  [_removeRecursively]: dart.fnType(dart.void, [dart.fnType(dart.void, [])], [dart.fnType(dart.void, [html$.DomException])]),
>+  [$removeRecursively]: dart.fnType(async.Future, [])
>+}));
>+dart.setLibraryUri(html$.DirectoryEntry, "dart:html");
>+dart.registerExtension("DirectoryEntry", html$.DirectoryEntry);
>+const _readEntries = dart.privateName(html$, "_readEntries");
>+html$.DirectoryReader = class DirectoryReader extends _interceptors.Interceptor {
>+  [_readEntries](...args) {
>+    return this.readEntries.apply(this, args);
>+  }
>+  [$readEntries]() {
>+    let completer = CompleterOfListOfEntry().new();
>+    this[_readEntries](dart.fn(values => {
>+      values[$forEach](dart.fn(value => {
>+        _js_helper.applyExtension("Entry", value);
>+        let entry = html$.Entry.as(value);
>+        if (dart.test(entry.isFile))
>+          _js_helper.applyExtension("FileEntry", entry);
>+        else if (dart.test(entry.isDirectory)) _js_helper.applyExtension("DirectoryEntry", entry);
>+      }, dynamicToNull()));
>+      completer.complete(ListOfEntry().from(values));
>+    }, ListToNull()), dart.fn(error => {
>+      completer.completeError(error);
>+    }, DomExceptionToNull()));
>+    return completer.future;
>+  }
>+};
>+dart.addTypeTests(html$.DirectoryReader);
>+dart.setMethodSignature(html$.DirectoryReader, () => ({
>+  __proto__: dart.getMethods(html$.DirectoryReader.__proto__),
>+  [_readEntries]: dart.fnType(dart.void, [dart.fnType(dart.void, [core.List])], [dart.fnType(dart.void, [html$.DomException])]),
>+  [$readEntries]: dart.fnType(async.Future$(core.List$(html$.Entry)), [])
>+}));
>+dart.setLibraryUri(html$.DirectoryReader, "dart:html");
>+dart.registerExtension("DirectoryReader", html$.DirectoryReader);
>+html$.DivElement = class DivElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("div");
>+  }
>+};
>+(html$.DivElement.created = function() {
>+  html$.DivElement.__proto__.created.call(this);
>+}).prototype = html$.DivElement.prototype;
>+dart.addTypeTests(html$.DivElement);
>+dart.setLibraryUri(html$.DivElement, "dart:html");
>+dart.registerExtension("HTMLDivElement", html$.DivElement);
>+const _body = dart.privateName(html$, "_body");
>+const _get_window = dart.privateName(html$, "_get_window");
>+const _head$ = dart.privateName(html$, "_head");
>+const _lastModified = dart.privateName(html$, "_lastModified");
>+const _preferredStylesheetSet = dart.privateName(html$, "_preferredStylesheetSet");
>+const _referrer = dart.privateName(html$, "_referrer");
>+const _selectedStylesheetSet = dart.privateName(html$, "_selectedStylesheetSet");
>+const _title = dart.privateName(html$, "_title");
>+const _visibilityState = dart.privateName(html$, "_visibilityState");
>+const _webkitFullscreenElement = dart.privateName(html$, "_webkitFullscreenElement");
>+const _webkitFullscreenEnabled = dart.privateName(html$, "_webkitFullscreenEnabled");
>+const _webkitHidden = dart.privateName(html$, "_webkitHidden");
>+const _webkitVisibilityState = dart.privateName(html$, "_webkitVisibilityState");
>+const _caretRangeFromPoint = dart.privateName(html$, "_caretRangeFromPoint");
>+const _createElement = dart.privateName(html$, "_createElement");
>+const _createElementNS = dart.privateName(html$, "_createElementNS");
>+const _createTextNode = dart.privateName(html$, "_createTextNode");
>+const _createTouch_1 = dart.privateName(html$, "_createTouch_1");
>+const _createTouch_2 = dart.privateName(html$, "_createTouch_2");
>+const _createTouch_3 = dart.privateName(html$, "_createTouch_3");
>+const _createTouch_4 = dart.privateName(html$, "_createTouch_4");
>+const _createTouch_5 = dart.privateName(html$, "_createTouch_5");
>+const _createTouch = dart.privateName(html$, "_createTouch");
>+const _createTouchList = dart.privateName(html$, "_createTouchList");
>+const _registerElement2_1 = dart.privateName(html$, "_registerElement2_1");
>+const _registerElement2_2 = dart.privateName(html$, "_registerElement2_2");
>+const _webkitExitFullscreen = dart.privateName(html$, "_webkitExitFullscreen");
>+const _styleSheets = dart.privateName(html$, "_styleSheets");
>+const _elementFromPoint = dart.privateName(html$, "_elementFromPoint");
>+const _createElement_2 = dart.privateName(html$, "_createElement_2");
>+const _createElementNS_2 = dart.privateName(html$, "_createElementNS_2");
>+const _createNodeIterator = dart.privateName(html$, "_createNodeIterator");
>+const _createTreeWalker = dart.privateName(html$, "_createTreeWalker");
>+html$.Document = class Document$ extends html$.Node {
>+  static new() {
>+    return html$.Document._create_1();
>+  }
>+  static _create_1() {
>+    return new Document();
>+  }
>+  get [$addressSpace]() {
>+    return this.addressSpace;
>+  }
>+  get [_body]() {
>+    return this.body;
>+  }
>+  set [_body](value) {
>+    this.body = value;
>+  }
>+  get [$contentType]() {
>+    return this.contentType;
>+  }
>+  get [$cookie]() {
>+    return this.cookie;
>+  }
>+  set [$cookie](value) {
>+    this.cookie = value;
>+  }
>+  get [$currentScript]() {
>+    return this.currentScript;
>+  }
>+  get [$window]() {
>+    return html$._convertNativeToDart_Window(this[_get_window]);
>+  }
>+  get [_get_window]() {
>+    return this.defaultView;
>+  }
>+  get [$documentElement]() {
>+    return this.documentElement;
>+  }
>+  get [$domain]() {
>+    return this.domain;
>+  }
>+  get [$fullscreenEnabled]() {
>+    return this.fullscreenEnabled;
>+  }
>+  get [_head$]() {
>+    return this.head;
>+  }
>+  get [$hidden]() {
>+    return this.hidden;
>+  }
>+  get [$implementation]() {
>+    return this.implementation;
>+  }
>+  get [_lastModified]() {
>+    return this.lastModified;
>+  }
>+  get [$origin]() {
>+    return this.origin;
>+  }
>+  get [_preferredStylesheetSet]() {
>+    return this.preferredStylesheetSet;
>+  }
>+  get [$readyState]() {
>+    return this.readyState;
>+  }
>+  get [_referrer]() {
>+    return this.referrer;
>+  }
>+  get [$rootElement]() {
>+    return this.rootElement;
>+  }
>+  get [$rootScroller]() {
>+    return this.rootScroller;
>+  }
>+  set [$rootScroller](value) {
>+    this.rootScroller = value;
>+  }
>+  get [$scrollingElement]() {
>+    return this.scrollingElement;
>+  }
>+  get [_selectedStylesheetSet]() {
>+    return this.selectedStylesheetSet;
>+  }
>+  set [_selectedStylesheetSet](value) {
>+    this.selectedStylesheetSet = value;
>+  }
>+  get [$suborigin]() {
>+    return this.suborigin;
>+  }
>+  get [$timeline]() {
>+    return this.timeline;
>+  }
>+  get [_title]() {
>+    return this.title;
>+  }
>+  set [_title](value) {
>+    this.title = value;
>+  }
>+  get [_visibilityState]() {
>+    return this.visibilityState;
>+  }
>+  get [_webkitFullscreenElement]() {
>+    return this.webkitFullscreenElement;
>+  }
>+  get [_webkitFullscreenEnabled]() {
>+    return this.webkitFullscreenEnabled;
>+  }
>+  get [_webkitHidden]() {
>+    return this.webkitHidden;
>+  }
>+  get [_webkitVisibilityState]() {
>+    return this.webkitVisibilityState;
>+  }
>+  [$adoptNode](...args) {
>+    return this.adoptNode.apply(this, args);
>+  }
>+  [_caretRangeFromPoint](...args) {
>+    return this.caretRangeFromPoint.apply(this, args);
>+  }
>+  [$createDocumentFragment](...args) {
>+    return this.createDocumentFragment.apply(this, args);
>+  }
>+  [_createElement](...args) {
>+    return this.createElement.apply(this, args);
>+  }
>+  [_createElementNS](...args) {
>+    return this.createElementNS.apply(this, args);
>+  }
>+  [_createEvent](...args) {
>+    return this.createEvent.apply(this, args);
>+  }
>+  [$createRange](...args) {
>+    return this.createRange.apply(this, args);
>+  }
>+  [_createTextNode](...args) {
>+    return this.createTextNode.apply(this, args);
>+  }
>+  [_createTouch](view, target, identifier, pageX, pageY, screenX, screenY, radiusX, radiusY, rotationAngle, force) {
>+    if (radiusX === void 0) radiusX = null;
>+    if (radiusY === void 0) radiusY = null;
>+    if (rotationAngle === void 0) rotationAngle = null;
>+    if (force === void 0) force = null;
>+    if (force != null) {
>+      let target_1 = html$._convertDartToNative_EventTarget(target);
>+      return this[_createTouch_1](view, target_1, identifier, pageX, pageY, screenX, screenY, radiusX, radiusY, rotationAngle, force);
>+    }
>+    if (rotationAngle != null) {
>+      let target_1 = html$._convertDartToNative_EventTarget(target);
>+      return this[_createTouch_2](view, target_1, identifier, pageX, pageY, screenX, screenY, radiusX, radiusY, rotationAngle);
>+    }
>+    if (radiusY != null) {
>+      let target_1 = html$._convertDartToNative_EventTarget(target);
>+      return this[_createTouch_3](view, target_1, identifier, pageX, pageY, screenX, screenY, radiusX, radiusY);
>+    }
>+    if (radiusX != null) {
>+      let target_1 = html$._convertDartToNative_EventTarget(target);
>+      return this[_createTouch_4](view, target_1, identifier, pageX, pageY, screenX, screenY, radiusX);
>+    }
>+    let target_1 = html$._convertDartToNative_EventTarget(target);
>+    return this[_createTouch_5](view, target_1, identifier, pageX, pageY, screenX, screenY);
>+  }
>+  [_createTouch_1](...args) {
>+    return this.createTouch.apply(this, args);
>+  }
>+  [_createTouch_2](...args) {
>+    return this.createTouch.apply(this, args);
>+  }
>+  [_createTouch_3](...args) {
>+    return this.createTouch.apply(this, args);
>+  }
>+  [_createTouch_4](...args) {
>+    return this.createTouch.apply(this, args);
>+  }
>+  [_createTouch_5](...args) {
>+    return this.createTouch.apply(this, args);
>+  }
>+  [_createTouchList](...args) {
>+    return this.createTouchList.apply(this, args);
>+  }
>+  [$execCommand](...args) {
>+    return this.execCommand.apply(this, args);
>+  }
>+  [$exitFullscreen](...args) {
>+    return this.exitFullscreen.apply(this, args);
>+  }
>+  [$exitPointerLock](...args) {
>+    return this.exitPointerLock.apply(this, args);
>+  }
>+  [$getAnimations](...args) {
>+    return this.getAnimations.apply(this, args);
>+  }
>+  [$getElementsByClassName](...args) {
>+    return this.getElementsByClassName.apply(this, args);
>+  }
>+  [$getElementsByName](...args) {
>+    return this.getElementsByName.apply(this, args);
>+  }
>+  [$getElementsByTagName](...args) {
>+    return this.getElementsByTagName.apply(this, args);
>+  }
>+  [$importNode](...args) {
>+    return this.importNode.apply(this, args);
>+  }
>+  [$queryCommandEnabled](...args) {
>+    return this.queryCommandEnabled.apply(this, args);
>+  }
>+  [$queryCommandIndeterm](...args) {
>+    return this.queryCommandIndeterm.apply(this, args);
>+  }
>+  [$queryCommandState](...args) {
>+    return this.queryCommandState.apply(this, args);
>+  }
>+  [$queryCommandSupported](...args) {
>+    return this.queryCommandSupported.apply(this, args);
>+  }
>+  [$queryCommandValue](...args) {
>+    return this.queryCommandValue.apply(this, args);
>+  }
>+  [$registerElement2](type, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      return this[_registerElement2_1](type, options_1);
>+    }
>+    return this[_registerElement2_2](type);
>+  }
>+  [_registerElement2_1](...args) {
>+    return this.registerElement.apply(this, args);
>+  }
>+  [_registerElement2_2](...args) {
>+    return this.registerElement.apply(this, args);
>+  }
>+  [_webkitExitFullscreen](...args) {
>+    return this.webkitExitFullscreen.apply(this, args);
>+  }
>+  [$getElementById](...args) {
>+    return this.getElementById.apply(this, args);
>+  }
>+  get [$activeElement]() {
>+    return this.activeElement;
>+  }
>+  get [$fullscreenElement]() {
>+    return this.fullscreenElement;
>+  }
>+  get [$pointerLockElement]() {
>+    return this.pointerLockElement;
>+  }
>+  get [_styleSheets]() {
>+    return this.styleSheets;
>+  }
>+  [_elementFromPoint](...args) {
>+    return this.elementFromPoint.apply(this, args);
>+  }
>+  [$elementsFromPoint](...args) {
>+    return this.elementsFromPoint.apply(this, args);
>+  }
>+  get [$fonts]() {
>+    return this.fonts;
>+  }
>+  get [_childElementCount]() {
>+    return this.childElementCount;
>+  }
>+  get [_children]() {
>+    return this.children;
>+  }
>+  get [_firstElementChild]() {
>+    return this.firstElementChild;
>+  }
>+  get [_lastElementChild]() {
>+    return this.lastElementChild;
>+  }
>+  [$querySelector](...args) {
>+    return this.querySelector.apply(this, args);
>+  }
>+  [_querySelectorAll](...args) {
>+    return this.querySelectorAll.apply(this, args);
>+  }
>+  get [$onAbort]() {
>+    return html$.Element.abortEvent.forTarget(this);
>+  }
>+  get [$onBeforeCopy]() {
>+    return html$.Element.beforeCopyEvent.forTarget(this);
>+  }
>+  get [$onBeforeCut]() {
>+    return html$.Element.beforeCutEvent.forTarget(this);
>+  }
>+  get [$onBeforePaste]() {
>+    return html$.Element.beforePasteEvent.forTarget(this);
>+  }
>+  get [$onBlur]() {
>+    return html$.Element.blurEvent.forTarget(this);
>+  }
>+  get [$onCanPlay]() {
>+    return html$.Element.canPlayEvent.forTarget(this);
>+  }
>+  get [$onCanPlayThrough]() {
>+    return html$.Element.canPlayThroughEvent.forTarget(this);
>+  }
>+  get [$onChange]() {
>+    return html$.Element.changeEvent.forTarget(this);
>+  }
>+  get [$onClick]() {
>+    return html$.Element.clickEvent.forTarget(this);
>+  }
>+  get [$onContextMenu]() {
>+    return html$.Element.contextMenuEvent.forTarget(this);
>+  }
>+  get [$onCopy]() {
>+    return html$.Element.copyEvent.forTarget(this);
>+  }
>+  get [$onCut]() {
>+    return html$.Element.cutEvent.forTarget(this);
>+  }
>+  get [$onDoubleClick]() {
>+    return html$.Element.doubleClickEvent.forTarget(this);
>+  }
>+  get [$onDrag]() {
>+    return html$.Element.dragEvent.forTarget(this);
>+  }
>+  get [$onDragEnd]() {
>+    return html$.Element.dragEndEvent.forTarget(this);
>+  }
>+  get [$onDragEnter]() {
>+    return html$.Element.dragEnterEvent.forTarget(this);
>+  }
>+  get [$onDragLeave]() {
>+    return html$.Element.dragLeaveEvent.forTarget(this);
>+  }
>+  get [$onDragOver]() {
>+    return html$.Element.dragOverEvent.forTarget(this);
>+  }
>+  get [$onDragStart]() {
>+    return html$.Element.dragStartEvent.forTarget(this);
>+  }
>+  get [$onDrop]() {
>+    return html$.Element.dropEvent.forTarget(this);
>+  }
>+  get [$onDurationChange]() {
>+    return html$.Element.durationChangeEvent.forTarget(this);
>+  }
>+  get [$onEmptied]() {
>+    return html$.Element.emptiedEvent.forTarget(this);
>+  }
>+  get [$onEnded]() {
>+    return html$.Element.endedEvent.forTarget(this);
>+  }
>+  get [$onError]() {
>+    return html$.Element.errorEvent.forTarget(this);
>+  }
>+  get [$onFocus]() {
>+    return html$.Element.focusEvent.forTarget(this);
>+  }
>+  get [$onInput]() {
>+    return html$.Element.inputEvent.forTarget(this);
>+  }
>+  get [$onInvalid]() {
>+    return html$.Element.invalidEvent.forTarget(this);
>+  }
>+  get [$onKeyDown]() {
>+    return html$.Element.keyDownEvent.forTarget(this);
>+  }
>+  get [$onKeyPress]() {
>+    return html$.Element.keyPressEvent.forTarget(this);
>+  }
>+  get [$onKeyUp]() {
>+    return html$.Element.keyUpEvent.forTarget(this);
>+  }
>+  get [$onLoad]() {
>+    return html$.Element.loadEvent.forTarget(this);
>+  }
>+  get [$onLoadedData]() {
>+    return html$.Element.loadedDataEvent.forTarget(this);
>+  }
>+  get [$onLoadedMetadata]() {
>+    return html$.Element.loadedMetadataEvent.forTarget(this);
>+  }
>+  get [$onMouseDown]() {
>+    return html$.Element.mouseDownEvent.forTarget(this);
>+  }
>+  get [$onMouseEnter]() {
>+    return html$.Element.mouseEnterEvent.forTarget(this);
>+  }
>+  get [$onMouseLeave]() {
>+    return html$.Element.mouseLeaveEvent.forTarget(this);
>+  }
>+  get [$onMouseMove]() {
>+    return html$.Element.mouseMoveEvent.forTarget(this);
>+  }
>+  get [$onMouseOut]() {
>+    return html$.Element.mouseOutEvent.forTarget(this);
>+  }
>+  get [$onMouseOver]() {
>+    return html$.Element.mouseOverEvent.forTarget(this);
>+  }
>+  get [$onMouseUp]() {
>+    return html$.Element.mouseUpEvent.forTarget(this);
>+  }
>+  get [$onMouseWheel]() {
>+    return html$.Element.mouseWheelEvent.forTarget(this);
>+  }
>+  get [$onPaste]() {
>+    return html$.Element.pasteEvent.forTarget(this);
>+  }
>+  get [$onPause]() {
>+    return html$.Element.pauseEvent.forTarget(this);
>+  }
>+  get [$onPlay]() {
>+    return html$.Element.playEvent.forTarget(this);
>+  }
>+  get [$onPlaying]() {
>+    return html$.Element.playingEvent.forTarget(this);
>+  }
>+  get [$onPointerLockChange]() {
>+    return html$.Document.pointerLockChangeEvent.forTarget(this);
>+  }
>+  get [$onPointerLockError]() {
>+    return html$.Document.pointerLockErrorEvent.forTarget(this);
>+  }
>+  get [$onRateChange]() {
>+    return html$.Element.rateChangeEvent.forTarget(this);
>+  }
>+  get [$onReadyStateChange]() {
>+    return html$.Document.readyStateChangeEvent.forTarget(this);
>+  }
>+  get [$onReset]() {
>+    return html$.Element.resetEvent.forTarget(this);
>+  }
>+  get [$onResize]() {
>+    return html$.Element.resizeEvent.forTarget(this);
>+  }
>+  get [$onScroll]() {
>+    return html$.Element.scrollEvent.forTarget(this);
>+  }
>+  get [$onSearch]() {
>+    return html$.Element.searchEvent.forTarget(this);
>+  }
>+  get [$onSecurityPolicyViolation]() {
>+    return html$.Document.securityPolicyViolationEvent.forTarget(this);
>+  }
>+  get [$onSeeked]() {
>+    return html$.Element.seekedEvent.forTarget(this);
>+  }
>+  get [$onSeeking]() {
>+    return html$.Element.seekingEvent.forTarget(this);
>+  }
>+  get [$onSelect]() {
>+    return html$.Element.selectEvent.forTarget(this);
>+  }
>+  get [$onSelectionChange]() {
>+    return html$.Document.selectionChangeEvent.forTarget(this);
>+  }
>+  get [$onSelectStart]() {
>+    return html$.Element.selectStartEvent.forTarget(this);
>+  }
>+  get [$onStalled]() {
>+    return html$.Element.stalledEvent.forTarget(this);
>+  }
>+  get [$onSubmit]() {
>+    return html$.Element.submitEvent.forTarget(this);
>+  }
>+  get [$onSuspend]() {
>+    return html$.Element.suspendEvent.forTarget(this);
>+  }
>+  get [$onTimeUpdate]() {
>+    return html$.Element.timeUpdateEvent.forTarget(this);
>+  }
>+  get [$onTouchCancel]() {
>+    return html$.Element.touchCancelEvent.forTarget(this);
>+  }
>+  get [$onTouchEnd]() {
>+    return html$.Element.touchEndEvent.forTarget(this);
>+  }
>+  get [$onTouchMove]() {
>+    return html$.Element.touchMoveEvent.forTarget(this);
>+  }
>+  get [$onTouchStart]() {
>+    return html$.Element.touchStartEvent.forTarget(this);
>+  }
>+  get [$onVolumeChange]() {
>+    return html$.Element.volumeChangeEvent.forTarget(this);
>+  }
>+  get [$onWaiting]() {
>+    return html$.Element.waitingEvent.forTarget(this);
>+  }
>+  get [$onFullscreenChange]() {
>+    return html$.Element.fullscreenChangeEvent.forTarget(this);
>+  }
>+  get [$onFullscreenError]() {
>+    return html$.Element.fullscreenErrorEvent.forTarget(this);
>+  }
>+  [$querySelectorAll](T, selectors) {
>+    return new (html$._FrozenElementList$(T))._wrap(this[_querySelectorAll](selectors));
>+  }
>+  get [$supportsRegisterElement]() {
>+    return "registerElement" in this;
>+  }
>+  get [$supportsRegister]() {
>+    return this[$supportsRegisterElement];
>+  }
>+  [$registerElement](tag, customElementClass, opts) {
>+    let extendsTag = opts && 'extendsTag' in opts ? opts.extendsTag : null;
>+    this[$registerElement2](tag, new _js_helper.LinkedMap.from(["prototype", customElementClass, "extends", extendsTag]));
>+  }
>+  [$createElement](tagName, typeExtension) {
>+    if (typeExtension === void 0) typeExtension = null;
>+    return html$.Element._check(typeExtension == null ? this[_createElement_2](tagName) : this[_createElement](tagName, typeExtension));
>+  }
>+  [_createElement_2](tagName) {
>+    return this.createElement(tagName);
>+  }
>+  [_createElementNS_2](namespaceURI, qualifiedName) {
>+    return this.createElementNS(namespaceURI, qualifiedName);
>+  }
>+  [$createElementNS](namespaceURI, qualifiedName, typeExtension) {
>+    if (typeExtension === void 0) typeExtension = null;
>+    return html$.Element._check(typeExtension == null ? this[_createElementNS_2](namespaceURI, qualifiedName) : this[_createElementNS](namespaceURI, qualifiedName, typeExtension));
>+  }
>+  [_createNodeIterator](root, whatToShow, filter) {
>+    if (whatToShow === void 0) whatToShow = null;
>+    if (filter === void 0) filter = null;
>+    return this.createNodeIterator(root, whatToShow, filter, false);
>+  }
>+  [_createTreeWalker](root, whatToShow, filter) {
>+    if (whatToShow === void 0) whatToShow = null;
>+    if (filter === void 0) filter = null;
>+    return this.createTreeWalker(root, whatToShow, filter, false);
>+  }
>+  get [$visibilityState]() {
>+    return this.visibilityState || this.mozVisibilityState || this.msVisibilityState || this.webkitVisibilityState;
>+  }
>+};
>+dart.addTypeTests(html$.Document);
>+const addressSpace$ = Symbol("Document.addressSpace");
>+const contentType = Symbol("Document.contentType");
>+const cookie = Symbol("Document.cookie");
>+const currentScript = Symbol("Document.currentScript");
>+const documentElement = Symbol("Document.documentElement");
>+const domain = Symbol("Document.domain");
>+const fullscreenEnabled = Symbol("Document.fullscreenEnabled");
>+const hidden$0 = Symbol("Document.hidden");
>+const implementation = Symbol("Document.implementation");
>+const origin$1 = Symbol("Document.origin");
>+const readyState$1 = Symbol("Document.readyState");
>+const rootElement = Symbol("Document.rootElement");
>+const rootScroller = Symbol("Document.rootScroller");
>+const scrollingElement = Symbol("Document.scrollingElement");
>+const suborigin = Symbol("Document.suborigin");
>+const timeline$ = Symbol("Document.timeline");
>+const activeElement = Symbol("Document.activeElement");
>+const fullscreenElement = Symbol("Document.fullscreenElement");
>+const pointerLockElement = Symbol("Document.pointerLockElement");
>+const fonts = Symbol("Document.fonts");
>+dart.setMethodSignature(html$.Document, () => ({
>+  __proto__: dart.getMethods(html$.Document.__proto__),
>+  [$adoptNode]: dart.fnType(html$.Node, [html$.Node]),
>+  [_caretRangeFromPoint]: dart.fnType(html$.Range, [core.int, core.int]),
>+  [$createDocumentFragment]: dart.fnType(html$.DocumentFragment, []),
>+  [_createElement]: dart.fnType(html$.Element, [core.String], [dart.dynamic]),
>+  [_createElementNS]: dart.fnType(html$.Element, [core.String, core.String], [dart.dynamic]),
>+  [_createEvent]: dart.fnType(html$.Event, [core.String]),
>+  [$createRange]: dart.fnType(html$.Range, []),
>+  [_createTextNode]: dart.fnType(html$.Text, [core.String]),
>+  [_createTouch]: dart.fnType(html$.Touch, [html$.Window, html$.EventTarget, core.int, core.num, core.num, core.num, core.num], [core.num, core.num, core.num, core.num]),
>+  [_createTouch_1]: dart.fnType(html$.Touch, [html$.Window, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic]),
>+  [_createTouch_2]: dart.fnType(html$.Touch, [html$.Window, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic]),
>+  [_createTouch_3]: dart.fnType(html$.Touch, [html$.Window, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic]),
>+  [_createTouch_4]: dart.fnType(html$.Touch, [html$.Window, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic]),
>+  [_createTouch_5]: dart.fnType(html$.Touch, [html$.Window, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic]),
>+  [_createTouchList]: dart.fnType(html$.TouchList, [html$.Touch]),
>+  [$execCommand]: dart.fnType(core.bool, [core.String], [core.bool, core.String]),
>+  [$exitFullscreen]: dart.fnType(dart.void, []),
>+  [$exitPointerLock]: dart.fnType(dart.void, []),
>+  [$getAnimations]: dart.fnType(core.List$(html$.Animation), []),
>+  [$getElementsByClassName]: dart.fnType(core.List$(html$.Node), [core.String]),
>+  [$getElementsByName]: dart.fnType(core.List$(html$.Node), [core.String]),
>+  [$getElementsByTagName]: dart.fnType(core.List$(html$.Node), [core.String]),
>+  [$importNode]: dart.fnType(html$.Node, [html$.Node], [core.bool]),
>+  [$queryCommandEnabled]: dart.fnType(core.bool, [core.String]),
>+  [$queryCommandIndeterm]: dart.fnType(core.bool, [core.String]),
>+  [$queryCommandState]: dart.fnType(core.bool, [core.String]),
>+  [$queryCommandSupported]: dart.fnType(core.bool, [core.String]),
>+  [$queryCommandValue]: dart.fnType(core.String, [core.String]),
>+  [$registerElement2]: dart.fnType(core.Function, [core.String], [core.Map]),
>+  [_registerElement2_1]: dart.fnType(core.Function, [dart.dynamic, dart.dynamic]),
>+  [_registerElement2_2]: dart.fnType(core.Function, [dart.dynamic]),
>+  [_webkitExitFullscreen]: dart.fnType(dart.void, []),
>+  [$getElementById]: dart.fnType(html$.Element, [core.String]),
>+  [_elementFromPoint]: dart.fnType(html$.Element, [core.int, core.int]),
>+  [$elementsFromPoint]: dart.fnType(core.List$(html$.Element), [core.int, core.int]),
>+  [$querySelector]: dart.fnType(html$.Element, [core.String]),
>+  [_querySelectorAll]: dart.fnType(core.List$(html$.Node), [core.String]),
>+  [$querySelectorAll]: dart.gFnType(T => [html$.ElementList$(T), [core.String]], T => [html$.Element]),
>+  [$registerElement]: dart.fnType(dart.void, [core.String, core.Type], {extendsTag: core.String}),
>+  [$createElement]: dart.fnType(html$.Element, [core.String], [core.String]),
>+  [_createElement_2]: dart.fnType(dart.dynamic, [core.String]),
>+  [_createElementNS_2]: dart.fnType(dart.dynamic, [core.String, core.String]),
>+  [$createElementNS]: dart.fnType(html$.Element, [core.String, core.String], [core.String]),
>+  [_createNodeIterator]: dart.fnType(html$.NodeIterator, [html$.Node], [core.int, html$.NodeFilter]),
>+  [_createTreeWalker]: dart.fnType(html$.TreeWalker, [html$.Node], [core.int, html$.NodeFilter])
>+}));
>+dart.setGetterSignature(html$.Document, () => ({
>+  __proto__: dart.getGetters(html$.Document.__proto__),
>+  [$window]: html$.WindowBase,
>+  [$onAbort]: async.Stream$(html$.Event),
>+  [$onBeforeCopy]: async.Stream$(html$.Event),
>+  [$onBeforeCut]: async.Stream$(html$.Event),
>+  [$onBeforePaste]: async.Stream$(html$.Event),
>+  [$onBlur]: async.Stream$(html$.Event),
>+  [$onCanPlay]: async.Stream$(html$.Event),
>+  [$onCanPlayThrough]: async.Stream$(html$.Event),
>+  [$onChange]: async.Stream$(html$.Event),
>+  [$onClick]: async.Stream$(html$.MouseEvent),
>+  [$onContextMenu]: async.Stream$(html$.MouseEvent),
>+  [$onCopy]: async.Stream$(html$.ClipboardEvent),
>+  [$onCut]: async.Stream$(html$.ClipboardEvent),
>+  [$onDoubleClick]: async.Stream$(html$.Event),
>+  [$onDrag]: async.Stream$(html$.MouseEvent),
>+  [$onDragEnd]: async.Stream$(html$.MouseEvent),
>+  [$onDragEnter]: async.Stream$(html$.MouseEvent),
>+  [$onDragLeave]: async.Stream$(html$.MouseEvent),
>+  [$onDragOver]: async.Stream$(html$.MouseEvent),
>+  [$onDragStart]: async.Stream$(html$.MouseEvent),
>+  [$onDrop]: async.Stream$(html$.MouseEvent),
>+  [$onDurationChange]: async.Stream$(html$.Event),
>+  [$onEmptied]: async.Stream$(html$.Event),
>+  [$onEnded]: async.Stream$(html$.Event),
>+  [$onError]: async.Stream$(html$.Event),
>+  [$onFocus]: async.Stream$(html$.Event),
>+  [$onInput]: async.Stream$(html$.Event),
>+  [$onInvalid]: async.Stream$(html$.Event),
>+  [$onKeyDown]: async.Stream$(html$.KeyboardEvent),
>+  [$onKeyPress]: async.Stream$(html$.KeyboardEvent),
>+  [$onKeyUp]: async.Stream$(html$.KeyboardEvent),
>+  [$onLoad]: async.Stream$(html$.Event),
>+  [$onLoadedData]: async.Stream$(html$.Event),
>+  [$onLoadedMetadata]: async.Stream$(html$.Event),
>+  [$onMouseDown]: async.Stream$(html$.MouseEvent),
>+  [$onMouseEnter]: async.Stream$(html$.MouseEvent),
>+  [$onMouseLeave]: async.Stream$(html$.MouseEvent),
>+  [$onMouseMove]: async.Stream$(html$.MouseEvent),
>+  [$onMouseOut]: async.Stream$(html$.MouseEvent),
>+  [$onMouseOver]: async.Stream$(html$.MouseEvent),
>+  [$onMouseUp]: async.Stream$(html$.MouseEvent),
>+  [$onMouseWheel]: async.Stream$(html$.WheelEvent),
>+  [$onPaste]: async.Stream$(html$.ClipboardEvent),
>+  [$onPause]: async.Stream$(html$.Event),
>+  [$onPlay]: async.Stream$(html$.Event),
>+  [$onPlaying]: async.Stream$(html$.Event),
>+  [$onPointerLockChange]: async.Stream$(html$.Event),
>+  [$onPointerLockError]: async.Stream$(html$.Event),
>+  [$onRateChange]: async.Stream$(html$.Event),
>+  [$onReadyStateChange]: async.Stream$(html$.Event),
>+  [$onReset]: async.Stream$(html$.Event),
>+  [$onResize]: async.Stream$(html$.Event),
>+  [$onScroll]: async.Stream$(html$.Event),
>+  [$onSearch]: async.Stream$(html$.Event),
>+  [$onSecurityPolicyViolation]: async.Stream$(html$.SecurityPolicyViolationEvent),
>+  [$onSeeked]: async.Stream$(html$.Event),
>+  [$onSeeking]: async.Stream$(html$.Event),
>+  [$onSelect]: async.Stream$(html$.Event),
>+  [$onSelectionChange]: async.Stream$(html$.Event),
>+  [$onSelectStart]: async.Stream$(html$.Event),
>+  [$onStalled]: async.Stream$(html$.Event),
>+  [$onSubmit]: async.Stream$(html$.Event),
>+  [$onSuspend]: async.Stream$(html$.Event),
>+  [$onTimeUpdate]: async.Stream$(html$.Event),
>+  [$onTouchCancel]: async.Stream$(html$.TouchEvent),
>+  [$onTouchEnd]: async.Stream$(html$.TouchEvent),
>+  [$onTouchMove]: async.Stream$(html$.TouchEvent),
>+  [$onTouchStart]: async.Stream$(html$.TouchEvent),
>+  [$onVolumeChange]: async.Stream$(html$.Event),
>+  [$onWaiting]: async.Stream$(html$.Event),
>+  [$onFullscreenChange]: async.Stream$(html$.Event),
>+  [$onFullscreenError]: async.Stream$(html$.Event),
>+  [$supportsRegisterElement]: core.bool,
>+  [$supportsRegister]: core.bool,
>+  [$visibilityState]: core.String
>+}));
>+dart.setLibraryUri(html$.Document, "dart:html");
>+dart.setFieldSignature(html$.Document, () => ({
>+  __proto__: dart.getFields(html$.Document.__proto__),
>+  [$addressSpace]: dart.finalFieldType(core.String),
>+  [_body]: dart.fieldType(html$.HtmlElement),
>+  [$contentType]: dart.finalFieldType(core.String),
>+  [$cookie]: dart.fieldType(core.String),
>+  [$currentScript]: dart.finalFieldType(html$.ScriptElement),
>+  [_get_window]: dart.finalFieldType(dart.dynamic),
>+  [$documentElement]: dart.finalFieldType(html$.Element),
>+  [$domain]: dart.finalFieldType(core.String),
>+  [$fullscreenEnabled]: dart.finalFieldType(core.bool),
>+  [_head$]: dart.finalFieldType(html$.HeadElement),
>+  [$hidden]: dart.finalFieldType(core.bool),
>+  [$implementation]: dart.finalFieldType(html$.DomImplementation),
>+  [_lastModified]: dart.finalFieldType(core.String),
>+  [$origin]: dart.finalFieldType(core.String),
>+  [_preferredStylesheetSet]: dart.finalFieldType(core.String),
>+  [$readyState]: dart.finalFieldType(core.String),
>+  [_referrer]: dart.finalFieldType(core.String),
>+  [$rootElement]: dart.finalFieldType(svg$.SvgSvgElement),
>+  [$rootScroller]: dart.fieldType(html$.Element),
>+  [$scrollingElement]: dart.finalFieldType(html$.Element),
>+  [_selectedStylesheetSet]: dart.fieldType(core.String),
>+  [$suborigin]: dart.finalFieldType(core.String),
>+  [$timeline]: dart.finalFieldType(html$.DocumentTimeline),
>+  [_title]: dart.fieldType(core.String),
>+  [_visibilityState]: dart.finalFieldType(core.String),
>+  [_webkitFullscreenElement]: dart.finalFieldType(html$.Element),
>+  [_webkitFullscreenEnabled]: dart.finalFieldType(core.bool),
>+  [_webkitHidden]: dart.finalFieldType(core.bool),
>+  [_webkitVisibilityState]: dart.finalFieldType(core.String),
>+  [$activeElement]: dart.finalFieldType(html$.Element),
>+  [$fullscreenElement]: dart.finalFieldType(html$.Element),
>+  [$pointerLockElement]: dart.finalFieldType(html$.Element),
>+  [_styleSheets]: dart.finalFieldType(ListOfStyleSheet()),
>+  [$fonts]: dart.finalFieldType(html$.FontFaceSet),
>+  [_childElementCount]: dart.finalFieldType(core.int),
>+  [_children]: dart.finalFieldType(ListOfNode()),
>+  [_firstElementChild]: dart.finalFieldType(html$.Element),
>+  [_lastElementChild]: dart.finalFieldType(html$.Element)
>+}));
>+dart.defineLazy(html$.Document, {
>+  /*html$.Document.pointerLockChangeEvent*/get pointerLockChangeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("pointerlockchange"));
>+  },
>+  /*html$.Document.pointerLockErrorEvent*/get pointerLockErrorEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("pointerlockerror"));
>+  },
>+  /*html$.Document.readyStateChangeEvent*/get readyStateChangeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("readystatechange"));
>+  },
>+  /*html$.Document.securityPolicyViolationEvent*/get securityPolicyViolationEvent() {
>+    return dart.const(new (EventStreamProviderOfSecurityPolicyViolationEvent()).new("securitypolicyviolation"));
>+  },
>+  /*html$.Document.selectionChangeEvent*/get selectionChangeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("selectionchange"));
>+  }
>+});
>+dart.registerExtension("Document", html$.Document);
>+const _docChildren = dart.privateName(html$, "_docChildren");
>+html$.DocumentFragment = class DocumentFragment extends html$.Node {
>+  static new() {
>+    return html$.document.createDocumentFragment();
>+  }
>+  static html(html, opts) {
>+    let validator = opts && 'validator' in opts ? opts.validator : null;
>+    let treeSanitizer = opts && 'treeSanitizer' in opts ? opts.treeSanitizer : null;
>+    return html$.document.body[$createFragment](html, {validator: validator, treeSanitizer: treeSanitizer});
>+  }
>+  static svg(svgContent, opts) {
>+    let validator = opts && 'validator' in opts ? opts.validator : null;
>+    let treeSanitizer = opts && 'treeSanitizer' in opts ? opts.treeSanitizer : null;
>+    return svg$.SvgSvgElement.new()[$createFragment](svgContent, {validator: validator, treeSanitizer: treeSanitizer});
>+  }
>+  get [_children]() {
>+    return dart.throw(new core.UnimplementedError.new("Use _docChildren instead"));
>+  }
>+  get [_docChildren]() {
>+    return this._docChildren;
>+  }
>+  set [_docChildren](value) {
>+    this._docChildren = value;
>+  }
>+  get [$children]() {
>+    if (this[_docChildren] == null) {
>+      this[_docChildren] = new html_common.FilteredElementList.new(this);
>+    }
>+    return this[_docChildren];
>+  }
>+  set [$children](value) {
>+    let copy = value[$toList]();
>+    let children = this[$children];
>+    children[$clear]();
>+    children[$addAll](copy);
>+  }
>+  [$querySelectorAll](T, selectors) {
>+    return new (html$._FrozenElementList$(T))._wrap(this[_querySelectorAll](selectors));
>+  }
>+  get [$innerHtml]() {
>+    let e = html$.DivElement.new();
>+    e[$append](this[$clone](true));
>+    return e[$innerHtml];
>+  }
>+  set [$innerHtml](value) {
>+    this[$setInnerHtml](value);
>+  }
>+  [$setInnerHtml](html, opts) {
>+    let validator = opts && 'validator' in opts ? opts.validator : null;
>+    let treeSanitizer = opts && 'treeSanitizer' in opts ? opts.treeSanitizer : null;
>+    this[$nodes][$clear]();
>+    this[$append](html$.document.body[$createFragment](html, {validator: validator, treeSanitizer: treeSanitizer}));
>+  }
>+  [$appendText](text) {
>+    this[$append](html$.Text.new(text));
>+  }
>+  [$appendHtml](text, opts) {
>+    let validator = opts && 'validator' in opts ? opts.validator : null;
>+    let treeSanitizer = opts && 'treeSanitizer' in opts ? opts.treeSanitizer : null;
>+    this[$append](html$.DocumentFragment.html(text, {validator: validator, treeSanitizer: treeSanitizer}));
>+  }
>+  [$getElementById](...args) {
>+    return this.getElementById.apply(this, args);
>+  }
>+  get [_childElementCount]() {
>+    return this.childElementCount;
>+  }
>+  get [_firstElementChild]() {
>+    return this.firstElementChild;
>+  }
>+  get [_lastElementChild]() {
>+    return this.lastElementChild;
>+  }
>+  [$querySelector](...args) {
>+    return this.querySelector.apply(this, args);
>+  }
>+  [_querySelectorAll](...args) {
>+    return this.querySelectorAll.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.DocumentFragment);
>+html$.DocumentFragment[dart.implements] = () => [html$.NonElementParentNode, html$.ParentNode];
>+dart.setMethodSignature(html$.DocumentFragment, () => ({
>+  __proto__: dart.getMethods(html$.DocumentFragment.__proto__),
>+  [$querySelectorAll]: dart.gFnType(T => [html$.ElementList$(T), [core.String]], T => [html$.Element]),
>+  [$setInnerHtml]: dart.fnType(dart.void, [core.String], {validator: html$.NodeValidator, treeSanitizer: html$.NodeTreeSanitizer}),
>+  [$appendText]: dart.fnType(dart.void, [core.String]),
>+  [$appendHtml]: dart.fnType(dart.void, [core.String], {validator: html$.NodeValidator, treeSanitizer: html$.NodeTreeSanitizer}),
>+  [$getElementById]: dart.fnType(html$.Element, [core.String]),
>+  [$querySelector]: dart.fnType(html$.Element, [core.String]),
>+  [_querySelectorAll]: dart.fnType(core.List$(html$.Node), [core.String])
>+}));
>+dart.setGetterSignature(html$.DocumentFragment, () => ({
>+  __proto__: dart.getGetters(html$.DocumentFragment.__proto__),
>+  [_children]: html$.HtmlCollection,
>+  [$children]: core.List$(html$.Element),
>+  [$innerHtml]: core.String
>+}));
>+dart.setSetterSignature(html$.DocumentFragment, () => ({
>+  __proto__: dart.getSetters(html$.DocumentFragment.__proto__),
>+  [$children]: core.List$(html$.Element),
>+  [$innerHtml]: core.String
>+}));
>+dart.setLibraryUri(html$.DocumentFragment, "dart:html");
>+dart.setFieldSignature(html$.DocumentFragment, () => ({
>+  __proto__: dart.getFields(html$.DocumentFragment.__proto__),
>+  [_docChildren]: dart.fieldType(ListOfElement()),
>+  [_childElementCount]: dart.finalFieldType(core.int),
>+  [_firstElementChild]: dart.finalFieldType(html$.Element),
>+  [_lastElementChild]: dart.finalFieldType(html$.Element)
>+}));
>+dart.registerExtension("DocumentFragment", html$.DocumentFragment);
>+html$.DocumentOrShadowRoot = class DocumentOrShadowRoot extends _interceptors.Interceptor {
>+  get [$activeElement]() {
>+    return this.activeElement;
>+  }
>+  get [$fullscreenElement]() {
>+    return this.fullscreenElement;
>+  }
>+  get [$pointerLockElement]() {
>+    return this.pointerLockElement;
>+  }
>+  get [$styleSheets]() {
>+    return this.styleSheets;
>+  }
>+  [$elementFromPoint](...args) {
>+    return this.elementFromPoint.apply(this, args);
>+  }
>+  [$elementsFromPoint](...args) {
>+    return this.elementsFromPoint.apply(this, args);
>+  }
>+  [$getSelection](...args) {
>+    return this.getSelection.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.DocumentOrShadowRoot);
>+const activeElement$ = Symbol("DocumentOrShadowRoot.activeElement");
>+const fullscreenElement$ = Symbol("DocumentOrShadowRoot.fullscreenElement");
>+const pointerLockElement$ = Symbol("DocumentOrShadowRoot.pointerLockElement");
>+const styleSheets = Symbol("DocumentOrShadowRoot.styleSheets");
>+dart.setMethodSignature(html$.DocumentOrShadowRoot, () => ({
>+  __proto__: dart.getMethods(html$.DocumentOrShadowRoot.__proto__),
>+  [$elementFromPoint]: dart.fnType(html$.Element, [core.int, core.int]),
>+  [$elementsFromPoint]: dart.fnType(core.List$(html$.Element), [core.int, core.int]),
>+  [$getSelection]: dart.fnType(html$.Selection, [])
>+}));
>+dart.setLibraryUri(html$.DocumentOrShadowRoot, "dart:html");
>+dart.setFieldSignature(html$.DocumentOrShadowRoot, () => ({
>+  __proto__: dart.getFields(html$.DocumentOrShadowRoot.__proto__),
>+  [$activeElement]: dart.finalFieldType(html$.Element),
>+  [$fullscreenElement]: dart.finalFieldType(html$.Element),
>+  [$pointerLockElement]: dart.finalFieldType(html$.Element),
>+  [$styleSheets]: dart.finalFieldType(ListOfStyleSheet())
>+}));
>+dart.registerExtension("DocumentOrShadowRoot", html$.DocumentOrShadowRoot);
>+html$.DocumentTimeline = class DocumentTimeline$ extends html$.AnimationTimeline {
>+  static new(options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      return html$.DocumentTimeline._create_1(options_1);
>+    }
>+    return html$.DocumentTimeline._create_2();
>+  }
>+  static _create_1(options) {
>+    return new DocumentTimeline(options);
>+  }
>+  static _create_2() {
>+    return new DocumentTimeline();
>+  }
>+};
>+dart.addTypeTests(html$.DocumentTimeline);
>+dart.setLibraryUri(html$.DocumentTimeline, "dart:html");
>+dart.registerExtension("DocumentTimeline", html$.DocumentTimeline);
>+html$.DomError = class DomError extends _interceptors.Interceptor {
>+  static new(name, message) {
>+    if (message === void 0) message = null;
>+    if (message != null) {
>+      return html$.DomError._create_1(name, message);
>+    }
>+    return html$.DomError._create_2(name);
>+  }
>+  static _create_1(name, message) {
>+    return new DOMError(name, message);
>+  }
>+  static _create_2(name) {
>+    return new DOMError(name);
>+  }
>+  get [$message]() {
>+    return this.message;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+};
>+dart.addTypeTests(html$.DomError);
>+const message$17 = Symbol("DomError.message");
>+const name$11 = Symbol("DomError.name");
>+dart.setLibraryUri(html$.DomError, "dart:html");
>+dart.setFieldSignature(html$.DomError, () => ({
>+  __proto__: dart.getFields(html$.DomError.__proto__),
>+  [$message]: dart.finalFieldType(core.String),
>+  [$name]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("DOMError", html$.DomError);
>+html$.DomException = class DomException extends _interceptors.Interceptor {
>+  get [$name]() {
>+    let errorName = this.name;
>+    if (dart.test(html_common.Device.isWebKit) && errorName === "SECURITY_ERR") return "SecurityError";
>+    if (dart.test(html_common.Device.isWebKit) && errorName === "SYNTAX_ERR") return "SyntaxError";
>+    return errorName;
>+  }
>+  get [$message]() {
>+    return this.message;
>+  }
>+  [$toString]() {
>+    return String(this);
>+  }
>+};
>+dart.addTypeTests(html$.DomException);
>+const message$18 = Symbol("DomException.message");
>+dart.setGetterSignature(html$.DomException, () => ({
>+  __proto__: dart.getGetters(html$.DomException.__proto__),
>+  [$name]: core.String
>+}));
>+dart.setLibraryUri(html$.DomException, "dart:html");
>+dart.setFieldSignature(html$.DomException, () => ({
>+  __proto__: dart.getFields(html$.DomException.__proto__),
>+  [$message]: dart.finalFieldType(core.String)
>+}));
>+dart.defineLazy(html$.DomException, {
>+  /*html$.DomException.INDEX_SIZE*/get INDEX_SIZE() {
>+    return "IndexSizeError";
>+  },
>+  /*html$.DomException.HIERARCHY_REQUEST*/get HIERARCHY_REQUEST() {
>+    return "HierarchyRequestError";
>+  },
>+  /*html$.DomException.WRONG_DOCUMENT*/get WRONG_DOCUMENT() {
>+    return "WrongDocumentError";
>+  },
>+  /*html$.DomException.INVALID_CHARACTER*/get INVALID_CHARACTER() {
>+    return "InvalidCharacterError";
>+  },
>+  /*html$.DomException.NO_MODIFICATION_ALLOWED*/get NO_MODIFICATION_ALLOWED() {
>+    return "NoModificationAllowedError";
>+  },
>+  /*html$.DomException.NOT_FOUND*/get NOT_FOUND() {
>+    return "NotFoundError";
>+  },
>+  /*html$.DomException.NOT_SUPPORTED*/get NOT_SUPPORTED() {
>+    return "NotSupportedError";
>+  },
>+  /*html$.DomException.INVALID_STATE*/get INVALID_STATE() {
>+    return "InvalidStateError";
>+  },
>+  /*html$.DomException.SYNTAX*/get SYNTAX() {
>+    return "SyntaxError";
>+  },
>+  /*html$.DomException.INVALID_MODIFICATION*/get INVALID_MODIFICATION() {
>+    return "InvalidModificationError";
>+  },
>+  /*html$.DomException.NAMESPACE*/get NAMESPACE() {
>+    return "NamespaceError";
>+  },
>+  /*html$.DomException.INVALID_ACCESS*/get INVALID_ACCESS() {
>+    return "InvalidAccessError";
>+  },
>+  /*html$.DomException.TYPE_MISMATCH*/get TYPE_MISMATCH() {
>+    return "TypeMismatchError";
>+  },
>+  /*html$.DomException.SECURITY*/get SECURITY() {
>+    return "SecurityError";
>+  },
>+  /*html$.DomException.NETWORK*/get NETWORK() {
>+    return "NetworkError";
>+  },
>+  /*html$.DomException.ABORT*/get ABORT() {
>+    return "AbortError";
>+  },
>+  /*html$.DomException.URL_MISMATCH*/get URL_MISMATCH() {
>+    return "URLMismatchError";
>+  },
>+  /*html$.DomException.QUOTA_EXCEEDED*/get QUOTA_EXCEEDED() {
>+    return "QuotaExceededError";
>+  },
>+  /*html$.DomException.TIMEOUT*/get TIMEOUT() {
>+    return "TimeoutError";
>+  },
>+  /*html$.DomException.INVALID_NODE_TYPE*/get INVALID_NODE_TYPE() {
>+    return "InvalidNodeTypeError";
>+  },
>+  /*html$.DomException.DATA_CLONE*/get DATA_CLONE() {
>+    return "DataCloneError";
>+  },
>+  /*html$.DomException.ENCODING*/get ENCODING() {
>+    return "EncodingError";
>+  },
>+  /*html$.DomException.NOT_READABLE*/get NOT_READABLE() {
>+    return "NotReadableError";
>+  },
>+  /*html$.DomException.UNKNOWN*/get UNKNOWN() {
>+    return "UnknownError";
>+  },
>+  /*html$.DomException.CONSTRAINT*/get CONSTRAINT() {
>+    return "ConstraintError";
>+  },
>+  /*html$.DomException.TRANSACTION_INACTIVE*/get TRANSACTION_INACTIVE() {
>+    return "TransactionInactiveError";
>+  },
>+  /*html$.DomException.READ_ONLY*/get READ_ONLY() {
>+    return "ReadOnlyError";
>+  },
>+  /*html$.DomException.VERSION*/get VERSION() {
>+    return "VersionError";
>+  },
>+  /*html$.DomException.OPERATION*/get OPERATION() {
>+    return "OperationError";
>+  },
>+  /*html$.DomException.NOT_ALLOWED*/get NOT_ALLOWED() {
>+    return "NotAllowedError";
>+  },
>+  /*html$.DomException.TYPE_ERROR*/get TYPE_ERROR() {
>+    return "TypeError";
>+  }
>+});
>+dart.registerExtension("DOMException", html$.DomException);
>+html$.DomImplementation = class DomImplementation extends _interceptors.Interceptor {
>+  [$createDocument](...args) {
>+    return this.createDocument.apply(this, args);
>+  }
>+  [$createDocumentType](...args) {
>+    return this.createDocumentType.apply(this, args);
>+  }
>+  [$createHtmlDocument](...args) {
>+    return this.createHTMLDocument.apply(this, args);
>+  }
>+  [$hasFeature](...args) {
>+    return this.hasFeature.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.DomImplementation);
>+dart.setMethodSignature(html$.DomImplementation, () => ({
>+  __proto__: dart.getMethods(html$.DomImplementation.__proto__),
>+  [$createDocument]: dart.fnType(html$.XmlDocument, [core.String, core.String, html$._DocumentType]),
>+  [$createDocumentType]: dart.fnType(html$._DocumentType, [core.String, core.String, core.String]),
>+  [$createHtmlDocument]: dart.fnType(html$.HtmlDocument, [], [core.String]),
>+  [$hasFeature]: dart.fnType(core.bool, [])
>+}));
>+dart.setLibraryUri(html$.DomImplementation, "dart:html");
>+dart.registerExtension("DOMImplementation", html$.DomImplementation);
>+html$.DomIterator = class DomIterator extends _interceptors.Interceptor {
>+  [$next](...args) {
>+    return this.next.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.DomIterator);
>+dart.setMethodSignature(html$.DomIterator, () => ({
>+  __proto__: dart.getMethods(html$.DomIterator.__proto__),
>+  [$next]: dart.fnType(core.Object, [], [core.Object])
>+}));
>+dart.setLibraryUri(html$.DomIterator, "dart:html");
>+dart.registerExtension("Iterator", html$.DomIterator);
>+const _multiplySelf_1 = dart.privateName(html$, "_multiplySelf_1");
>+const _multiplySelf_2 = dart.privateName(html$, "_multiplySelf_2");
>+const _preMultiplySelf_1 = dart.privateName(html$, "_preMultiplySelf_1");
>+const _preMultiplySelf_2 = dart.privateName(html$, "_preMultiplySelf_2");
>+const _multiply_1 = dart.privateName(html$, "_multiply_1");
>+const _multiply_2 = dart.privateName(html$, "_multiply_2");
>+const _transformPoint_1 = dart.privateName(html$, "_transformPoint_1");
>+const _transformPoint_2 = dart.privateName(html$, "_transformPoint_2");
>+html$.DomMatrixReadOnly = class DomMatrixReadOnly extends _interceptors.Interceptor {
>+  static new(init) {
>+    if (init === void 0) init = null;
>+    if (init != null) {
>+      return html$.DomMatrixReadOnly._create_1(init);
>+    }
>+    return html$.DomMatrixReadOnly._create_2();
>+  }
>+  static _create_1(init) {
>+    return new DOMMatrixReadOnly(init);
>+  }
>+  static _create_2() {
>+    return new DOMMatrixReadOnly();
>+  }
>+  get [$a]() {
>+    return this.a;
>+  }
>+  get [$b]() {
>+    return this.b;
>+  }
>+  get [$c]() {
>+    return this.c;
>+  }
>+  get [$d]() {
>+    return this.d;
>+  }
>+  get [$e]() {
>+    return this.e;
>+  }
>+  get [$f]() {
>+    return this.f;
>+  }
>+  get [$is2D]() {
>+    return this.is2D;
>+  }
>+  get [$isIdentity]() {
>+    return this.isIdentity;
>+  }
>+  get [$m11]() {
>+    return this.m11;
>+  }
>+  get [$m12]() {
>+    return this.m12;
>+  }
>+  get [$m13]() {
>+    return this.m13;
>+  }
>+  get [$m14]() {
>+    return this.m14;
>+  }
>+  get [$m21]() {
>+    return this.m21;
>+  }
>+  get [$m22]() {
>+    return this.m22;
>+  }
>+  get [$m23]() {
>+    return this.m23;
>+  }
>+  get [$m24]() {
>+    return this.m24;
>+  }
>+  get [$m31]() {
>+    return this.m31;
>+  }
>+  get [$m32]() {
>+    return this.m32;
>+  }
>+  get [$m33]() {
>+    return this.m33;
>+  }
>+  get [$m34]() {
>+    return this.m34;
>+  }
>+  get [$m41]() {
>+    return this.m41;
>+  }
>+  get [$m42]() {
>+    return this.m42;
>+  }
>+  get [$m43]() {
>+    return this.m43;
>+  }
>+  get [$m44]() {
>+    return this.m44;
>+  }
>+  [$flipX](...args) {
>+    return this.flipX.apply(this, args);
>+  }
>+  [$flipY](...args) {
>+    return this.flipY.apply(this, args);
>+  }
>+  static fromMatrix(other) {
>+    if (other === void 0) other = null;
>+    if (other != null) {
>+      let other_1 = html_common.convertDartToNative_Dictionary(other);
>+      return dart.global.DOMMatrixReadOnly.fromMatrix(other_1);
>+    }
>+    return dart.global.DOMMatrixReadOnly.fromMatrix();
>+  }
>+  [$inverse](...args) {
>+    return this.inverse.apply(this, args);
>+  }
>+  [$multiply](other) {
>+    if (other === void 0) other = null;
>+    if (other != null) {
>+      let other_1 = html_common.convertDartToNative_Dictionary(other);
>+      return this[_multiply_1](other_1);
>+    }
>+    return this[_multiply_2]();
>+  }
>+  [_multiply_1](...args) {
>+    return this.multiply.apply(this, args);
>+  }
>+  [_multiply_2](...args) {
>+    return this.multiply.apply(this, args);
>+  }
>+  [$rotate](...args) {
>+    return this.rotate.apply(this, args);
>+  }
>+  [$rotateAxisAngle](...args) {
>+    return this.rotateAxisAngle.apply(this, args);
>+  }
>+  [$rotateFromVector](...args) {
>+    return this.rotateFromVector.apply(this, args);
>+  }
>+  [$scale](...args) {
>+    return this.scale.apply(this, args);
>+  }
>+  [$scale3d](...args) {
>+    return this.scale3d.apply(this, args);
>+  }
>+  [$skewX](...args) {
>+    return this.skewX.apply(this, args);
>+  }
>+  [$skewY](...args) {
>+    return this.skewY.apply(this, args);
>+  }
>+  [$toFloat32Array](...args) {
>+    return this.toFloat32Array.apply(this, args);
>+  }
>+  [$toFloat64Array](...args) {
>+    return this.toFloat64Array.apply(this, args);
>+  }
>+  [$transformPoint](point) {
>+    if (point === void 0) point = null;
>+    if (point != null) {
>+      let point_1 = html_common.convertDartToNative_Dictionary(point);
>+      return this[_transformPoint_1](point_1);
>+    }
>+    return this[_transformPoint_2]();
>+  }
>+  [_transformPoint_1](...args) {
>+    return this.transformPoint.apply(this, args);
>+  }
>+  [_transformPoint_2](...args) {
>+    return this.transformPoint.apply(this, args);
>+  }
>+  [$translate](...args) {
>+    return this.translate.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.DomMatrixReadOnly);
>+dart.setMethodSignature(html$.DomMatrixReadOnly, () => ({
>+  __proto__: dart.getMethods(html$.DomMatrixReadOnly.__proto__),
>+  [$flipX]: dart.fnType(html$.DomMatrix, []),
>+  [$flipY]: dart.fnType(html$.DomMatrix, []),
>+  [$inverse]: dart.fnType(html$.DomMatrix, []),
>+  [$multiply]: dart.fnType(html$.DomMatrix, [], [core.Map]),
>+  [_multiply_1]: dart.fnType(html$.DomMatrix, [dart.dynamic]),
>+  [_multiply_2]: dart.fnType(html$.DomMatrix, []),
>+  [$rotate]: dart.fnType(html$.DomMatrix, [], [core.num, core.num, core.num]),
>+  [$rotateAxisAngle]: dart.fnType(html$.DomMatrix, [], [core.num, core.num, core.num, core.num]),
>+  [$rotateFromVector]: dart.fnType(html$.DomMatrix, [], [core.num, core.num]),
>+  [$scale]: dart.fnType(html$.DomMatrix, [], [core.num, core.num, core.num, core.num, core.num, core.num]),
>+  [$scale3d]: dart.fnType(html$.DomMatrix, [], [core.num, core.num, core.num, core.num]),
>+  [$skewX]: dart.fnType(html$.DomMatrix, [], [core.num]),
>+  [$skewY]: dart.fnType(html$.DomMatrix, [], [core.num]),
>+  [$toFloat32Array]: dart.fnType(typed_data.Float32List, []),
>+  [$toFloat64Array]: dart.fnType(typed_data.Float64List, []),
>+  [$transformPoint]: dart.fnType(html$.DomPoint, [], [core.Map]),
>+  [_transformPoint_1]: dart.fnType(html$.DomPoint, [dart.dynamic]),
>+  [_transformPoint_2]: dart.fnType(html$.DomPoint, []),
>+  [$translate]: dart.fnType(html$.DomMatrix, [], [core.num, core.num, core.num])
>+}));
>+dart.setGetterSignature(html$.DomMatrixReadOnly, () => ({
>+  __proto__: dart.getGetters(html$.DomMatrixReadOnly.__proto__),
>+  [$a]: core.num,
>+  [$b]: core.num,
>+  [$c]: core.num,
>+  [$d]: core.num,
>+  [$e]: core.num,
>+  [$f]: core.num,
>+  [$is2D]: core.bool,
>+  [$isIdentity]: core.bool,
>+  [$m11]: core.num,
>+  [$m12]: core.num,
>+  [$m13]: core.num,
>+  [$m14]: core.num,
>+  [$m21]: core.num,
>+  [$m22]: core.num,
>+  [$m23]: core.num,
>+  [$m24]: core.num,
>+  [$m31]: core.num,
>+  [$m32]: core.num,
>+  [$m33]: core.num,
>+  [$m34]: core.num,
>+  [$m41]: core.num,
>+  [$m42]: core.num,
>+  [$m43]: core.num,
>+  [$m44]: core.num
>+}));
>+dart.setLibraryUri(html$.DomMatrixReadOnly, "dart:html");
>+dart.registerExtension("DOMMatrixReadOnly", html$.DomMatrixReadOnly);
>+html$.DomMatrix = class DomMatrix extends html$.DomMatrixReadOnly {
>+  static new(init) {
>+    if (init === void 0) init = null;
>+    if (init != null) {
>+      return html$.DomMatrix._create_1(init);
>+    }
>+    return html$.DomMatrix._create_2();
>+  }
>+  static _create_1(init) {
>+    return new DOMMatrix(init);
>+  }
>+  static _create_2() {
>+    return new DOMMatrix();
>+  }
>+  get [$a]() {
>+    return this.a;
>+  }
>+  set [$a](value) {
>+    this.a = value;
>+  }
>+  get [$b]() {
>+    return this.b;
>+  }
>+  set [$b](value) {
>+    this.b = value;
>+  }
>+  get [$c]() {
>+    return this.c;
>+  }
>+  set [$c](value) {
>+    this.c = value;
>+  }
>+  get [$d]() {
>+    return this.d;
>+  }
>+  set [$d](value) {
>+    this.d = value;
>+  }
>+  get [$e]() {
>+    return this.e;
>+  }
>+  set [$e](value) {
>+    this.e = value;
>+  }
>+  get [$f]() {
>+    return this.f;
>+  }
>+  set [$f](value) {
>+    this.f = value;
>+  }
>+  get [$m11]() {
>+    return this.m11;
>+  }
>+  set [$m11](value) {
>+    this.m11 = value;
>+  }
>+  get [$m12]() {
>+    return this.m12;
>+  }
>+  set [$m12](value) {
>+    this.m12 = value;
>+  }
>+  get [$m13]() {
>+    return this.m13;
>+  }
>+  set [$m13](value) {
>+    this.m13 = value;
>+  }
>+  get [$m14]() {
>+    return this.m14;
>+  }
>+  set [$m14](value) {
>+    this.m14 = value;
>+  }
>+  get [$m21]() {
>+    return this.m21;
>+  }
>+  set [$m21](value) {
>+    this.m21 = value;
>+  }
>+  get [$m22]() {
>+    return this.m22;
>+  }
>+  set [$m22](value) {
>+    this.m22 = value;
>+  }
>+  get [$m23]() {
>+    return this.m23;
>+  }
>+  set [$m23](value) {
>+    this.m23 = value;
>+  }
>+  get [$m24]() {
>+    return this.m24;
>+  }
>+  set [$m24](value) {
>+    this.m24 = value;
>+  }
>+  get [$m31]() {
>+    return this.m31;
>+  }
>+  set [$m31](value) {
>+    this.m31 = value;
>+  }
>+  get [$m32]() {
>+    return this.m32;
>+  }
>+  set [$m32](value) {
>+    this.m32 = value;
>+  }
>+  get [$m33]() {
>+    return this.m33;
>+  }
>+  set [$m33](value) {
>+    this.m33 = value;
>+  }
>+  get [$m34]() {
>+    return this.m34;
>+  }
>+  set [$m34](value) {
>+    this.m34 = value;
>+  }
>+  get [$m41]() {
>+    return this.m41;
>+  }
>+  set [$m41](value) {
>+    this.m41 = value;
>+  }
>+  get [$m42]() {
>+    return this.m42;
>+  }
>+  set [$m42](value) {
>+    this.m42 = value;
>+  }
>+  get [$m43]() {
>+    return this.m43;
>+  }
>+  set [$m43](value) {
>+    this.m43 = value;
>+  }
>+  get [$m44]() {
>+    return this.m44;
>+  }
>+  set [$m44](value) {
>+    this.m44 = value;
>+  }
>+  static fromMatrix(other) {
>+    if (other === void 0) other = null;
>+    if (other != null) {
>+      let other_1 = html_common.convertDartToNative_Dictionary(other);
>+      return dart.global.DOMMatrix.fromMatrix(other_1);
>+    }
>+    return dart.global.DOMMatrix.fromMatrix();
>+  }
>+  [$invertSelf](...args) {
>+    return this.invertSelf.apply(this, args);
>+  }
>+  [$multiplySelf](other) {
>+    if (other === void 0) other = null;
>+    if (other != null) {
>+      let other_1 = html_common.convertDartToNative_Dictionary(other);
>+      return this[_multiplySelf_1](other_1);
>+    }
>+    return this[_multiplySelf_2]();
>+  }
>+  [_multiplySelf_1](...args) {
>+    return this.multiplySelf.apply(this, args);
>+  }
>+  [_multiplySelf_2](...args) {
>+    return this.multiplySelf.apply(this, args);
>+  }
>+  [$preMultiplySelf](other) {
>+    if (other === void 0) other = null;
>+    if (other != null) {
>+      let other_1 = html_common.convertDartToNative_Dictionary(other);
>+      return this[_preMultiplySelf_1](other_1);
>+    }
>+    return this[_preMultiplySelf_2]();
>+  }
>+  [_preMultiplySelf_1](...args) {
>+    return this.preMultiplySelf.apply(this, args);
>+  }
>+  [_preMultiplySelf_2](...args) {
>+    return this.preMultiplySelf.apply(this, args);
>+  }
>+  [$rotateAxisAngleSelf](...args) {
>+    return this.rotateAxisAngleSelf.apply(this, args);
>+  }
>+  [$rotateFromVectorSelf](...args) {
>+    return this.rotateFromVectorSelf.apply(this, args);
>+  }
>+  [$rotateSelf](...args) {
>+    return this.rotateSelf.apply(this, args);
>+  }
>+  [$scale3dSelf](...args) {
>+    return this.scale3dSelf.apply(this, args);
>+  }
>+  [$scaleSelf](...args) {
>+    return this.scaleSelf.apply(this, args);
>+  }
>+  [$setMatrixValue](...args) {
>+    return this.setMatrixValue.apply(this, args);
>+  }
>+  [$skewXSelf](...args) {
>+    return this.skewXSelf.apply(this, args);
>+  }
>+  [$skewYSelf](...args) {
>+    return this.skewYSelf.apply(this, args);
>+  }
>+  [$translateSelf](...args) {
>+    return this.translateSelf.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.DomMatrix);
>+dart.setMethodSignature(html$.DomMatrix, () => ({
>+  __proto__: dart.getMethods(html$.DomMatrix.__proto__),
>+  [$invertSelf]: dart.fnType(html$.DomMatrix, []),
>+  [$multiplySelf]: dart.fnType(html$.DomMatrix, [], [core.Map]),
>+  [_multiplySelf_1]: dart.fnType(html$.DomMatrix, [dart.dynamic]),
>+  [_multiplySelf_2]: dart.fnType(html$.DomMatrix, []),
>+  [$preMultiplySelf]: dart.fnType(html$.DomMatrix, [], [core.Map]),
>+  [_preMultiplySelf_1]: dart.fnType(html$.DomMatrix, [dart.dynamic]),
>+  [_preMultiplySelf_2]: dart.fnType(html$.DomMatrix, []),
>+  [$rotateAxisAngleSelf]: dart.fnType(html$.DomMatrix, [], [core.num, core.num, core.num, core.num]),
>+  [$rotateFromVectorSelf]: dart.fnType(html$.DomMatrix, [], [core.num, core.num]),
>+  [$rotateSelf]: dart.fnType(html$.DomMatrix, [], [core.num, core.num, core.num]),
>+  [$scale3dSelf]: dart.fnType(html$.DomMatrix, [], [core.num, core.num, core.num, core.num]),
>+  [$scaleSelf]: dart.fnType(html$.DomMatrix, [], [core.num, core.num, core.num, core.num, core.num, core.num]),
>+  [$setMatrixValue]: dart.fnType(html$.DomMatrix, [core.String]),
>+  [$skewXSelf]: dart.fnType(html$.DomMatrix, [], [core.num]),
>+  [$skewYSelf]: dart.fnType(html$.DomMatrix, [], [core.num]),
>+  [$translateSelf]: dart.fnType(html$.DomMatrix, [], [core.num, core.num, core.num])
>+}));
>+dart.setSetterSignature(html$.DomMatrix, () => ({
>+  __proto__: dart.getSetters(html$.DomMatrix.__proto__),
>+  [$a]: core.num,
>+  [$b]: core.num,
>+  [$c]: core.num,
>+  [$d]: core.num,
>+  [$e]: core.num,
>+  [$f]: core.num,
>+  [$m11]: core.num,
>+  [$m12]: core.num,
>+  [$m13]: core.num,
>+  [$m14]: core.num,
>+  [$m21]: core.num,
>+  [$m22]: core.num,
>+  [$m23]: core.num,
>+  [$m24]: core.num,
>+  [$m31]: core.num,
>+  [$m32]: core.num,
>+  [$m33]: core.num,
>+  [$m34]: core.num,
>+  [$m41]: core.num,
>+  [$m42]: core.num,
>+  [$m43]: core.num,
>+  [$m44]: core.num
>+}));
>+dart.setLibraryUri(html$.DomMatrix, "dart:html");
>+dart.registerExtension("DOMMatrix", html$.DomMatrix);
>+html$.DomParser = class DomParser extends _interceptors.Interceptor {
>+  static new() {
>+    return html$.DomParser._create_1();
>+  }
>+  static _create_1() {
>+    return new DOMParser();
>+  }
>+  [$parseFromString](...args) {
>+    return this.parseFromString.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.DomParser);
>+dart.setMethodSignature(html$.DomParser, () => ({
>+  __proto__: dart.getMethods(html$.DomParser.__proto__),
>+  [$parseFromString]: dart.fnType(html$.Document, [core.String, core.String])
>+}));
>+dart.setLibraryUri(html$.DomParser, "dart:html");
>+dart.registerExtension("DOMParser", html$.DomParser);
>+const _matrixTransform_1 = dart.privateName(html$, "_matrixTransform_1");
>+const _matrixTransform_2 = dart.privateName(html$, "_matrixTransform_2");
>+html$.DomPointReadOnly = class DomPointReadOnly extends _interceptors.Interceptor {
>+  static new(x, y, z, w) {
>+    if (x === void 0) x = null;
>+    if (y === void 0) y = null;
>+    if (z === void 0) z = null;
>+    if (w === void 0) w = null;
>+    if (w != null) {
>+      return html$.DomPointReadOnly._create_1(x, y, z, w);
>+    }
>+    if (z != null) {
>+      return html$.DomPointReadOnly._create_2(x, y, z);
>+    }
>+    if (y != null) {
>+      return html$.DomPointReadOnly._create_3(x, y);
>+    }
>+    if (x != null) {
>+      return html$.DomPointReadOnly._create_4(x);
>+    }
>+    return html$.DomPointReadOnly._create_5();
>+  }
>+  static _create_1(x, y, z, w) {
>+    return new DOMPointReadOnly(x, y, z, w);
>+  }
>+  static _create_2(x, y, z) {
>+    return new DOMPointReadOnly(x, y, z);
>+  }
>+  static _create_3(x, y) {
>+    return new DOMPointReadOnly(x, y);
>+  }
>+  static _create_4(x) {
>+    return new DOMPointReadOnly(x);
>+  }
>+  static _create_5() {
>+    return new DOMPointReadOnly();
>+  }
>+  get [$w]() {
>+    return this.w;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+  get [$z]() {
>+    return this.z;
>+  }
>+  static fromPoint(other) {
>+    if (other === void 0) other = null;
>+    if (other != null) {
>+      let other_1 = html_common.convertDartToNative_Dictionary(other);
>+      return dart.global.DOMPointReadOnly.fromPoint(other_1);
>+    }
>+    return dart.global.DOMPointReadOnly.fromPoint();
>+  }
>+  [$matrixTransform](matrix) {
>+    if (matrix === void 0) matrix = null;
>+    if (matrix != null) {
>+      let matrix_1 = html_common.convertDartToNative_Dictionary(matrix);
>+      return this[_matrixTransform_1](matrix_1);
>+    }
>+    return this[_matrixTransform_2]();
>+  }
>+  [_matrixTransform_1](...args) {
>+    return this.matrixTransform.apply(this, args);
>+  }
>+  [_matrixTransform_2](...args) {
>+    return this.matrixTransform.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.DomPointReadOnly);
>+dart.setMethodSignature(html$.DomPointReadOnly, () => ({
>+  __proto__: dart.getMethods(html$.DomPointReadOnly.__proto__),
>+  [$matrixTransform]: dart.fnType(html$.DomPoint, [], [core.Map]),
>+  [_matrixTransform_1]: dart.fnType(html$.DomPoint, [dart.dynamic]),
>+  [_matrixTransform_2]: dart.fnType(html$.DomPoint, [])
>+}));
>+dart.setGetterSignature(html$.DomPointReadOnly, () => ({
>+  __proto__: dart.getGetters(html$.DomPointReadOnly.__proto__),
>+  [$w]: core.num,
>+  [$x]: core.num,
>+  [$y]: core.num,
>+  [$z]: core.num
>+}));
>+dart.setLibraryUri(html$.DomPointReadOnly, "dart:html");
>+dart.registerExtension("DOMPointReadOnly", html$.DomPointReadOnly);
>+html$.DomPoint = class DomPoint extends html$.DomPointReadOnly {
>+  static new(x, y, z, w) {
>+    if (x === void 0) x = null;
>+    if (y === void 0) y = null;
>+    if (z === void 0) z = null;
>+    if (w === void 0) w = null;
>+    if (w != null) {
>+      return html$.DomPoint._create_1(x, y, z, w);
>+    }
>+    if (z != null) {
>+      return html$.DomPoint._create_2(x, y, z);
>+    }
>+    if (y != null) {
>+      return html$.DomPoint._create_3(x, y);
>+    }
>+    if (x != null) {
>+      return html$.DomPoint._create_4(x);
>+    }
>+    return html$.DomPoint._create_5();
>+  }
>+  static _create_1(x, y, z, w) {
>+    return new DOMPoint(x, y, z, w);
>+  }
>+  static _create_2(x, y, z) {
>+    return new DOMPoint(x, y, z);
>+  }
>+  static _create_3(x, y) {
>+    return new DOMPoint(x, y);
>+  }
>+  static _create_4(x) {
>+    return new DOMPoint(x);
>+  }
>+  static _create_5() {
>+    return new DOMPoint();
>+  }
>+  static get supported() {
>+    return !!window.DOMPoint || !!window.WebKitPoint;
>+  }
>+  get [$w]() {
>+    return this.w;
>+  }
>+  set [$w](value) {
>+    this.w = value;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  set [$x](value) {
>+    this.x = value;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+  set [$y](value) {
>+    this.y = value;
>+  }
>+  get [$z]() {
>+    return this.z;
>+  }
>+  set [$z](value) {
>+    this.z = value;
>+  }
>+  static fromPoint(other) {
>+    if (other === void 0) other = null;
>+    if (other != null) {
>+      let other_1 = html_common.convertDartToNative_Dictionary(other);
>+      return dart.global.DOMPoint.fromPoint(other_1);
>+    }
>+    return dart.global.DOMPoint.fromPoint();
>+  }
>+};
>+dart.addTypeTests(html$.DomPoint);
>+dart.setSetterSignature(html$.DomPoint, () => ({
>+  __proto__: dart.getSetters(html$.DomPoint.__proto__),
>+  [$w]: core.num,
>+  [$x]: core.num,
>+  [$y]: core.num,
>+  [$z]: core.num
>+}));
>+dart.setLibraryUri(html$.DomPoint, "dart:html");
>+dart.registerExtension("DOMPoint", html$.DomPoint);
>+html$.DomQuad = class DomQuad extends _interceptors.Interceptor {
>+  static new(p1, p2, p3, p4) {
>+    if (p1 === void 0) p1 = null;
>+    if (p2 === void 0) p2 = null;
>+    if (p3 === void 0) p3 = null;
>+    if (p4 === void 0) p4 = null;
>+    if (p4 != null) {
>+      let p1_1 = html_common.convertDartToNative_Dictionary(p1);
>+      let p2_2 = html_common.convertDartToNative_Dictionary(p2);
>+      let p3_3 = html_common.convertDartToNative_Dictionary(p3);
>+      let p4_4 = html_common.convertDartToNative_Dictionary(p4);
>+      return html$.DomQuad._create_1(p1_1, p2_2, p3_3, p4_4);
>+    }
>+    if (p3 != null) {
>+      let p1_1 = html_common.convertDartToNative_Dictionary(p1);
>+      let p2_2 = html_common.convertDartToNative_Dictionary(p2);
>+      let p3_3 = html_common.convertDartToNative_Dictionary(p3);
>+      return html$.DomQuad._create_2(p1_1, p2_2, p3_3);
>+    }
>+    if (p2 != null) {
>+      let p1_1 = html_common.convertDartToNative_Dictionary(p1);
>+      let p2_2 = html_common.convertDartToNative_Dictionary(p2);
>+      return html$.DomQuad._create_3(p1_1, p2_2);
>+    }
>+    if (p1 != null) {
>+      let p1_1 = html_common.convertDartToNative_Dictionary(p1);
>+      return html$.DomQuad._create_4(p1_1);
>+    }
>+    return html$.DomQuad._create_5();
>+  }
>+  static _create_1(p1, p2, p3, p4) {
>+    return new DOMQuad(p1, p2, p3, p4);
>+  }
>+  static _create_2(p1, p2, p3) {
>+    return new DOMQuad(p1, p2, p3);
>+  }
>+  static _create_3(p1, p2) {
>+    return new DOMQuad(p1, p2);
>+  }
>+  static _create_4(p1) {
>+    return new DOMQuad(p1);
>+  }
>+  static _create_5() {
>+    return new DOMQuad();
>+  }
>+  get [$p1]() {
>+    return this.p1;
>+  }
>+  get [$p2]() {
>+    return this.p2;
>+  }
>+  get [$p3]() {
>+    return this.p3;
>+  }
>+  get [$p4]() {
>+    return this.p4;
>+  }
>+  static fromQuad(other) {
>+    if (other === void 0) other = null;
>+    if (other != null) {
>+      let other_1 = html_common.convertDartToNative_Dictionary(other);
>+      return dart.global.DOMQuad.fromQuad(other_1);
>+    }
>+    return dart.global.DOMQuad.fromQuad();
>+  }
>+  static fromRect(other) {
>+    if (other === void 0) other = null;
>+    if (other != null) {
>+      let other_1 = html_common.convertDartToNative_Dictionary(other);
>+      return dart.global.DOMQuad.fromRect(other_1);
>+    }
>+    return dart.global.DOMQuad.fromRect();
>+  }
>+  [$getBounds](...args) {
>+    return this.getBounds.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.DomQuad);
>+const p1 = Symbol("DomQuad.p1");
>+const p2 = Symbol("DomQuad.p2");
>+const p3 = Symbol("DomQuad.p3");
>+const p4 = Symbol("DomQuad.p4");
>+dart.setMethodSignature(html$.DomQuad, () => ({
>+  __proto__: dart.getMethods(html$.DomQuad.__proto__),
>+  [$getBounds]: dart.fnType(math.Rectangle$(core.num), [])
>+}));
>+dart.setLibraryUri(html$.DomQuad, "dart:html");
>+dart.setFieldSignature(html$.DomQuad, () => ({
>+  __proto__: dart.getFields(html$.DomQuad.__proto__),
>+  [$p1]: dart.finalFieldType(html$.DomPoint),
>+  [$p2]: dart.finalFieldType(html$.DomPoint),
>+  [$p3]: dart.finalFieldType(html$.DomPoint),
>+  [$p4]: dart.finalFieldType(html$.DomPoint)
>+}));
>+dart.registerExtension("DOMQuad", html$.DomQuad);
>+const _is_ImmutableListMixin_default = Symbol('_is_ImmutableListMixin_default');
>+html$.ImmutableListMixin$ = dart.generic(E => {
>+  let FixedSizeListIteratorOfE = () => (FixedSizeListIteratorOfE = dart.constFn(html$.FixedSizeListIterator$(E)))();
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  let ListOfE = () => (ListOfE = dart.constFn(core.List$(E)))();
>+  class ImmutableListMixin extends core.Object {
>+    get iterator() {
>+      return new (FixedSizeListIteratorOfE()).new(this);
>+    }
>+    [Symbol.iterator]() {
>+      return new dart.JsIterator(this[$iterator]);
>+    }
>+    add(value) {
>+      E._check(value);
>+      dart.throw(new core.UnsupportedError.new("Cannot add to immutable List."));
>+    }
>+    addAll(iterable) {
>+      IterableOfE()._check(iterable);
>+      dart.throw(new core.UnsupportedError.new("Cannot add to immutable List."));
>+    }
>+    sort(compare) {
>+      if (compare === void 0) compare = null;
>+      dart.throw(new core.UnsupportedError.new("Cannot sort immutable List."));
>+    }
>+    shuffle(random) {
>+      if (random === void 0) random = null;
>+      dart.throw(new core.UnsupportedError.new("Cannot shuffle immutable List."));
>+    }
>+    insert(index, element) {
>+      E._check(element);
>+      dart.throw(new core.UnsupportedError.new("Cannot add to immutable List."));
>+    }
>+    insertAll(index, iterable) {
>+      IterableOfE()._check(iterable);
>+      dart.throw(new core.UnsupportedError.new("Cannot add to immutable List."));
>+    }
>+    setAll(index, iterable) {
>+      IterableOfE()._check(iterable);
>+      dart.throw(new core.UnsupportedError.new("Cannot modify an immutable List."));
>+    }
>+    removeAt(pos) {
>+      dart.throw(new core.UnsupportedError.new("Cannot remove from immutable List."));
>+    }
>+    removeLast() {
>+      dart.throw(new core.UnsupportedError.new("Cannot remove from immutable List."));
>+    }
>+    remove(object) {
>+      dart.throw(new core.UnsupportedError.new("Cannot remove from immutable List."));
>+    }
>+    removeWhere(test) {
>+      dart.throw(new core.UnsupportedError.new("Cannot remove from immutable List."));
>+    }
>+    retainWhere(test) {
>+      dart.throw(new core.UnsupportedError.new("Cannot remove from immutable List."));
>+    }
>+    setRange(start, end, iterable, skipCount) {
>+      IterableOfE()._check(iterable);
>+      if (skipCount === void 0) skipCount = 0;
>+      dart.throw(new core.UnsupportedError.new("Cannot setRange on immutable List."));
>+    }
>+    removeRange(start, end) {
>+      dart.throw(new core.UnsupportedError.new("Cannot removeRange on immutable List."));
>+    }
>+    replaceRange(start, end, iterable) {
>+      IterableOfE()._check(iterable);
>+      dart.throw(new core.UnsupportedError.new("Cannot modify an immutable List."));
>+    }
>+    fillRange(start, end, fillValue) {
>+      if (fillValue === void 0) fillValue = null;
>+      E._check(fillValue);
>+      dart.throw(new core.UnsupportedError.new("Cannot modify an immutable List."));
>+    }
>+  }
>+  (ImmutableListMixin.new = function() {
>+  }).prototype = ImmutableListMixin.prototype;
>+  ImmutableListMixin.prototype[dart.isList] = true;
>+  dart.addTypeTests(ImmutableListMixin);
>+  ImmutableListMixin.prototype[_is_ImmutableListMixin_default] = true;
>+  ImmutableListMixin[dart.implements] = () => [ListOfE()];
>+  dart.setMethodSignature(ImmutableListMixin, () => ({
>+    __proto__: dart.getMethods(ImmutableListMixin.__proto__),
>+    add: dart.fnType(dart.void, [core.Object]),
>+    [$add]: dart.fnType(dart.void, [core.Object]),
>+    addAll: dart.fnType(dart.void, [core.Object]),
>+    [$addAll]: dart.fnType(dart.void, [core.Object]),
>+    sort: dart.fnType(dart.void, [], [dart.fnType(core.int, [E, E])]),
>+    [$sort]: dart.fnType(dart.void, [], [dart.fnType(core.int, [E, E])]),
>+    shuffle: dart.fnType(dart.void, [], [math.Random]),
>+    [$shuffle]: dart.fnType(dart.void, [], [math.Random]),
>+    insert: dart.fnType(dart.void, [core.int, core.Object]),
>+    [$insert]: dart.fnType(dart.void, [core.int, core.Object]),
>+    insertAll: dart.fnType(dart.void, [core.int, core.Object]),
>+    [$insertAll]: dart.fnType(dart.void, [core.int, core.Object]),
>+    setAll: dart.fnType(dart.void, [core.int, core.Object]),
>+    [$setAll]: dart.fnType(dart.void, [core.int, core.Object]),
>+    removeAt: dart.fnType(E, [core.int]),
>+    [$removeAt]: dart.fnType(E, [core.int]),
>+    removeLast: dart.fnType(E, []),
>+    [$removeLast]: dart.fnType(E, []),
>+    remove: dart.fnType(core.bool, [core.Object]),
>+    [$remove]: dart.fnType(core.bool, [core.Object]),
>+    removeWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [E])]),
>+    [$removeWhere]: dart.fnType(dart.void, [dart.fnType(core.bool, [E])]),
>+    retainWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [E])]),
>+    [$retainWhere]: dart.fnType(dart.void, [dart.fnType(core.bool, [E])]),
>+    setRange: dart.fnType(dart.void, [core.int, core.int, core.Object], [core.int]),
>+    [$setRange]: dart.fnType(dart.void, [core.int, core.int, core.Object], [core.int]),
>+    removeRange: dart.fnType(dart.void, [core.int, core.int]),
>+    [$removeRange]: dart.fnType(dart.void, [core.int, core.int]),
>+    replaceRange: dart.fnType(dart.void, [core.int, core.int, core.Object]),
>+    [$replaceRange]: dart.fnType(dart.void, [core.int, core.int, core.Object]),
>+    fillRange: dart.fnType(dart.void, [core.int, core.int], [core.Object]),
>+    [$fillRange]: dart.fnType(dart.void, [core.int, core.int], [core.Object])
>+  }));
>+  dart.setGetterSignature(ImmutableListMixin, () => ({
>+    __proto__: dart.getGetters(ImmutableListMixin.__proto__),
>+    iterator: core.Iterator$(E),
>+    [$iterator]: core.Iterator$(E)
>+  }));
>+  dart.setLibraryUri(ImmutableListMixin, "dart:html");
>+  dart.defineExtensionMethods(ImmutableListMixin, [
>+    'add',
>+    'addAll',
>+    'sort',
>+    'shuffle',
>+    'insert',
>+    'insertAll',
>+    'setAll',
>+    'removeAt',
>+    'removeLast',
>+    'remove',
>+    'removeWhere',
>+    'retainWhere',
>+    'setRange',
>+    'removeRange',
>+    'replaceRange',
>+    'fillRange'
>+  ]);
>+  dart.defineExtensionAccessors(ImmutableListMixin, ['iterator']);
>+  return ImmutableListMixin;
>+});
>+html$.ImmutableListMixin = html$.ImmutableListMixin$();
>+dart.addTypeTests(html$.ImmutableListMixin, _is_ImmutableListMixin_default);
>+const Interceptor_ListMixin$ = class Interceptor_ListMixin extends _interceptors.Interceptor {};
>+(Interceptor_ListMixin$.new = function() {
>+  Interceptor_ListMixin$.__proto__.new.call(this);
>+}).prototype = Interceptor_ListMixin$.prototype;
>+dart.applyMixin(Interceptor_ListMixin$, collection.ListMixin$(math.Rectangle$(core.num)));
>+const Interceptor_ImmutableListMixin$ = class Interceptor_ImmutableListMixin extends Interceptor_ListMixin$ {};
>+(Interceptor_ImmutableListMixin$.new = function() {
>+  Interceptor_ImmutableListMixin$.__proto__.new.call(this);
>+}).prototype = Interceptor_ImmutableListMixin$.prototype;
>+dart.applyMixin(Interceptor_ImmutableListMixin$, html$.ImmutableListMixin$(math.Rectangle$(core.num)));
>+html$.DomRectList = class DomRectList extends Interceptor_ImmutableListMixin$ {
>+  get [$length]() {
>+    return this.length;
>+  }
>+  [$_get](index) {
>+    if (index >>> 0 !== index || index >= this[$length]) dart.throw(core.RangeError.index(index, this));
>+    return this[index];
>+  }
>+  [$_set](index, value) {
>+    RectangleOfnum()._check(value);
>+    dart.throw(new core.UnsupportedError.new("Cannot assign element of immutable List."));
>+    return value;
>+  }
>+  set [$length](value) {
>+    dart.throw(new core.UnsupportedError.new("Cannot resize immutable List."));
>+  }
>+  get [$first]() {
>+    if (dart.notNull(this[$length]) > 0) {
>+      return this[0];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$first](value) {
>+    super[$first] = value;
>+  }
>+  get [$last]() {
>+    let len = this[$length];
>+    if (dart.notNull(len) > 0) {
>+      return this[dart.notNull(len) - 1];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$last](value) {
>+    super[$last] = value;
>+  }
>+  get [$single]() {
>+    let len = this[$length];
>+    if (len === 1) {
>+      return this[0];
>+    }
>+    if (len === 0) dart.throw(new core.StateError.new("No elements"));
>+    dart.throw(new core.StateError.new("More than one element"));
>+  }
>+  [$elementAt](index) {
>+    return this[$_get](index);
>+  }
>+  [$item](...args) {
>+    return this.item.apply(this, args);
>+  }
>+};
>+html$.DomRectList.prototype[dart.isList] = true;
>+dart.addTypeTests(html$.DomRectList);
>+html$.DomRectList[dart.implements] = () => [ListOfRectangleOfnum(), JavaScriptIndexingBehaviorOfRectangleOfnum()];
>+dart.setMethodSignature(html$.DomRectList, () => ({
>+  __proto__: dart.getMethods(html$.DomRectList.__proto__),
>+  [$_get]: dart.fnType(math.Rectangle$(core.num), [core.int]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$elementAt]: dart.fnType(math.Rectangle$(core.num), [core.int]),
>+  [$item]: dart.fnType(math.Rectangle$(core.num), [core.int])
>+}));
>+dart.setGetterSignature(html$.DomRectList, () => ({
>+  __proto__: dart.getGetters(html$.DomRectList.__proto__),
>+  [$length]: core.int,
>+  [$first]: math.Rectangle$(core.num),
>+  [$last]: math.Rectangle$(core.num),
>+  [$single]: math.Rectangle$(core.num)
>+}));
>+dart.setSetterSignature(html$.DomRectList, () => ({
>+  __proto__: dart.getSetters(html$.DomRectList.__proto__),
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(html$.DomRectList, "dart:html");
>+dart.registerExtension("ClientRectList", html$.DomRectList);
>+dart.registerExtension("DOMRectList", html$.DomRectList);
>+html$.DomRectReadOnly = class DomRectReadOnly extends _interceptors.Interceptor {
>+  [$toString]() {
>+    return "Rectangle (" + dart.str(this[$left]) + ", " + dart.str(this[$top]) + ") " + dart.str(this[$width]) + " x " + dart.str(this[$height]);
>+  }
>+  [$_equals](other) {
>+    if (!RectangleOfnum().is(other)) return false;
>+    return core.identical(this[$left], dart.dload(other, 'left')) && core.identical(this[$top], dart.dload(other, 'top')) && core.identical(this[$width], dart.dload(other, 'width')) && core.identical(this[$height], dart.dload(other, 'height'));
>+  }
>+  get [$hashCode]() {
>+    return html$._JenkinsSmiHash.hash4(dart.hashCode(this[$left]), dart.hashCode(this[$top]), dart.hashCode(this[$width]), dart.hashCode(this[$height]));
>+  }
>+  [$intersection](other) {
>+    let x0 = math.max(core.num, this[$left], other[$left]);
>+    let x1 = math.min(core.num, dart.notNull(this[$left]) + dart.notNull(this[$width]), dart.notNull(other[$left]) + dart.notNull(other[$width]));
>+    if (x0 <= x1) {
>+      let y0 = math.max(core.num, this[$top], other[$top]);
>+      let y1 = math.min(core.num, dart.notNull(this[$top]) + dart.notNull(this[$height]), dart.notNull(other[$top]) + dart.notNull(other[$height]));
>+      if (y0 <= y1) {
>+        return new (RectangleOfnum()).new(x0, y0, x1 - x0, y1 - y0);
>+      }
>+    }
>+    return null;
>+  }
>+  [$intersects](other) {
>+    return dart.notNull(this[$left]) <= dart.notNull(other[$left]) + dart.notNull(other[$width]) && dart.notNull(other[$left]) <= dart.notNull(this[$left]) + dart.notNull(this[$width]) && dart.notNull(this[$top]) <= dart.notNull(other[$top]) + dart.notNull(other[$height]) && dart.notNull(other[$top]) <= dart.notNull(this[$top]) + dart.notNull(this[$height]);
>+  }
>+  [$boundingBox](other) {
>+    let right = math.max(core.num, dart.notNull(this[$left]) + dart.notNull(this[$width]), dart.notNull(other[$left]) + dart.notNull(other[$width]));
>+    let bottom = math.max(core.num, dart.notNull(this[$top]) + dart.notNull(this[$height]), dart.notNull(other[$top]) + dart.notNull(other[$height]));
>+    let left = math.min(core.num, this[$left], other[$left]);
>+    let top = math.min(core.num, this[$top], other[$top]);
>+    return new (RectangleOfnum()).new(left, top, right - left, bottom - top);
>+  }
>+  [$containsRectangle](another) {
>+    return dart.notNull(this[$left]) <= dart.notNull(another[$left]) && dart.notNull(this[$left]) + dart.notNull(this[$width]) >= dart.notNull(another[$left]) + dart.notNull(another[$width]) && dart.notNull(this[$top]) <= dart.notNull(another[$top]) && dart.notNull(this[$top]) + dart.notNull(this[$height]) >= dart.notNull(another[$top]) + dart.notNull(another[$height]);
>+  }
>+  [$containsPoint](another) {
>+    return dart.notNull(another.x) >= dart.notNull(this[$left]) && dart.notNull(another.x) <= dart.notNull(this[$left]) + dart.notNull(this[$width]) && dart.notNull(another.y) >= dart.notNull(this[$top]) && dart.notNull(another.y) <= dart.notNull(this[$top]) + dart.notNull(this[$height]);
>+  }
>+  get [$topLeft]() {
>+    return new (PointOfnum()).new(this[$left], this[$top]);
>+  }
>+  get [$topRight]() {
>+    return new (PointOfnum()).new(dart.notNull(this[$left]) + dart.notNull(this[$width]), this[$top]);
>+  }
>+  get [$bottomRight]() {
>+    return new (PointOfnum()).new(dart.notNull(this[$left]) + dart.notNull(this[$width]), dart.notNull(this[$top]) + dart.notNull(this[$height]));
>+  }
>+  get [$bottomLeft]() {
>+    return new (PointOfnum()).new(this[$left], dart.notNull(this[$top]) + dart.notNull(this[$height]));
>+  }
>+  static new(x, y, width, height) {
>+    if (x === void 0) x = null;
>+    if (y === void 0) y = null;
>+    if (width === void 0) width = null;
>+    if (height === void 0) height = null;
>+    if (height != null) {
>+      return html$.DomRectReadOnly._create_1(x, y, width, height);
>+    }
>+    if (width != null) {
>+      return html$.DomRectReadOnly._create_2(x, y, width);
>+    }
>+    if (y != null) {
>+      return html$.DomRectReadOnly._create_3(x, y);
>+    }
>+    if (x != null) {
>+      return html$.DomRectReadOnly._create_4(x);
>+    }
>+    return html$.DomRectReadOnly._create_5();
>+  }
>+  static _create_1(x, y, width, height) {
>+    return new DOMRectReadOnly(x, y, width, height);
>+  }
>+  static _create_2(x, y, width) {
>+    return new DOMRectReadOnly(x, y, width);
>+  }
>+  static _create_3(x, y) {
>+    return new DOMRectReadOnly(x, y);
>+  }
>+  static _create_4(x) {
>+    return new DOMRectReadOnly(x);
>+  }
>+  static _create_5() {
>+    return new DOMRectReadOnly();
>+  }
>+  get [$bottom]() {
>+    return this.bottom;
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$left]() {
>+    return this.left;
>+  }
>+  get [$right]() {
>+    return this.right;
>+  }
>+  get [$top]() {
>+    return this.top;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+  static fromRect(other) {
>+    if (other === void 0) other = null;
>+    if (other != null) {
>+      let other_1 = html_common.convertDartToNative_Dictionary(other);
>+      return dart.global.DOMRectReadOnly.fromRect(other_1);
>+    }
>+    return dart.global.DOMRectReadOnly.fromRect();
>+  }
>+};
>+dart.addTypeTests(html$.DomRectReadOnly);
>+html$.DomRectReadOnly[dart.implements] = () => [RectangleOfnum()];
>+dart.setMethodSignature(html$.DomRectReadOnly, () => ({
>+  __proto__: dart.getMethods(html$.DomRectReadOnly.__proto__),
>+  [$intersection]: dart.fnType(math.Rectangle$(core.num), [math.Rectangle$(core.num)]),
>+  [$intersects]: dart.fnType(core.bool, [math.Rectangle$(core.num)]),
>+  [$boundingBox]: dart.fnType(math.Rectangle$(core.num), [math.Rectangle$(core.num)]),
>+  [$containsRectangle]: dart.fnType(core.bool, [math.Rectangle$(core.num)]),
>+  [$containsPoint]: dart.fnType(core.bool, [math.Point$(core.num)])
>+}));
>+dart.setGetterSignature(html$.DomRectReadOnly, () => ({
>+  __proto__: dart.getGetters(html$.DomRectReadOnly.__proto__),
>+  [$topLeft]: math.Point$(core.num),
>+  [$topRight]: math.Point$(core.num),
>+  [$bottomRight]: math.Point$(core.num),
>+  [$bottomLeft]: math.Point$(core.num),
>+  [$bottom]: core.num,
>+  [$height]: core.num,
>+  [$left]: core.num,
>+  [$right]: core.num,
>+  [$top]: core.num,
>+  [$width]: core.num,
>+  [$x]: core.num,
>+  [$y]: core.num
>+}));
>+dart.setLibraryUri(html$.DomRectReadOnly, "dart:html");
>+dart.registerExtension("DOMRectReadOnly", html$.DomRectReadOnly);
>+const Interceptor_ListMixin$$ = class Interceptor_ListMixin extends _interceptors.Interceptor {};
>+(Interceptor_ListMixin$$.new = function() {
>+  Interceptor_ListMixin$$.__proto__.new.call(this);
>+}).prototype = Interceptor_ListMixin$$.prototype;
>+dart.applyMixin(Interceptor_ListMixin$$, collection.ListMixin$(core.String));
>+const Interceptor_ImmutableListMixin$$ = class Interceptor_ImmutableListMixin extends Interceptor_ListMixin$$ {};
>+(Interceptor_ImmutableListMixin$$.new = function() {
>+  Interceptor_ImmutableListMixin$$.__proto__.new.call(this);
>+}).prototype = Interceptor_ImmutableListMixin$$.prototype;
>+dart.applyMixin(Interceptor_ImmutableListMixin$$, html$.ImmutableListMixin$(core.String));
>+html$.DomStringList = class DomStringList extends Interceptor_ImmutableListMixin$$ {
>+  get [$length]() {
>+    return this.length;
>+  }
>+  [$_get](index) {
>+    if (index >>> 0 !== index || index >= this[$length]) dart.throw(core.RangeError.index(index, this));
>+    return this[index];
>+  }
>+  [$_set](index, value) {
>+    core.String._check(value);
>+    dart.throw(new core.UnsupportedError.new("Cannot assign element of immutable List."));
>+    return value;
>+  }
>+  set [$length](value) {
>+    dart.throw(new core.UnsupportedError.new("Cannot resize immutable List."));
>+  }
>+  get [$first]() {
>+    if (dart.notNull(this[$length]) > 0) {
>+      return this[0];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$first](value) {
>+    super[$first] = value;
>+  }
>+  get [$last]() {
>+    let len = this[$length];
>+    if (dart.notNull(len) > 0) {
>+      return this[dart.notNull(len) - 1];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$last](value) {
>+    super[$last] = value;
>+  }
>+  get [$single]() {
>+    let len = this[$length];
>+    if (len === 1) {
>+      return this[0];
>+    }
>+    if (len === 0) dart.throw(new core.StateError.new("No elements"));
>+    dart.throw(new core.StateError.new("More than one element"));
>+  }
>+  [$elementAt](index) {
>+    return this[$_get](index);
>+  }
>+  [$item](...args) {
>+    return this.item.apply(this, args);
>+  }
>+};
>+html$.DomStringList.prototype[dart.isList] = true;
>+dart.addTypeTests(html$.DomStringList);
>+html$.DomStringList[dart.implements] = () => [JavaScriptIndexingBehaviorOfString(), ListOfString()];
>+dart.setMethodSignature(html$.DomStringList, () => ({
>+  __proto__: dart.getMethods(html$.DomStringList.__proto__),
>+  [$_get]: dart.fnType(core.String, [core.int]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$elementAt]: dart.fnType(core.String, [core.int]),
>+  [$item]: dart.fnType(core.String, [core.int])
>+}));
>+dart.setGetterSignature(html$.DomStringList, () => ({
>+  __proto__: dart.getGetters(html$.DomStringList.__proto__),
>+  [$length]: core.int,
>+  [$first]: core.String,
>+  [$last]: core.String,
>+  [$single]: core.String
>+}));
>+dart.setSetterSignature(html$.DomStringList, () => ({
>+  __proto__: dart.getSetters(html$.DomStringList.__proto__),
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(html$.DomStringList, "dart:html");
>+dart.registerExtension("DOMStringList", html$.DomStringList);
>+const __delete__ = dart.privateName(html$, "__delete__");
>+html$.DomStringMap = class DomStringMap extends _interceptors.Interceptor {
>+  [__delete__](...args) {
>+    return this.__delete__.apply(this, args);
>+  }
>+  [__setter__](...args) {
>+    return this.__setter__.apply(this, args);
>+  }
>+  [$item](...args) {
>+    return this.item.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.DomStringMap);
>+dart.setMethodSignature(html$.DomStringMap, () => ({
>+  __proto__: dart.getMethods(html$.DomStringMap.__proto__),
>+  [__delete__]: dart.fnType(dart.void, [core.String]),
>+  [__setter__]: dart.fnType(dart.void, [core.String, core.String]),
>+  [$item]: dart.fnType(core.String, [core.String])
>+}));
>+dart.setLibraryUri(html$.DomStringMap, "dart:html");
>+dart.registerExtension("DOMStringMap", html$.DomStringMap);
>+html$.DomTokenList = class DomTokenList extends _interceptors.Interceptor {
>+  get [$length]() {
>+    return this.length;
>+  }
>+  get [$value]() {
>+    return this.value;
>+  }
>+  set [$value](value) {
>+    this.value = value;
>+  }
>+  [$add](...args) {
>+    return this.add.apply(this, args);
>+  }
>+  [$contains](...args) {
>+    return this.contains.apply(this, args);
>+  }
>+  [$item](...args) {
>+    return this.item.apply(this, args);
>+  }
>+  [$remove](...args) {
>+    return this.remove.apply(this, args);
>+  }
>+  [$replace](...args) {
>+    return this.replace.apply(this, args);
>+  }
>+  [$supports](...args) {
>+    return this.supports.apply(this, args);
>+  }
>+  [$toggle](...args) {
>+    return this.toggle.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.DomTokenList);
>+const length$6 = Symbol("DomTokenList.length");
>+const value$5 = Symbol("DomTokenList.value");
>+dart.setMethodSignature(html$.DomTokenList, () => ({
>+  __proto__: dart.getMethods(html$.DomTokenList.__proto__),
>+  [$add]: dart.fnType(dart.void, [core.String]),
>+  [$contains]: dart.fnType(core.bool, [core.String]),
>+  [$item]: dart.fnType(core.String, [core.int]),
>+  [$remove]: dart.fnType(dart.void, [core.String]),
>+  [$replace]: dart.fnType(dart.void, [core.String, core.String]),
>+  [$supports]: dart.fnType(core.bool, [core.String]),
>+  [$toggle]: dart.fnType(core.bool, [core.String], [core.bool])
>+}));
>+dart.setLibraryUri(html$.DomTokenList, "dart:html");
>+dart.setFieldSignature(html$.DomTokenList, () => ({
>+  __proto__: dart.getFields(html$.DomTokenList.__proto__),
>+  [$length]: dart.finalFieldType(core.int),
>+  [$value]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("DOMTokenList", html$.DomTokenList);
>+const _childElements = dart.privateName(html$, "_childElements");
>+const _element$ = dart.privateName(html$, "_element");
>+const _filter$0 = dart.privateName(html$, "_filter");
>+html$._ChildrenElementList = class _ChildrenElementList extends collection.ListBase$(html$.Element) {
>+  contains(element) {
>+    return this[_childElements][$contains](element);
>+  }
>+  get isEmpty() {
>+    return this[_element$][_firstElementChild] == null;
>+  }
>+  get length() {
>+    return this[_childElements][$length];
>+  }
>+  _get(index) {
>+    return html$.Element._check(this[_childElements][$_get](index));
>+  }
>+  _set(index, value) {
>+    html$.Element._check(value);
>+    this[_element$][_replaceChild](value, this[_childElements][$_get](index));
>+    return value;
>+  }
>+  set length(newLength) {
>+    dart.throw(new core.UnsupportedError.new("Cannot resize element lists"));
>+  }
>+  add(value) {
>+    html$.Element._check(value);
>+    this[_element$][$append](value);
>+    return value;
>+  }
>+  get iterator() {
>+    return this[$toList]()[$iterator];
>+  }
>+  addAll(iterable) {
>+    IterableOfElement()._check(iterable);
>+    if (html$._ChildNodeListLazy.is(iterable)) {
>+      iterable = ListOfElement().from(iterable);
>+    }
>+    for (let element of iterable) {
>+      this[_element$][$append](element);
>+    }
>+  }
>+  sort(compare) {
>+    if (compare === void 0) compare = null;
>+    dart.throw(new core.UnsupportedError.new("Cannot sort element lists"));
>+  }
>+  shuffle(random) {
>+    if (random === void 0) random = null;
>+    dart.throw(new core.UnsupportedError.new("Cannot shuffle element lists"));
>+  }
>+  removeWhere(test) {
>+    this[_filter$0](test, false);
>+  }
>+  retainWhere(test) {
>+    this[_filter$0](test, true);
>+  }
>+  [_filter$0](test, retainMatching) {
>+    let removed = null;
>+    if (dart.test(retainMatching)) {
>+      removed = this[_element$][$children][$where](dart.fn(e => !dart.test(test(e)), ElementTobool()));
>+    } else {
>+      removed = this[_element$][$children][$where](test);
>+    }
>+    for (let e of core.Iterable._check(removed))
>+      dart.dsend(e, 'remove', []);
>+  }
>+  fillRange(start, end, fillValue) {
>+    if (fillValue === void 0) fillValue = null;
>+    html$.Element._check(fillValue);
>+    dart.throw(new core.UnimplementedError.new());
>+  }
>+  replaceRange(start, end, iterable) {
>+    IterableOfElement()._check(iterable);
>+    dart.throw(new core.UnimplementedError.new());
>+  }
>+  removeRange(start, end) {
>+    dart.throw(new core.UnimplementedError.new());
>+  }
>+  setRange(start, end, iterable, skipCount) {
>+    IterableOfElement()._check(iterable);
>+    if (skipCount === void 0) skipCount = 0;
>+    dart.throw(new core.UnimplementedError.new());
>+  }
>+  remove(object) {
>+    if (html$.Element.is(object)) {
>+      let element = object;
>+      if (element.parentNode == this[_element$]) {
>+        this[_element$][_removeChild](element);
>+        return true;
>+      }
>+    }
>+    return false;
>+  }
>+  insert(index, element) {
>+    html$.Element._check(element);
>+    if (dart.notNull(index) < 0 || dart.notNull(index) > dart.notNull(this.length)) {
>+      dart.throw(new core.RangeError.range(index, 0, this.length));
>+    }
>+    if (index == this.length) {
>+      this[_element$][$append](element);
>+    } else {
>+      this[_element$].insertBefore(element, this._get(index));
>+    }
>+  }
>+  setAll(index, iterable) {
>+    IterableOfElement()._check(iterable);
>+    dart.throw(new core.UnimplementedError.new());
>+  }
>+  clear() {
>+    this[_element$][_clearChildren]();
>+  }
>+  removeAt(index) {
>+    let result = this._get(index);
>+    if (result != null) {
>+      this[_element$][_removeChild](result);
>+    }
>+    return result;
>+  }
>+  removeLast() {
>+    let result = this.last;
>+    if (result != null) {
>+      this[_element$][_removeChild](result);
>+    }
>+    return result;
>+  }
>+  get first() {
>+    let result = this[_element$][_firstElementChild];
>+    if (result == null) dart.throw(new core.StateError.new("No elements"));
>+    return result;
>+  }
>+  set first(value) {
>+    super.first = value;
>+  }
>+  get last() {
>+    let result = this[_element$][_lastElementChild];
>+    if (result == null) dart.throw(new core.StateError.new("No elements"));
>+    return result;
>+  }
>+  set last(value) {
>+    super.last = value;
>+  }
>+  get single() {
>+    if (dart.notNull(this.length) > 1) dart.throw(new core.StateError.new("More than one element"));
>+    return this.first;
>+  }
>+  get rawList() {
>+    return this[_childElements];
>+  }
>+};
>+(html$._ChildrenElementList._wrap = function(element) {
>+  this[_childElements] = html$.HtmlCollection._check(element[_children]);
>+  this[_element$] = element;
>+}).prototype = html$._ChildrenElementList.prototype;
>+dart.addTypeTests(html$._ChildrenElementList);
>+html$._ChildrenElementList[dart.implements] = () => [html_common.NodeListWrapper];
>+dart.setMethodSignature(html$._ChildrenElementList, () => ({
>+  __proto__: dart.getMethods(html$._ChildrenElementList.__proto__),
>+  contains: dart.fnType(core.bool, [core.Object]),
>+  [$contains]: dart.fnType(core.bool, [core.Object]),
>+  _get: dart.fnType(html$.Element, [core.int]),
>+  [$_get]: dart.fnType(html$.Element, [core.int]),
>+  _set: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  add: dart.fnType(html$.Element, [core.Object]),
>+  [$add]: dart.fnType(html$.Element, [core.Object]),
>+  addAll: dart.fnType(dart.void, [core.Object]),
>+  [$addAll]: dart.fnType(dart.void, [core.Object]),
>+  sort: dart.fnType(dart.void, [], [dart.fnType(core.int, [html$.Element, html$.Element])]),
>+  [$sort]: dart.fnType(dart.void, [], [dart.fnType(core.int, [html$.Element, html$.Element])]),
>+  shuffle: dart.fnType(dart.void, [], [math.Random]),
>+  [$shuffle]: dart.fnType(dart.void, [], [math.Random]),
>+  removeWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [html$.Element])]),
>+  [$removeWhere]: dart.fnType(dart.void, [dart.fnType(core.bool, [html$.Element])]),
>+  retainWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [html$.Element])]),
>+  [$retainWhere]: dart.fnType(dart.void, [dart.fnType(core.bool, [html$.Element])]),
>+  [_filter$0]: dart.fnType(dart.void, [dart.fnType(core.bool, [html$.Element]), core.bool]),
>+  fillRange: dart.fnType(dart.void, [core.int, core.int], [core.Object]),
>+  [$fillRange]: dart.fnType(dart.void, [core.int, core.int], [core.Object]),
>+  replaceRange: dart.fnType(dart.void, [core.int, core.int, core.Object]),
>+  [$replaceRange]: dart.fnType(dart.void, [core.int, core.int, core.Object]),
>+  removeRange: dart.fnType(dart.void, [core.int, core.int]),
>+  [$removeRange]: dart.fnType(dart.void, [core.int, core.int]),
>+  setRange: dart.fnType(dart.void, [core.int, core.int, core.Object], [core.int]),
>+  [$setRange]: dart.fnType(dart.void, [core.int, core.int, core.Object], [core.int]),
>+  remove: dart.fnType(core.bool, [core.Object]),
>+  [$remove]: dart.fnType(core.bool, [core.Object]),
>+  insert: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$insert]: dart.fnType(dart.void, [core.int, core.Object]),
>+  setAll: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$setAll]: dart.fnType(dart.void, [core.int, core.Object]),
>+  clear: dart.fnType(dart.void, []),
>+  [$clear]: dart.fnType(dart.void, []),
>+  removeAt: dart.fnType(html$.Element, [core.int]),
>+  [$removeAt]: dart.fnType(html$.Element, [core.int]),
>+  removeLast: dart.fnType(html$.Element, []),
>+  [$removeLast]: dart.fnType(html$.Element, [])
>+}));
>+dart.setGetterSignature(html$._ChildrenElementList, () => ({
>+  __proto__: dart.getGetters(html$._ChildrenElementList.__proto__),
>+  isEmpty: core.bool,
>+  [$isEmpty]: core.bool,
>+  length: core.int,
>+  [$length]: core.int,
>+  iterator: core.Iterator$(html$.Element),
>+  [$iterator]: core.Iterator$(html$.Element),
>+  first: html$.Element,
>+  [$first]: html$.Element,
>+  last: html$.Element,
>+  [$last]: html$.Element,
>+  single: html$.Element,
>+  [$single]: html$.Element,
>+  rawList: core.List$(html$.Node)
>+}));
>+dart.setSetterSignature(html$._ChildrenElementList, () => ({
>+  __proto__: dart.getSetters(html$._ChildrenElementList.__proto__),
>+  length: core.int,
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(html$._ChildrenElementList, "dart:html");
>+dart.setFieldSignature(html$._ChildrenElementList, () => ({
>+  __proto__: dart.getFields(html$._ChildrenElementList.__proto__),
>+  [_element$]: dart.finalFieldType(html$.Element),
>+  [_childElements]: dart.finalFieldType(html$.HtmlCollection)
>+}));
>+dart.defineExtensionMethods(html$._ChildrenElementList, [
>+  'contains',
>+  '_get',
>+  '_set',
>+  'add',
>+  'addAll',
>+  'sort',
>+  'shuffle',
>+  'removeWhere',
>+  'retainWhere',
>+  'fillRange',
>+  'replaceRange',
>+  'removeRange',
>+  'setRange',
>+  'remove',
>+  'insert',
>+  'setAll',
>+  'clear',
>+  'removeAt',
>+  'removeLast'
>+]);
>+dart.defineExtensionAccessors(html$._ChildrenElementList, [
>+  'isEmpty',
>+  'length',
>+  'iterator',
>+  'first',
>+  'last',
>+  'single'
>+]);
>+const _is_ElementList_default = Symbol('_is_ElementList_default');
>+html$.ElementList$ = dart.generic(T => {
>+  class ElementList extends collection.ListBase$(T) {}
>+  (ElementList.new = function() {
>+  }).prototype = ElementList.prototype;
>+  dart.addTypeTests(ElementList);
>+  ElementList.prototype[_is_ElementList_default] = true;
>+  dart.setLibraryUri(ElementList, "dart:html");
>+  return ElementList;
>+});
>+html$.ElementList = html$.ElementList$();
>+dart.addTypeTests(html$.ElementList, _is_ElementList_default);
>+const _nodeList = dart.privateName(html$, "_nodeList");
>+const _forElementList = dart.privateName(html$, "_forElementList");
>+const _is__FrozenElementList_default = Symbol('_is__FrozenElementList_default');
>+html$._FrozenElementList$ = dart.generic(E => {
>+  let EToIterableOfString = () => (EToIterableOfString = dart.constFn(dart.fnType(IterableOfString(), [E])))();
>+  let ElementListOfE = () => (ElementListOfE = dart.constFn(html$.ElementList$(E)))();
>+  class _FrozenElementList extends collection.ListBase$(E) {
>+    get length() {
>+      return this[_nodeList][$length];
>+    }
>+    _get(index) {
>+      return E._check(this[_nodeList][$_get](index));
>+    }
>+    _set(index, value) {
>+      E._check(value);
>+      dart.throw(new core.UnsupportedError.new("Cannot modify list"));
>+      return value;
>+    }
>+    set length(newLength) {
>+      dart.throw(new core.UnsupportedError.new("Cannot modify list"));
>+    }
>+    sort(compare) {
>+      if (compare === void 0) compare = null;
>+      dart.throw(new core.UnsupportedError.new("Cannot sort list"));
>+    }
>+    shuffle(random) {
>+      if (random === void 0) random = null;
>+      dart.throw(new core.UnsupportedError.new("Cannot shuffle list"));
>+    }
>+    get first() {
>+      return E._check(this[_nodeList][$first]);
>+    }
>+    set first(value) {
>+      super.first = value;
>+    }
>+    get last() {
>+      return E._check(this[_nodeList][$last]);
>+    }
>+    set last(value) {
>+      super.last = value;
>+    }
>+    get single() {
>+      return E._check(this[_nodeList][$single]);
>+    }
>+    get classes() {
>+      return html$._MultiElementCssClassSet.new(this);
>+    }
>+    get style() {
>+      return new html$._CssStyleDeclarationSet.new(this);
>+    }
>+    set classes(value) {
>+      this[$forEach](dart.fn(e => e[$classes] = value, EToIterableOfString()));
>+    }
>+    get contentEdge() {
>+      return new html$._ContentCssListRect.new(this);
>+    }
>+    get paddingEdge() {
>+      return this.first[$paddingEdge];
>+    }
>+    get borderEdge() {
>+      return this.first[$borderEdge];
>+    }
>+    get marginEdge() {
>+      return this.first[$marginEdge];
>+    }
>+    get rawList() {
>+      return this[_nodeList];
>+    }
>+    get onAbort() {
>+      return html$.Element.abortEvent[_forElementList](this);
>+    }
>+    get onBeforeCopy() {
>+      return html$.Element.beforeCopyEvent[_forElementList](this);
>+    }
>+    get onBeforeCut() {
>+      return html$.Element.beforeCutEvent[_forElementList](this);
>+    }
>+    get onBeforePaste() {
>+      return html$.Element.beforePasteEvent[_forElementList](this);
>+    }
>+    get onBlur() {
>+      return html$.Element.blurEvent[_forElementList](this);
>+    }
>+    get onCanPlay() {
>+      return html$.Element.canPlayEvent[_forElementList](this);
>+    }
>+    get onCanPlayThrough() {
>+      return html$.Element.canPlayThroughEvent[_forElementList](this);
>+    }
>+    get onChange() {
>+      return html$.Element.changeEvent[_forElementList](this);
>+    }
>+    get onClick() {
>+      return html$.Element.clickEvent[_forElementList](this);
>+    }
>+    get onContextMenu() {
>+      return html$.Element.contextMenuEvent[_forElementList](this);
>+    }
>+    get onCopy() {
>+      return html$.Element.copyEvent[_forElementList](this);
>+    }
>+    get onCut() {
>+      return html$.Element.cutEvent[_forElementList](this);
>+    }
>+    get onDoubleClick() {
>+      return html$.Element.doubleClickEvent[_forElementList](this);
>+    }
>+    get onDrag() {
>+      return html$.Element.dragEvent[_forElementList](this);
>+    }
>+    get onDragEnd() {
>+      return html$.Element.dragEndEvent[_forElementList](this);
>+    }
>+    get onDragEnter() {
>+      return html$.Element.dragEnterEvent[_forElementList](this);
>+    }
>+    get onDragLeave() {
>+      return html$.Element.dragLeaveEvent[_forElementList](this);
>+    }
>+    get onDragOver() {
>+      return html$.Element.dragOverEvent[_forElementList](this);
>+    }
>+    get onDragStart() {
>+      return html$.Element.dragStartEvent[_forElementList](this);
>+    }
>+    get onDrop() {
>+      return html$.Element.dropEvent[_forElementList](this);
>+    }
>+    get onDurationChange() {
>+      return html$.Element.durationChangeEvent[_forElementList](this);
>+    }
>+    get onEmptied() {
>+      return html$.Element.emptiedEvent[_forElementList](this);
>+    }
>+    get onEnded() {
>+      return html$.Element.endedEvent[_forElementList](this);
>+    }
>+    get onError() {
>+      return html$.Element.errorEvent[_forElementList](this);
>+    }
>+    get onFocus() {
>+      return html$.Element.focusEvent[_forElementList](this);
>+    }
>+    get onInput() {
>+      return html$.Element.inputEvent[_forElementList](this);
>+    }
>+    get onInvalid() {
>+      return html$.Element.invalidEvent[_forElementList](this);
>+    }
>+    get onKeyDown() {
>+      return html$.Element.keyDownEvent[_forElementList](this);
>+    }
>+    get onKeyPress() {
>+      return html$.Element.keyPressEvent[_forElementList](this);
>+    }
>+    get onKeyUp() {
>+      return html$.Element.keyUpEvent[_forElementList](this);
>+    }
>+    get onLoad() {
>+      return html$.Element.loadEvent[_forElementList](this);
>+    }
>+    get onLoadedData() {
>+      return html$.Element.loadedDataEvent[_forElementList](this);
>+    }
>+    get onLoadedMetadata() {
>+      return html$.Element.loadedMetadataEvent[_forElementList](this);
>+    }
>+    get onMouseDown() {
>+      return html$.Element.mouseDownEvent[_forElementList](this);
>+    }
>+    get onMouseEnter() {
>+      return html$.Element.mouseEnterEvent[_forElementList](this);
>+    }
>+    get onMouseLeave() {
>+      return html$.Element.mouseLeaveEvent[_forElementList](this);
>+    }
>+    get onMouseMove() {
>+      return html$.Element.mouseMoveEvent[_forElementList](this);
>+    }
>+    get onMouseOut() {
>+      return html$.Element.mouseOutEvent[_forElementList](this);
>+    }
>+    get onMouseOver() {
>+      return html$.Element.mouseOverEvent[_forElementList](this);
>+    }
>+    get onMouseUp() {
>+      return html$.Element.mouseUpEvent[_forElementList](this);
>+    }
>+    get onMouseWheel() {
>+      return html$.Element.mouseWheelEvent[_forElementList](this);
>+    }
>+    get onPaste() {
>+      return html$.Element.pasteEvent[_forElementList](this);
>+    }
>+    get onPause() {
>+      return html$.Element.pauseEvent[_forElementList](this);
>+    }
>+    get onPlay() {
>+      return html$.Element.playEvent[_forElementList](this);
>+    }
>+    get onPlaying() {
>+      return html$.Element.playingEvent[_forElementList](this);
>+    }
>+    get onRateChange() {
>+      return html$.Element.rateChangeEvent[_forElementList](this);
>+    }
>+    get onReset() {
>+      return html$.Element.resetEvent[_forElementList](this);
>+    }
>+    get onResize() {
>+      return html$.Element.resizeEvent[_forElementList](this);
>+    }
>+    get onScroll() {
>+      return html$.Element.scrollEvent[_forElementList](this);
>+    }
>+    get onSearch() {
>+      return html$.Element.searchEvent[_forElementList](this);
>+    }
>+    get onSeeked() {
>+      return html$.Element.seekedEvent[_forElementList](this);
>+    }
>+    get onSeeking() {
>+      return html$.Element.seekingEvent[_forElementList](this);
>+    }
>+    get onSelect() {
>+      return html$.Element.selectEvent[_forElementList](this);
>+    }
>+    get onSelectStart() {
>+      return html$.Element.selectStartEvent[_forElementList](this);
>+    }
>+    get onStalled() {
>+      return html$.Element.stalledEvent[_forElementList](this);
>+    }
>+    get onSubmit() {
>+      return html$.Element.submitEvent[_forElementList](this);
>+    }
>+    get onSuspend() {
>+      return html$.Element.suspendEvent[_forElementList](this);
>+    }
>+    get onTimeUpdate() {
>+      return html$.Element.timeUpdateEvent[_forElementList](this);
>+    }
>+    get onTouchCancel() {
>+      return html$.Element.touchCancelEvent[_forElementList](this);
>+    }
>+    get onTouchEnd() {
>+      return html$.Element.touchEndEvent[_forElementList](this);
>+    }
>+    get onTouchEnter() {
>+      return html$.Element.touchEnterEvent[_forElementList](this);
>+    }
>+    get onTouchLeave() {
>+      return html$.Element.touchLeaveEvent[_forElementList](this);
>+    }
>+    get onTouchMove() {
>+      return html$.Element.touchMoveEvent[_forElementList](this);
>+    }
>+    get onTouchStart() {
>+      return html$.Element.touchStartEvent[_forElementList](this);
>+    }
>+    get onTransitionEnd() {
>+      return html$.Element.transitionEndEvent[_forElementList](this);
>+    }
>+    get onVolumeChange() {
>+      return html$.Element.volumeChangeEvent[_forElementList](this);
>+    }
>+    get onWaiting() {
>+      return html$.Element.waitingEvent[_forElementList](this);
>+    }
>+    get onFullscreenChange() {
>+      return html$.Element.fullscreenChangeEvent[_forElementList](this);
>+    }
>+    get onFullscreenError() {
>+      return html$.Element.fullscreenErrorEvent[_forElementList](this);
>+    }
>+    get onWheel() {
>+      return html$.Element.wheelEvent[_forElementList](this);
>+    }
>+  }
>+  (_FrozenElementList._wrap = function(nodeList) {
>+    this[_nodeList] = nodeList;
>+    if (!dart.test(this[_nodeList][$every](dart.fn(element => E.is(element), NodeTobool())))) dart.assertFailed("Query expects only HTML elements of type " + dart.str(dart.wrapType(E)) + " but found " + dart.str(this[_nodeList][$firstWhere](dart.fn(e => !E.is(e), NodeTobool()))), "dart:html", 11665, 12, "this._nodeList.every((element) => element is E)");
>+  }).prototype = _FrozenElementList.prototype;
>+  dart.addTypeTests(_FrozenElementList);
>+  _FrozenElementList.prototype[_is__FrozenElementList_default] = true;
>+  _FrozenElementList[dart.implements] = () => [ElementListOfE(), html_common.NodeListWrapper];
>+  dart.setMethodSignature(_FrozenElementList, () => ({
>+    __proto__: dart.getMethods(_FrozenElementList.__proto__),
>+    _get: dart.fnType(E, [core.int]),
>+    [$_get]: dart.fnType(E, [core.int]),
>+    _set: dart.fnType(dart.void, [core.int, core.Object]),
>+    [$_set]: dart.fnType(dart.void, [core.int, core.Object])
>+  }));
>+  dart.setGetterSignature(_FrozenElementList, () => ({
>+    __proto__: dart.getGetters(_FrozenElementList.__proto__),
>+    length: core.int,
>+    [$length]: core.int,
>+    classes: html$.CssClassSet,
>+    style: html$.CssStyleDeclarationBase,
>+    contentEdge: html$.CssRect,
>+    paddingEdge: html$.CssRect,
>+    borderEdge: html$.CssRect,
>+    marginEdge: html$.CssRect,
>+    rawList: core.List$(html$.Node),
>+    onAbort: html$.ElementStream$(html$.Event),
>+    onBeforeCopy: html$.ElementStream$(html$.Event),
>+    onBeforeCut: html$.ElementStream$(html$.Event),
>+    onBeforePaste: html$.ElementStream$(html$.Event),
>+    onBlur: html$.ElementStream$(html$.Event),
>+    onCanPlay: html$.ElementStream$(html$.Event),
>+    onCanPlayThrough: html$.ElementStream$(html$.Event),
>+    onChange: html$.ElementStream$(html$.Event),
>+    onClick: html$.ElementStream$(html$.MouseEvent),
>+    onContextMenu: html$.ElementStream$(html$.MouseEvent),
>+    onCopy: html$.ElementStream$(html$.ClipboardEvent),
>+    onCut: html$.ElementStream$(html$.ClipboardEvent),
>+    onDoubleClick: html$.ElementStream$(html$.Event),
>+    onDrag: html$.ElementStream$(html$.MouseEvent),
>+    onDragEnd: html$.ElementStream$(html$.MouseEvent),
>+    onDragEnter: html$.ElementStream$(html$.MouseEvent),
>+    onDragLeave: html$.ElementStream$(html$.MouseEvent),
>+    onDragOver: html$.ElementStream$(html$.MouseEvent),
>+    onDragStart: html$.ElementStream$(html$.MouseEvent),
>+    onDrop: html$.ElementStream$(html$.MouseEvent),
>+    onDurationChange: html$.ElementStream$(html$.Event),
>+    onEmptied: html$.ElementStream$(html$.Event),
>+    onEnded: html$.ElementStream$(html$.Event),
>+    onError: html$.ElementStream$(html$.Event),
>+    onFocus: html$.ElementStream$(html$.Event),
>+    onInput: html$.ElementStream$(html$.Event),
>+    onInvalid: html$.ElementStream$(html$.Event),
>+    onKeyDown: html$.ElementStream$(html$.KeyboardEvent),
>+    onKeyPress: html$.ElementStream$(html$.KeyboardEvent),
>+    onKeyUp: html$.ElementStream$(html$.KeyboardEvent),
>+    onLoad: html$.ElementStream$(html$.Event),
>+    onLoadedData: html$.ElementStream$(html$.Event),
>+    onLoadedMetadata: html$.ElementStream$(html$.Event),
>+    onMouseDown: html$.ElementStream$(html$.MouseEvent),
>+    onMouseEnter: html$.ElementStream$(html$.MouseEvent),
>+    onMouseLeave: html$.ElementStream$(html$.MouseEvent),
>+    onMouseMove: html$.ElementStream$(html$.MouseEvent),
>+    onMouseOut: html$.ElementStream$(html$.MouseEvent),
>+    onMouseOver: html$.ElementStream$(html$.MouseEvent),
>+    onMouseUp: html$.ElementStream$(html$.MouseEvent),
>+    onMouseWheel: html$.ElementStream$(html$.WheelEvent),
>+    onPaste: html$.ElementStream$(html$.ClipboardEvent),
>+    onPause: html$.ElementStream$(html$.Event),
>+    onPlay: html$.ElementStream$(html$.Event),
>+    onPlaying: html$.ElementStream$(html$.Event),
>+    onRateChange: html$.ElementStream$(html$.Event),
>+    onReset: html$.ElementStream$(html$.Event),
>+    onResize: html$.ElementStream$(html$.Event),
>+    onScroll: html$.ElementStream$(html$.Event),
>+    onSearch: html$.ElementStream$(html$.Event),
>+    onSeeked: html$.ElementStream$(html$.Event),
>+    onSeeking: html$.ElementStream$(html$.Event),
>+    onSelect: html$.ElementStream$(html$.Event),
>+    onSelectStart: html$.ElementStream$(html$.Event),
>+    onStalled: html$.ElementStream$(html$.Event),
>+    onSubmit: html$.ElementStream$(html$.Event),
>+    onSuspend: html$.ElementStream$(html$.Event),
>+    onTimeUpdate: html$.ElementStream$(html$.Event),
>+    onTouchCancel: html$.ElementStream$(html$.TouchEvent),
>+    onTouchEnd: html$.ElementStream$(html$.TouchEvent),
>+    onTouchEnter: html$.ElementStream$(html$.TouchEvent),
>+    onTouchLeave: html$.ElementStream$(html$.TouchEvent),
>+    onTouchMove: html$.ElementStream$(html$.TouchEvent),
>+    onTouchStart: html$.ElementStream$(html$.TouchEvent),
>+    onTransitionEnd: html$.ElementStream$(html$.TransitionEvent),
>+    onVolumeChange: html$.ElementStream$(html$.Event),
>+    onWaiting: html$.ElementStream$(html$.Event),
>+    onFullscreenChange: html$.ElementStream$(html$.Event),
>+    onFullscreenError: html$.ElementStream$(html$.Event),
>+    onWheel: html$.ElementStream$(html$.WheelEvent)
>+  }));
>+  dart.setSetterSignature(_FrozenElementList, () => ({
>+    __proto__: dart.getSetters(_FrozenElementList.__proto__),
>+    length: core.int,
>+    [$length]: core.int,
>+    classes: core.Iterable$(core.String)
>+  }));
>+  dart.setLibraryUri(_FrozenElementList, "dart:html");
>+  dart.setFieldSignature(_FrozenElementList, () => ({
>+    __proto__: dart.getFields(_FrozenElementList.__proto__),
>+    [_nodeList]: dart.finalFieldType(ListOfNode())
>+  }));
>+  dart.defineExtensionMethods(_FrozenElementList, ['_get', '_set', 'sort', 'shuffle']);
>+  dart.defineExtensionAccessors(_FrozenElementList, ['length', 'first', 'last', 'single']);
>+  return _FrozenElementList;
>+});
>+html$._FrozenElementList = html$._FrozenElementList$();
>+dart.addTypeTests(html$._FrozenElementList, _is__FrozenElementList_default);
>+html$._ElementFactoryProvider = class _ElementFactoryProvider extends core.Object {
>+  static createElement_tag(tag, typeExtension) {
>+    if (typeExtension != null) {
>+      return document.createElement(tag, typeExtension);
>+    }
>+    return document.createElement(tag);
>+  }
>+};
>+(html$._ElementFactoryProvider.new = function() {
>+}).prototype = html$._ElementFactoryProvider.prototype;
>+dart.addTypeTests(html$._ElementFactoryProvider);
>+dart.setLibraryUri(html$._ElementFactoryProvider, "dart:html");
>+const _value$3 = dart.privateName(html$, "_value");
>+html$.ScrollAlignment = class ScrollAlignment extends core.Object {
>+  toString() {
>+    return "ScrollAlignment." + dart.str(this[_value$3]);
>+  }
>+};
>+(html$.ScrollAlignment._internal = function(value) {
>+  this[_value$3] = value;
>+}).prototype = html$.ScrollAlignment.prototype;
>+dart.addTypeTests(html$.ScrollAlignment);
>+dart.setLibraryUri(html$.ScrollAlignment, "dart:html");
>+dart.setFieldSignature(html$.ScrollAlignment, () => ({
>+  __proto__: dart.getFields(html$.ScrollAlignment.__proto__),
>+  [_value$3]: dart.finalFieldType(dart.dynamic)
>+}));
>+dart.defineExtensionMethods(html$.ScrollAlignment, ['toString']);
>+dart.defineLazy(html$.ScrollAlignment, {
>+  /*html$.ScrollAlignment.TOP*/get TOP() {
>+    return dart.const(new html$.ScrollAlignment._internal("TOP"));
>+  },
>+  /*html$.ScrollAlignment.CENTER*/get CENTER() {
>+    return dart.const(new html$.ScrollAlignment._internal("CENTER"));
>+  },
>+  /*html$.ScrollAlignment.BOTTOM*/get BOTTOM() {
>+    return dart.const(new html$.ScrollAlignment._internal("BOTTOM"));
>+  }
>+});
>+html$.EmbedElement = class EmbedElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.EmbedElement._check(html$.document[$createElement]("embed"));
>+  }
>+  static get supported() {
>+    return html$.Element.isTagSupported("embed");
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  set [$height](value) {
>+    this.height = value;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+  set [$name](value) {
>+    this.name = value;
>+  }
>+  get [$src]() {
>+    return this.src;
>+  }
>+  set [$src](value) {
>+    this.src = value;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  set [$type](value) {
>+    this.type = value;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  set [$width](value) {
>+    this.width = value;
>+  }
>+  [__getter__](...args) {
>+    return this.__getter__.apply(this, args);
>+  }
>+  [__setter__](...args) {
>+    return this.__setter__.apply(this, args);
>+  }
>+};
>+(html$.EmbedElement.created = function() {
>+  this[height$] = null;
>+  this[name$12] = null;
>+  this[src$] = null;
>+  this[type$13] = null;
>+  this[width$] = null;
>+  html$.EmbedElement.__proto__.created.call(this);
>+}).prototype = html$.EmbedElement.prototype;
>+dart.addTypeTests(html$.EmbedElement);
>+const height$ = Symbol("EmbedElement.height");
>+const name$12 = Symbol("EmbedElement.name");
>+const src$ = Symbol("EmbedElement.src");
>+const type$13 = Symbol("EmbedElement.type");
>+const width$ = Symbol("EmbedElement.width");
>+dart.setMethodSignature(html$.EmbedElement, () => ({
>+  __proto__: dart.getMethods(html$.EmbedElement.__proto__),
>+  [__getter__]: dart.fnType(html$.Node, [core.String]),
>+  [__setter__]: dart.fnType(dart.void, [core.String, html$.Node])
>+}));
>+dart.setLibraryUri(html$.EmbedElement, "dart:html");
>+dart.setFieldSignature(html$.EmbedElement, () => ({
>+  __proto__: dart.getFields(html$.EmbedElement.__proto__),
>+  [$height]: dart.fieldType(core.String),
>+  [$name]: dart.fieldType(core.String),
>+  [$src]: dart.fieldType(core.String),
>+  [$type]: dart.fieldType(core.String),
>+  [$width]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("HTMLEmbedElement", html$.EmbedElement);
>+html$.ErrorEvent = class ErrorEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.ErrorEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.ErrorEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new ErrorEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new ErrorEvent(type);
>+  }
>+  get [$colno]() {
>+    return this.colno;
>+  }
>+  get [$error]() {
>+    return this.error;
>+  }
>+  get [$filename]() {
>+    return this.filename;
>+  }
>+  get [$lineno]() {
>+    return this.lineno;
>+  }
>+  get [$message]() {
>+    return this.message;
>+  }
>+};
>+dart.addTypeTests(html$.ErrorEvent);
>+const colno = Symbol("ErrorEvent.colno");
>+const error$2 = Symbol("ErrorEvent.error");
>+const filename = Symbol("ErrorEvent.filename");
>+const lineno = Symbol("ErrorEvent.lineno");
>+const message$19 = Symbol("ErrorEvent.message");
>+dart.setLibraryUri(html$.ErrorEvent, "dart:html");
>+dart.setFieldSignature(html$.ErrorEvent, () => ({
>+  __proto__: dart.getFields(html$.ErrorEvent.__proto__),
>+  [$colno]: dart.finalFieldType(core.int),
>+  [$error]: dart.finalFieldType(core.Object),
>+  [$filename]: dart.finalFieldType(core.String),
>+  [$lineno]: dart.finalFieldType(core.int),
>+  [$message]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("ErrorEvent", html$.ErrorEvent);
>+html$.EventSource = class EventSource$ extends html$.EventTarget {
>+  static new(url, opts) {
>+    let withCredentials = opts && 'withCredentials' in opts ? opts.withCredentials : false;
>+    let parsedOptions = new (IdentityMapOfString$dynamic()).from(["withCredentials", withCredentials]);
>+    return html$.EventSource._factoryEventSource(url, parsedOptions);
>+  }
>+  static _factoryEventSource(url, eventSourceInitDict) {
>+    if (eventSourceInitDict === void 0) eventSourceInitDict = null;
>+    if (eventSourceInitDict != null) {
>+      let eventSourceInitDict_1 = html_common.convertDartToNative_Dictionary(eventSourceInitDict);
>+      return html$.EventSource._create_1(url, eventSourceInitDict_1);
>+    }
>+    return html$.EventSource._create_2(url);
>+  }
>+  static _create_1(url, eventSourceInitDict) {
>+    return new EventSource(url, eventSourceInitDict);
>+  }
>+  static _create_2(url) {
>+    return new EventSource(url);
>+  }
>+  get [$readyState]() {
>+    return this.readyState;
>+  }
>+  get [$url]() {
>+    return this.url;
>+  }
>+  get [$withCredentials]() {
>+    return this.withCredentials;
>+  }
>+  [$close](...args) {
>+    return this.close.apply(this, args);
>+  }
>+  get [$onError]() {
>+    return html$.EventSource.errorEvent.forTarget(this);
>+  }
>+  get [$onMessage]() {
>+    return html$.EventSource.messageEvent.forTarget(this);
>+  }
>+  get [$onOpen]() {
>+    return html$.EventSource.openEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.EventSource);
>+const readyState$2 = Symbol("EventSource.readyState");
>+const url$1 = Symbol("EventSource.url");
>+const withCredentials = Symbol("EventSource.withCredentials");
>+dart.setMethodSignature(html$.EventSource, () => ({
>+  __proto__: dart.getMethods(html$.EventSource.__proto__),
>+  [$close]: dart.fnType(dart.void, [])
>+}));
>+dart.setGetterSignature(html$.EventSource, () => ({
>+  __proto__: dart.getGetters(html$.EventSource.__proto__),
>+  [$onError]: async.Stream$(html$.Event),
>+  [$onMessage]: async.Stream$(html$.MessageEvent),
>+  [$onOpen]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.EventSource, "dart:html");
>+dart.setFieldSignature(html$.EventSource, () => ({
>+  __proto__: dart.getFields(html$.EventSource.__proto__),
>+  [$readyState]: dart.finalFieldType(core.int),
>+  [$url]: dart.finalFieldType(core.String),
>+  [$withCredentials]: dart.finalFieldType(core.bool)
>+}));
>+dart.defineLazy(html$.EventSource, {
>+  /*html$.EventSource.errorEvent*/get errorEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("error"));
>+  },
>+  /*html$.EventSource.messageEvent*/get messageEvent() {
>+    return dart.const(new (EventStreamProviderOfMessageEvent()).new("message"));
>+  },
>+  /*html$.EventSource.openEvent*/get openEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("open"));
>+  },
>+  /*html$.EventSource.CLOSED*/get CLOSED() {
>+    return 2;
>+  },
>+  /*html$.EventSource.CONNECTING*/get CONNECTING() {
>+    return 0;
>+  },
>+  /*html$.EventSource.OPEN*/get OPEN() {
>+    return 1;
>+  }
>+});
>+dart.registerExtension("EventSource", html$.EventSource);
>+const _ptr = dart.privateName(html$, "_ptr");
>+html$.Events = class Events extends core.Object {
>+  _get(type) {
>+    return new (_EventStreamOfEvent()).new(this[_ptr], type, false);
>+  }
>+};
>+(html$.Events.new = function(ptr) {
>+  this[_ptr] = ptr;
>+}).prototype = html$.Events.prototype;
>+dart.addTypeTests(html$.Events);
>+dart.setMethodSignature(html$.Events, () => ({
>+  __proto__: dart.getMethods(html$.Events.__proto__),
>+  _get: dart.fnType(async.Stream$(html$.Event), [core.String])
>+}));
>+dart.setLibraryUri(html$.Events, "dart:html");
>+dart.setFieldSignature(html$.Events, () => ({
>+  __proto__: dart.getFields(html$.Events.__proto__),
>+  [_ptr]: dart.finalFieldType(html$.EventTarget)
>+}));
>+html$.ElementEvents = class ElementEvents extends html$.Events {
>+  _get(type) {
>+    if (dart.test(html$.ElementEvents.webkitEvents[$keys][$contains](type[$toLowerCase]()))) {
>+      if (dart.test(html_common.Device.isWebKit)) {
>+        return new (_ElementEventStreamImplOfEvent()).new(this[_ptr], html$.ElementEvents.webkitEvents[$_get](type[$toLowerCase]()), false);
>+      }
>+    }
>+    return new (_ElementEventStreamImplOfEvent()).new(this[_ptr], type, false);
>+  }
>+};
>+(html$.ElementEvents.new = function(ptr) {
>+  html$.ElementEvents.__proto__.new.call(this, ptr);
>+}).prototype = html$.ElementEvents.prototype;
>+dart.addTypeTests(html$.ElementEvents);
>+dart.setLibraryUri(html$.ElementEvents, "dart:html");
>+dart.defineLazy(html$.ElementEvents, {
>+  /*html$.ElementEvents.webkitEvents*/get webkitEvents() {
>+    return new (IdentityMapOfString$String()).from(["animationend", "webkitAnimationEnd", "animationiteration", "webkitAnimationIteration", "animationstart", "webkitAnimationStart", "fullscreenchange", "webkitfullscreenchange", "fullscreenerror", "webkitfullscreenerror", "keyadded", "webkitkeyadded", "keyerror", "webkitkeyerror", "keymessage", "webkitkeymessage", "needkey", "webkitneedkey", "pointerlockchange", "webkitpointerlockchange", "pointerlockerror", "webkitpointerlockerror", "resourcetimingbufferfull", "webkitresourcetimingbufferfull", "transitionend", "webkitTransitionEnd", "speechchange", "webkitSpeechChange"]);
>+  }
>+});
>+html$.ExtendableMessageEvent = class ExtendableMessageEvent extends html$.ExtendableEvent {
>+  get [$data]() {
>+    return this.data;
>+  }
>+  get [$lastEventId]() {
>+    return this.lastEventId;
>+  }
>+  get [$origin]() {
>+    return this.origin;
>+  }
>+  get [$ports]() {
>+    return this.ports;
>+  }
>+  get [$source]() {
>+    return this.source;
>+  }
>+};
>+dart.addTypeTests(html$.ExtendableMessageEvent);
>+const data$2 = Symbol("ExtendableMessageEvent.data");
>+const lastEventId = Symbol("ExtendableMessageEvent.lastEventId");
>+const origin$2 = Symbol("ExtendableMessageEvent.origin");
>+const ports = Symbol("ExtendableMessageEvent.ports");
>+const source$1 = Symbol("ExtendableMessageEvent.source");
>+dart.setLibraryUri(html$.ExtendableMessageEvent, "dart:html");
>+dart.setFieldSignature(html$.ExtendableMessageEvent, () => ({
>+  __proto__: dart.getFields(html$.ExtendableMessageEvent.__proto__),
>+  [$data]: dart.finalFieldType(core.Object),
>+  [$lastEventId]: dart.finalFieldType(core.String),
>+  [$origin]: dart.finalFieldType(core.String),
>+  [$ports]: dart.finalFieldType(ListOfMessagePort()),
>+  [$source]: dart.finalFieldType(core.Object)
>+}));
>+dart.registerExtension("ExtendableMessageEvent", html$.ExtendableMessageEvent);
>+html$.External = class External extends _interceptors.Interceptor {
>+  [$AddSearchProvider](...args) {
>+    return this.AddSearchProvider.apply(this, args);
>+  }
>+  [$IsSearchProviderInstalled](...args) {
>+    return this.IsSearchProviderInstalled.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.External);
>+dart.setMethodSignature(html$.External, () => ({
>+  __proto__: dart.getMethods(html$.External.__proto__),
>+  [$AddSearchProvider]: dart.fnType(dart.void, []),
>+  [$IsSearchProviderInstalled]: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(html$.External, "dart:html");
>+dart.registerExtension("External", html$.External);
>+html$.FaceDetector = class FaceDetector$ extends _interceptors.Interceptor {
>+  static new(faceDetectorOptions) {
>+    if (faceDetectorOptions === void 0) faceDetectorOptions = null;
>+    if (faceDetectorOptions != null) {
>+      let faceDetectorOptions_1 = html_common.convertDartToNative_Dictionary(faceDetectorOptions);
>+      return html$.FaceDetector._create_1(faceDetectorOptions_1);
>+    }
>+    return html$.FaceDetector._create_2();
>+  }
>+  static _create_1(faceDetectorOptions) {
>+    return new FaceDetector(faceDetectorOptions);
>+  }
>+  static _create_2() {
>+    return new FaceDetector();
>+  }
>+  [$detect](image) {
>+    return html$.promiseToFuture(ListOfDetectedFace(), this.detect(image));
>+  }
>+};
>+dart.addTypeTests(html$.FaceDetector);
>+dart.setMethodSignature(html$.FaceDetector, () => ({
>+  __proto__: dart.getMethods(html$.FaceDetector.__proto__),
>+  [$detect]: dart.fnType(async.Future$(core.List$(html$.DetectedFace)), [dart.dynamic])
>+}));
>+dart.setLibraryUri(html$.FaceDetector, "dart:html");
>+dart.registerExtension("FaceDetector", html$.FaceDetector);
>+html$.FederatedCredential = class FederatedCredential$ extends html$.Credential {
>+  static new(data) {
>+    let data_1 = html_common.convertDartToNative_Dictionary(data);
>+    return html$.FederatedCredential._create_1(data_1);
>+  }
>+  static _create_1(data) {
>+    return new FederatedCredential(data);
>+  }
>+  get [$protocol]() {
>+    return this.protocol;
>+  }
>+  get [$provider]() {
>+    return this.provider;
>+  }
>+  get [$iconUrl]() {
>+    return this.iconURL;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+};
>+dart.addTypeTests(html$.FederatedCredential);
>+const protocol$0 = Symbol("FederatedCredential.protocol");
>+const provider = Symbol("FederatedCredential.provider");
>+const iconUrl$ = Symbol("FederatedCredential.iconUrl");
>+const name$13 = Symbol("FederatedCredential.name");
>+html$.FederatedCredential[dart.implements] = () => [html$.CredentialUserData];
>+dart.setLibraryUri(html$.FederatedCredential, "dart:html");
>+dart.setFieldSignature(html$.FederatedCredential, () => ({
>+  __proto__: dart.getFields(html$.FederatedCredential.__proto__),
>+  [$protocol]: dart.finalFieldType(core.String),
>+  [$provider]: dart.finalFieldType(core.String),
>+  [$iconUrl]: dart.finalFieldType(core.String),
>+  [$name]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("FederatedCredential", html$.FederatedCredential);
>+html$.FetchEvent = class FetchEvent$ extends html$.ExtendableEvent {
>+  static new(type, eventInitDict) {
>+    let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+    return html$.FetchEvent._create_1(type, eventInitDict_1);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new FetchEvent(type, eventInitDict);
>+  }
>+  get [$clientId]() {
>+    return this.clientId;
>+  }
>+  get [$isReload]() {
>+    return this.isReload;
>+  }
>+  get [$preloadResponse]() {
>+    return html$.promiseToFuture(dart.dynamic, this.preloadResponse);
>+  }
>+  get [$request]() {
>+    return this.request;
>+  }
>+  [$respondWith](...args) {
>+    return this.respondWith.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.FetchEvent);
>+const clientId = Symbol("FetchEvent.clientId");
>+const isReload = Symbol("FetchEvent.isReload");
>+const request$ = Symbol("FetchEvent.request");
>+dart.setMethodSignature(html$.FetchEvent, () => ({
>+  __proto__: dart.getMethods(html$.FetchEvent.__proto__),
>+  [$respondWith]: dart.fnType(dart.void, [async.Future])
>+}));
>+dart.setGetterSignature(html$.FetchEvent, () => ({
>+  __proto__: dart.getGetters(html$.FetchEvent.__proto__),
>+  [$preloadResponse]: async.Future
>+}));
>+dart.setLibraryUri(html$.FetchEvent, "dart:html");
>+dart.setFieldSignature(html$.FetchEvent, () => ({
>+  __proto__: dart.getFields(html$.FetchEvent.__proto__),
>+  [$clientId]: dart.finalFieldType(core.String),
>+  [$isReload]: dart.finalFieldType(core.bool),
>+  [$request]: dart.finalFieldType(html$._Request)
>+}));
>+dart.registerExtension("FetchEvent", html$.FetchEvent);
>+html$.FieldSetElement = class FieldSetElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("fieldset");
>+  }
>+  get [$disabled]() {
>+    return this.disabled;
>+  }
>+  set [$disabled](value) {
>+    this.disabled = value;
>+  }
>+  get [$elements]() {
>+    return this.elements;
>+  }
>+  get [$form]() {
>+    return this.form;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+  set [$name](value) {
>+    this.name = value;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  get [$validationMessage]() {
>+    return this.validationMessage;
>+  }
>+  get [$validity]() {
>+    return this.validity;
>+  }
>+  get [$willValidate]() {
>+    return this.willValidate;
>+  }
>+  [$checkValidity](...args) {
>+    return this.checkValidity.apply(this, args);
>+  }
>+  [$reportValidity](...args) {
>+    return this.reportValidity.apply(this, args);
>+  }
>+  [$setCustomValidity](...args) {
>+    return this.setCustomValidity.apply(this, args);
>+  }
>+};
>+(html$.FieldSetElement.created = function() {
>+  this[disabled$1] = null;
>+  this[elements] = null;
>+  this[form$] = null;
>+  this[name$14] = null;
>+  this[type$14] = null;
>+  this[validationMessage$] = null;
>+  this[validity$] = null;
>+  this[willValidate$] = null;
>+  html$.FieldSetElement.__proto__.created.call(this);
>+}).prototype = html$.FieldSetElement.prototype;
>+dart.addTypeTests(html$.FieldSetElement);
>+const disabled$1 = Symbol("FieldSetElement.disabled");
>+const elements = Symbol("FieldSetElement.elements");
>+const form$ = Symbol("FieldSetElement.form");
>+const name$14 = Symbol("FieldSetElement.name");
>+const type$14 = Symbol("FieldSetElement.type");
>+const validationMessage$ = Symbol("FieldSetElement.validationMessage");
>+const validity$ = Symbol("FieldSetElement.validity");
>+const willValidate$ = Symbol("FieldSetElement.willValidate");
>+dart.setMethodSignature(html$.FieldSetElement, () => ({
>+  __proto__: dart.getMethods(html$.FieldSetElement.__proto__),
>+  [$checkValidity]: dart.fnType(core.bool, []),
>+  [$reportValidity]: dart.fnType(core.bool, []),
>+  [$setCustomValidity]: dart.fnType(dart.void, [core.String])
>+}));
>+dart.setLibraryUri(html$.FieldSetElement, "dart:html");
>+dart.setFieldSignature(html$.FieldSetElement, () => ({
>+  __proto__: dart.getFields(html$.FieldSetElement.__proto__),
>+  [$disabled]: dart.fieldType(core.bool),
>+  [$elements]: dart.finalFieldType(ListOfNode()),
>+  [$form]: dart.finalFieldType(html$.FormElement),
>+  [$name]: dart.fieldType(core.String),
>+  [$type]: dart.finalFieldType(core.String),
>+  [$validationMessage]: dart.finalFieldType(core.String),
>+  [$validity]: dart.finalFieldType(html$.ValidityState),
>+  [$willValidate]: dart.finalFieldType(core.bool)
>+}));
>+dart.registerExtension("HTMLFieldSetElement", html$.FieldSetElement);
>+const _get_lastModifiedDate = dart.privateName(html$, "_get_lastModifiedDate");
>+html$.File = class File$ extends html$.Blob {
>+  static new(fileBits, fileName, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      return html$.File._create_1(fileBits, fileName, options_1);
>+    }
>+    return html$.File._create_2(fileBits, fileName);
>+  }
>+  static _create_1(fileBits, fileName, options) {
>+    return new File(fileBits, fileName, options);
>+  }
>+  static _create_2(fileBits, fileName) {
>+    return new File(fileBits, fileName);
>+  }
>+  get [$lastModified]() {
>+    return this.lastModified;
>+  }
>+  get [$lastModifiedDate]() {
>+    return html_common.convertNativeToDart_DateTime(this[_get_lastModifiedDate]);
>+  }
>+  get [_get_lastModifiedDate]() {
>+    return this.lastModifiedDate;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+  get [$relativePath]() {
>+    return this.webkitRelativePath;
>+  }
>+};
>+dart.addTypeTests(html$.File);
>+const lastModified = Symbol("File.lastModified");
>+const name$15 = Symbol("File.name");
>+const relativePath = Symbol("File.relativePath");
>+dart.setGetterSignature(html$.File, () => ({
>+  __proto__: dart.getGetters(html$.File.__proto__),
>+  [$lastModifiedDate]: core.DateTime
>+}));
>+dart.setLibraryUri(html$.File, "dart:html");
>+dart.setFieldSignature(html$.File, () => ({
>+  __proto__: dart.getFields(html$.File.__proto__),
>+  [$lastModified]: dart.finalFieldType(core.int),
>+  [_get_lastModifiedDate]: dart.finalFieldType(dart.dynamic),
>+  [$name]: dart.finalFieldType(core.String),
>+  [$relativePath]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("File", html$.File);
>+const _createWriter = dart.privateName(html$, "_createWriter");
>+const _file$ = dart.privateName(html$, "_file");
>+html$.FileEntry = class FileEntry extends html$.Entry {
>+  [_createWriter](...args) {
>+    return this.createWriter.apply(this, args);
>+  }
>+  [$createWriter]() {
>+    let completer = CompleterOfFileWriter().new();
>+    this[_createWriter](dart.fn(value => {
>+      _js_helper.applyExtension("FileWriter", value);
>+      completer.complete(value);
>+    }, FileWriterToNull()), dart.fn(error => {
>+      completer.completeError(error);
>+    }, DomExceptionToNull()));
>+    return completer.future;
>+  }
>+  [_file$](...args) {
>+    return this.file.apply(this, args);
>+  }
>+  [$file]() {
>+    let completer = CompleterOfFile$().new();
>+    this[_file$](dart.fn(value => {
>+      _js_helper.applyExtension("File", value);
>+      completer.complete(value);
>+    }, FileToNull()), dart.fn(error => {
>+      completer.completeError(error);
>+    }, DomExceptionToNull()));
>+    return completer.future;
>+  }
>+};
>+dart.addTypeTests(html$.FileEntry);
>+dart.setMethodSignature(html$.FileEntry, () => ({
>+  __proto__: dart.getMethods(html$.FileEntry.__proto__),
>+  [_createWriter]: dart.fnType(dart.void, [dart.fnType(dart.void, [html$.FileWriter])], [dart.fnType(dart.void, [html$.DomException])]),
>+  [$createWriter]: dart.fnType(async.Future$(html$.FileWriter), []),
>+  [_file$]: dart.fnType(dart.void, [dart.fnType(dart.void, [html$.File])], [dart.fnType(dart.void, [html$.DomException])]),
>+  [$file]: dart.fnType(async.Future$(html$.File), [])
>+}));
>+dart.setLibraryUri(html$.FileEntry, "dart:html");
>+dart.registerExtension("FileEntry", html$.FileEntry);
>+const Interceptor_ListMixin$$0 = class Interceptor_ListMixin extends _interceptors.Interceptor {};
>+(Interceptor_ListMixin$$0.new = function() {
>+  Interceptor_ListMixin$$0.__proto__.new.call(this);
>+}).prototype = Interceptor_ListMixin$$0.prototype;
>+dart.applyMixin(Interceptor_ListMixin$$0, collection.ListMixin$(html$.File));
>+const Interceptor_ImmutableListMixin$$0 = class Interceptor_ImmutableListMixin extends Interceptor_ListMixin$$0 {};
>+(Interceptor_ImmutableListMixin$$0.new = function() {
>+  Interceptor_ImmutableListMixin$$0.__proto__.new.call(this);
>+}).prototype = Interceptor_ImmutableListMixin$$0.prototype;
>+dart.applyMixin(Interceptor_ImmutableListMixin$$0, html$.ImmutableListMixin$(html$.File));
>+html$.FileList = class FileList extends Interceptor_ImmutableListMixin$$0 {
>+  get [$length]() {
>+    return this.length;
>+  }
>+  [$_get](index) {
>+    if (index >>> 0 !== index || index >= this[$length]) dart.throw(core.RangeError.index(index, this));
>+    return this[index];
>+  }
>+  [$_set](index, value) {
>+    html$.File._check(value);
>+    dart.throw(new core.UnsupportedError.new("Cannot assign element of immutable List."));
>+    return value;
>+  }
>+  set [$length](value) {
>+    dart.throw(new core.UnsupportedError.new("Cannot resize immutable List."));
>+  }
>+  get [$first]() {
>+    if (dart.notNull(this[$length]) > 0) {
>+      return this[0];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$first](value) {
>+    super[$first] = value;
>+  }
>+  get [$last]() {
>+    let len = this[$length];
>+    if (dart.notNull(len) > 0) {
>+      return this[dart.notNull(len) - 1];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$last](value) {
>+    super[$last] = value;
>+  }
>+  get [$single]() {
>+    let len = this[$length];
>+    if (len === 1) {
>+      return this[0];
>+    }
>+    if (len === 0) dart.throw(new core.StateError.new("No elements"));
>+    dart.throw(new core.StateError.new("More than one element"));
>+  }
>+  [$elementAt](index) {
>+    return this[$_get](index);
>+  }
>+  [$item](...args) {
>+    return this.item.apply(this, args);
>+  }
>+};
>+html$.FileList.prototype[dart.isList] = true;
>+dart.addTypeTests(html$.FileList);
>+html$.FileList[dart.implements] = () => [ListOfFile(), JavaScriptIndexingBehaviorOfFile()];
>+dart.setMethodSignature(html$.FileList, () => ({
>+  __proto__: dart.getMethods(html$.FileList.__proto__),
>+  [$_get]: dart.fnType(html$.File, [core.int]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$elementAt]: dart.fnType(html$.File, [core.int]),
>+  [$item]: dart.fnType(html$.File, [core.int])
>+}));
>+dart.setGetterSignature(html$.FileList, () => ({
>+  __proto__: dart.getGetters(html$.FileList.__proto__),
>+  [$length]: core.int,
>+  [$first]: html$.File,
>+  [$last]: html$.File,
>+  [$single]: html$.File
>+}));
>+dart.setSetterSignature(html$.FileList, () => ({
>+  __proto__: dart.getSetters(html$.FileList.__proto__),
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(html$.FileList, "dart:html");
>+dart.registerExtension("FileList", html$.FileList);
>+html$.FileReader = class FileReader$ extends html$.EventTarget {
>+  get [$result]() {
>+    let res = this.result;
>+    if (typed_data.ByteBuffer.is(res)) {
>+      return typed_data.Uint8List.view(res);
>+    }
>+    return res;
>+  }
>+  static new() {
>+    return html$.FileReader._create_1();
>+  }
>+  static _create_1() {
>+    return new FileReader();
>+  }
>+  get [$error]() {
>+    return this.error;
>+  }
>+  get [$readyState]() {
>+    return this.readyState;
>+  }
>+  [$abort](...args) {
>+    return this.abort.apply(this, args);
>+  }
>+  [$readAsArrayBuffer](...args) {
>+    return this.readAsArrayBuffer.apply(this, args);
>+  }
>+  [$readAsDataUrl](...args) {
>+    return this.readAsDataURL.apply(this, args);
>+  }
>+  [$readAsText](...args) {
>+    return this.readAsText.apply(this, args);
>+  }
>+  get [$onAbort]() {
>+    return html$.FileReader.abortEvent.forTarget(this);
>+  }
>+  get [$onError]() {
>+    return html$.FileReader.errorEvent.forTarget(this);
>+  }
>+  get [$onLoad]() {
>+    return html$.FileReader.loadEvent.forTarget(this);
>+  }
>+  get [$onLoadEnd]() {
>+    return html$.FileReader.loadEndEvent.forTarget(this);
>+  }
>+  get [$onLoadStart]() {
>+    return html$.FileReader.loadStartEvent.forTarget(this);
>+  }
>+  get [$onProgress]() {
>+    return html$.FileReader.progressEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.FileReader);
>+const error$3 = Symbol("FileReader.error");
>+const readyState$3 = Symbol("FileReader.readyState");
>+dart.setMethodSignature(html$.FileReader, () => ({
>+  __proto__: dart.getMethods(html$.FileReader.__proto__),
>+  [$abort]: dart.fnType(dart.void, []),
>+  [$readAsArrayBuffer]: dart.fnType(dart.void, [html$.Blob]),
>+  [$readAsDataUrl]: dart.fnType(dart.void, [html$.Blob]),
>+  [$readAsText]: dart.fnType(dart.void, [html$.Blob], [core.String])
>+}));
>+dart.setGetterSignature(html$.FileReader, () => ({
>+  __proto__: dart.getGetters(html$.FileReader.__proto__),
>+  [$result]: core.Object,
>+  [$onAbort]: async.Stream$(html$.ProgressEvent),
>+  [$onError]: async.Stream$(html$.ProgressEvent),
>+  [$onLoad]: async.Stream$(html$.ProgressEvent),
>+  [$onLoadEnd]: async.Stream$(html$.ProgressEvent),
>+  [$onLoadStart]: async.Stream$(html$.ProgressEvent),
>+  [$onProgress]: async.Stream$(html$.ProgressEvent)
>+}));
>+dart.setLibraryUri(html$.FileReader, "dart:html");
>+dart.setFieldSignature(html$.FileReader, () => ({
>+  __proto__: dart.getFields(html$.FileReader.__proto__),
>+  [$error]: dart.finalFieldType(html$.DomException),
>+  [$readyState]: dart.finalFieldType(core.int)
>+}));
>+dart.defineLazy(html$.FileReader, {
>+  /*html$.FileReader.abortEvent*/get abortEvent() {
>+    return dart.const(new (EventStreamProviderOfProgressEvent()).new("abort"));
>+  },
>+  /*html$.FileReader.errorEvent*/get errorEvent() {
>+    return dart.const(new (EventStreamProviderOfProgressEvent()).new("error"));
>+  },
>+  /*html$.FileReader.loadEvent*/get loadEvent() {
>+    return dart.const(new (EventStreamProviderOfProgressEvent()).new("load"));
>+  },
>+  /*html$.FileReader.loadEndEvent*/get loadEndEvent() {
>+    return dart.const(new (EventStreamProviderOfProgressEvent()).new("loadend"));
>+  },
>+  /*html$.FileReader.loadStartEvent*/get loadStartEvent() {
>+    return dart.const(new (EventStreamProviderOfProgressEvent()).new("loadstart"));
>+  },
>+  /*html$.FileReader.progressEvent*/get progressEvent() {
>+    return dart.const(new (EventStreamProviderOfProgressEvent()).new("progress"));
>+  },
>+  /*html$.FileReader.DONE*/get DONE() {
>+    return 2;
>+  },
>+  /*html$.FileReader.EMPTY*/get EMPTY() {
>+    return 0;
>+  },
>+  /*html$.FileReader.LOADING*/get LOADING() {
>+    return 1;
>+  }
>+});
>+dart.registerExtension("FileReader", html$.FileReader);
>+html$.FileSystem = class FileSystem extends _interceptors.Interceptor {
>+  static get supported() {
>+    return !!window.webkitRequestFileSystem;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+  get [$root]() {
>+    return this.root;
>+  }
>+};
>+dart.addTypeTests(html$.FileSystem);
>+const name$16 = Symbol("FileSystem.name");
>+const root = Symbol("FileSystem.root");
>+dart.setLibraryUri(html$.FileSystem, "dart:html");
>+dart.setFieldSignature(html$.FileSystem, () => ({
>+  __proto__: dart.getFields(html$.FileSystem.__proto__),
>+  [$name]: dart.finalFieldType(core.String),
>+  [$root]: dart.finalFieldType(html$.DirectoryEntry)
>+}));
>+dart.registerExtension("DOMFileSystem", html$.FileSystem);
>+html$.FileWriter = class FileWriter extends html$.EventTarget {
>+  get [$error]() {
>+    return this.error;
>+  }
>+  get [$length]() {
>+    return this.length;
>+  }
>+  get [$position]() {
>+    return this.position;
>+  }
>+  get [$readyState]() {
>+    return this.readyState;
>+  }
>+  [$abort](...args) {
>+    return this.abort.apply(this, args);
>+  }
>+  [$seek](...args) {
>+    return this.seek.apply(this, args);
>+  }
>+  [$truncate](...args) {
>+    return this.truncate.apply(this, args);
>+  }
>+  [$write](...args) {
>+    return this.write.apply(this, args);
>+  }
>+  get [$onAbort]() {
>+    return html$.FileWriter.abortEvent.forTarget(this);
>+  }
>+  get [$onError]() {
>+    return html$.FileWriter.errorEvent.forTarget(this);
>+  }
>+  get [$onProgress]() {
>+    return html$.FileWriter.progressEvent.forTarget(this);
>+  }
>+  get [$onWrite]() {
>+    return html$.FileWriter.writeEvent.forTarget(this);
>+  }
>+  get [$onWriteEnd]() {
>+    return html$.FileWriter.writeEndEvent.forTarget(this);
>+  }
>+  get [$onWriteStart]() {
>+    return html$.FileWriter.writeStartEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.FileWriter);
>+const error$4 = Symbol("FileWriter.error");
>+const length$7 = Symbol("FileWriter.length");
>+const position = Symbol("FileWriter.position");
>+const readyState$4 = Symbol("FileWriter.readyState");
>+dart.setMethodSignature(html$.FileWriter, () => ({
>+  __proto__: dart.getMethods(html$.FileWriter.__proto__),
>+  [$abort]: dart.fnType(dart.void, []),
>+  [$seek]: dart.fnType(dart.void, [core.int]),
>+  [$truncate]: dart.fnType(dart.void, [core.int]),
>+  [$write]: dart.fnType(dart.void, [html$.Blob])
>+}));
>+dart.setGetterSignature(html$.FileWriter, () => ({
>+  __proto__: dart.getGetters(html$.FileWriter.__proto__),
>+  [$onAbort]: async.Stream$(html$.ProgressEvent),
>+  [$onError]: async.Stream$(html$.Event),
>+  [$onProgress]: async.Stream$(html$.ProgressEvent),
>+  [$onWrite]: async.Stream$(html$.ProgressEvent),
>+  [$onWriteEnd]: async.Stream$(html$.ProgressEvent),
>+  [$onWriteStart]: async.Stream$(html$.ProgressEvent)
>+}));
>+dart.setLibraryUri(html$.FileWriter, "dart:html");
>+dart.setFieldSignature(html$.FileWriter, () => ({
>+  __proto__: dart.getFields(html$.FileWriter.__proto__),
>+  [$error]: dart.finalFieldType(html$.DomException),
>+  [$length]: dart.finalFieldType(core.int),
>+  [$position]: dart.finalFieldType(core.int),
>+  [$readyState]: dart.finalFieldType(core.int)
>+}));
>+dart.defineLazy(html$.FileWriter, {
>+  /*html$.FileWriter.abortEvent*/get abortEvent() {
>+    return dart.const(new (EventStreamProviderOfProgressEvent()).new("abort"));
>+  },
>+  /*html$.FileWriter.errorEvent*/get errorEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("error"));
>+  },
>+  /*html$.FileWriter.progressEvent*/get progressEvent() {
>+    return dart.const(new (EventStreamProviderOfProgressEvent()).new("progress"));
>+  },
>+  /*html$.FileWriter.writeEvent*/get writeEvent() {
>+    return dart.const(new (EventStreamProviderOfProgressEvent()).new("write"));
>+  },
>+  /*html$.FileWriter.writeEndEvent*/get writeEndEvent() {
>+    return dart.const(new (EventStreamProviderOfProgressEvent()).new("writeend"));
>+  },
>+  /*html$.FileWriter.writeStartEvent*/get writeStartEvent() {
>+    return dart.const(new (EventStreamProviderOfProgressEvent()).new("writestart"));
>+  },
>+  /*html$.FileWriter.DONE*/get DONE() {
>+    return 2;
>+  },
>+  /*html$.FileWriter.INIT*/get INIT() {
>+    return 0;
>+  },
>+  /*html$.FileWriter.WRITING*/get WRITING() {
>+    return 1;
>+  }
>+});
>+dart.registerExtension("FileWriter", html$.FileWriter);
>+const _get_relatedTarget = dart.privateName(html$, "_get_relatedTarget");
>+html$.FocusEvent = class FocusEvent$ extends html$.UIEvent {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.FocusEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.FocusEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new FocusEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new FocusEvent(type);
>+  }
>+  get [$relatedTarget]() {
>+    return html$._convertNativeToDart_EventTarget(this[_get_relatedTarget]);
>+  }
>+  get [_get_relatedTarget]() {
>+    return this.relatedTarget;
>+  }
>+};
>+dart.addTypeTests(html$.FocusEvent);
>+dart.setGetterSignature(html$.FocusEvent, () => ({
>+  __proto__: dart.getGetters(html$.FocusEvent.__proto__),
>+  [$relatedTarget]: html$.EventTarget
>+}));
>+dart.setLibraryUri(html$.FocusEvent, "dart:html");
>+dart.setFieldSignature(html$.FocusEvent, () => ({
>+  __proto__: dart.getFields(html$.FocusEvent.__proto__),
>+  [_get_relatedTarget]: dart.finalFieldType(dart.dynamic)
>+}));
>+dart.registerExtension("FocusEvent", html$.FocusEvent);
>+html$.FontFace = class FontFace$ extends _interceptors.Interceptor {
>+  static new(family, source, descriptors) {
>+    if (descriptors === void 0) descriptors = null;
>+    if (descriptors != null) {
>+      let descriptors_1 = html_common.convertDartToNative_Dictionary(descriptors);
>+      return html$.FontFace._create_1(family, source, descriptors_1);
>+    }
>+    return html$.FontFace._create_2(family, source);
>+  }
>+  static _create_1(family, source, descriptors) {
>+    return new FontFace(family, source, descriptors);
>+  }
>+  static _create_2(family, source) {
>+    return new FontFace(family, source);
>+  }
>+  get [$display]() {
>+    return this.display;
>+  }
>+  set [$display](value) {
>+    this.display = value;
>+  }
>+  get [$family]() {
>+    return this.family;
>+  }
>+  set [$family](value) {
>+    this.family = value;
>+  }
>+  get [$featureSettings]() {
>+    return this.featureSettings;
>+  }
>+  set [$featureSettings](value) {
>+    this.featureSettings = value;
>+  }
>+  get [$loaded]() {
>+    return html$.promiseToFuture(html$.FontFace, this.loaded);
>+  }
>+  get [$status]() {
>+    return this.status;
>+  }
>+  get [$stretch]() {
>+    return this.stretch;
>+  }
>+  set [$stretch](value) {
>+    this.stretch = value;
>+  }
>+  get [$style]() {
>+    return this.style;
>+  }
>+  set [$style](value) {
>+    this.style = value;
>+  }
>+  get [$unicodeRange]() {
>+    return this.unicodeRange;
>+  }
>+  set [$unicodeRange](value) {
>+    this.unicodeRange = value;
>+  }
>+  get [$variant]() {
>+    return this.variant;
>+  }
>+  set [$variant](value) {
>+    this.variant = value;
>+  }
>+  get [$weight]() {
>+    return this.weight;
>+  }
>+  set [$weight](value) {
>+    this.weight = value;
>+  }
>+  [$load]() {
>+    return html$.promiseToFuture(html$.FontFace, this.load());
>+  }
>+};
>+dart.addTypeTests(html$.FontFace);
>+const display = Symbol("FontFace.display");
>+const family = Symbol("FontFace.family");
>+const featureSettings = Symbol("FontFace.featureSettings");
>+const status$0 = Symbol("FontFace.status");
>+const stretch = Symbol("FontFace.stretch");
>+const style$4 = Symbol("FontFace.style");
>+const unicodeRange = Symbol("FontFace.unicodeRange");
>+const variant = Symbol("FontFace.variant");
>+const weight = Symbol("FontFace.weight");
>+dart.setMethodSignature(html$.FontFace, () => ({
>+  __proto__: dart.getMethods(html$.FontFace.__proto__),
>+  [$load]: dart.fnType(async.Future$(html$.FontFace), [])
>+}));
>+dart.setGetterSignature(html$.FontFace, () => ({
>+  __proto__: dart.getGetters(html$.FontFace.__proto__),
>+  [$loaded]: async.Future$(html$.FontFace)
>+}));
>+dart.setLibraryUri(html$.FontFace, "dart:html");
>+dart.setFieldSignature(html$.FontFace, () => ({
>+  __proto__: dart.getFields(html$.FontFace.__proto__),
>+  [$display]: dart.fieldType(core.String),
>+  [$family]: dart.fieldType(core.String),
>+  [$featureSettings]: dart.fieldType(core.String),
>+  [$status]: dart.finalFieldType(core.String),
>+  [$stretch]: dart.fieldType(core.String),
>+  [$style]: dart.fieldType(core.String),
>+  [$unicodeRange]: dart.fieldType(core.String),
>+  [$variant]: dart.fieldType(core.String),
>+  [$weight]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("FontFace", html$.FontFace);
>+html$.FontFaceSet = class FontFaceSet extends html$.EventTarget {
>+  get [$status]() {
>+    return this.status;
>+  }
>+  [$add](...args) {
>+    return this.add.apply(this, args);
>+  }
>+  [$check](...args) {
>+    return this.check.apply(this, args);
>+  }
>+  [$clear](...args) {
>+    return this.clear.apply(this, args);
>+  }
>+  [$delete](...args) {
>+    return this.delete.apply(this, args);
>+  }
>+  [$forEach](...args) {
>+    return this.forEach.apply(this, args);
>+  }
>+  [$has](...args) {
>+    return this.has.apply(this, args);
>+  }
>+  get [$onLoading]() {
>+    return html$.FontFaceSet.loadingEvent.forTarget(this);
>+  }
>+  get [$onLoadingDone]() {
>+    return html$.FontFaceSet.loadingDoneEvent.forTarget(this);
>+  }
>+  get [$onLoadingError]() {
>+    return html$.FontFaceSet.loadingErrorEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.FontFaceSet);
>+const status$1 = Symbol("FontFaceSet.status");
>+dart.setMethodSignature(html$.FontFaceSet, () => ({
>+  __proto__: dart.getMethods(html$.FontFaceSet.__proto__),
>+  [$add]: dart.fnType(html$.FontFaceSet, [html$.FontFace]),
>+  [$check]: dart.fnType(core.bool, [core.String], [core.String]),
>+  [$clear]: dart.fnType(dart.void, []),
>+  [$delete]: dart.fnType(core.bool, [html$.FontFace]),
>+  [$forEach]: dart.fnType(dart.void, [dart.fnType(dart.void, [html$.FontFace, html$.FontFace, html$.FontFaceSet])], [core.Object]),
>+  [$has]: dart.fnType(core.bool, [html$.FontFace])
>+}));
>+dart.setGetterSignature(html$.FontFaceSet, () => ({
>+  __proto__: dart.getGetters(html$.FontFaceSet.__proto__),
>+  [$onLoading]: async.Stream$(html$.FontFaceSetLoadEvent),
>+  [$onLoadingDone]: async.Stream$(html$.FontFaceSetLoadEvent),
>+  [$onLoadingError]: async.Stream$(html$.FontFaceSetLoadEvent)
>+}));
>+dart.setLibraryUri(html$.FontFaceSet, "dart:html");
>+dart.setFieldSignature(html$.FontFaceSet, () => ({
>+  __proto__: dart.getFields(html$.FontFaceSet.__proto__),
>+  [$status]: dart.finalFieldType(core.String)
>+}));
>+dart.defineLazy(html$.FontFaceSet, {
>+  /*html$.FontFaceSet.loadingEvent*/get loadingEvent() {
>+    return dart.const(new (EventStreamProviderOfFontFaceSetLoadEvent()).new("loading"));
>+  },
>+  /*html$.FontFaceSet.loadingDoneEvent*/get loadingDoneEvent() {
>+    return dart.const(new (EventStreamProviderOfFontFaceSetLoadEvent()).new("loadingdone"));
>+  },
>+  /*html$.FontFaceSet.loadingErrorEvent*/get loadingErrorEvent() {
>+    return dart.const(new (EventStreamProviderOfFontFaceSetLoadEvent()).new("loadingerror"));
>+  }
>+});
>+dart.registerExtension("FontFaceSet", html$.FontFaceSet);
>+html$.FontFaceSetLoadEvent = class FontFaceSetLoadEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.FontFaceSetLoadEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.FontFaceSetLoadEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new FontFaceSetLoadEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new FontFaceSetLoadEvent(type);
>+  }
>+  get [$fontfaces]() {
>+    return this.fontfaces;
>+  }
>+};
>+dart.addTypeTests(html$.FontFaceSetLoadEvent);
>+const fontfaces = Symbol("FontFaceSetLoadEvent.fontfaces");
>+dart.setLibraryUri(html$.FontFaceSetLoadEvent, "dart:html");
>+dart.setFieldSignature(html$.FontFaceSetLoadEvent, () => ({
>+  __proto__: dart.getFields(html$.FontFaceSetLoadEvent.__proto__),
>+  [$fontfaces]: dart.finalFieldType(ListOfFontFace())
>+}));
>+dart.registerExtension("FontFaceSetLoadEvent", html$.FontFaceSetLoadEvent);
>+html$.FontFaceSource = class FontFaceSource extends _interceptors.Interceptor {
>+  get [$fonts]() {
>+    return this.fonts;
>+  }
>+};
>+dart.addTypeTests(html$.FontFaceSource);
>+const fonts$ = Symbol("FontFaceSource.fonts");
>+dart.setLibraryUri(html$.FontFaceSource, "dart:html");
>+dart.setFieldSignature(html$.FontFaceSource, () => ({
>+  __proto__: dart.getFields(html$.FontFaceSource.__proto__),
>+  [$fonts]: dart.finalFieldType(html$.FontFaceSet)
>+}));
>+dart.registerExtension("FontFaceSource", html$.FontFaceSource);
>+html$.ForeignFetchEvent = class ForeignFetchEvent$ extends html$.ExtendableEvent {
>+  static new(type, eventInitDict) {
>+    let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+    return html$.ForeignFetchEvent._create_1(type, eventInitDict_1);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new ForeignFetchEvent(type, eventInitDict);
>+  }
>+  get [$origin]() {
>+    return this.origin;
>+  }
>+  get [$request]() {
>+    return this.request;
>+  }
>+  [$respondWith](...args) {
>+    return this.respondWith.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.ForeignFetchEvent);
>+const origin$3 = Symbol("ForeignFetchEvent.origin");
>+const request$0 = Symbol("ForeignFetchEvent.request");
>+dart.setMethodSignature(html$.ForeignFetchEvent, () => ({
>+  __proto__: dart.getMethods(html$.ForeignFetchEvent.__proto__),
>+  [$respondWith]: dart.fnType(dart.void, [async.Future])
>+}));
>+dart.setLibraryUri(html$.ForeignFetchEvent, "dart:html");
>+dart.setFieldSignature(html$.ForeignFetchEvent, () => ({
>+  __proto__: dart.getFields(html$.ForeignFetchEvent.__proto__),
>+  [$origin]: dart.finalFieldType(core.String),
>+  [$request]: dart.finalFieldType(html$._Request)
>+}));
>+dart.registerExtension("ForeignFetchEvent", html$.ForeignFetchEvent);
>+html$.FormData = class FormData$ extends _interceptors.Interceptor {
>+  static new(form) {
>+    if (form === void 0) form = null;
>+    if (form != null) {
>+      return html$.FormData._create_1(form);
>+    }
>+    return html$.FormData._create_2();
>+  }
>+  static _create_1(form) {
>+    return new FormData(form);
>+  }
>+  static _create_2() {
>+    return new FormData();
>+  }
>+  static get supported() {
>+    return !!window.FormData;
>+  }
>+  [$append](...args) {
>+    return this.append.apply(this, args);
>+  }
>+  [$appendBlob](...args) {
>+    return this.append.apply(this, args);
>+  }
>+  [$delete](...args) {
>+    return this.delete.apply(this, args);
>+  }
>+  [$get](...args) {
>+    return this.get.apply(this, args);
>+  }
>+  [$getAll](...args) {
>+    return this.getAll.apply(this, args);
>+  }
>+  [$has](...args) {
>+    return this.has.apply(this, args);
>+  }
>+  [$set](...args) {
>+    return this.set.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.FormData);
>+dart.setMethodSignature(html$.FormData, () => ({
>+  __proto__: dart.getMethods(html$.FormData.__proto__),
>+  [$append]: dart.fnType(dart.void, [core.String, core.String]),
>+  [$appendBlob]: dart.fnType(dart.void, [core.String, html$.Blob], [core.String]),
>+  [$delete]: dart.fnType(dart.void, [core.String]),
>+  [$get]: dart.fnType(core.Object, [core.String]),
>+  [$getAll]: dart.fnType(core.List$(core.Object), [core.String]),
>+  [$has]: dart.fnType(core.bool, [core.String]),
>+  [$set]: dart.fnType(dart.void, [core.String, dart.dynamic], [core.String])
>+}));
>+dart.setLibraryUri(html$.FormData, "dart:html");
>+dart.registerExtension("FormData", html$.FormData);
>+const _requestAutocomplete_1 = dart.privateName(html$, "_requestAutocomplete_1");
>+html$.FormElement = class FormElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("form");
>+  }
>+  get [$acceptCharset]() {
>+    return this.acceptCharset;
>+  }
>+  set [$acceptCharset](value) {
>+    this.acceptCharset = value;
>+  }
>+  get [$action]() {
>+    return this.action;
>+  }
>+  set [$action](value) {
>+    this.action = value;
>+  }
>+  get [$autocomplete]() {
>+    return this.autocomplete;
>+  }
>+  set [$autocomplete](value) {
>+    this.autocomplete = value;
>+  }
>+  get [$encoding]() {
>+    return this.encoding;
>+  }
>+  set [$encoding](value) {
>+    this.encoding = value;
>+  }
>+  get [$enctype]() {
>+    return this.enctype;
>+  }
>+  set [$enctype](value) {
>+    this.enctype = value;
>+  }
>+  get [$length]() {
>+    return this.length;
>+  }
>+  get [$method]() {
>+    return this.method;
>+  }
>+  set [$method](value) {
>+    this.method = value;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+  set [$name](value) {
>+    this.name = value;
>+  }
>+  get [$noValidate]() {
>+    return this.noValidate;
>+  }
>+  set [$noValidate](value) {
>+    this.noValidate = value;
>+  }
>+  get [$target]() {
>+    return this.target;
>+  }
>+  set [$target](value) {
>+    this.target = value;
>+  }
>+  [__getter__](...args) {
>+    return this.__getter__.apply(this, args);
>+  }
>+  [$checkValidity](...args) {
>+    return this.checkValidity.apply(this, args);
>+  }
>+  [$item](...args) {
>+    return this.item.apply(this, args);
>+  }
>+  [$reportValidity](...args) {
>+    return this.reportValidity.apply(this, args);
>+  }
>+  [$requestAutocomplete](details) {
>+    let details_1 = html_common.convertDartToNative_Dictionary(details);
>+    this[_requestAutocomplete_1](details_1);
>+    return;
>+  }
>+  [_requestAutocomplete_1](...args) {
>+    return this.requestAutocomplete.apply(this, args);
>+  }
>+  [$reset](...args) {
>+    return this.reset.apply(this, args);
>+  }
>+  [$submit](...args) {
>+    return this.submit.apply(this, args);
>+  }
>+};
>+(html$.FormElement.created = function() {
>+  this[acceptCharset] = null;
>+  this[action] = null;
>+  this[autocomplete$] = null;
>+  this[encoding$0] = null;
>+  this[enctype] = null;
>+  this[length$8] = null;
>+  this[method] = null;
>+  this[name$17] = null;
>+  this[noValidate] = null;
>+  this[target$2] = null;
>+  html$.FormElement.__proto__.created.call(this);
>+}).prototype = html$.FormElement.prototype;
>+dart.addTypeTests(html$.FormElement);
>+const acceptCharset = Symbol("FormElement.acceptCharset");
>+const action = Symbol("FormElement.action");
>+const autocomplete$ = Symbol("FormElement.autocomplete");
>+const encoding$0 = Symbol("FormElement.encoding");
>+const enctype = Symbol("FormElement.enctype");
>+const length$8 = Symbol("FormElement.length");
>+const method = Symbol("FormElement.method");
>+const name$17 = Symbol("FormElement.name");
>+const noValidate = Symbol("FormElement.noValidate");
>+const target$2 = Symbol("FormElement.target");
>+dart.setMethodSignature(html$.FormElement, () => ({
>+  __proto__: dart.getMethods(html$.FormElement.__proto__),
>+  [__getter__]: dart.fnType(core.Object, [core.String]),
>+  [$checkValidity]: dart.fnType(core.bool, []),
>+  [$item]: dart.fnType(html$.Element, [core.int]),
>+  [$reportValidity]: dart.fnType(core.bool, []),
>+  [$requestAutocomplete]: dart.fnType(dart.void, [core.Map]),
>+  [_requestAutocomplete_1]: dart.fnType(dart.void, [dart.dynamic]),
>+  [$reset]: dart.fnType(dart.void, []),
>+  [$submit]: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(html$.FormElement, "dart:html");
>+dart.setFieldSignature(html$.FormElement, () => ({
>+  __proto__: dart.getFields(html$.FormElement.__proto__),
>+  [$acceptCharset]: dart.fieldType(core.String),
>+  [$action]: dart.fieldType(core.String),
>+  [$autocomplete]: dart.fieldType(core.String),
>+  [$encoding]: dart.fieldType(core.String),
>+  [$enctype]: dart.fieldType(core.String),
>+  [$length]: dart.finalFieldType(core.int),
>+  [$method]: dart.fieldType(core.String),
>+  [$name]: dart.fieldType(core.String),
>+  [$noValidate]: dart.fieldType(core.bool),
>+  [$target]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("HTMLFormElement", html$.FormElement);
>+html$.Gamepad = class Gamepad extends _interceptors.Interceptor {
>+  get [$axes]() {
>+    return this.axes;
>+  }
>+  get [$buttons]() {
>+    return this.buttons;
>+  }
>+  get [$connected]() {
>+    return this.connected;
>+  }
>+  get [$displayId]() {
>+    return this.displayId;
>+  }
>+  get [$hand]() {
>+    return this.hand;
>+  }
>+  get [$id]() {
>+    return this.id;
>+  }
>+  get [$index]() {
>+    return this.index;
>+  }
>+  get [$mapping]() {
>+    return this.mapping;
>+  }
>+  get [$pose]() {
>+    return this.pose;
>+  }
>+  get [$timestamp]() {
>+    return this.timestamp;
>+  }
>+};
>+dart.addTypeTests(html$.Gamepad);
>+const axes = Symbol("Gamepad.axes");
>+const buttons = Symbol("Gamepad.buttons");
>+const connected = Symbol("Gamepad.connected");
>+const displayId = Symbol("Gamepad.displayId");
>+const hand = Symbol("Gamepad.hand");
>+const id$6 = Symbol("Gamepad.id");
>+const index = Symbol("Gamepad.index");
>+const mapping = Symbol("Gamepad.mapping");
>+const pose = Symbol("Gamepad.pose");
>+const timestamp$ = Symbol("Gamepad.timestamp");
>+dart.setLibraryUri(html$.Gamepad, "dart:html");
>+dart.setFieldSignature(html$.Gamepad, () => ({
>+  __proto__: dart.getFields(html$.Gamepad.__proto__),
>+  [$axes]: dart.finalFieldType(ListOfnum()),
>+  [$buttons]: dart.finalFieldType(ListOfGamepadButton()),
>+  [$connected]: dart.finalFieldType(core.bool),
>+  [$displayId]: dart.finalFieldType(core.int),
>+  [$hand]: dart.finalFieldType(core.String),
>+  [$id]: dart.finalFieldType(core.String),
>+  [$index]: dart.finalFieldType(core.int),
>+  [$mapping]: dart.finalFieldType(core.String),
>+  [$pose]: dart.finalFieldType(html$.GamepadPose),
>+  [$timestamp]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("Gamepad", html$.Gamepad);
>+html$.GamepadButton = class GamepadButton extends _interceptors.Interceptor {
>+  get [$pressed]() {
>+    return this.pressed;
>+  }
>+  get [$touched]() {
>+    return this.touched;
>+  }
>+  get [$value]() {
>+    return this.value;
>+  }
>+};
>+dart.addTypeTests(html$.GamepadButton);
>+const pressed$ = Symbol("GamepadButton.pressed");
>+const touched = Symbol("GamepadButton.touched");
>+const value$6 = Symbol("GamepadButton.value");
>+dart.setLibraryUri(html$.GamepadButton, "dart:html");
>+dart.setFieldSignature(html$.GamepadButton, () => ({
>+  __proto__: dart.getFields(html$.GamepadButton.__proto__),
>+  [$pressed]: dart.finalFieldType(core.bool),
>+  [$touched]: dart.finalFieldType(core.bool),
>+  [$value]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("GamepadButton", html$.GamepadButton);
>+html$.GamepadEvent = class GamepadEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.GamepadEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.GamepadEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new GamepadEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new GamepadEvent(type);
>+  }
>+  get [$gamepad]() {
>+    return this.gamepad;
>+  }
>+};
>+dart.addTypeTests(html$.GamepadEvent);
>+const gamepad = Symbol("GamepadEvent.gamepad");
>+dart.setLibraryUri(html$.GamepadEvent, "dart:html");
>+dart.setFieldSignature(html$.GamepadEvent, () => ({
>+  __proto__: dart.getFields(html$.GamepadEvent.__proto__),
>+  [$gamepad]: dart.finalFieldType(html$.Gamepad)
>+}));
>+dart.registerExtension("GamepadEvent", html$.GamepadEvent);
>+html$.GamepadPose = class GamepadPose extends _interceptors.Interceptor {
>+  get [$angularAcceleration]() {
>+    return this.angularAcceleration;
>+  }
>+  get [$angularVelocity]() {
>+    return this.angularVelocity;
>+  }
>+  get [$hasOrientation]() {
>+    return this.hasOrientation;
>+  }
>+  get [$hasPosition]() {
>+    return this.hasPosition;
>+  }
>+  get [$linearAcceleration]() {
>+    return this.linearAcceleration;
>+  }
>+  get [$linearVelocity]() {
>+    return this.linearVelocity;
>+  }
>+  get [$orientation]() {
>+    return this.orientation;
>+  }
>+  get [$position]() {
>+    return this.position;
>+  }
>+};
>+dart.addTypeTests(html$.GamepadPose);
>+const angularAcceleration = Symbol("GamepadPose.angularAcceleration");
>+const angularVelocity = Symbol("GamepadPose.angularVelocity");
>+const hasOrientation = Symbol("GamepadPose.hasOrientation");
>+const hasPosition = Symbol("GamepadPose.hasPosition");
>+const linearAcceleration = Symbol("GamepadPose.linearAcceleration");
>+const linearVelocity = Symbol("GamepadPose.linearVelocity");
>+const orientation$ = Symbol("GamepadPose.orientation");
>+const position$ = Symbol("GamepadPose.position");
>+dart.setLibraryUri(html$.GamepadPose, "dart:html");
>+dart.setFieldSignature(html$.GamepadPose, () => ({
>+  __proto__: dart.getFields(html$.GamepadPose.__proto__),
>+  [$angularAcceleration]: dart.finalFieldType(typed_data.Float32List),
>+  [$angularVelocity]: dart.finalFieldType(typed_data.Float32List),
>+  [$hasOrientation]: dart.finalFieldType(core.bool),
>+  [$hasPosition]: dart.finalFieldType(core.bool),
>+  [$linearAcceleration]: dart.finalFieldType(typed_data.Float32List),
>+  [$linearVelocity]: dart.finalFieldType(typed_data.Float32List),
>+  [$orientation]: dart.finalFieldType(typed_data.Float32List),
>+  [$position]: dart.finalFieldType(typed_data.Float32List)
>+}));
>+dart.registerExtension("GamepadPose", html$.GamepadPose);
>+const _ensurePosition = dart.privateName(html$, "_ensurePosition");
>+const _getCurrentPosition = dart.privateName(html$, "_getCurrentPosition");
>+const _watchPosition = dart.privateName(html$, "_watchPosition");
>+const _clearWatch = dart.privateName(html$, "_clearWatch");
>+const _getCurrentPosition_1 = dart.privateName(html$, "_getCurrentPosition_1");
>+const _getCurrentPosition_2 = dart.privateName(html$, "_getCurrentPosition_2");
>+const _getCurrentPosition_3 = dart.privateName(html$, "_getCurrentPosition_3");
>+const _watchPosition_1 = dart.privateName(html$, "_watchPosition_1");
>+const _watchPosition_2 = dart.privateName(html$, "_watchPosition_2");
>+const _watchPosition_3 = dart.privateName(html$, "_watchPosition_3");
>+html$.Geolocation = class Geolocation extends _interceptors.Interceptor {
>+  [$getCurrentPosition](opts) {
>+    let enableHighAccuracy = opts && 'enableHighAccuracy' in opts ? opts.enableHighAccuracy : null;
>+    let timeout = opts && 'timeout' in opts ? opts.timeout : null;
>+    let maximumAge = opts && 'maximumAge' in opts ? opts.maximumAge : null;
>+    let options = new _js_helper.LinkedMap.new();
>+    if (enableHighAccuracy != null) {
>+      options[$_set]("enableHighAccuracy", enableHighAccuracy);
>+    }
>+    if (timeout != null) {
>+      options[$_set]("timeout", timeout.inMilliseconds);
>+    }
>+    if (maximumAge != null) {
>+      options[$_set]("maximumAge", maximumAge.inMilliseconds);
>+    }
>+    let completer = CompleterOfGeoposition().new();
>+    try {
>+      this[_getCurrentPosition](dart.fn(position => {
>+        completer.complete(this[_ensurePosition](position));
>+      }, GeopositionToNull()), dart.fn(error => {
>+        completer.completeError(error);
>+      }, PositionErrorToNull()), options);
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      let stacktrace = dart.stackTrace(e$);
>+      completer.completeError(e, stacktrace);
>+    }
>+    return completer.future;
>+  }
>+  [$watchPosition](opts) {
>+    let enableHighAccuracy = opts && 'enableHighAccuracy' in opts ? opts.enableHighAccuracy : null;
>+    let timeout = opts && 'timeout' in opts ? opts.timeout : null;
>+    let maximumAge = opts && 'maximumAge' in opts ? opts.maximumAge : null;
>+    let options = new _js_helper.LinkedMap.new();
>+    if (enableHighAccuracy != null) {
>+      options[$_set]("enableHighAccuracy", enableHighAccuracy);
>+    }
>+    if (timeout != null) {
>+      options[$_set]("timeout", timeout.inMilliseconds);
>+    }
>+    if (maximumAge != null) {
>+      options[$_set]("maximumAge", maximumAge.inMilliseconds);
>+    }
>+    let watchId = null;
>+    let controller = null;
>+    controller = StreamControllerOfGeoposition().new({sync: true, onListen: dart.fn(() => {
>+        if (!(watchId == null)) dart.assertFailed(null, "dart:html", 16185, 18, "watchId == null");
>+        watchId = this[_watchPosition](dart.fn(position => {
>+          controller.add(this[_ensurePosition](position));
>+        }, GeopositionToNull()), dart.fn(error => {
>+          controller.addError(error);
>+        }, PositionErrorToNull()), options);
>+      }, VoidToNull()), onCancel: dart.fn(() => {
>+        if (!(watchId != null)) dart.assertFailed(null, "dart:html", 16193, 18, "watchId != null");
>+        this[_clearWatch](watchId);
>+      }, VoidToNull())});
>+    return controller.stream;
>+  }
>+  [_ensurePosition](domPosition) {
>+    try {
>+      if (html$.Geoposition.is(domPosition)) {
>+        return domPosition;
>+      }
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+    }
>+    return new html$._GeopositionWrapper.new(domPosition);
>+  }
>+  [_clearWatch](...args) {
>+    return this.clearWatch.apply(this, args);
>+  }
>+  [_getCurrentPosition](successCallback, errorCallback, options) {
>+    if (errorCallback === void 0) errorCallback = null;
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let successCallback_1 = _js_helper.convertDartClosureToJS(GeopositionTovoid(), successCallback, 1);
>+      let options_2 = html_common.convertDartToNative_Dictionary(options);
>+      this[_getCurrentPosition_1](successCallback_1, errorCallback, options_2);
>+      return;
>+    }
>+    if (errorCallback != null) {
>+      let successCallback_1 = _js_helper.convertDartClosureToJS(GeopositionTovoid(), successCallback, 1);
>+      this[_getCurrentPosition_2](successCallback_1, errorCallback);
>+      return;
>+    }
>+    let successCallback_1 = _js_helper.convertDartClosureToJS(GeopositionTovoid(), successCallback, 1);
>+    this[_getCurrentPosition_3](successCallback_1);
>+    return;
>+  }
>+  [_getCurrentPosition_1](...args) {
>+    return this.getCurrentPosition.apply(this, args);
>+  }
>+  [_getCurrentPosition_2](...args) {
>+    return this.getCurrentPosition.apply(this, args);
>+  }
>+  [_getCurrentPosition_3](...args) {
>+    return this.getCurrentPosition.apply(this, args);
>+  }
>+  [_watchPosition](successCallback, errorCallback, options) {
>+    if (errorCallback === void 0) errorCallback = null;
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let successCallback_1 = _js_helper.convertDartClosureToJS(GeopositionTovoid(), successCallback, 1);
>+      let options_2 = html_common.convertDartToNative_Dictionary(options);
>+      return this[_watchPosition_1](successCallback_1, errorCallback, options_2);
>+    }
>+    if (errorCallback != null) {
>+      let successCallback_1 = _js_helper.convertDartClosureToJS(GeopositionTovoid(), successCallback, 1);
>+      return this[_watchPosition_2](successCallback_1, errorCallback);
>+    }
>+    let successCallback_1 = _js_helper.convertDartClosureToJS(GeopositionTovoid(), successCallback, 1);
>+    return this[_watchPosition_3](successCallback_1);
>+  }
>+  [_watchPosition_1](...args) {
>+    return this.watchPosition.apply(this, args);
>+  }
>+  [_watchPosition_2](...args) {
>+    return this.watchPosition.apply(this, args);
>+  }
>+  [_watchPosition_3](...args) {
>+    return this.watchPosition.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.Geolocation);
>+dart.setMethodSignature(html$.Geolocation, () => ({
>+  __proto__: dart.getMethods(html$.Geolocation.__proto__),
>+  [$getCurrentPosition]: dart.fnType(async.Future$(html$.Geoposition), [], {enableHighAccuracy: core.bool, timeout: core.Duration, maximumAge: core.Duration}),
>+  [$watchPosition]: dart.fnType(async.Stream$(html$.Geoposition), [], {enableHighAccuracy: core.bool, timeout: core.Duration, maximumAge: core.Duration}),
>+  [_ensurePosition]: dart.fnType(html$.Geoposition, [dart.dynamic]),
>+  [_clearWatch]: dart.fnType(dart.void, [core.int]),
>+  [_getCurrentPosition]: dart.fnType(dart.void, [dart.fnType(dart.void, [html$.Geoposition])], [dart.fnType(dart.void, [html$.PositionError]), core.Map]),
>+  [_getCurrentPosition_1]: dart.fnType(dart.void, [dart.dynamic, dart.fnType(dart.void, [html$.PositionError]), dart.dynamic]),
>+  [_getCurrentPosition_2]: dart.fnType(dart.void, [dart.dynamic, dart.fnType(dart.void, [html$.PositionError])]),
>+  [_getCurrentPosition_3]: dart.fnType(dart.void, [dart.dynamic]),
>+  [_watchPosition]: dart.fnType(core.int, [dart.fnType(dart.void, [html$.Geoposition])], [dart.fnType(dart.void, [html$.PositionError]), core.Map]),
>+  [_watchPosition_1]: dart.fnType(core.int, [dart.dynamic, dart.fnType(dart.void, [html$.PositionError]), dart.dynamic]),
>+  [_watchPosition_2]: dart.fnType(core.int, [dart.dynamic, dart.fnType(dart.void, [html$.PositionError])]),
>+  [_watchPosition_3]: dart.fnType(core.int, [dart.dynamic])
>+}));
>+dart.setLibraryUri(html$.Geolocation, "dart:html");
>+dart.registerExtension("Geolocation", html$.Geolocation);
>+html$._GeopositionWrapper = class _GeopositionWrapper extends core.Object {
>+  get coords() {
>+    return this[_ptr].coords;
>+  }
>+  get timestamp() {
>+    return this[_ptr].timestamp;
>+  }
>+};
>+(html$._GeopositionWrapper.new = function(ptr) {
>+  this[_ptr] = ptr;
>+}).prototype = html$._GeopositionWrapper.prototype;
>+dart.addTypeTests(html$._GeopositionWrapper);
>+html$._GeopositionWrapper[dart.implements] = () => [html$.Geoposition];
>+dart.setGetterSignature(html$._GeopositionWrapper, () => ({
>+  __proto__: dart.getGetters(html$._GeopositionWrapper.__proto__),
>+  coords: html$.Coordinates,
>+  [$coords]: html$.Coordinates,
>+  timestamp: core.int,
>+  [$timestamp]: core.int
>+}));
>+dart.setLibraryUri(html$._GeopositionWrapper, "dart:html");
>+dart.setFieldSignature(html$._GeopositionWrapper, () => ({
>+  __proto__: dart.getFields(html$._GeopositionWrapper.__proto__),
>+  [_ptr]: dart.fieldType(dart.dynamic)
>+}));
>+dart.defineExtensionAccessors(html$._GeopositionWrapper, ['coords', 'timestamp']);
>+html$.Geoposition = class Geoposition extends _interceptors.Interceptor {
>+  get [$coords]() {
>+    return this.coords;
>+  }
>+  get [$timestamp]() {
>+    return this.timestamp;
>+  }
>+};
>+dart.addTypeTests(html$.Geoposition);
>+const coords$ = Symbol("Geoposition.coords");
>+const timestamp$0 = Symbol("Geoposition.timestamp");
>+dart.setLibraryUri(html$.Geoposition, "dart:html");
>+dart.setFieldSignature(html$.Geoposition, () => ({
>+  __proto__: dart.getFields(html$.Geoposition.__proto__),
>+  [$coords]: dart.finalFieldType(html$.Coordinates),
>+  [$timestamp]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("Position", html$.Geoposition);
>+html$.GlobalEventHandlers = class GlobalEventHandlers extends core.Object {
>+  get onAbort() {
>+    return html$.GlobalEventHandlers.abortEvent.forTarget(this);
>+  }
>+  get onBlur() {
>+    return html$.GlobalEventHandlers.blurEvent.forTarget(this);
>+  }
>+  get onCanPlay() {
>+    return html$.GlobalEventHandlers.canPlayEvent.forTarget(this);
>+  }
>+  get onCanPlayThrough() {
>+    return html$.GlobalEventHandlers.canPlayThroughEvent.forTarget(this);
>+  }
>+  get onChange() {
>+    return html$.GlobalEventHandlers.changeEvent.forTarget(this);
>+  }
>+  get onClick() {
>+    return html$.GlobalEventHandlers.clickEvent.forTarget(this);
>+  }
>+  get onContextMenu() {
>+    return html$.GlobalEventHandlers.contextMenuEvent.forTarget(this);
>+  }
>+  get onDoubleClick() {
>+    return html$.GlobalEventHandlers.doubleClickEvent.forTarget(this);
>+  }
>+  get onDrag() {
>+    return html$.GlobalEventHandlers.dragEvent.forTarget(this);
>+  }
>+  get onDragEnd() {
>+    return html$.GlobalEventHandlers.dragEndEvent.forTarget(this);
>+  }
>+  get onDragEnter() {
>+    return html$.GlobalEventHandlers.dragEnterEvent.forTarget(this);
>+  }
>+  get onDragLeave() {
>+    return html$.GlobalEventHandlers.dragLeaveEvent.forTarget(this);
>+  }
>+  get onDragOver() {
>+    return html$.GlobalEventHandlers.dragOverEvent.forTarget(this);
>+  }
>+  get onDragStart() {
>+    return html$.GlobalEventHandlers.dragStartEvent.forTarget(this);
>+  }
>+  get onDrop() {
>+    return html$.GlobalEventHandlers.dropEvent.forTarget(this);
>+  }
>+  get onDurationChange() {
>+    return html$.GlobalEventHandlers.durationChangeEvent.forTarget(this);
>+  }
>+  get onEmptied() {
>+    return html$.GlobalEventHandlers.emptiedEvent.forTarget(this);
>+  }
>+  get onEnded() {
>+    return html$.GlobalEventHandlers.endedEvent.forTarget(this);
>+  }
>+  get onError() {
>+    return html$.GlobalEventHandlers.errorEvent.forTarget(this);
>+  }
>+  get onFocus() {
>+    return html$.GlobalEventHandlers.focusEvent.forTarget(this);
>+  }
>+  get onInput() {
>+    return html$.GlobalEventHandlers.inputEvent.forTarget(this);
>+  }
>+  get onInvalid() {
>+    return html$.GlobalEventHandlers.invalidEvent.forTarget(this);
>+  }
>+  get onKeyDown() {
>+    return html$.GlobalEventHandlers.keyDownEvent.forTarget(this);
>+  }
>+  get onKeyPress() {
>+    return html$.GlobalEventHandlers.keyPressEvent.forTarget(this);
>+  }
>+  get onKeyUp() {
>+    return html$.GlobalEventHandlers.keyUpEvent.forTarget(this);
>+  }
>+  get onLoad() {
>+    return html$.GlobalEventHandlers.loadEvent.forTarget(this);
>+  }
>+  get onLoadedData() {
>+    return html$.GlobalEventHandlers.loadedDataEvent.forTarget(this);
>+  }
>+  get onLoadedMetadata() {
>+    return html$.GlobalEventHandlers.loadedMetadataEvent.forTarget(this);
>+  }
>+  get onMouseDown() {
>+    return html$.GlobalEventHandlers.mouseDownEvent.forTarget(this);
>+  }
>+  get onMouseEnter() {
>+    return html$.GlobalEventHandlers.mouseEnterEvent.forTarget(this);
>+  }
>+  get onMouseLeave() {
>+    return html$.GlobalEventHandlers.mouseLeaveEvent.forTarget(this);
>+  }
>+  get onMouseMove() {
>+    return html$.GlobalEventHandlers.mouseMoveEvent.forTarget(this);
>+  }
>+  get onMouseOut() {
>+    return html$.GlobalEventHandlers.mouseOutEvent.forTarget(this);
>+  }
>+  get onMouseOver() {
>+    return html$.GlobalEventHandlers.mouseOverEvent.forTarget(this);
>+  }
>+  get onMouseUp() {
>+    return html$.GlobalEventHandlers.mouseUpEvent.forTarget(this);
>+  }
>+  get onMouseWheel() {
>+    return html$.GlobalEventHandlers.mouseWheelEvent.forTarget(this);
>+  }
>+  get onPause() {
>+    return html$.GlobalEventHandlers.pauseEvent.forTarget(this);
>+  }
>+  get onPlay() {
>+    return html$.GlobalEventHandlers.playEvent.forTarget(this);
>+  }
>+  get onPlaying() {
>+    return html$.GlobalEventHandlers.playingEvent.forTarget(this);
>+  }
>+  get onRateChange() {
>+    return html$.GlobalEventHandlers.rateChangeEvent.forTarget(this);
>+  }
>+  get onReset() {
>+    return html$.GlobalEventHandlers.resetEvent.forTarget(this);
>+  }
>+  get onResize() {
>+    return html$.GlobalEventHandlers.resizeEvent.forTarget(this);
>+  }
>+  get onScroll() {
>+    return html$.GlobalEventHandlers.scrollEvent.forTarget(this);
>+  }
>+  get onSeeked() {
>+    return html$.GlobalEventHandlers.seekedEvent.forTarget(this);
>+  }
>+  get onSeeking() {
>+    return html$.GlobalEventHandlers.seekingEvent.forTarget(this);
>+  }
>+  get onSelect() {
>+    return html$.GlobalEventHandlers.selectEvent.forTarget(this);
>+  }
>+  get onStalled() {
>+    return html$.GlobalEventHandlers.stalledEvent.forTarget(this);
>+  }
>+  get onSubmit() {
>+    return html$.GlobalEventHandlers.submitEvent.forTarget(this);
>+  }
>+  get onSuspend() {
>+    return html$.GlobalEventHandlers.suspendEvent.forTarget(this);
>+  }
>+  get onTimeUpdate() {
>+    return html$.GlobalEventHandlers.timeUpdateEvent.forTarget(this);
>+  }
>+  get onTouchCancel() {
>+    return html$.GlobalEventHandlers.touchCancelEvent.forTarget(this);
>+  }
>+  get onTouchEnd() {
>+    return html$.GlobalEventHandlers.touchEndEvent.forTarget(this);
>+  }
>+  get onTouchMove() {
>+    return html$.GlobalEventHandlers.touchMoveEvent.forTarget(this);
>+  }
>+  get onTouchStart() {
>+    return html$.GlobalEventHandlers.touchStartEvent.forTarget(this);
>+  }
>+  get onVolumeChange() {
>+    return html$.GlobalEventHandlers.volumeChangeEvent.forTarget(this);
>+  }
>+  get onWaiting() {
>+    return html$.GlobalEventHandlers.waitingEvent.forTarget(this);
>+  }
>+  get onWheel() {
>+    return html$.GlobalEventHandlers.wheelEvent.forTarget(this);
>+  }
>+};
>+(html$.GlobalEventHandlers[dart.mixinNew] = function() {
>+}).prototype = html$.GlobalEventHandlers.prototype;
>+dart.addTypeTests(html$.GlobalEventHandlers);
>+html$.GlobalEventHandlers[dart.implements] = () => [html$.EventTarget];
>+dart.setGetterSignature(html$.GlobalEventHandlers, () => ({
>+  __proto__: dart.getGetters(html$.GlobalEventHandlers.__proto__),
>+  onAbort: async.Stream$(html$.Event),
>+  [$onAbort]: async.Stream$(html$.Event),
>+  onBlur: async.Stream$(html$.Event),
>+  [$onBlur]: async.Stream$(html$.Event),
>+  onCanPlay: async.Stream$(html$.Event),
>+  [$onCanPlay]: async.Stream$(html$.Event),
>+  onCanPlayThrough: async.Stream$(html$.Event),
>+  [$onCanPlayThrough]: async.Stream$(html$.Event),
>+  onChange: async.Stream$(html$.Event),
>+  [$onChange]: async.Stream$(html$.Event),
>+  onClick: async.Stream$(html$.MouseEvent),
>+  [$onClick]: async.Stream$(html$.MouseEvent),
>+  onContextMenu: async.Stream$(html$.MouseEvent),
>+  [$onContextMenu]: async.Stream$(html$.MouseEvent),
>+  onDoubleClick: async.Stream$(html$.Event),
>+  [$onDoubleClick]: async.Stream$(html$.Event),
>+  onDrag: async.Stream$(html$.MouseEvent),
>+  [$onDrag]: async.Stream$(html$.MouseEvent),
>+  onDragEnd: async.Stream$(html$.MouseEvent),
>+  [$onDragEnd]: async.Stream$(html$.MouseEvent),
>+  onDragEnter: async.Stream$(html$.MouseEvent),
>+  [$onDragEnter]: async.Stream$(html$.MouseEvent),
>+  onDragLeave: async.Stream$(html$.MouseEvent),
>+  [$onDragLeave]: async.Stream$(html$.MouseEvent),
>+  onDragOver: async.Stream$(html$.MouseEvent),
>+  [$onDragOver]: async.Stream$(html$.MouseEvent),
>+  onDragStart: async.Stream$(html$.MouseEvent),
>+  [$onDragStart]: async.Stream$(html$.MouseEvent),
>+  onDrop: async.Stream$(html$.MouseEvent),
>+  [$onDrop]: async.Stream$(html$.MouseEvent),
>+  onDurationChange: async.Stream$(html$.Event),
>+  [$onDurationChange]: async.Stream$(html$.Event),
>+  onEmptied: async.Stream$(html$.Event),
>+  [$onEmptied]: async.Stream$(html$.Event),
>+  onEnded: async.Stream$(html$.Event),
>+  [$onEnded]: async.Stream$(html$.Event),
>+  onError: async.Stream$(html$.Event),
>+  [$onError]: async.Stream$(html$.Event),
>+  onFocus: async.Stream$(html$.Event),
>+  [$onFocus]: async.Stream$(html$.Event),
>+  onInput: async.Stream$(html$.Event),
>+  [$onInput]: async.Stream$(html$.Event),
>+  onInvalid: async.Stream$(html$.Event),
>+  [$onInvalid]: async.Stream$(html$.Event),
>+  onKeyDown: async.Stream$(html$.KeyboardEvent),
>+  [$onKeyDown]: async.Stream$(html$.KeyboardEvent),
>+  onKeyPress: async.Stream$(html$.KeyboardEvent),
>+  [$onKeyPress]: async.Stream$(html$.KeyboardEvent),
>+  onKeyUp: async.Stream$(html$.KeyboardEvent),
>+  [$onKeyUp]: async.Stream$(html$.KeyboardEvent),
>+  onLoad: async.Stream$(html$.Event),
>+  [$onLoad]: async.Stream$(html$.Event),
>+  onLoadedData: async.Stream$(html$.Event),
>+  [$onLoadedData]: async.Stream$(html$.Event),
>+  onLoadedMetadata: async.Stream$(html$.Event),
>+  [$onLoadedMetadata]: async.Stream$(html$.Event),
>+  onMouseDown: async.Stream$(html$.MouseEvent),
>+  [$onMouseDown]: async.Stream$(html$.MouseEvent),
>+  onMouseEnter: async.Stream$(html$.MouseEvent),
>+  [$onMouseEnter]: async.Stream$(html$.MouseEvent),
>+  onMouseLeave: async.Stream$(html$.MouseEvent),
>+  [$onMouseLeave]: async.Stream$(html$.MouseEvent),
>+  onMouseMove: async.Stream$(html$.MouseEvent),
>+  [$onMouseMove]: async.Stream$(html$.MouseEvent),
>+  onMouseOut: async.Stream$(html$.MouseEvent),
>+  [$onMouseOut]: async.Stream$(html$.MouseEvent),
>+  onMouseOver: async.Stream$(html$.MouseEvent),
>+  [$onMouseOver]: async.Stream$(html$.MouseEvent),
>+  onMouseUp: async.Stream$(html$.MouseEvent),
>+  [$onMouseUp]: async.Stream$(html$.MouseEvent),
>+  onMouseWheel: async.Stream$(html$.WheelEvent),
>+  [$onMouseWheel]: async.Stream$(html$.WheelEvent),
>+  onPause: async.Stream$(html$.Event),
>+  [$onPause]: async.Stream$(html$.Event),
>+  onPlay: async.Stream$(html$.Event),
>+  [$onPlay]: async.Stream$(html$.Event),
>+  onPlaying: async.Stream$(html$.Event),
>+  [$onPlaying]: async.Stream$(html$.Event),
>+  onRateChange: async.Stream$(html$.Event),
>+  [$onRateChange]: async.Stream$(html$.Event),
>+  onReset: async.Stream$(html$.Event),
>+  [$onReset]: async.Stream$(html$.Event),
>+  onResize: async.Stream$(html$.Event),
>+  [$onResize]: async.Stream$(html$.Event),
>+  onScroll: async.Stream$(html$.Event),
>+  [$onScroll]: async.Stream$(html$.Event),
>+  onSeeked: async.Stream$(html$.Event),
>+  [$onSeeked]: async.Stream$(html$.Event),
>+  onSeeking: async.Stream$(html$.Event),
>+  [$onSeeking]: async.Stream$(html$.Event),
>+  onSelect: async.Stream$(html$.Event),
>+  [$onSelect]: async.Stream$(html$.Event),
>+  onStalled: async.Stream$(html$.Event),
>+  [$onStalled]: async.Stream$(html$.Event),
>+  onSubmit: async.Stream$(html$.Event),
>+  [$onSubmit]: async.Stream$(html$.Event),
>+  onSuspend: async.Stream$(html$.Event),
>+  [$onSuspend]: async.Stream$(html$.Event),
>+  onTimeUpdate: async.Stream$(html$.Event),
>+  [$onTimeUpdate]: async.Stream$(html$.Event),
>+  onTouchCancel: async.Stream$(html$.TouchEvent),
>+  [$onTouchCancel]: async.Stream$(html$.TouchEvent),
>+  onTouchEnd: async.Stream$(html$.TouchEvent),
>+  [$onTouchEnd]: async.Stream$(html$.TouchEvent),
>+  onTouchMove: async.Stream$(html$.TouchEvent),
>+  [$onTouchMove]: async.Stream$(html$.TouchEvent),
>+  onTouchStart: async.Stream$(html$.TouchEvent),
>+  [$onTouchStart]: async.Stream$(html$.TouchEvent),
>+  onVolumeChange: async.Stream$(html$.Event),
>+  [$onVolumeChange]: async.Stream$(html$.Event),
>+  onWaiting: async.Stream$(html$.Event),
>+  [$onWaiting]: async.Stream$(html$.Event),
>+  onWheel: async.Stream$(html$.WheelEvent),
>+  [$onWheel]: async.Stream$(html$.WheelEvent)
>+}));
>+dart.setLibraryUri(html$.GlobalEventHandlers, "dart:html");
>+dart.defineExtensionAccessors(html$.GlobalEventHandlers, [
>+  'onAbort',
>+  'onBlur',
>+  'onCanPlay',
>+  'onCanPlayThrough',
>+  'onChange',
>+  'onClick',
>+  'onContextMenu',
>+  'onDoubleClick',
>+  'onDrag',
>+  'onDragEnd',
>+  'onDragEnter',
>+  'onDragLeave',
>+  'onDragOver',
>+  'onDragStart',
>+  'onDrop',
>+  'onDurationChange',
>+  'onEmptied',
>+  'onEnded',
>+  'onError',
>+  'onFocus',
>+  'onInput',
>+  'onInvalid',
>+  'onKeyDown',
>+  'onKeyPress',
>+  'onKeyUp',
>+  'onLoad',
>+  'onLoadedData',
>+  'onLoadedMetadata',
>+  'onMouseDown',
>+  'onMouseEnter',
>+  'onMouseLeave',
>+  'onMouseMove',
>+  'onMouseOut',
>+  'onMouseOver',
>+  'onMouseUp',
>+  'onMouseWheel',
>+  'onPause',
>+  'onPlay',
>+  'onPlaying',
>+  'onRateChange',
>+  'onReset',
>+  'onResize',
>+  'onScroll',
>+  'onSeeked',
>+  'onSeeking',
>+  'onSelect',
>+  'onStalled',
>+  'onSubmit',
>+  'onSuspend',
>+  'onTimeUpdate',
>+  'onTouchCancel',
>+  'onTouchEnd',
>+  'onTouchMove',
>+  'onTouchStart',
>+  'onVolumeChange',
>+  'onWaiting',
>+  'onWheel'
>+]);
>+dart.defineLazy(html$.GlobalEventHandlers, {
>+  /*html$.GlobalEventHandlers.abortEvent*/get abortEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("abort"));
>+  },
>+  /*html$.GlobalEventHandlers.blurEvent*/get blurEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("blur"));
>+  },
>+  /*html$.GlobalEventHandlers.canPlayEvent*/get canPlayEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("canplay"));
>+  },
>+  /*html$.GlobalEventHandlers.canPlayThroughEvent*/get canPlayThroughEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("canplaythrough"));
>+  },
>+  /*html$.GlobalEventHandlers.changeEvent*/get changeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("change"));
>+  },
>+  /*html$.GlobalEventHandlers.clickEvent*/get clickEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("click"));
>+  },
>+  /*html$.GlobalEventHandlers.contextMenuEvent*/get contextMenuEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("contextmenu"));
>+  },
>+  /*html$.GlobalEventHandlers.doubleClickEvent*/get doubleClickEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("dblclick"));
>+  },
>+  /*html$.GlobalEventHandlers.dragEvent*/get dragEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("drag"));
>+  },
>+  /*html$.GlobalEventHandlers.dragEndEvent*/get dragEndEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("dragend"));
>+  },
>+  /*html$.GlobalEventHandlers.dragEnterEvent*/get dragEnterEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("dragenter"));
>+  },
>+  /*html$.GlobalEventHandlers.dragLeaveEvent*/get dragLeaveEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("dragleave"));
>+  },
>+  /*html$.GlobalEventHandlers.dragOverEvent*/get dragOverEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("dragover"));
>+  },
>+  /*html$.GlobalEventHandlers.dragStartEvent*/get dragStartEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("dragstart"));
>+  },
>+  /*html$.GlobalEventHandlers.dropEvent*/get dropEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("drop"));
>+  },
>+  /*html$.GlobalEventHandlers.durationChangeEvent*/get durationChangeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("durationchange"));
>+  },
>+  /*html$.GlobalEventHandlers.emptiedEvent*/get emptiedEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("emptied"));
>+  },
>+  /*html$.GlobalEventHandlers.endedEvent*/get endedEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("ended"));
>+  },
>+  /*html$.GlobalEventHandlers.errorEvent*/get errorEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("error"));
>+  },
>+  /*html$.GlobalEventHandlers.focusEvent*/get focusEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("focus"));
>+  },
>+  /*html$.GlobalEventHandlers.inputEvent*/get inputEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("input"));
>+  },
>+  /*html$.GlobalEventHandlers.invalidEvent*/get invalidEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("invalid"));
>+  },
>+  /*html$.GlobalEventHandlers.keyDownEvent*/get keyDownEvent() {
>+    return dart.const(new (EventStreamProviderOfKeyboardEvent()).new("keydown"));
>+  },
>+  /*html$.GlobalEventHandlers.keyPressEvent*/get keyPressEvent() {
>+    return dart.const(new (EventStreamProviderOfKeyboardEvent()).new("keypress"));
>+  },
>+  /*html$.GlobalEventHandlers.keyUpEvent*/get keyUpEvent() {
>+    return dart.const(new (EventStreamProviderOfKeyboardEvent()).new("keyup"));
>+  },
>+  /*html$.GlobalEventHandlers.loadEvent*/get loadEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("load"));
>+  },
>+  /*html$.GlobalEventHandlers.loadedDataEvent*/get loadedDataEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("loadeddata"));
>+  },
>+  /*html$.GlobalEventHandlers.loadedMetadataEvent*/get loadedMetadataEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("loadedmetadata"));
>+  },
>+  /*html$.GlobalEventHandlers.mouseDownEvent*/get mouseDownEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("mousedown"));
>+  },
>+  /*html$.GlobalEventHandlers.mouseEnterEvent*/get mouseEnterEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("mouseenter"));
>+  },
>+  /*html$.GlobalEventHandlers.mouseLeaveEvent*/get mouseLeaveEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("mouseleave"));
>+  },
>+  /*html$.GlobalEventHandlers.mouseMoveEvent*/get mouseMoveEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("mousemove"));
>+  },
>+  /*html$.GlobalEventHandlers.mouseOutEvent*/get mouseOutEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("mouseout"));
>+  },
>+  /*html$.GlobalEventHandlers.mouseOverEvent*/get mouseOverEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("mouseover"));
>+  },
>+  /*html$.GlobalEventHandlers.mouseUpEvent*/get mouseUpEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("mouseup"));
>+  },
>+  /*html$.GlobalEventHandlers.mouseWheelEvent*/get mouseWheelEvent() {
>+    return dart.const(new (EventStreamProviderOfWheelEvent()).new("mousewheel"));
>+  },
>+  /*html$.GlobalEventHandlers.pauseEvent*/get pauseEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("pause"));
>+  },
>+  /*html$.GlobalEventHandlers.playEvent*/get playEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("play"));
>+  },
>+  /*html$.GlobalEventHandlers.playingEvent*/get playingEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("playing"));
>+  },
>+  /*html$.GlobalEventHandlers.rateChangeEvent*/get rateChangeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("ratechange"));
>+  },
>+  /*html$.GlobalEventHandlers.resetEvent*/get resetEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("reset"));
>+  },
>+  /*html$.GlobalEventHandlers.resizeEvent*/get resizeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("resize"));
>+  },
>+  /*html$.GlobalEventHandlers.scrollEvent*/get scrollEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("scroll"));
>+  },
>+  /*html$.GlobalEventHandlers.seekedEvent*/get seekedEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("seeked"));
>+  },
>+  /*html$.GlobalEventHandlers.seekingEvent*/get seekingEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("seeking"));
>+  },
>+  /*html$.GlobalEventHandlers.selectEvent*/get selectEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("select"));
>+  },
>+  /*html$.GlobalEventHandlers.stalledEvent*/get stalledEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("stalled"));
>+  },
>+  /*html$.GlobalEventHandlers.submitEvent*/get submitEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("submit"));
>+  },
>+  /*html$.GlobalEventHandlers.suspendEvent*/get suspendEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("suspend"));
>+  },
>+  /*html$.GlobalEventHandlers.timeUpdateEvent*/get timeUpdateEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("timeupdate"));
>+  },
>+  /*html$.GlobalEventHandlers.touchCancelEvent*/get touchCancelEvent() {
>+    return dart.const(new (EventStreamProviderOfTouchEvent()).new("touchcancel"));
>+  },
>+  /*html$.GlobalEventHandlers.touchEndEvent*/get touchEndEvent() {
>+    return dart.const(new (EventStreamProviderOfTouchEvent()).new("touchend"));
>+  },
>+  /*html$.GlobalEventHandlers.touchMoveEvent*/get touchMoveEvent() {
>+    return dart.const(new (EventStreamProviderOfTouchEvent()).new("touchmove"));
>+  },
>+  /*html$.GlobalEventHandlers.touchStartEvent*/get touchStartEvent() {
>+    return dart.const(new (EventStreamProviderOfTouchEvent()).new("touchstart"));
>+  },
>+  /*html$.GlobalEventHandlers.volumeChangeEvent*/get volumeChangeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("volumechange"));
>+  },
>+  /*html$.GlobalEventHandlers.waitingEvent*/get waitingEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("waiting"));
>+  },
>+  /*html$.GlobalEventHandlers.wheelEvent*/get wheelEvent() {
>+    return dart.const(new (EventStreamProviderOfWheelEvent()).new("wheel"));
>+  }
>+});
>+html$.Gyroscope = class Gyroscope$ extends html$.Sensor {
>+  static new(sensorOptions) {
>+    if (sensorOptions === void 0) sensorOptions = null;
>+    if (sensorOptions != null) {
>+      let sensorOptions_1 = html_common.convertDartToNative_Dictionary(sensorOptions);
>+      return html$.Gyroscope._create_1(sensorOptions_1);
>+    }
>+    return html$.Gyroscope._create_2();
>+  }
>+  static _create_1(sensorOptions) {
>+    return new Gyroscope(sensorOptions);
>+  }
>+  static _create_2() {
>+    return new Gyroscope();
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+  get [$z]() {
>+    return this.z;
>+  }
>+};
>+dart.addTypeTests(html$.Gyroscope);
>+const x$4 = Symbol("Gyroscope.x");
>+const y$4 = Symbol("Gyroscope.y");
>+const z$3 = Symbol("Gyroscope.z");
>+dart.setLibraryUri(html$.Gyroscope, "dart:html");
>+dart.setFieldSignature(html$.Gyroscope, () => ({
>+  __proto__: dart.getFields(html$.Gyroscope.__proto__),
>+  [$x]: dart.finalFieldType(core.num),
>+  [$y]: dart.finalFieldType(core.num),
>+  [$z]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("Gyroscope", html$.Gyroscope);
>+html$.HRElement = class HRElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("hr");
>+  }
>+  get [$color]() {
>+    return this.color;
>+  }
>+  set [$color](value) {
>+    this.color = value;
>+  }
>+};
>+(html$.HRElement.created = function() {
>+  this[color] = null;
>+  html$.HRElement.__proto__.created.call(this);
>+}).prototype = html$.HRElement.prototype;
>+dart.addTypeTests(html$.HRElement);
>+const color = Symbol("HRElement.color");
>+dart.setLibraryUri(html$.HRElement, "dart:html");
>+dart.setFieldSignature(html$.HRElement, () => ({
>+  __proto__: dart.getFields(html$.HRElement.__proto__),
>+  [$color]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("HTMLHRElement", html$.HRElement);
>+html$.HashChangeEvent = class HashChangeEvent$ extends html$.Event {
>+  static new(type, opts) {
>+    let canBubble = opts && 'canBubble' in opts ? opts.canBubble : true;
>+    let cancelable = opts && 'cancelable' in opts ? opts.cancelable : true;
>+    let oldUrl = opts && 'oldUrl' in opts ? opts.oldUrl : null;
>+    let newUrl = opts && 'newUrl' in opts ? opts.newUrl : null;
>+    let options = new (IdentityMapOfString$Object()).from(["canBubble", canBubble, "cancelable", cancelable, "oldURL", oldUrl, "newURL", newUrl]);
>+    return new HashChangeEvent(type, html_common.convertDartToNative_Dictionary(options));
>+  }
>+  static __(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.HashChangeEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.HashChangeEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new HashChangeEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new HashChangeEvent(type);
>+  }
>+  static get supported() {
>+    return html_common.Device.isEventTypeSupported("HashChangeEvent");
>+  }
>+  get [$newUrl]() {
>+    return this.newURL;
>+  }
>+  get [$oldUrl]() {
>+    return this.oldURL;
>+  }
>+};
>+dart.addTypeTests(html$.HashChangeEvent);
>+const newUrl = Symbol("HashChangeEvent.newUrl");
>+const oldUrl = Symbol("HashChangeEvent.oldUrl");
>+dart.setLibraryUri(html$.HashChangeEvent, "dart:html");
>+dart.setFieldSignature(html$.HashChangeEvent, () => ({
>+  __proto__: dart.getFields(html$.HashChangeEvent.__proto__),
>+  [$newUrl]: dart.finalFieldType(core.String),
>+  [$oldUrl]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("HashChangeEvent", html$.HashChangeEvent);
>+html$.HeadElement = class HeadElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("head");
>+  }
>+};
>+(html$.HeadElement.created = function() {
>+  html$.HeadElement.__proto__.created.call(this);
>+}).prototype = html$.HeadElement.prototype;
>+dart.addTypeTests(html$.HeadElement);
>+dart.setLibraryUri(html$.HeadElement, "dart:html");
>+dart.registerExtension("HTMLHeadElement", html$.HeadElement);
>+html$.Headers = class Headers$ extends _interceptors.Interceptor {
>+  static new(init) {
>+    if (init === void 0) init = null;
>+    if (init != null) {
>+      return html$.Headers._create_1(init);
>+    }
>+    return html$.Headers._create_2();
>+  }
>+  static _create_1(init) {
>+    return new Headers(init);
>+  }
>+  static _create_2() {
>+    return new Headers();
>+  }
>+};
>+dart.addTypeTests(html$.Headers);
>+dart.setLibraryUri(html$.Headers, "dart:html");
>+dart.registerExtension("Headers", html$.Headers);
>+html$.HeadingElement = class HeadingElement extends html$.HtmlElement {
>+  static h1() {
>+    return html$.document.createElement("h1");
>+  }
>+  static h2() {
>+    return html$.document.createElement("h2");
>+  }
>+  static h3() {
>+    return html$.document.createElement("h3");
>+  }
>+  static h4() {
>+    return html$.document.createElement("h4");
>+  }
>+  static h5() {
>+    return html$.document.createElement("h5");
>+  }
>+  static h6() {
>+    return html$.document.createElement("h6");
>+  }
>+};
>+(html$.HeadingElement.created = function() {
>+  html$.HeadingElement.__proto__.created.call(this);
>+}).prototype = html$.HeadingElement.prototype;
>+dart.addTypeTests(html$.HeadingElement);
>+dart.setLibraryUri(html$.HeadingElement, "dart:html");
>+dart.registerExtension("HTMLHeadingElement", html$.HeadingElement);
>+const _get_state = dart.privateName(html$, "_get_state");
>+const _pushState_1 = dart.privateName(html$, "_pushState_1");
>+const _replaceState_1 = dart.privateName(html$, "_replaceState_1");
>+html$.History = class History extends _interceptors.Interceptor {
>+  static get supportsState() {
>+    return !!window.history.pushState;
>+  }
>+  get [$length]() {
>+    return this.length;
>+  }
>+  get [$scrollRestoration]() {
>+    return this.scrollRestoration;
>+  }
>+  set [$scrollRestoration](value) {
>+    this.scrollRestoration = value;
>+  }
>+  get [$state]() {
>+    return html_common.convertNativeToDart_SerializedScriptValue(this[_get_state]);
>+  }
>+  get [_get_state]() {
>+    return this.state;
>+  }
>+  [$back](...args) {
>+    return this.back.apply(this, args);
>+  }
>+  [$forward](...args) {
>+    return this.forward.apply(this, args);
>+  }
>+  [$go](...args) {
>+    return this.go.apply(this, args);
>+  }
>+  [$pushState](data, title, url) {
>+    let data_1 = html_common.convertDartToNative_SerializedScriptValue(data);
>+    this[_pushState_1](data_1, title, url);
>+    return;
>+  }
>+  [_pushState_1](...args) {
>+    return this.pushState.apply(this, args);
>+  }
>+  [$replaceState](data, title, url) {
>+    let data_1 = html_common.convertDartToNative_SerializedScriptValue(data);
>+    this[_replaceState_1](data_1, title, url);
>+    return;
>+  }
>+  [_replaceState_1](...args) {
>+    return this.replaceState.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.History);
>+const length$9 = Symbol("History.length");
>+const scrollRestoration = Symbol("History.scrollRestoration");
>+html$.History[dart.implements] = () => [html$.HistoryBase];
>+dart.setMethodSignature(html$.History, () => ({
>+  __proto__: dart.getMethods(html$.History.__proto__),
>+  [$back]: dart.fnType(dart.void, []),
>+  [$forward]: dart.fnType(dart.void, []),
>+  [$go]: dart.fnType(dart.void, [], [core.int]),
>+  [$pushState]: dart.fnType(dart.void, [dart.dynamic, core.String, core.String]),
>+  [_pushState_1]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic]),
>+  [$replaceState]: dart.fnType(dart.void, [dart.dynamic, core.String, core.String]),
>+  [_replaceState_1]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic])
>+}));
>+dart.setGetterSignature(html$.History, () => ({
>+  __proto__: dart.getGetters(html$.History.__proto__),
>+  [$state]: dart.dynamic
>+}));
>+dart.setLibraryUri(html$.History, "dart:html");
>+dart.setFieldSignature(html$.History, () => ({
>+  __proto__: dart.getFields(html$.History.__proto__),
>+  [$length]: dart.finalFieldType(core.int),
>+  [$scrollRestoration]: dart.fieldType(core.String),
>+  [_get_state]: dart.finalFieldType(dart.dynamic)
>+}));
>+dart.registerExtension("History", html$.History);
>+const Interceptor_ListMixin$$1 = class Interceptor_ListMixin extends _interceptors.Interceptor {};
>+(Interceptor_ListMixin$$1.new = function() {
>+  Interceptor_ListMixin$$1.__proto__.new.call(this);
>+}).prototype = Interceptor_ListMixin$$1.prototype;
>+dart.applyMixin(Interceptor_ListMixin$$1, collection.ListMixin$(html$.Node));
>+const Interceptor_ImmutableListMixin$$1 = class Interceptor_ImmutableListMixin extends Interceptor_ListMixin$$1 {};
>+(Interceptor_ImmutableListMixin$$1.new = function() {
>+  Interceptor_ImmutableListMixin$$1.__proto__.new.call(this);
>+}).prototype = Interceptor_ImmutableListMixin$$1.prototype;
>+dart.applyMixin(Interceptor_ImmutableListMixin$$1, html$.ImmutableListMixin$(html$.Node));
>+html$.HtmlCollection = class HtmlCollection extends Interceptor_ImmutableListMixin$$1 {
>+  get [$length]() {
>+    return this.length;
>+  }
>+  [$_get](index) {
>+    if (index >>> 0 !== index || index >= this[$length]) dart.throw(core.RangeError.index(index, this));
>+    return this[index];
>+  }
>+  [$_set](index, value) {
>+    html$.Node._check(value);
>+    dart.throw(new core.UnsupportedError.new("Cannot assign element of immutable List."));
>+    return value;
>+  }
>+  set [$length](value) {
>+    dart.throw(new core.UnsupportedError.new("Cannot resize immutable List."));
>+  }
>+  get [$first]() {
>+    if (dart.notNull(this[$length]) > 0) {
>+      return this[0];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$first](value) {
>+    super[$first] = value;
>+  }
>+  get [$last]() {
>+    let len = this[$length];
>+    if (dart.notNull(len) > 0) {
>+      return this[dart.notNull(len) - 1];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$last](value) {
>+    super[$last] = value;
>+  }
>+  get [$single]() {
>+    let len = this[$length];
>+    if (len === 1) {
>+      return this[0];
>+    }
>+    if (len === 0) dart.throw(new core.StateError.new("No elements"));
>+    dart.throw(new core.StateError.new("More than one element"));
>+  }
>+  [$elementAt](index) {
>+    return this[$_get](index);
>+  }
>+  [$item](...args) {
>+    return this.item.apply(this, args);
>+  }
>+  [$namedItem](...args) {
>+    return this.namedItem.apply(this, args);
>+  }
>+};
>+html$.HtmlCollection.prototype[dart.isList] = true;
>+dart.addTypeTests(html$.HtmlCollection);
>+html$.HtmlCollection[dart.implements] = () => [JavaScriptIndexingBehaviorOfNode(), ListOfNode()];
>+dart.setMethodSignature(html$.HtmlCollection, () => ({
>+  __proto__: dart.getMethods(html$.HtmlCollection.__proto__),
>+  [$_get]: dart.fnType(html$.Node, [core.int]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$elementAt]: dart.fnType(html$.Node, [core.int]),
>+  [$item]: dart.fnType(html$.Node, [core.int]),
>+  [$namedItem]: dart.fnType(core.Object, [core.String])
>+}));
>+dart.setGetterSignature(html$.HtmlCollection, () => ({
>+  __proto__: dart.getGetters(html$.HtmlCollection.__proto__),
>+  [$length]: core.int,
>+  [$first]: html$.Node,
>+  [$last]: html$.Node,
>+  [$single]: html$.Node
>+}));
>+dart.setSetterSignature(html$.HtmlCollection, () => ({
>+  __proto__: dart.getSetters(html$.HtmlCollection.__proto__),
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(html$.HtmlCollection, "dart:html");
>+dart.registerExtension("HTMLCollection", html$.HtmlCollection);
>+html$.HtmlDocument = class HtmlDocument extends html$.Document {
>+  get [$body]() {
>+    return this.body;
>+  }
>+  set [$body](value) {
>+    this.body = value;
>+  }
>+  [$caretRangeFromPoint](x, y) {
>+    return this[_caretRangeFromPoint](x, y);
>+  }
>+  [$elementFromPoint](x, y) {
>+    return this[_elementFromPoint](x, y);
>+  }
>+  get [$head]() {
>+    return this[_head$];
>+  }
>+  get [$lastModified]() {
>+    return this[_lastModified];
>+  }
>+  get [$preferredStylesheetSet]() {
>+    return this[_preferredStylesheetSet];
>+  }
>+  get [$referrer]() {
>+    return this[_referrer];
>+  }
>+  get [$selectedStylesheetSet]() {
>+    return this[_selectedStylesheetSet];
>+  }
>+  set [$selectedStylesheetSet](value) {
>+    this[_selectedStylesheetSet] = value;
>+  }
>+  get [$styleSheets]() {
>+    return this[_styleSheets];
>+  }
>+  get [$title]() {
>+    return this[_title];
>+  }
>+  set [$title](value) {
>+    this[_title] = value;
>+  }
>+  [$exitFullscreen]() {
>+    this[_webkitExitFullscreen]();
>+  }
>+  [$registerElement2](tag, options) {
>+    if (options === void 0) options = null;
>+    return html$._registerCustomElement(window, this, tag, options);
>+  }
>+  [$register](tag, customElementClass, opts) {
>+    let extendsTag = opts && 'extendsTag' in opts ? opts.extendsTag : null;
>+    return this[$registerElement](tag, customElementClass, {extendsTag: extendsTag});
>+  }
>+  static _determineVisibilityChangeEventType(e) {
>+    if (typeof e.hidden !== "undefined") {
>+      return "visibilitychange";
>+    } else if (typeof e.mozHidden !== "undefined") {
>+      return "mozvisibilitychange";
>+    } else if (typeof e.msHidden !== "undefined") {
>+      return "msvisibilitychange";
>+    } else if (typeof e.webkitHidden !== "undefined") {
>+      return "webkitvisibilitychange";
>+    }
>+    return "visibilitychange";
>+  }
>+  get [$onVisibilityChange]() {
>+    return html$.HtmlDocument.visibilityChangeEvent.forTarget(this);
>+  }
>+  [$createElementUpgrader](type, opts) {
>+    let extendsTag = opts && 'extendsTag' in opts ? opts.extendsTag : null;
>+    return new html$._JSElementUpgrader.new(this, type, extendsTag);
>+  }
>+};
>+dart.addTypeTests(html$.HtmlDocument);
>+const body = Symbol("HtmlDocument.body");
>+dart.setMethodSignature(html$.HtmlDocument, () => ({
>+  __proto__: dart.getMethods(html$.HtmlDocument.__proto__),
>+  [$caretRangeFromPoint]: dart.fnType(html$.Range, [core.int, core.int]),
>+  [$elementFromPoint]: dart.fnType(html$.Element, [core.int, core.int]),
>+  [$register]: dart.fnType(dart.void, [core.String, core.Type], {extendsTag: core.String}),
>+  [$createElementUpgrader]: dart.fnType(html$.ElementUpgrader, [core.Type], {extendsTag: core.String})
>+}));
>+dart.setGetterSignature(html$.HtmlDocument, () => ({
>+  __proto__: dart.getGetters(html$.HtmlDocument.__proto__),
>+  [$head]: html$.HeadElement,
>+  [$lastModified]: core.String,
>+  [$preferredStylesheetSet]: core.String,
>+  [$referrer]: core.String,
>+  [$selectedStylesheetSet]: core.String,
>+  [$styleSheets]: core.List$(html$.StyleSheet),
>+  [$title]: core.String,
>+  [$onVisibilityChange]: async.Stream$(html$.Event)
>+}));
>+dart.setSetterSignature(html$.HtmlDocument, () => ({
>+  __proto__: dart.getSetters(html$.HtmlDocument.__proto__),
>+  [$selectedStylesheetSet]: core.String,
>+  [$title]: core.String
>+}));
>+dart.setLibraryUri(html$.HtmlDocument, "dart:html");
>+dart.setFieldSignature(html$.HtmlDocument, () => ({
>+  __proto__: dart.getFields(html$.HtmlDocument.__proto__),
>+  [$body]: dart.fieldType(html$.BodyElement)
>+}));
>+dart.defineLazy(html$.HtmlDocument, {
>+  /*html$.HtmlDocument.visibilityChangeEvent*/get visibilityChangeEvent() {
>+    return dart.const(new (_CustomEventStreamProviderOfEvent()).new(dart.fn(html$.HtmlDocument._determineVisibilityChangeEventType, EventTargetToString())));
>+  }
>+});
>+dart.registerExtension("HTMLDocument", html$.HtmlDocument);
>+html$.HtmlFormControlsCollection = class HtmlFormControlsCollection extends html$.HtmlCollection {
>+  [$item](...args) {
>+    return this.item.apply(this, args);
>+  }
>+  [$namedItem](...args) {
>+    return this.namedItem.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.HtmlFormControlsCollection);
>+dart.setLibraryUri(html$.HtmlFormControlsCollection, "dart:html");
>+dart.registerExtension("HTMLFormControlsCollection", html$.HtmlFormControlsCollection);
>+html$.HtmlHtmlElement = class HtmlHtmlElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("html");
>+  }
>+};
>+(html$.HtmlHtmlElement.created = function() {
>+  html$.HtmlHtmlElement.__proto__.created.call(this);
>+}).prototype = html$.HtmlHtmlElement.prototype;
>+dart.addTypeTests(html$.HtmlHtmlElement);
>+dart.setLibraryUri(html$.HtmlHtmlElement, "dart:html");
>+dart.registerExtension("HTMLHtmlElement", html$.HtmlHtmlElement);
>+html$.HtmlHyperlinkElementUtils = class HtmlHyperlinkElementUtils extends _interceptors.Interceptor {
>+  get [$hash]() {
>+    return this.hash;
>+  }
>+  set [$hash](value) {
>+    this.hash = value;
>+  }
>+  get [$host]() {
>+    return this.host;
>+  }
>+  set [$host](value) {
>+    this.host = value;
>+  }
>+  get [$hostname]() {
>+    return this.hostname;
>+  }
>+  set [$hostname](value) {
>+    this.hostname = value;
>+  }
>+  get [$href]() {
>+    return this.href;
>+  }
>+  set [$href](value) {
>+    this.href = value;
>+  }
>+  get [$origin]() {
>+    return this.origin;
>+  }
>+  get [$password]() {
>+    return this.password;
>+  }
>+  set [$password](value) {
>+    this.password = value;
>+  }
>+  get [$pathname]() {
>+    return this.pathname;
>+  }
>+  set [$pathname](value) {
>+    this.pathname = value;
>+  }
>+  get [$port]() {
>+    return this.port;
>+  }
>+  set [$port](value) {
>+    this.port = value;
>+  }
>+  get [$protocol]() {
>+    return this.protocol;
>+  }
>+  set [$protocol](value) {
>+    this.protocol = value;
>+  }
>+  get [$search]() {
>+    return this.search;
>+  }
>+  set [$search](value) {
>+    this.search = value;
>+  }
>+  get [$username]() {
>+    return this.username;
>+  }
>+  set [$username](value) {
>+    this.username = value;
>+  }
>+};
>+dart.addTypeTests(html$.HtmlHyperlinkElementUtils);
>+const hash$0 = Symbol("HtmlHyperlinkElementUtils.hash");
>+const host$0 = Symbol("HtmlHyperlinkElementUtils.host");
>+const hostname$0 = Symbol("HtmlHyperlinkElementUtils.hostname");
>+const href$3 = Symbol("HtmlHyperlinkElementUtils.href");
>+const origin$4 = Symbol("HtmlHyperlinkElementUtils.origin");
>+const password$0 = Symbol("HtmlHyperlinkElementUtils.password");
>+const pathname$0 = Symbol("HtmlHyperlinkElementUtils.pathname");
>+const port$2 = Symbol("HtmlHyperlinkElementUtils.port");
>+const protocol$1 = Symbol("HtmlHyperlinkElementUtils.protocol");
>+const search$0 = Symbol("HtmlHyperlinkElementUtils.search");
>+const username$0 = Symbol("HtmlHyperlinkElementUtils.username");
>+dart.setLibraryUri(html$.HtmlHyperlinkElementUtils, "dart:html");
>+dart.setFieldSignature(html$.HtmlHyperlinkElementUtils, () => ({
>+  __proto__: dart.getFields(html$.HtmlHyperlinkElementUtils.__proto__),
>+  [$hash]: dart.fieldType(core.String),
>+  [$host]: dart.fieldType(core.String),
>+  [$hostname]: dart.fieldType(core.String),
>+  [$href]: dart.fieldType(core.String),
>+  [$origin]: dart.finalFieldType(core.String),
>+  [$password]: dart.fieldType(core.String),
>+  [$pathname]: dart.fieldType(core.String),
>+  [$port]: dart.fieldType(core.String),
>+  [$protocol]: dart.fieldType(core.String),
>+  [$search]: dart.fieldType(core.String),
>+  [$username]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("HTMLHyperlinkElementUtils", html$.HtmlHyperlinkElementUtils);
>+const _item = dart.privateName(html$, "_item");
>+html$.HtmlOptionsCollection = class HtmlOptionsCollection extends html$.HtmlCollection {
>+  [_item](...args) {
>+    return this.item.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.HtmlOptionsCollection);
>+dart.setMethodSignature(html$.HtmlOptionsCollection, () => ({
>+  __proto__: dart.getMethods(html$.HtmlOptionsCollection.__proto__),
>+  [_item]: dart.fnType(html$.Element, [core.int])
>+}));
>+dart.setLibraryUri(html$.HtmlOptionsCollection, "dart:html");
>+dart.registerExtension("HTMLOptionsCollection", html$.HtmlOptionsCollection);
>+const _get_response = dart.privateName(html$, "_get_response");
>+html$.HttpRequestEventTarget = class HttpRequestEventTarget extends html$.EventTarget {
>+  get [$onAbort]() {
>+    return html$.HttpRequestEventTarget.abortEvent.forTarget(this);
>+  }
>+  get [$onError]() {
>+    return html$.HttpRequestEventTarget.errorEvent.forTarget(this);
>+  }
>+  get [$onLoad]() {
>+    return html$.HttpRequestEventTarget.loadEvent.forTarget(this);
>+  }
>+  get [$onLoadEnd]() {
>+    return html$.HttpRequestEventTarget.loadEndEvent.forTarget(this);
>+  }
>+  get [$onLoadStart]() {
>+    return html$.HttpRequestEventTarget.loadStartEvent.forTarget(this);
>+  }
>+  get [$onProgress]() {
>+    return html$.HttpRequestEventTarget.progressEvent.forTarget(this);
>+  }
>+  get [$onTimeout]() {
>+    return html$.HttpRequestEventTarget.timeoutEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.HttpRequestEventTarget);
>+dart.setGetterSignature(html$.HttpRequestEventTarget, () => ({
>+  __proto__: dart.getGetters(html$.HttpRequestEventTarget.__proto__),
>+  [$onAbort]: async.Stream$(html$.ProgressEvent),
>+  [$onError]: async.Stream$(html$.ProgressEvent),
>+  [$onLoad]: async.Stream$(html$.ProgressEvent),
>+  [$onLoadEnd]: async.Stream$(html$.ProgressEvent),
>+  [$onLoadStart]: async.Stream$(html$.ProgressEvent),
>+  [$onProgress]: async.Stream$(html$.ProgressEvent),
>+  [$onTimeout]: async.Stream$(html$.ProgressEvent)
>+}));
>+dart.setLibraryUri(html$.HttpRequestEventTarget, "dart:html");
>+dart.defineLazy(html$.HttpRequestEventTarget, {
>+  /*html$.HttpRequestEventTarget.abortEvent*/get abortEvent() {
>+    return dart.const(new (EventStreamProviderOfProgressEvent()).new("abort"));
>+  },
>+  /*html$.HttpRequestEventTarget.errorEvent*/get errorEvent() {
>+    return dart.const(new (EventStreamProviderOfProgressEvent()).new("error"));
>+  },
>+  /*html$.HttpRequestEventTarget.loadEvent*/get loadEvent() {
>+    return dart.const(new (EventStreamProviderOfProgressEvent()).new("load"));
>+  },
>+  /*html$.HttpRequestEventTarget.loadEndEvent*/get loadEndEvent() {
>+    return dart.const(new (EventStreamProviderOfProgressEvent()).new("loadend"));
>+  },
>+  /*html$.HttpRequestEventTarget.loadStartEvent*/get loadStartEvent() {
>+    return dart.const(new (EventStreamProviderOfProgressEvent()).new("loadstart"));
>+  },
>+  /*html$.HttpRequestEventTarget.progressEvent*/get progressEvent() {
>+    return dart.const(new (EventStreamProviderOfProgressEvent()).new("progress"));
>+  },
>+  /*html$.HttpRequestEventTarget.timeoutEvent*/get timeoutEvent() {
>+    return dart.const(new (EventStreamProviderOfProgressEvent()).new("timeout"));
>+  }
>+});
>+dart.registerExtension("XMLHttpRequestEventTarget", html$.HttpRequestEventTarget);
>+html$.HttpRequest = class HttpRequest extends html$.HttpRequestEventTarget {
>+  static getString(url, opts) {
>+    let withCredentials = opts && 'withCredentials' in opts ? opts.withCredentials : null;
>+    let onProgress = opts && 'onProgress' in opts ? opts.onProgress : null;
>+    return FutureOfString()._check(html$.HttpRequest.request(url, {withCredentials: withCredentials, onProgress: onProgress}).then(core.String, dart.fn(xhr => xhr.responseText, HttpRequestToString())));
>+  }
>+  static postFormData(url, data, opts) {
>+    let withCredentials = opts && 'withCredentials' in opts ? opts.withCredentials : null;
>+    let responseType = opts && 'responseType' in opts ? opts.responseType : null;
>+    let requestHeaders = opts && 'requestHeaders' in opts ? opts.requestHeaders : null;
>+    let onProgress = opts && 'onProgress' in opts ? opts.onProgress : null;
>+    let parts = [];
>+    data[$forEach](dart.fn((key, value) => {
>+      parts[$add](dart.str(core.Uri.encodeQueryComponent(key)) + "=" + dart.str(core.Uri.encodeQueryComponent(value)));
>+    }, StringAndStringToNull()));
>+    let formData = parts[$join]("&");
>+    if (requestHeaders == null) {
>+      requestHeaders = new (IdentityMapOfString$String()).new();
>+    }
>+    requestHeaders[$putIfAbsent]("Content-Type", dart.fn(() => "application/x-www-form-urlencoded; charset=UTF-8", VoidToString()));
>+    return html$.HttpRequest.request(url, {method: "POST", withCredentials: withCredentials, responseType: responseType, requestHeaders: requestHeaders, sendData: formData, onProgress: onProgress});
>+  }
>+  static request(url, opts) {
>+    let method = opts && 'method' in opts ? opts.method : null;
>+    let withCredentials = opts && 'withCredentials' in opts ? opts.withCredentials : null;
>+    let responseType = opts && 'responseType' in opts ? opts.responseType : null;
>+    let mimeType = opts && 'mimeType' in opts ? opts.mimeType : null;
>+    let requestHeaders = opts && 'requestHeaders' in opts ? opts.requestHeaders : null;
>+    let sendData = opts && 'sendData' in opts ? opts.sendData : null;
>+    let onProgress = opts && 'onProgress' in opts ? opts.onProgress : null;
>+    let completer = CompleterOfHttpRequest().new();
>+    let xhr = html$.HttpRequest.new();
>+    if (method == null) {
>+      method = "GET";
>+    }
>+    xhr.open(method, url, {async: true});
>+    if (withCredentials != null) {
>+      xhr.withCredentials = withCredentials;
>+    }
>+    if (responseType != null) {
>+      xhr.responseType = responseType;
>+    }
>+    if (mimeType != null) {
>+      xhr.overrideMimeType(mimeType);
>+    }
>+    if (requestHeaders != null) {
>+      requestHeaders[$forEach](dart.fn((header, value) => {
>+        xhr.setRequestHeader(header, value);
>+      }, StringAndStringToNull()));
>+    }
>+    if (onProgress != null) {
>+      xhr[$onProgress].listen(onProgress);
>+    }
>+    xhr[$onLoad].listen(dart.fn(e => {
>+      let accepted = dart.notNull(xhr.status) >= 200 && dart.notNull(xhr.status) < 300;
>+      let fileUri = xhr.status === 0;
>+      let notModified = xhr.status === 304;
>+      let unknownRedirect = dart.notNull(xhr.status) > 307 && dart.notNull(xhr.status) < 400;
>+      if (accepted || fileUri || notModified || unknownRedirect) {
>+        completer.complete(xhr);
>+      } else {
>+        completer.completeError(e);
>+      }
>+    }, ProgressEventToNull()));
>+    xhr[$onError].listen(dart.bind(completer, 'completeError'));
>+    if (sendData != null) {
>+      xhr.send(sendData);
>+    } else {
>+      xhr.send();
>+    }
>+    return completer.future;
>+  }
>+  static get supportsProgressEvent() {
>+    let xhr = html$.HttpRequest.new();
>+    return "onprogress" in xhr;
>+  }
>+  static get supportsCrossOrigin() {
>+    let xhr = html$.HttpRequest.new();
>+    return "withCredentials" in xhr;
>+  }
>+  static get supportsLoadEndEvent() {
>+    let xhr = html$.HttpRequest.new();
>+    return "onloadend" in xhr;
>+  }
>+  static get supportsOverrideMimeType() {
>+    let xhr = html$.HttpRequest.new();
>+    return "overrideMimeType" in xhr;
>+  }
>+  static requestCrossOrigin(url, opts) {
>+    let method = opts && 'method' in opts ? opts.method : null;
>+    let sendData = opts && 'sendData' in opts ? opts.sendData : null;
>+    if (dart.test(html$.HttpRequest.supportsCrossOrigin)) {
>+      return FutureOfString()._check(html$.HttpRequest.request(url, {method: method, sendData: sendData}).then(core.String, dart.fn(xhr => xhr.responseText, HttpRequestToString())));
>+    }
>+    let completer = CompleterOfString().new();
>+    if (method == null) {
>+      method = "GET";
>+    }
>+    let xhr = new XDomainRequest();
>+    xhr.open(method, url);
>+    xhr.onload = _js_helper.convertDartClosureToJS(dynamicToNull(), dart.fn(e => {
>+      let response = xhr.responseText;
>+      completer.complete(response);
>+    }, dynamicToNull()), 1);
>+    xhr.onerror = _js_helper.convertDartClosureToJS(dynamicToNull(), dart.fn(e => {
>+      completer.completeError(e);
>+    }, dynamicToNull()), 1);
>+    xhr.onprogress = {};
>+    xhr.ontimeout = {};
>+    xhr.timeout = Number.MAX_VALUE;
>+    if (sendData != null) {
>+      xhr.send(sendData);
>+    } else {
>+      xhr.send();
>+    }
>+    return completer.future;
>+  }
>+  get [$responseHeaders]() {
>+    let headers = new (IdentityMapOfString$String()).new();
>+    let headersString = this.getAllResponseHeaders();
>+    if (headersString == null) {
>+      return headers;
>+    }
>+    let headersList = headersString[$split]("\r\n");
>+    for (let header of headersList) {
>+      if (header[$isEmpty]) {
>+        continue;
>+      }
>+      let splitIdx = header[$indexOf](": ");
>+      if (splitIdx === -1) {
>+        continue;
>+      }
>+      let key = header[$substring](0, splitIdx)[$toLowerCase]();
>+      let value = header[$substring](splitIdx + 2);
>+      if (dart.test(headers[$containsKey](key))) {
>+        headers[$_set](key, dart.str(headers[$_get](key)) + ", " + value);
>+      } else {
>+        headers[$_set](key, value);
>+      }
>+    }
>+    return headers;
>+  }
>+  [$open](...args) {
>+    return this.open.apply(this, args);
>+  }
>+  static new() {
>+    return html$.HttpRequest._create_1();
>+  }
>+  static _create_1() {
>+    return new XMLHttpRequest();
>+  }
>+  get [$readyState]() {
>+    return this.readyState;
>+  }
>+  get [$response]() {
>+    return html$._convertNativeToDart_XHR_Response(this[_get_response]);
>+  }
>+  get [_get_response]() {
>+    return this.response;
>+  }
>+  get [$responseText]() {
>+    return this.responseText;
>+  }
>+  get [$responseType]() {
>+    return this.responseType;
>+  }
>+  set [$responseType](value) {
>+    this.responseType = value;
>+  }
>+  get [$responseUrl]() {
>+    return this.responseURL;
>+  }
>+  get [$responseXml]() {
>+    return this.responseXML;
>+  }
>+  get [$status]() {
>+    return this.status;
>+  }
>+  get [$statusText]() {
>+    return this.statusText;
>+  }
>+  get [$timeout]() {
>+    return this.timeout;
>+  }
>+  set [$timeout](value) {
>+    this.timeout = value;
>+  }
>+  get [$upload]() {
>+    return this.upload;
>+  }
>+  get [$withCredentials]() {
>+    return this.withCredentials;
>+  }
>+  set [$withCredentials](value) {
>+    this.withCredentials = value;
>+  }
>+  [$abort](...args) {
>+    return this.abort.apply(this, args);
>+  }
>+  [$getAllResponseHeaders](...args) {
>+    return this.getAllResponseHeaders.apply(this, args);
>+  }
>+  [$getResponseHeader](...args) {
>+    return this.getResponseHeader.apply(this, args);
>+  }
>+  [$overrideMimeType](...args) {
>+    return this.overrideMimeType.apply(this, args);
>+  }
>+  [$send](...args) {
>+    return this.send.apply(this, args);
>+  }
>+  [$setRequestHeader](...args) {
>+    return this.setRequestHeader.apply(this, args);
>+  }
>+  get [$onReadyStateChange]() {
>+    return html$.HttpRequest.readyStateChangeEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.HttpRequest);
>+const readyState$5 = Symbol("HttpRequest.readyState");
>+const responseText = Symbol("HttpRequest.responseText");
>+const responseType = Symbol("HttpRequest.responseType");
>+const responseUrl = Symbol("HttpRequest.responseUrl");
>+const responseXml = Symbol("HttpRequest.responseXml");
>+const status$2 = Symbol("HttpRequest.status");
>+const statusText = Symbol("HttpRequest.statusText");
>+const timeout = Symbol("HttpRequest.timeout");
>+const upload = Symbol("HttpRequest.upload");
>+const withCredentials$ = Symbol("HttpRequest.withCredentials");
>+dart.setMethodSignature(html$.HttpRequest, () => ({
>+  __proto__: dart.getMethods(html$.HttpRequest.__proto__),
>+  [$open]: dart.fnType(dart.void, [core.String, core.String], {async: core.bool, user: core.String, password: core.String}),
>+  [$abort]: dart.fnType(dart.void, []),
>+  [$getAllResponseHeaders]: dart.fnType(core.String, []),
>+  [$getResponseHeader]: dart.fnType(core.String, [core.String]),
>+  [$overrideMimeType]: dart.fnType(dart.void, [core.String]),
>+  [$send]: dart.fnType(dart.void, [], [dart.dynamic]),
>+  [$setRequestHeader]: dart.fnType(dart.void, [core.String, core.String])
>+}));
>+dart.setGetterSignature(html$.HttpRequest, () => ({
>+  __proto__: dart.getGetters(html$.HttpRequest.__proto__),
>+  [$responseHeaders]: core.Map$(core.String, core.String),
>+  [$response]: dart.dynamic,
>+  [$onReadyStateChange]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.HttpRequest, "dart:html");
>+dart.setFieldSignature(html$.HttpRequest, () => ({
>+  __proto__: dart.getFields(html$.HttpRequest.__proto__),
>+  [$readyState]: dart.finalFieldType(core.int),
>+  [_get_response]: dart.finalFieldType(dart.dynamic),
>+  [$responseText]: dart.finalFieldType(core.String),
>+  [$responseType]: dart.fieldType(core.String),
>+  [$responseUrl]: dart.finalFieldType(core.String),
>+  [$responseXml]: dart.finalFieldType(html$.Document),
>+  [$status]: dart.finalFieldType(core.int),
>+  [$statusText]: dart.finalFieldType(core.String),
>+  [$timeout]: dart.fieldType(core.int),
>+  [$upload]: dart.finalFieldType(html$.HttpRequestUpload),
>+  [$withCredentials]: dart.fieldType(core.bool)
>+}));
>+dart.defineLazy(html$.HttpRequest, {
>+  /*html$.HttpRequest.readyStateChangeEvent*/get readyStateChangeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("readystatechange"));
>+  },
>+  /*html$.HttpRequest.DONE*/get DONE() {
>+    return 4;
>+  },
>+  /*html$.HttpRequest.HEADERS_RECEIVED*/get HEADERS_RECEIVED() {
>+    return 2;
>+  },
>+  /*html$.HttpRequest.LOADING*/get LOADING() {
>+    return 3;
>+  },
>+  /*html$.HttpRequest.OPENED*/get OPENED() {
>+    return 1;
>+  },
>+  /*html$.HttpRequest.UNSENT*/get UNSENT() {
>+    return 0;
>+  }
>+});
>+dart.registerExtension("XMLHttpRequest", html$.HttpRequest);
>+html$.HttpRequestUpload = class HttpRequestUpload extends html$.HttpRequestEventTarget {};
>+dart.addTypeTests(html$.HttpRequestUpload);
>+dart.setLibraryUri(html$.HttpRequestUpload, "dart:html");
>+dart.registerExtension("XMLHttpRequestUpload", html$.HttpRequestUpload);
>+const _get_contentWindow = dart.privateName(html$, "_get_contentWindow");
>+html$.IFrameElement = class IFrameElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("iframe");
>+  }
>+  get [$allow]() {
>+    return this.allow;
>+  }
>+  set [$allow](value) {
>+    this.allow = value;
>+  }
>+  get [$allowFullscreen]() {
>+    return this.allowFullscreen;
>+  }
>+  set [$allowFullscreen](value) {
>+    this.allowFullscreen = value;
>+  }
>+  get [$allowPaymentRequest]() {
>+    return this.allowPaymentRequest;
>+  }
>+  set [$allowPaymentRequest](value) {
>+    this.allowPaymentRequest = value;
>+  }
>+  get [$contentWindow]() {
>+    return html$._convertNativeToDart_Window(this[_get_contentWindow]);
>+  }
>+  get [_get_contentWindow]() {
>+    return this.contentWindow;
>+  }
>+  get [$csp]() {
>+    return this.csp;
>+  }
>+  set [$csp](value) {
>+    this.csp = value;
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  set [$height](value) {
>+    this.height = value;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+  set [$name](value) {
>+    this.name = value;
>+  }
>+  get [$referrerPolicy]() {
>+    return this.referrerPolicy;
>+  }
>+  set [$referrerPolicy](value) {
>+    this.referrerPolicy = value;
>+  }
>+  get [$sandbox]() {
>+    return this.sandbox;
>+  }
>+  get [$src]() {
>+    return this.src;
>+  }
>+  set [$src](value) {
>+    this.src = value;
>+  }
>+  get [$srcdoc]() {
>+    return this.srcdoc;
>+  }
>+  set [$srcdoc](value) {
>+    this.srcdoc = value;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  set [$width](value) {
>+    this.width = value;
>+  }
>+};
>+(html$.IFrameElement.created = function() {
>+  this[allow] = null;
>+  this[allowFullscreen] = null;
>+  this[allowPaymentRequest] = null;
>+  this[_get_contentWindow] = null;
>+  this[csp] = null;
>+  this[height$0] = null;
>+  this[name$18] = null;
>+  this[referrerPolicy$0] = null;
>+  this[sandbox] = null;
>+  this[src$0] = null;
>+  this[srcdoc] = null;
>+  this[width$0] = null;
>+  html$.IFrameElement.__proto__.created.call(this);
>+}).prototype = html$.IFrameElement.prototype;
>+dart.addTypeTests(html$.IFrameElement);
>+const allow = Symbol("IFrameElement.allow");
>+const allowFullscreen = Symbol("IFrameElement.allowFullscreen");
>+const allowPaymentRequest = Symbol("IFrameElement.allowPaymentRequest");
>+const csp = Symbol("IFrameElement.csp");
>+const height$0 = Symbol("IFrameElement.height");
>+const name$18 = Symbol("IFrameElement.name");
>+const referrerPolicy$0 = Symbol("IFrameElement.referrerPolicy");
>+const sandbox = Symbol("IFrameElement.sandbox");
>+const src$0 = Symbol("IFrameElement.src");
>+const srcdoc = Symbol("IFrameElement.srcdoc");
>+const width$0 = Symbol("IFrameElement.width");
>+dart.setGetterSignature(html$.IFrameElement, () => ({
>+  __proto__: dart.getGetters(html$.IFrameElement.__proto__),
>+  [$contentWindow]: html$.WindowBase
>+}));
>+dart.setLibraryUri(html$.IFrameElement, "dart:html");
>+dart.setFieldSignature(html$.IFrameElement, () => ({
>+  __proto__: dart.getFields(html$.IFrameElement.__proto__),
>+  [$allow]: dart.fieldType(core.String),
>+  [$allowFullscreen]: dart.fieldType(core.bool),
>+  [$allowPaymentRequest]: dart.fieldType(core.bool),
>+  [_get_contentWindow]: dart.finalFieldType(dart.dynamic),
>+  [$csp]: dart.fieldType(core.String),
>+  [$height]: dart.fieldType(core.String),
>+  [$name]: dart.fieldType(core.String),
>+  [$referrerPolicy]: dart.fieldType(core.String),
>+  [$sandbox]: dart.finalFieldType(html$.DomTokenList),
>+  [$src]: dart.fieldType(core.String),
>+  [$srcdoc]: dart.fieldType(core.String),
>+  [$width]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("HTMLIFrameElement", html$.IFrameElement);
>+html$.IdleDeadline = class IdleDeadline extends _interceptors.Interceptor {
>+  get [$didTimeout]() {
>+    return this.didTimeout;
>+  }
>+  [$timeRemaining](...args) {
>+    return this.timeRemaining.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.IdleDeadline);
>+const didTimeout = Symbol("IdleDeadline.didTimeout");
>+dart.setMethodSignature(html$.IdleDeadline, () => ({
>+  __proto__: dart.getMethods(html$.IdleDeadline.__proto__),
>+  [$timeRemaining]: dart.fnType(core.double, [])
>+}));
>+dart.setLibraryUri(html$.IdleDeadline, "dart:html");
>+dart.setFieldSignature(html$.IdleDeadline, () => ({
>+  __proto__: dart.getFields(html$.IdleDeadline.__proto__),
>+  [$didTimeout]: dart.finalFieldType(core.bool)
>+}));
>+dart.registerExtension("IdleDeadline", html$.IdleDeadline);
>+html$.ImageBitmap = class ImageBitmap extends _interceptors.Interceptor {
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  [$close](...args) {
>+    return this.close.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.ImageBitmap);
>+const height$1 = Symbol("ImageBitmap.height");
>+const width$1 = Symbol("ImageBitmap.width");
>+dart.setMethodSignature(html$.ImageBitmap, () => ({
>+  __proto__: dart.getMethods(html$.ImageBitmap.__proto__),
>+  [$close]: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(html$.ImageBitmap, "dart:html");
>+dart.setFieldSignature(html$.ImageBitmap, () => ({
>+  __proto__: dart.getFields(html$.ImageBitmap.__proto__),
>+  [$height]: dart.finalFieldType(core.int),
>+  [$width]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("ImageBitmap", html$.ImageBitmap);
>+html$.ImageBitmapRenderingContext = class ImageBitmapRenderingContext extends _interceptors.Interceptor {
>+  get [$canvas]() {
>+    return this.canvas;
>+  }
>+  [$transferFromImageBitmap](...args) {
>+    return this.transferFromImageBitmap.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.ImageBitmapRenderingContext);
>+const canvas$0 = Symbol("ImageBitmapRenderingContext.canvas");
>+dart.setMethodSignature(html$.ImageBitmapRenderingContext, () => ({
>+  __proto__: dart.getMethods(html$.ImageBitmapRenderingContext.__proto__),
>+  [$transferFromImageBitmap]: dart.fnType(dart.void, [html$.ImageBitmap])
>+}));
>+dart.setLibraryUri(html$.ImageBitmapRenderingContext, "dart:html");
>+dart.setFieldSignature(html$.ImageBitmapRenderingContext, () => ({
>+  __proto__: dart.getFields(html$.ImageBitmapRenderingContext.__proto__),
>+  [$canvas]: dart.finalFieldType(html$.CanvasElement)
>+}));
>+dart.registerExtension("ImageBitmapRenderingContext", html$.ImageBitmapRenderingContext);
>+html$.ImageCapture = class ImageCapture$ extends _interceptors.Interceptor {
>+  static new(track) {
>+    return html$.ImageCapture._create_1(track);
>+  }
>+  static _create_1(track) {
>+    return new ImageCapture(track);
>+  }
>+  get [$track]() {
>+    return this.track;
>+  }
>+  [$getPhotoCapabilities]() {
>+    return html$.promiseToFuture(html$.PhotoCapabilities, this.getPhotoCapabilities());
>+  }
>+  [$getPhotoSettings]() {
>+    return html$.promiseToFutureAsMap(this.getPhotoSettings());
>+  }
>+  [$grabFrame]() {
>+    return html$.promiseToFuture(html$.ImageBitmap, this.grabFrame());
>+  }
>+  [$setOptions](photoSettings) {
>+    let photoSettings_dict = html_common.convertDartToNative_Dictionary(photoSettings);
>+    return html$.promiseToFuture(dart.dynamic, this.setOptions(photoSettings_dict));
>+  }
>+  [$takePhoto](photoSettings) {
>+    if (photoSettings === void 0) photoSettings = null;
>+    let photoSettings_dict = null;
>+    if (photoSettings != null) {
>+      photoSettings_dict = html_common.convertDartToNative_Dictionary(photoSettings);
>+    }
>+    return html$.promiseToFuture(html$.Blob, this.takePhoto(photoSettings_dict));
>+  }
>+};
>+dart.addTypeTests(html$.ImageCapture);
>+const track = Symbol("ImageCapture.track");
>+dart.setMethodSignature(html$.ImageCapture, () => ({
>+  __proto__: dart.getMethods(html$.ImageCapture.__proto__),
>+  [$getPhotoCapabilities]: dart.fnType(async.Future$(html$.PhotoCapabilities), []),
>+  [$getPhotoSettings]: dart.fnType(async.Future$(core.Map$(core.String, dart.dynamic)), []),
>+  [$grabFrame]: dart.fnType(async.Future$(html$.ImageBitmap), []),
>+  [$setOptions]: dart.fnType(async.Future, [core.Map]),
>+  [$takePhoto]: dart.fnType(async.Future$(html$.Blob), [], [core.Map])
>+}));
>+dart.setLibraryUri(html$.ImageCapture, "dart:html");
>+dart.setFieldSignature(html$.ImageCapture, () => ({
>+  __proto__: dart.getFields(html$.ImageCapture.__proto__),
>+  [$track]: dart.finalFieldType(html$.MediaStreamTrack)
>+}));
>+dart.registerExtension("ImageCapture", html$.ImageCapture);
>+html$.ImageData = class ImageData$ extends _interceptors.Interceptor {
>+  static new(data_OR_sw, sh_OR_sw, sh) {
>+    if (sh === void 0) sh = null;
>+    if (core.int.is(sh_OR_sw) && core.int.is(data_OR_sw) && sh == null) {
>+      return html$.ImageData._create_1(data_OR_sw, sh_OR_sw);
>+    }
>+    if (core.int.is(sh_OR_sw) && typed_data.Uint8ClampedList.is(data_OR_sw) && sh == null) {
>+      return html$.ImageData._create_2(data_OR_sw, sh_OR_sw);
>+    }
>+    if (core.int.is(sh) && core.int.is(sh_OR_sw) && typed_data.Uint8ClampedList.is(data_OR_sw)) {
>+      return html$.ImageData._create_3(data_OR_sw, sh_OR_sw, sh);
>+    }
>+    dart.throw(new core.ArgumentError.new("Incorrect number or type of arguments"));
>+  }
>+  static _create_1(data_OR_sw, sh_OR_sw) {
>+    return new ImageData(data_OR_sw, sh_OR_sw);
>+  }
>+  static _create_2(data_OR_sw, sh_OR_sw) {
>+    return new ImageData(data_OR_sw, sh_OR_sw);
>+  }
>+  static _create_3(data_OR_sw, sh_OR_sw, sh) {
>+    return new ImageData(data_OR_sw, sh_OR_sw, sh);
>+  }
>+  get [$data]() {
>+    return this.data;
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+};
>+dart.addTypeTests(html$.ImageData);
>+const data$3 = Symbol("ImageData.data");
>+const height$2 = Symbol("ImageData.height");
>+const width$2 = Symbol("ImageData.width");
>+dart.setLibraryUri(html$.ImageData, "dart:html");
>+dart.setFieldSignature(html$.ImageData, () => ({
>+  __proto__: dart.getFields(html$.ImageData.__proto__),
>+  [$data]: dart.finalFieldType(typed_data.Uint8ClampedList),
>+  [$height]: dart.finalFieldType(core.int),
>+  [$width]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("ImageData", html$.ImageData);
>+html$.ImageElement = class ImageElement extends html$.HtmlElement {
>+  static new(opts) {
>+    let src = opts && 'src' in opts ? opts.src : null;
>+    let width = opts && 'width' in opts ? opts.width : null;
>+    let height = opts && 'height' in opts ? opts.height : null;
>+    let e = html$.document.createElement("img");
>+    if (src != null) e.src = src;
>+    if (width != null) e.width = width;
>+    if (height != null) e.height = height;
>+    return e;
>+  }
>+  get [$alt]() {
>+    return this.alt;
>+  }
>+  set [$alt](value) {
>+    this.alt = value;
>+  }
>+  get [$async]() {
>+    return this.async;
>+  }
>+  set [$async](value) {
>+    this.async = value;
>+  }
>+  get [$complete]() {
>+    return this.complete;
>+  }
>+  get [$crossOrigin]() {
>+    return this.crossOrigin;
>+  }
>+  set [$crossOrigin](value) {
>+    this.crossOrigin = value;
>+  }
>+  get [$currentSrc]() {
>+    return this.currentSrc;
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  set [$height](value) {
>+    this.height = value;
>+  }
>+  get [$isMap]() {
>+    return this.isMap;
>+  }
>+  set [$isMap](value) {
>+    this.isMap = value;
>+  }
>+  get [$naturalHeight]() {
>+    return this.naturalHeight;
>+  }
>+  get [$naturalWidth]() {
>+    return this.naturalWidth;
>+  }
>+  get [$referrerPolicy]() {
>+    return this.referrerPolicy;
>+  }
>+  set [$referrerPolicy](value) {
>+    this.referrerPolicy = value;
>+  }
>+  get [$sizes]() {
>+    return this.sizes;
>+  }
>+  set [$sizes](value) {
>+    this.sizes = value;
>+  }
>+  get [$src]() {
>+    return this.src;
>+  }
>+  set [$src](value) {
>+    this.src = value;
>+  }
>+  get [$srcset]() {
>+    return this.srcset;
>+  }
>+  set [$srcset](value) {
>+    this.srcset = value;
>+  }
>+  get [$useMap]() {
>+    return this.useMap;
>+  }
>+  set [$useMap](value) {
>+    this.useMap = value;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  set [$width](value) {
>+    this.width = value;
>+  }
>+  [$decode]() {
>+    return html$.promiseToFuture(dart.dynamic, this.decode());
>+  }
>+};
>+(html$.ImageElement.created = function() {
>+  this[alt$] = null;
>+  this[async$] = null;
>+  this[complete] = null;
>+  this[crossOrigin$] = null;
>+  this[currentSrc$] = null;
>+  this[height$3] = null;
>+  this[isMap] = null;
>+  this[naturalHeight] = null;
>+  this[naturalWidth] = null;
>+  this[referrerPolicy$1] = null;
>+  this[sizes] = null;
>+  this[src$1] = null;
>+  this[srcset] = null;
>+  this[useMap] = null;
>+  this[width$3] = null;
>+  html$.ImageElement.__proto__.created.call(this);
>+}).prototype = html$.ImageElement.prototype;
>+dart.addTypeTests(html$.ImageElement);
>+const alt$ = Symbol("ImageElement.alt");
>+const async$ = Symbol("ImageElement.async");
>+const complete = Symbol("ImageElement.complete");
>+const crossOrigin$ = Symbol("ImageElement.crossOrigin");
>+const currentSrc$ = Symbol("ImageElement.currentSrc");
>+const height$3 = Symbol("ImageElement.height");
>+const isMap = Symbol("ImageElement.isMap");
>+const naturalHeight = Symbol("ImageElement.naturalHeight");
>+const naturalWidth = Symbol("ImageElement.naturalWidth");
>+const referrerPolicy$1 = Symbol("ImageElement.referrerPolicy");
>+const sizes = Symbol("ImageElement.sizes");
>+const src$1 = Symbol("ImageElement.src");
>+const srcset = Symbol("ImageElement.srcset");
>+const useMap = Symbol("ImageElement.useMap");
>+const width$3 = Symbol("ImageElement.width");
>+html$.ImageElement[dart.implements] = () => [html$.CanvasImageSource];
>+dart.setMethodSignature(html$.ImageElement, () => ({
>+  __proto__: dart.getMethods(html$.ImageElement.__proto__),
>+  [$decode]: dart.fnType(async.Future, [])
>+}));
>+dart.setLibraryUri(html$.ImageElement, "dart:html");
>+dart.setFieldSignature(html$.ImageElement, () => ({
>+  __proto__: dart.getFields(html$.ImageElement.__proto__),
>+  [$alt]: dart.fieldType(core.String),
>+  [$async]: dart.fieldType(core.String),
>+  [$complete]: dart.finalFieldType(core.bool),
>+  [$crossOrigin]: dart.fieldType(core.String),
>+  [$currentSrc]: dart.finalFieldType(core.String),
>+  [$height]: dart.fieldType(core.int),
>+  [$isMap]: dart.fieldType(core.bool),
>+  [$naturalHeight]: dart.finalFieldType(core.int),
>+  [$naturalWidth]: dart.finalFieldType(core.int),
>+  [$referrerPolicy]: dart.fieldType(core.String),
>+  [$sizes]: dart.fieldType(core.String),
>+  [$src]: dart.fieldType(core.String),
>+  [$srcset]: dart.fieldType(core.String),
>+  [$useMap]: dart.fieldType(core.String),
>+  [$width]: dart.fieldType(core.int)
>+}));
>+dart.registerExtension("HTMLImageElement", html$.ImageElement);
>+html$.InputDeviceCapabilities = class InputDeviceCapabilities$ extends _interceptors.Interceptor {
>+  static new(deviceInitDict) {
>+    if (deviceInitDict === void 0) deviceInitDict = null;
>+    if (deviceInitDict != null) {
>+      let deviceInitDict_1 = html_common.convertDartToNative_Dictionary(deviceInitDict);
>+      return html$.InputDeviceCapabilities._create_1(deviceInitDict_1);
>+    }
>+    return html$.InputDeviceCapabilities._create_2();
>+  }
>+  static _create_1(deviceInitDict) {
>+    return new InputDeviceCapabilities(deviceInitDict);
>+  }
>+  static _create_2() {
>+    return new InputDeviceCapabilities();
>+  }
>+  get [$firesTouchEvents]() {
>+    return this.firesTouchEvents;
>+  }
>+};
>+dart.addTypeTests(html$.InputDeviceCapabilities);
>+const firesTouchEvents = Symbol("InputDeviceCapabilities.firesTouchEvents");
>+dart.setLibraryUri(html$.InputDeviceCapabilities, "dart:html");
>+dart.setFieldSignature(html$.InputDeviceCapabilities, () => ({
>+  __proto__: dart.getFields(html$.InputDeviceCapabilities.__proto__),
>+  [$firesTouchEvents]: dart.finalFieldType(core.bool)
>+}));
>+dart.registerExtension("InputDeviceCapabilities", html$.InputDeviceCapabilities);
>+const _get_valueAsDate = dart.privateName(html$, "_get_valueAsDate");
>+const _set_valueAsDate = dart.privateName(html$, "_set_valueAsDate");
>+html$.InputElement = class InputElement extends html$.HtmlElement {
>+  static new(opts) {
>+    let type = opts && 'type' in opts ? opts.type : null;
>+    let e = html$.InputElement._check(html$.document[$createElement]("input"));
>+    if (type != null) {
>+      try {
>+        e.type = type;
>+      } catch (e$) {
>+        let _ = dart.getThrown(e$);
>+      }
>+    }
>+    return e;
>+  }
>+  get [$accept]() {
>+    return this.accept;
>+  }
>+  set [$accept](value) {
>+    this.accept = value;
>+  }
>+  get [$alt]() {
>+    return this.alt;
>+  }
>+  set [$alt](value) {
>+    this.alt = value;
>+  }
>+  get [$autocapitalize]() {
>+    return this.autocapitalize;
>+  }
>+  set [$autocapitalize](value) {
>+    this.autocapitalize = value;
>+  }
>+  get [$autocomplete]() {
>+    return this.autocomplete;
>+  }
>+  set [$autocomplete](value) {
>+    this.autocomplete = value;
>+  }
>+  get [$autofocus]() {
>+    return this.autofocus;
>+  }
>+  set [$autofocus](value) {
>+    this.autofocus = value;
>+  }
>+  get [$capture]() {
>+    return this.capture;
>+  }
>+  set [$capture](value) {
>+    this.capture = value;
>+  }
>+  get [$checked]() {
>+    return this.checked;
>+  }
>+  set [$checked](value) {
>+    this.checked = value;
>+  }
>+  get [$defaultChecked]() {
>+    return this.defaultChecked;
>+  }
>+  set [$defaultChecked](value) {
>+    this.defaultChecked = value;
>+  }
>+  get [$defaultValue]() {
>+    return this.defaultValue;
>+  }
>+  set [$defaultValue](value) {
>+    this.defaultValue = value;
>+  }
>+  get [$dirName]() {
>+    return this.dirName;
>+  }
>+  set [$dirName](value) {
>+    this.dirName = value;
>+  }
>+  get [$disabled]() {
>+    return this.disabled;
>+  }
>+  set [$disabled](value) {
>+    this.disabled = value;
>+  }
>+  get [$files]() {
>+    return this.files;
>+  }
>+  set [$files](value) {
>+    this.files = value;
>+  }
>+  get [$form]() {
>+    return this.form;
>+  }
>+  get [$formAction]() {
>+    return this.formAction;
>+  }
>+  set [$formAction](value) {
>+    this.formAction = value;
>+  }
>+  get [$formEnctype]() {
>+    return this.formEnctype;
>+  }
>+  set [$formEnctype](value) {
>+    this.formEnctype = value;
>+  }
>+  get [$formMethod]() {
>+    return this.formMethod;
>+  }
>+  set [$formMethod](value) {
>+    this.formMethod = value;
>+  }
>+  get [$formNoValidate]() {
>+    return this.formNoValidate;
>+  }
>+  set [$formNoValidate](value) {
>+    this.formNoValidate = value;
>+  }
>+  get [$formTarget]() {
>+    return this.formTarget;
>+  }
>+  set [$formTarget](value) {
>+    this.formTarget = value;
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  set [$height](value) {
>+    this.height = value;
>+  }
>+  get [$incremental]() {
>+    return this.incremental;
>+  }
>+  set [$incremental](value) {
>+    this.incremental = value;
>+  }
>+  get [$indeterminate]() {
>+    return this.indeterminate;
>+  }
>+  set [$indeterminate](value) {
>+    this.indeterminate = value;
>+  }
>+  get [$labels]() {
>+    return this.labels;
>+  }
>+  get [$list]() {
>+    return this.list;
>+  }
>+  get [$max]() {
>+    return this.max;
>+  }
>+  set [$max](value) {
>+    this.max = value;
>+  }
>+  get [$maxLength]() {
>+    return this.maxLength;
>+  }
>+  set [$maxLength](value) {
>+    this.maxLength = value;
>+  }
>+  get [$min]() {
>+    return this.min;
>+  }
>+  set [$min](value) {
>+    this.min = value;
>+  }
>+  get [$minLength]() {
>+    return this.minLength;
>+  }
>+  set [$minLength](value) {
>+    this.minLength = value;
>+  }
>+  get [$multiple]() {
>+    return this.multiple;
>+  }
>+  set [$multiple](value) {
>+    this.multiple = value;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+  set [$name](value) {
>+    this.name = value;
>+  }
>+  get [$pattern]() {
>+    return this.pattern;
>+  }
>+  set [$pattern](value) {
>+    this.pattern = value;
>+  }
>+  get [$placeholder]() {
>+    return this.placeholder;
>+  }
>+  set [$placeholder](value) {
>+    this.placeholder = value;
>+  }
>+  get [$readOnly]() {
>+    return this.readOnly;
>+  }
>+  set [$readOnly](value) {
>+    this.readOnly = value;
>+  }
>+  get [$required]() {
>+    return this.required;
>+  }
>+  set [$required](value) {
>+    this.required = value;
>+  }
>+  get [$selectionDirection]() {
>+    return this.selectionDirection;
>+  }
>+  set [$selectionDirection](value) {
>+    this.selectionDirection = value;
>+  }
>+  get [$selectionEnd]() {
>+    return this.selectionEnd;
>+  }
>+  set [$selectionEnd](value) {
>+    this.selectionEnd = value;
>+  }
>+  get [$selectionStart]() {
>+    return this.selectionStart;
>+  }
>+  set [$selectionStart](value) {
>+    this.selectionStart = value;
>+  }
>+  get [$size]() {
>+    return this.size;
>+  }
>+  set [$size](value) {
>+    this.size = value;
>+  }
>+  get [$src]() {
>+    return this.src;
>+  }
>+  set [$src](value) {
>+    this.src = value;
>+  }
>+  get [$step]() {
>+    return this.step;
>+  }
>+  set [$step](value) {
>+    this.step = value;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  set [$type](value) {
>+    this.type = value;
>+  }
>+  get [$validationMessage]() {
>+    return this.validationMessage;
>+  }
>+  get [$validity]() {
>+    return this.validity;
>+  }
>+  get [$value]() {
>+    return this.value;
>+  }
>+  set [$value](value) {
>+    this.value = value;
>+  }
>+  get [$valueAsDate]() {
>+    return html_common.convertNativeToDart_DateTime(this[_get_valueAsDate]);
>+  }
>+  get [_get_valueAsDate]() {
>+    return this.valueAsDate;
>+  }
>+  set [$valueAsDate](value) {
>+    this[_set_valueAsDate] = html_common.convertDartToNative_DateTime(value);
>+  }
>+  set [_set_valueAsDate](value) {
>+    this.valueAsDate = value;
>+  }
>+  get [$valueAsNumber]() {
>+    return this.valueAsNumber;
>+  }
>+  set [$valueAsNumber](value) {
>+    this.valueAsNumber = value;
>+  }
>+  get [$entries]() {
>+    return this.webkitEntries;
>+  }
>+  get [$directory]() {
>+    return this.webkitdirectory;
>+  }
>+  set [$directory](value) {
>+    this.webkitdirectory = value;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  set [$width](value) {
>+    this.width = value;
>+  }
>+  get [$willValidate]() {
>+    return this.willValidate;
>+  }
>+  [$checkValidity](...args) {
>+    return this.checkValidity.apply(this, args);
>+  }
>+  [$reportValidity](...args) {
>+    return this.reportValidity.apply(this, args);
>+  }
>+  [$select](...args) {
>+    return this.select.apply(this, args);
>+  }
>+  [$setCustomValidity](...args) {
>+    return this.setCustomValidity.apply(this, args);
>+  }
>+  [$setRangeText](...args) {
>+    return this.setRangeText.apply(this, args);
>+  }
>+  [$setSelectionRange](...args) {
>+    return this.setSelectionRange.apply(this, args);
>+  }
>+  [$stepDown](...args) {
>+    return this.stepDown.apply(this, args);
>+  }
>+  [$stepUp](...args) {
>+    return this.stepUp.apply(this, args);
>+  }
>+};
>+(html$.InputElement.created = function() {
>+  this[accept] = null;
>+  this[alt$0] = null;
>+  this[autocapitalize] = null;
>+  this[autocomplete$0] = null;
>+  this[autofocus$] = null;
>+  this[capture] = null;
>+  this[checked$] = null;
>+  this[defaultChecked] = null;
>+  this[defaultValue] = null;
>+  this[dirName] = null;
>+  this[disabled$2] = null;
>+  this[files$] = null;
>+  this[form$0] = null;
>+  this[formAction$] = null;
>+  this[formEnctype$] = null;
>+  this[formMethod$] = null;
>+  this[formNoValidate$] = null;
>+  this[formTarget$] = null;
>+  this[height$4] = null;
>+  this[incremental] = null;
>+  this[indeterminate] = null;
>+  this[labels$] = null;
>+  this[list] = null;
>+  this[max] = null;
>+  this[maxLength] = null;
>+  this[min] = null;
>+  this[minLength] = null;
>+  this[multiple] = null;
>+  this[name$19] = null;
>+  this[pattern] = null;
>+  this[placeholder$] = null;
>+  this[readOnly$] = null;
>+  this[required$] = null;
>+  this[selectionDirection] = null;
>+  this[selectionEnd] = null;
>+  this[selectionStart] = null;
>+  this[size$0] = null;
>+  this[src$2] = null;
>+  this[step] = null;
>+  this[type$15] = null;
>+  this[validationMessage$0] = null;
>+  this[validity$0] = null;
>+  this[value$7] = null;
>+  this[_get_valueAsDate] = null;
>+  this[valueAsNumber] = null;
>+  this[entries] = null;
>+  this[directory] = null;
>+  this[width$4] = null;
>+  this[willValidate$0] = null;
>+  html$.InputElement.__proto__.created.call(this);
>+}).prototype = html$.InputElement.prototype;
>+dart.addTypeTests(html$.InputElement);
>+const accept = Symbol("InputElement.accept");
>+const alt$0 = Symbol("InputElement.alt");
>+const autocapitalize = Symbol("InputElement.autocapitalize");
>+const autocomplete$0 = Symbol("InputElement.autocomplete");
>+const autofocus$ = Symbol("InputElement.autofocus");
>+const capture = Symbol("InputElement.capture");
>+const checked$ = Symbol("InputElement.checked");
>+const defaultChecked = Symbol("InputElement.defaultChecked");
>+const defaultValue = Symbol("InputElement.defaultValue");
>+const dirName = Symbol("InputElement.dirName");
>+const disabled$2 = Symbol("InputElement.disabled");
>+const files$ = Symbol("InputElement.files");
>+const form$0 = Symbol("InputElement.form");
>+const formAction$ = Symbol("InputElement.formAction");
>+const formEnctype$ = Symbol("InputElement.formEnctype");
>+const formMethod$ = Symbol("InputElement.formMethod");
>+const formNoValidate$ = Symbol("InputElement.formNoValidate");
>+const formTarget$ = Symbol("InputElement.formTarget");
>+const height$4 = Symbol("InputElement.height");
>+const incremental = Symbol("InputElement.incremental");
>+const indeterminate = Symbol("InputElement.indeterminate");
>+const labels$ = Symbol("InputElement.labels");
>+const list = Symbol("InputElement.list");
>+const max = Symbol("InputElement.max");
>+const maxLength = Symbol("InputElement.maxLength");
>+const min = Symbol("InputElement.min");
>+const minLength = Symbol("InputElement.minLength");
>+const multiple = Symbol("InputElement.multiple");
>+const name$19 = Symbol("InputElement.name");
>+const pattern = Symbol("InputElement.pattern");
>+const placeholder$ = Symbol("InputElement.placeholder");
>+const readOnly$ = Symbol("InputElement.readOnly");
>+const required$ = Symbol("InputElement.required");
>+const selectionDirection = Symbol("InputElement.selectionDirection");
>+const selectionEnd = Symbol("InputElement.selectionEnd");
>+const selectionStart = Symbol("InputElement.selectionStart");
>+const size$0 = Symbol("InputElement.size");
>+const src$2 = Symbol("InputElement.src");
>+const step = Symbol("InputElement.step");
>+const type$15 = Symbol("InputElement.type");
>+const validationMessage$0 = Symbol("InputElement.validationMessage");
>+const validity$0 = Symbol("InputElement.validity");
>+const value$7 = Symbol("InputElement.value");
>+const valueAsNumber = Symbol("InputElement.valueAsNumber");
>+const entries = Symbol("InputElement.entries");
>+const directory = Symbol("InputElement.directory");
>+const width$4 = Symbol("InputElement.width");
>+const willValidate$0 = Symbol("InputElement.willValidate");
>+html$.InputElement[dart.implements] = () => [html$.HiddenInputElement, html$.SearchInputElement, html$.TextInputElement, html$.UrlInputElement, html$.TelephoneInputElement, html$.EmailInputElement, html$.PasswordInputElement, html$.DateInputElement, html$.MonthInputElement, html$.WeekInputElement, html$.TimeInputElement, html$.LocalDateTimeInputElement, html$.NumberInputElement, html$.RangeInputElement, html$.CheckboxInputElement, html$.RadioButtonInputElement, html$.FileUploadInputElement, html$.SubmitButtonInputElement, html$.ImageButtonInputElement, html$.ResetButtonInputElement, html$.ButtonInputElement];
>+dart.setMethodSignature(html$.InputElement, () => ({
>+  __proto__: dart.getMethods(html$.InputElement.__proto__),
>+  [$checkValidity]: dart.fnType(core.bool, []),
>+  [$reportValidity]: dart.fnType(core.bool, []),
>+  [$select]: dart.fnType(dart.void, []),
>+  [$setCustomValidity]: dart.fnType(dart.void, [core.String]),
>+  [$setRangeText]: dart.fnType(dart.void, [core.String], {start: core.int, end: core.int, selectionMode: core.String}),
>+  [$setSelectionRange]: dart.fnType(dart.void, [core.int, core.int], [core.String]),
>+  [$stepDown]: dart.fnType(dart.void, [], [core.int]),
>+  [$stepUp]: dart.fnType(dart.void, [], [core.int])
>+}));
>+dart.setGetterSignature(html$.InputElement, () => ({
>+  __proto__: dart.getGetters(html$.InputElement.__proto__),
>+  [$valueAsDate]: core.DateTime
>+}));
>+dart.setSetterSignature(html$.InputElement, () => ({
>+  __proto__: dart.getSetters(html$.InputElement.__proto__),
>+  [$valueAsDate]: core.DateTime,
>+  [_set_valueAsDate]: dart.dynamic
>+}));
>+dart.setLibraryUri(html$.InputElement, "dart:html");
>+dart.setFieldSignature(html$.InputElement, () => ({
>+  __proto__: dart.getFields(html$.InputElement.__proto__),
>+  [$accept]: dart.fieldType(core.String),
>+  [$alt]: dart.fieldType(core.String),
>+  [$autocapitalize]: dart.fieldType(core.String),
>+  [$autocomplete]: dart.fieldType(core.String),
>+  [$autofocus]: dart.fieldType(core.bool),
>+  [$capture]: dart.fieldType(core.String),
>+  [$checked]: dart.fieldType(core.bool),
>+  [$defaultChecked]: dart.fieldType(core.bool),
>+  [$defaultValue]: dart.fieldType(core.String),
>+  [$dirName]: dart.fieldType(core.String),
>+  [$disabled]: dart.fieldType(core.bool),
>+  [$files]: dart.fieldType(ListOfFile()),
>+  [$form]: dart.finalFieldType(html$.FormElement),
>+  [$formAction]: dart.fieldType(core.String),
>+  [$formEnctype]: dart.fieldType(core.String),
>+  [$formMethod]: dart.fieldType(core.String),
>+  [$formNoValidate]: dart.fieldType(core.bool),
>+  [$formTarget]: dart.fieldType(core.String),
>+  [$height]: dart.fieldType(core.int),
>+  [$incremental]: dart.fieldType(core.bool),
>+  [$indeterminate]: dart.fieldType(core.bool),
>+  [$labels]: dart.finalFieldType(ListOfNode()),
>+  [$list]: dart.finalFieldType(html$.HtmlElement),
>+  [$max]: dart.fieldType(core.String),
>+  [$maxLength]: dart.fieldType(core.int),
>+  [$min]: dart.fieldType(core.String),
>+  [$minLength]: dart.fieldType(core.int),
>+  [$multiple]: dart.fieldType(core.bool),
>+  [$name]: dart.fieldType(core.String),
>+  [$pattern]: dart.fieldType(core.String),
>+  [$placeholder]: dart.fieldType(core.String),
>+  [$readOnly]: dart.fieldType(core.bool),
>+  [$required]: dart.fieldType(core.bool),
>+  [$selectionDirection]: dart.fieldType(core.String),
>+  [$selectionEnd]: dart.fieldType(core.int),
>+  [$selectionStart]: dart.fieldType(core.int),
>+  [$size]: dart.fieldType(core.int),
>+  [$src]: dart.fieldType(core.String),
>+  [$step]: dart.fieldType(core.String),
>+  [$type]: dart.fieldType(core.String),
>+  [$validationMessage]: dart.finalFieldType(core.String),
>+  [$validity]: dart.finalFieldType(html$.ValidityState),
>+  [$value]: dart.fieldType(core.String),
>+  [_get_valueAsDate]: dart.finalFieldType(dart.dynamic),
>+  [$valueAsNumber]: dart.fieldType(core.num),
>+  [$entries]: dart.finalFieldType(ListOfEntry()),
>+  [$directory]: dart.fieldType(core.bool),
>+  [$width]: dart.fieldType(core.int),
>+  [$willValidate]: dart.finalFieldType(core.bool)
>+}));
>+dart.registerExtension("HTMLInputElement", html$.InputElement);
>+html$.InputElementBase = class InputElementBase extends core.Object {
>+  get autofocus() {
>+    return this[autofocus$0];
>+  }
>+  set autofocus(value) {
>+    this[autofocus$0] = value;
>+  }
>+  get disabled() {
>+    return this[disabled$3];
>+  }
>+  set disabled(value) {
>+    this[disabled$3] = value;
>+  }
>+  get incremental() {
>+    return this[incremental$];
>+  }
>+  set incremental(value) {
>+    this[incremental$] = value;
>+  }
>+  get indeterminate() {
>+    return this[indeterminate$];
>+  }
>+  set indeterminate(value) {
>+    this[indeterminate$] = value;
>+  }
>+  get name() {
>+    return this[name$20];
>+  }
>+  set name(value) {
>+    this[name$20] = value;
>+  }
>+  get value() {
>+    return this[value$8];
>+  }
>+  set value(value) {
>+    this[value$8] = value;
>+  }
>+};
>+(html$.InputElementBase.new = function() {
>+  this[autofocus$0] = null;
>+  this[disabled$3] = null;
>+  this[incremental$] = null;
>+  this[indeterminate$] = null;
>+  this[name$20] = null;
>+  this[value$8] = null;
>+}).prototype = html$.InputElementBase.prototype;
>+dart.addTypeTests(html$.InputElementBase);
>+const autofocus$0 = Symbol("InputElementBase.autofocus");
>+const disabled$3 = Symbol("InputElementBase.disabled");
>+const incremental$ = Symbol("InputElementBase.incremental");
>+const indeterminate$ = Symbol("InputElementBase.indeterminate");
>+const name$20 = Symbol("InputElementBase.name");
>+const value$8 = Symbol("InputElementBase.value");
>+html$.InputElementBase[dart.implements] = () => [html$.Element];
>+dart.setLibraryUri(html$.InputElementBase, "dart:html");
>+dart.setFieldSignature(html$.InputElementBase, () => ({
>+  __proto__: dart.getFields(html$.InputElementBase.__proto__),
>+  autofocus: dart.fieldType(core.bool),
>+  disabled: dart.fieldType(core.bool),
>+  incremental: dart.fieldType(core.bool),
>+  indeterminate: dart.fieldType(core.bool),
>+  name: dart.fieldType(core.String),
>+  value: dart.fieldType(core.String)
>+}));
>+dart.defineExtensionAccessors(html$.InputElementBase, [
>+  'autofocus',
>+  'disabled',
>+  'incremental',
>+  'indeterminate',
>+  'name',
>+  'value'
>+]);
>+html$.HiddenInputElement = class HiddenInputElement extends core.Object {
>+  static new() {
>+    return html$.InputElement.new({type: "hidden"});
>+  }
>+};
>+(html$.HiddenInputElement[dart.mixinNew] = function() {
>+}).prototype = html$.HiddenInputElement.prototype;
>+dart.addTypeTests(html$.HiddenInputElement);
>+html$.HiddenInputElement[dart.implements] = () => [html$.InputElementBase];
>+dart.setLibraryUri(html$.HiddenInputElement, "dart:html");
>+html$.TextInputElementBase = class TextInputElementBase extends core.Object {
>+  get autocomplete() {
>+    return this[autocomplete$1];
>+  }
>+  set autocomplete(value) {
>+    this[autocomplete$1] = value;
>+  }
>+  get maxLength() {
>+    return this[maxLength$];
>+  }
>+  set maxLength(value) {
>+    this[maxLength$] = value;
>+  }
>+  get pattern() {
>+    return this[pattern$];
>+  }
>+  set pattern(value) {
>+    this[pattern$] = value;
>+  }
>+  get placeholder() {
>+    return this[placeholder$0];
>+  }
>+  set placeholder(value) {
>+    this[placeholder$0] = value;
>+  }
>+  get readOnly() {
>+    return this[readOnly$0];
>+  }
>+  set readOnly(value) {
>+    this[readOnly$0] = value;
>+  }
>+  get required() {
>+    return this[required$0];
>+  }
>+  set required(value) {
>+    this[required$0] = value;
>+  }
>+  get size() {
>+    return this[size$1];
>+  }
>+  set size(value) {
>+    this[size$1] = value;
>+  }
>+  get selectionDirection() {
>+    return this[selectionDirection$];
>+  }
>+  set selectionDirection(value) {
>+    this[selectionDirection$] = value;
>+  }
>+  get selectionEnd() {
>+    return this[selectionEnd$];
>+  }
>+  set selectionEnd(value) {
>+    this[selectionEnd$] = value;
>+  }
>+  get selectionStart() {
>+    return this[selectionStart$];
>+  }
>+  set selectionStart(value) {
>+    this[selectionStart$] = value;
>+  }
>+};
>+(html$.TextInputElementBase.new = function() {
>+  this[autocomplete$1] = null;
>+  this[maxLength$] = null;
>+  this[pattern$] = null;
>+  this[placeholder$0] = null;
>+  this[readOnly$0] = null;
>+  this[required$0] = null;
>+  this[size$1] = null;
>+  this[selectionDirection$] = null;
>+  this[selectionEnd$] = null;
>+  this[selectionStart$] = null;
>+}).prototype = html$.TextInputElementBase.prototype;
>+dart.addTypeTests(html$.TextInputElementBase);
>+const autocomplete$1 = Symbol("TextInputElementBase.autocomplete");
>+const maxLength$ = Symbol("TextInputElementBase.maxLength");
>+const pattern$ = Symbol("TextInputElementBase.pattern");
>+const placeholder$0 = Symbol("TextInputElementBase.placeholder");
>+const readOnly$0 = Symbol("TextInputElementBase.readOnly");
>+const required$0 = Symbol("TextInputElementBase.required");
>+const size$1 = Symbol("TextInputElementBase.size");
>+const selectionDirection$ = Symbol("TextInputElementBase.selectionDirection");
>+const selectionEnd$ = Symbol("TextInputElementBase.selectionEnd");
>+const selectionStart$ = Symbol("TextInputElementBase.selectionStart");
>+html$.TextInputElementBase[dart.implements] = () => [html$.InputElementBase];
>+dart.setLibraryUri(html$.TextInputElementBase, "dart:html");
>+dart.setFieldSignature(html$.TextInputElementBase, () => ({
>+  __proto__: dart.getFields(html$.TextInputElementBase.__proto__),
>+  autocomplete: dart.fieldType(core.String),
>+  maxLength: dart.fieldType(core.int),
>+  pattern: dart.fieldType(core.String),
>+  placeholder: dart.fieldType(core.String),
>+  readOnly: dart.fieldType(core.bool),
>+  required: dart.fieldType(core.bool),
>+  size: dart.fieldType(core.int),
>+  selectionDirection: dart.fieldType(core.String),
>+  selectionEnd: dart.fieldType(core.int),
>+  selectionStart: dart.fieldType(core.int)
>+}));
>+dart.defineExtensionAccessors(html$.TextInputElementBase, [
>+  'autocomplete',
>+  'maxLength',
>+  'pattern',
>+  'placeholder',
>+  'readOnly',
>+  'required',
>+  'size',
>+  'selectionDirection',
>+  'selectionEnd',
>+  'selectionStart'
>+]);
>+html$.SearchInputElement = class SearchInputElement extends core.Object {
>+  static new() {
>+    return html$.InputElement.new({type: "search"});
>+  }
>+  get dirName() {
>+    return this[dirName$];
>+  }
>+  set dirName(value) {
>+    this[dirName$] = value;
>+  }
>+  static get supported() {
>+    return html$.InputElement.new({type: "search"}).type === "search";
>+  }
>+};
>+(html$.SearchInputElement[dart.mixinNew] = function() {
>+  this[dirName$] = null;
>+}).prototype = html$.SearchInputElement.prototype;
>+dart.addTypeTests(html$.SearchInputElement);
>+const dirName$ = Symbol("SearchInputElement.dirName");
>+html$.SearchInputElement[dart.implements] = () => [html$.TextInputElementBase];
>+dart.setLibraryUri(html$.SearchInputElement, "dart:html");
>+dart.setFieldSignature(html$.SearchInputElement, () => ({
>+  __proto__: dart.getFields(html$.SearchInputElement.__proto__),
>+  dirName: dart.fieldType(core.String)
>+}));
>+dart.defineExtensionAccessors(html$.SearchInputElement, ['dirName']);
>+html$.TextInputElement = class TextInputElement extends core.Object {
>+  static new() {
>+    return html$.InputElement.new({type: "text"});
>+  }
>+  get dirName() {
>+    return this[dirName$0];
>+  }
>+  set dirName(value) {
>+    this[dirName$0] = value;
>+  }
>+};
>+(html$.TextInputElement[dart.mixinNew] = function() {
>+  this[dirName$0] = null;
>+}).prototype = html$.TextInputElement.prototype;
>+dart.addTypeTests(html$.TextInputElement);
>+const dirName$0 = Symbol("TextInputElement.dirName");
>+html$.TextInputElement[dart.implements] = () => [html$.TextInputElementBase];
>+dart.setLibraryUri(html$.TextInputElement, "dart:html");
>+dart.setFieldSignature(html$.TextInputElement, () => ({
>+  __proto__: dart.getFields(html$.TextInputElement.__proto__),
>+  dirName: dart.fieldType(core.String)
>+}));
>+dart.defineExtensionAccessors(html$.TextInputElement, ['dirName']);
>+html$.UrlInputElement = class UrlInputElement extends core.Object {
>+  static new() {
>+    return html$.InputElement.new({type: "url"});
>+  }
>+  static get supported() {
>+    return html$.InputElement.new({type: "url"}).type === "url";
>+  }
>+};
>+(html$.UrlInputElement[dart.mixinNew] = function() {
>+}).prototype = html$.UrlInputElement.prototype;
>+dart.addTypeTests(html$.UrlInputElement);
>+html$.UrlInputElement[dart.implements] = () => [html$.TextInputElementBase];
>+dart.setLibraryUri(html$.UrlInputElement, "dart:html");
>+html$.TelephoneInputElement = class TelephoneInputElement extends core.Object {
>+  static new() {
>+    return html$.InputElement.new({type: "tel"});
>+  }
>+  static get supported() {
>+    return html$.InputElement.new({type: "tel"}).type === "tel";
>+  }
>+};
>+(html$.TelephoneInputElement[dart.mixinNew] = function() {
>+}).prototype = html$.TelephoneInputElement.prototype;
>+dart.addTypeTests(html$.TelephoneInputElement);
>+html$.TelephoneInputElement[dart.implements] = () => [html$.TextInputElementBase];
>+dart.setLibraryUri(html$.TelephoneInputElement, "dart:html");
>+html$.EmailInputElement = class EmailInputElement extends core.Object {
>+  static new() {
>+    return html$.InputElement.new({type: "email"});
>+  }
>+  get autocomplete() {
>+    return this[autocomplete$2];
>+  }
>+  set autocomplete(value) {
>+    this[autocomplete$2] = value;
>+  }
>+  get autofocus() {
>+    return this[autofocus$1];
>+  }
>+  set autofocus(value) {
>+    this[autofocus$1] = value;
>+  }
>+  get maxLength() {
>+    return this[maxLength$0];
>+  }
>+  set maxLength(value) {
>+    this[maxLength$0] = value;
>+  }
>+  get multiple() {
>+    return this[multiple$];
>+  }
>+  set multiple(value) {
>+    this[multiple$] = value;
>+  }
>+  get pattern() {
>+    return this[pattern$0];
>+  }
>+  set pattern(value) {
>+    this[pattern$0] = value;
>+  }
>+  get placeholder() {
>+    return this[placeholder$1];
>+  }
>+  set placeholder(value) {
>+    this[placeholder$1] = value;
>+  }
>+  get readOnly() {
>+    return this[readOnly$1];
>+  }
>+  set readOnly(value) {
>+    this[readOnly$1] = value;
>+  }
>+  get required() {
>+    return this[required$1];
>+  }
>+  set required(value) {
>+    this[required$1] = value;
>+  }
>+  get size() {
>+    return this[size$2];
>+  }
>+  set size(value) {
>+    this[size$2] = value;
>+  }
>+  static get supported() {
>+    return html$.InputElement.new({type: "email"}).type === "email";
>+  }
>+};
>+(html$.EmailInputElement[dart.mixinNew] = function() {
>+  this[autocomplete$2] = null;
>+  this[autofocus$1] = null;
>+  this[maxLength$0] = null;
>+  this[multiple$] = null;
>+  this[pattern$0] = null;
>+  this[placeholder$1] = null;
>+  this[readOnly$1] = null;
>+  this[required$1] = null;
>+  this[size$2] = null;
>+}).prototype = html$.EmailInputElement.prototype;
>+dart.addTypeTests(html$.EmailInputElement);
>+const autocomplete$2 = Symbol("EmailInputElement.autocomplete");
>+const autofocus$1 = Symbol("EmailInputElement.autofocus");
>+const maxLength$0 = Symbol("EmailInputElement.maxLength");
>+const multiple$ = Symbol("EmailInputElement.multiple");
>+const pattern$0 = Symbol("EmailInputElement.pattern");
>+const placeholder$1 = Symbol("EmailInputElement.placeholder");
>+const readOnly$1 = Symbol("EmailInputElement.readOnly");
>+const required$1 = Symbol("EmailInputElement.required");
>+const size$2 = Symbol("EmailInputElement.size");
>+html$.EmailInputElement[dart.implements] = () => [html$.TextInputElementBase];
>+dart.setLibraryUri(html$.EmailInputElement, "dart:html");
>+dart.setFieldSignature(html$.EmailInputElement, () => ({
>+  __proto__: dart.getFields(html$.EmailInputElement.__proto__),
>+  autocomplete: dart.fieldType(core.String),
>+  autofocus: dart.fieldType(core.bool),
>+  maxLength: dart.fieldType(core.int),
>+  multiple: dart.fieldType(core.bool),
>+  pattern: dart.fieldType(core.String),
>+  placeholder: dart.fieldType(core.String),
>+  readOnly: dart.fieldType(core.bool),
>+  required: dart.fieldType(core.bool),
>+  size: dart.fieldType(core.int)
>+}));
>+dart.defineExtensionAccessors(html$.EmailInputElement, [
>+  'autocomplete',
>+  'autofocus',
>+  'maxLength',
>+  'multiple',
>+  'pattern',
>+  'placeholder',
>+  'readOnly',
>+  'required',
>+  'size'
>+]);
>+html$.PasswordInputElement = class PasswordInputElement extends core.Object {
>+  static new() {
>+    return html$.InputElement.new({type: "password"});
>+  }
>+};
>+(html$.PasswordInputElement[dart.mixinNew] = function() {
>+}).prototype = html$.PasswordInputElement.prototype;
>+dart.addTypeTests(html$.PasswordInputElement);
>+html$.PasswordInputElement[dart.implements] = () => [html$.TextInputElementBase];
>+dart.setLibraryUri(html$.PasswordInputElement, "dart:html");
>+html$.RangeInputElementBase = class RangeInputElementBase extends core.Object {
>+  get max() {
>+    return this[max$0];
>+  }
>+  set max(value) {
>+    this[max$0] = value;
>+  }
>+  get min() {
>+    return this[min$0];
>+  }
>+  set min(value) {
>+    this[min$0] = value;
>+  }
>+  get step() {
>+    return this[step$];
>+  }
>+  set step(value) {
>+    this[step$] = value;
>+  }
>+  get valueAsNumber() {
>+    return this[valueAsNumber$];
>+  }
>+  set valueAsNumber(value) {
>+    this[valueAsNumber$] = value;
>+  }
>+};
>+(html$.RangeInputElementBase.new = function() {
>+  this[max$0] = null;
>+  this[min$0] = null;
>+  this[step$] = null;
>+  this[valueAsNumber$] = null;
>+}).prototype = html$.RangeInputElementBase.prototype;
>+dart.addTypeTests(html$.RangeInputElementBase);
>+const max$0 = Symbol("RangeInputElementBase.max");
>+const min$0 = Symbol("RangeInputElementBase.min");
>+const step$ = Symbol("RangeInputElementBase.step");
>+const valueAsNumber$ = Symbol("RangeInputElementBase.valueAsNumber");
>+html$.RangeInputElementBase[dart.implements] = () => [html$.InputElementBase];
>+dart.setLibraryUri(html$.RangeInputElementBase, "dart:html");
>+dart.setFieldSignature(html$.RangeInputElementBase, () => ({
>+  __proto__: dart.getFields(html$.RangeInputElementBase.__proto__),
>+  max: dart.fieldType(core.String),
>+  min: dart.fieldType(core.String),
>+  step: dart.fieldType(core.String),
>+  valueAsNumber: dart.fieldType(core.num)
>+}));
>+dart.defineExtensionAccessors(html$.RangeInputElementBase, ['max', 'min', 'step', 'valueAsNumber']);
>+html$.DateInputElement = class DateInputElement extends core.Object {
>+  static new() {
>+    return html$.InputElement.new({type: "date"});
>+  }
>+  get valueAsDate() {
>+    return this[valueAsDate];
>+  }
>+  set valueAsDate(value) {
>+    this[valueAsDate] = value;
>+  }
>+  get readOnly() {
>+    return this[readOnly$2];
>+  }
>+  set readOnly(value) {
>+    this[readOnly$2] = value;
>+  }
>+  get required() {
>+    return this[required$2];
>+  }
>+  set required(value) {
>+    this[required$2] = value;
>+  }
>+  static get supported() {
>+    return html$.InputElement.new({type: "date"}).type === "date";
>+  }
>+};
>+(html$.DateInputElement[dart.mixinNew] = function() {
>+  this[valueAsDate] = null;
>+  this[readOnly$2] = null;
>+  this[required$2] = null;
>+}).prototype = html$.DateInputElement.prototype;
>+dart.addTypeTests(html$.DateInputElement);
>+const valueAsDate = Symbol("DateInputElement.valueAsDate");
>+const readOnly$2 = Symbol("DateInputElement.readOnly");
>+const required$2 = Symbol("DateInputElement.required");
>+html$.DateInputElement[dart.implements] = () => [html$.RangeInputElementBase];
>+dart.setLibraryUri(html$.DateInputElement, "dart:html");
>+dart.setFieldSignature(html$.DateInputElement, () => ({
>+  __proto__: dart.getFields(html$.DateInputElement.__proto__),
>+  valueAsDate: dart.fieldType(core.DateTime),
>+  readOnly: dart.fieldType(core.bool),
>+  required: dart.fieldType(core.bool)
>+}));
>+dart.defineExtensionAccessors(html$.DateInputElement, ['valueAsDate', 'readOnly', 'required']);
>+html$.MonthInputElement = class MonthInputElement extends core.Object {
>+  static new() {
>+    return html$.InputElement.new({type: "month"});
>+  }
>+  get valueAsDate() {
>+    return this[valueAsDate$];
>+  }
>+  set valueAsDate(value) {
>+    this[valueAsDate$] = value;
>+  }
>+  get readOnly() {
>+    return this[readOnly$3];
>+  }
>+  set readOnly(value) {
>+    this[readOnly$3] = value;
>+  }
>+  get required() {
>+    return this[required$3];
>+  }
>+  set required(value) {
>+    this[required$3] = value;
>+  }
>+  static get supported() {
>+    return html$.InputElement.new({type: "month"}).type === "month";
>+  }
>+};
>+(html$.MonthInputElement[dart.mixinNew] = function() {
>+  this[valueAsDate$] = null;
>+  this[readOnly$3] = null;
>+  this[required$3] = null;
>+}).prototype = html$.MonthInputElement.prototype;
>+dart.addTypeTests(html$.MonthInputElement);
>+const valueAsDate$ = Symbol("MonthInputElement.valueAsDate");
>+const readOnly$3 = Symbol("MonthInputElement.readOnly");
>+const required$3 = Symbol("MonthInputElement.required");
>+html$.MonthInputElement[dart.implements] = () => [html$.RangeInputElementBase];
>+dart.setLibraryUri(html$.MonthInputElement, "dart:html");
>+dart.setFieldSignature(html$.MonthInputElement, () => ({
>+  __proto__: dart.getFields(html$.MonthInputElement.__proto__),
>+  valueAsDate: dart.fieldType(core.DateTime),
>+  readOnly: dart.fieldType(core.bool),
>+  required: dart.fieldType(core.bool)
>+}));
>+dart.defineExtensionAccessors(html$.MonthInputElement, ['valueAsDate', 'readOnly', 'required']);
>+html$.WeekInputElement = class WeekInputElement extends core.Object {
>+  static new() {
>+    return html$.InputElement.new({type: "week"});
>+  }
>+  get valueAsDate() {
>+    return this[valueAsDate$0];
>+  }
>+  set valueAsDate(value) {
>+    this[valueAsDate$0] = value;
>+  }
>+  get readOnly() {
>+    return this[readOnly$4];
>+  }
>+  set readOnly(value) {
>+    this[readOnly$4] = value;
>+  }
>+  get required() {
>+    return this[required$4];
>+  }
>+  set required(value) {
>+    this[required$4] = value;
>+  }
>+  static get supported() {
>+    return html$.InputElement.new({type: "week"}).type === "week";
>+  }
>+};
>+(html$.WeekInputElement[dart.mixinNew] = function() {
>+  this[valueAsDate$0] = null;
>+  this[readOnly$4] = null;
>+  this[required$4] = null;
>+}).prototype = html$.WeekInputElement.prototype;
>+dart.addTypeTests(html$.WeekInputElement);
>+const valueAsDate$0 = Symbol("WeekInputElement.valueAsDate");
>+const readOnly$4 = Symbol("WeekInputElement.readOnly");
>+const required$4 = Symbol("WeekInputElement.required");
>+html$.WeekInputElement[dart.implements] = () => [html$.RangeInputElementBase];
>+dart.setLibraryUri(html$.WeekInputElement, "dart:html");
>+dart.setFieldSignature(html$.WeekInputElement, () => ({
>+  __proto__: dart.getFields(html$.WeekInputElement.__proto__),
>+  valueAsDate: dart.fieldType(core.DateTime),
>+  readOnly: dart.fieldType(core.bool),
>+  required: dart.fieldType(core.bool)
>+}));
>+dart.defineExtensionAccessors(html$.WeekInputElement, ['valueAsDate', 'readOnly', 'required']);
>+html$.TimeInputElement = class TimeInputElement extends core.Object {
>+  static new() {
>+    return html$.InputElement.new({type: "time"});
>+  }
>+  get valueAsDate() {
>+    return this[valueAsDate$1];
>+  }
>+  set valueAsDate(value) {
>+    this[valueAsDate$1] = value;
>+  }
>+  get readOnly() {
>+    return this[readOnly$5];
>+  }
>+  set readOnly(value) {
>+    this[readOnly$5] = value;
>+  }
>+  get required() {
>+    return this[required$5];
>+  }
>+  set required(value) {
>+    this[required$5] = value;
>+  }
>+  static get supported() {
>+    return html$.InputElement.new({type: "time"}).type === "time";
>+  }
>+};
>+(html$.TimeInputElement[dart.mixinNew] = function() {
>+  this[valueAsDate$1] = null;
>+  this[readOnly$5] = null;
>+  this[required$5] = null;
>+}).prototype = html$.TimeInputElement.prototype;
>+dart.addTypeTests(html$.TimeInputElement);
>+const valueAsDate$1 = Symbol("TimeInputElement.valueAsDate");
>+const readOnly$5 = Symbol("TimeInputElement.readOnly");
>+const required$5 = Symbol("TimeInputElement.required");
>+html$.TimeInputElement[dart.implements] = () => [html$.RangeInputElementBase];
>+dart.setLibraryUri(html$.TimeInputElement, "dart:html");
>+dart.setFieldSignature(html$.TimeInputElement, () => ({
>+  __proto__: dart.getFields(html$.TimeInputElement.__proto__),
>+  valueAsDate: dart.fieldType(core.DateTime),
>+  readOnly: dart.fieldType(core.bool),
>+  required: dart.fieldType(core.bool)
>+}));
>+dart.defineExtensionAccessors(html$.TimeInputElement, ['valueAsDate', 'readOnly', 'required']);
>+html$.LocalDateTimeInputElement = class LocalDateTimeInputElement extends core.Object {
>+  static new() {
>+    return html$.InputElement.new({type: "datetime-local"});
>+  }
>+  get readOnly() {
>+    return this[readOnly$6];
>+  }
>+  set readOnly(value) {
>+    this[readOnly$6] = value;
>+  }
>+  get required() {
>+    return this[required$6];
>+  }
>+  set required(value) {
>+    this[required$6] = value;
>+  }
>+  static get supported() {
>+    return html$.InputElement.new({type: "datetime-local"}).type === "datetime-local";
>+  }
>+};
>+(html$.LocalDateTimeInputElement[dart.mixinNew] = function() {
>+  this[readOnly$6] = null;
>+  this[required$6] = null;
>+}).prototype = html$.LocalDateTimeInputElement.prototype;
>+dart.addTypeTests(html$.LocalDateTimeInputElement);
>+const readOnly$6 = Symbol("LocalDateTimeInputElement.readOnly");
>+const required$6 = Symbol("LocalDateTimeInputElement.required");
>+html$.LocalDateTimeInputElement[dart.implements] = () => [html$.RangeInputElementBase];
>+dart.setLibraryUri(html$.LocalDateTimeInputElement, "dart:html");
>+dart.setFieldSignature(html$.LocalDateTimeInputElement, () => ({
>+  __proto__: dart.getFields(html$.LocalDateTimeInputElement.__proto__),
>+  readOnly: dart.fieldType(core.bool),
>+  required: dart.fieldType(core.bool)
>+}));
>+dart.defineExtensionAccessors(html$.LocalDateTimeInputElement, ['readOnly', 'required']);
>+html$.NumberInputElement = class NumberInputElement extends core.Object {
>+  static new() {
>+    return html$.InputElement.new({type: "number"});
>+  }
>+  get placeholder() {
>+    return this[placeholder$2];
>+  }
>+  set placeholder(value) {
>+    this[placeholder$2] = value;
>+  }
>+  get readOnly() {
>+    return this[readOnly$7];
>+  }
>+  set readOnly(value) {
>+    this[readOnly$7] = value;
>+  }
>+  get required() {
>+    return this[required$7];
>+  }
>+  set required(value) {
>+    this[required$7] = value;
>+  }
>+  static get supported() {
>+    return html$.InputElement.new({type: "number"}).type === "number";
>+  }
>+};
>+(html$.NumberInputElement[dart.mixinNew] = function() {
>+  this[placeholder$2] = null;
>+  this[readOnly$7] = null;
>+  this[required$7] = null;
>+}).prototype = html$.NumberInputElement.prototype;
>+dart.addTypeTests(html$.NumberInputElement);
>+const placeholder$2 = Symbol("NumberInputElement.placeholder");
>+const readOnly$7 = Symbol("NumberInputElement.readOnly");
>+const required$7 = Symbol("NumberInputElement.required");
>+html$.NumberInputElement[dart.implements] = () => [html$.RangeInputElementBase];
>+dart.setLibraryUri(html$.NumberInputElement, "dart:html");
>+dart.setFieldSignature(html$.NumberInputElement, () => ({
>+  __proto__: dart.getFields(html$.NumberInputElement.__proto__),
>+  placeholder: dart.fieldType(core.String),
>+  readOnly: dart.fieldType(core.bool),
>+  required: dart.fieldType(core.bool)
>+}));
>+dart.defineExtensionAccessors(html$.NumberInputElement, ['placeholder', 'readOnly', 'required']);
>+html$.RangeInputElement = class RangeInputElement extends core.Object {
>+  static new() {
>+    return html$.InputElement.new({type: "range"});
>+  }
>+  static get supported() {
>+    return html$.InputElement.new({type: "range"}).type === "range";
>+  }
>+};
>+(html$.RangeInputElement[dart.mixinNew] = function() {
>+}).prototype = html$.RangeInputElement.prototype;
>+dart.addTypeTests(html$.RangeInputElement);
>+html$.RangeInputElement[dart.implements] = () => [html$.RangeInputElementBase];
>+dart.setLibraryUri(html$.RangeInputElement, "dart:html");
>+html$.CheckboxInputElement = class CheckboxInputElement extends core.Object {
>+  static new() {
>+    return html$.InputElement.new({type: "checkbox"});
>+  }
>+  get checked() {
>+    return this[checked$0];
>+  }
>+  set checked(value) {
>+    this[checked$0] = value;
>+  }
>+  get required() {
>+    return this[required$8];
>+  }
>+  set required(value) {
>+    this[required$8] = value;
>+  }
>+};
>+(html$.CheckboxInputElement[dart.mixinNew] = function() {
>+  this[checked$0] = null;
>+  this[required$8] = null;
>+}).prototype = html$.CheckboxInputElement.prototype;
>+dart.addTypeTests(html$.CheckboxInputElement);
>+const checked$0 = Symbol("CheckboxInputElement.checked");
>+const required$8 = Symbol("CheckboxInputElement.required");
>+html$.CheckboxInputElement[dart.implements] = () => [html$.InputElementBase];
>+dart.setLibraryUri(html$.CheckboxInputElement, "dart:html");
>+dart.setFieldSignature(html$.CheckboxInputElement, () => ({
>+  __proto__: dart.getFields(html$.CheckboxInputElement.__proto__),
>+  checked: dart.fieldType(core.bool),
>+  required: dart.fieldType(core.bool)
>+}));
>+dart.defineExtensionAccessors(html$.CheckboxInputElement, ['checked', 'required']);
>+html$.RadioButtonInputElement = class RadioButtonInputElement extends core.Object {
>+  static new() {
>+    return html$.InputElement.new({type: "radio"});
>+  }
>+  get checked() {
>+    return this[checked$1];
>+  }
>+  set checked(value) {
>+    this[checked$1] = value;
>+  }
>+  get required() {
>+    return this[required$9];
>+  }
>+  set required(value) {
>+    this[required$9] = value;
>+  }
>+};
>+(html$.RadioButtonInputElement[dart.mixinNew] = function() {
>+  this[checked$1] = null;
>+  this[required$9] = null;
>+}).prototype = html$.RadioButtonInputElement.prototype;
>+dart.addTypeTests(html$.RadioButtonInputElement);
>+const checked$1 = Symbol("RadioButtonInputElement.checked");
>+const required$9 = Symbol("RadioButtonInputElement.required");
>+html$.RadioButtonInputElement[dart.implements] = () => [html$.InputElementBase];
>+dart.setLibraryUri(html$.RadioButtonInputElement, "dart:html");
>+dart.setFieldSignature(html$.RadioButtonInputElement, () => ({
>+  __proto__: dart.getFields(html$.RadioButtonInputElement.__proto__),
>+  checked: dart.fieldType(core.bool),
>+  required: dart.fieldType(core.bool)
>+}));
>+dart.defineExtensionAccessors(html$.RadioButtonInputElement, ['checked', 'required']);
>+html$.FileUploadInputElement = class FileUploadInputElement extends core.Object {
>+  static new() {
>+    return html$.InputElement.new({type: "file"});
>+  }
>+  get accept() {
>+    return this[accept$];
>+  }
>+  set accept(value) {
>+    this[accept$] = value;
>+  }
>+  get multiple() {
>+    return this[multiple$0];
>+  }
>+  set multiple(value) {
>+    this[multiple$0] = value;
>+  }
>+  get required() {
>+    return this[required$10];
>+  }
>+  set required(value) {
>+    this[required$10] = value;
>+  }
>+  get files() {
>+    return this[files$0];
>+  }
>+  set files(value) {
>+    this[files$0] = value;
>+  }
>+};
>+(html$.FileUploadInputElement[dart.mixinNew] = function() {
>+  this[accept$] = null;
>+  this[multiple$0] = null;
>+  this[required$10] = null;
>+  this[files$0] = null;
>+}).prototype = html$.FileUploadInputElement.prototype;
>+dart.addTypeTests(html$.FileUploadInputElement);
>+const accept$ = Symbol("FileUploadInputElement.accept");
>+const multiple$0 = Symbol("FileUploadInputElement.multiple");
>+const required$10 = Symbol("FileUploadInputElement.required");
>+const files$0 = Symbol("FileUploadInputElement.files");
>+html$.FileUploadInputElement[dart.implements] = () => [html$.InputElementBase];
>+dart.setLibraryUri(html$.FileUploadInputElement, "dart:html");
>+dart.setFieldSignature(html$.FileUploadInputElement, () => ({
>+  __proto__: dart.getFields(html$.FileUploadInputElement.__proto__),
>+  accept: dart.fieldType(core.String),
>+  multiple: dart.fieldType(core.bool),
>+  required: dart.fieldType(core.bool),
>+  files: dart.fieldType(ListOfFile())
>+}));
>+dart.defineExtensionAccessors(html$.FileUploadInputElement, ['accept', 'multiple', 'required', 'files']);
>+html$.SubmitButtonInputElement = class SubmitButtonInputElement extends core.Object {
>+  static new() {
>+    return html$.InputElement.new({type: "submit"});
>+  }
>+  get formAction() {
>+    return this[formAction$0];
>+  }
>+  set formAction(value) {
>+    this[formAction$0] = value;
>+  }
>+  get formEnctype() {
>+    return this[formEnctype$0];
>+  }
>+  set formEnctype(value) {
>+    this[formEnctype$0] = value;
>+  }
>+  get formMethod() {
>+    return this[formMethod$0];
>+  }
>+  set formMethod(value) {
>+    this[formMethod$0] = value;
>+  }
>+  get formNoValidate() {
>+    return this[formNoValidate$0];
>+  }
>+  set formNoValidate(value) {
>+    this[formNoValidate$0] = value;
>+  }
>+  get formTarget() {
>+    return this[formTarget$0];
>+  }
>+  set formTarget(value) {
>+    this[formTarget$0] = value;
>+  }
>+};
>+(html$.SubmitButtonInputElement[dart.mixinNew] = function() {
>+  this[formAction$0] = null;
>+  this[formEnctype$0] = null;
>+  this[formMethod$0] = null;
>+  this[formNoValidate$0] = null;
>+  this[formTarget$0] = null;
>+}).prototype = html$.SubmitButtonInputElement.prototype;
>+dart.addTypeTests(html$.SubmitButtonInputElement);
>+const formAction$0 = Symbol("SubmitButtonInputElement.formAction");
>+const formEnctype$0 = Symbol("SubmitButtonInputElement.formEnctype");
>+const formMethod$0 = Symbol("SubmitButtonInputElement.formMethod");
>+const formNoValidate$0 = Symbol("SubmitButtonInputElement.formNoValidate");
>+const formTarget$0 = Symbol("SubmitButtonInputElement.formTarget");
>+html$.SubmitButtonInputElement[dart.implements] = () => [html$.InputElementBase];
>+dart.setLibraryUri(html$.SubmitButtonInputElement, "dart:html");
>+dart.setFieldSignature(html$.SubmitButtonInputElement, () => ({
>+  __proto__: dart.getFields(html$.SubmitButtonInputElement.__proto__),
>+  formAction: dart.fieldType(core.String),
>+  formEnctype: dart.fieldType(core.String),
>+  formMethod: dart.fieldType(core.String),
>+  formNoValidate: dart.fieldType(core.bool),
>+  formTarget: dart.fieldType(core.String)
>+}));
>+dart.defineExtensionAccessors(html$.SubmitButtonInputElement, [
>+  'formAction',
>+  'formEnctype',
>+  'formMethod',
>+  'formNoValidate',
>+  'formTarget'
>+]);
>+html$.ImageButtonInputElement = class ImageButtonInputElement extends core.Object {
>+  static new() {
>+    return html$.InputElement.new({type: "image"});
>+  }
>+  get alt() {
>+    return this[alt$1];
>+  }
>+  set alt(value) {
>+    this[alt$1] = value;
>+  }
>+  get formAction() {
>+    return this[formAction$1];
>+  }
>+  set formAction(value) {
>+    this[formAction$1] = value;
>+  }
>+  get formEnctype() {
>+    return this[formEnctype$1];
>+  }
>+  set formEnctype(value) {
>+    this[formEnctype$1] = value;
>+  }
>+  get formMethod() {
>+    return this[formMethod$1];
>+  }
>+  set formMethod(value) {
>+    this[formMethod$1] = value;
>+  }
>+  get formNoValidate() {
>+    return this[formNoValidate$1];
>+  }
>+  set formNoValidate(value) {
>+    this[formNoValidate$1] = value;
>+  }
>+  get formTarget() {
>+    return this[formTarget$1];
>+  }
>+  set formTarget(value) {
>+    this[formTarget$1] = value;
>+  }
>+  get height() {
>+    return this[height$5];
>+  }
>+  set height(value) {
>+    this[height$5] = value;
>+  }
>+  get src() {
>+    return this[src$3];
>+  }
>+  set src(value) {
>+    this[src$3] = value;
>+  }
>+  get width() {
>+    return this[width$5];
>+  }
>+  set width(value) {
>+    this[width$5] = value;
>+  }
>+};
>+(html$.ImageButtonInputElement[dart.mixinNew] = function() {
>+  this[alt$1] = null;
>+  this[formAction$1] = null;
>+  this[formEnctype$1] = null;
>+  this[formMethod$1] = null;
>+  this[formNoValidate$1] = null;
>+  this[formTarget$1] = null;
>+  this[height$5] = null;
>+  this[src$3] = null;
>+  this[width$5] = null;
>+}).prototype = html$.ImageButtonInputElement.prototype;
>+dart.addTypeTests(html$.ImageButtonInputElement);
>+const alt$1 = Symbol("ImageButtonInputElement.alt");
>+const formAction$1 = Symbol("ImageButtonInputElement.formAction");
>+const formEnctype$1 = Symbol("ImageButtonInputElement.formEnctype");
>+const formMethod$1 = Symbol("ImageButtonInputElement.formMethod");
>+const formNoValidate$1 = Symbol("ImageButtonInputElement.formNoValidate");
>+const formTarget$1 = Symbol("ImageButtonInputElement.formTarget");
>+const height$5 = Symbol("ImageButtonInputElement.height");
>+const src$3 = Symbol("ImageButtonInputElement.src");
>+const width$5 = Symbol("ImageButtonInputElement.width");
>+html$.ImageButtonInputElement[dart.implements] = () => [html$.InputElementBase];
>+dart.setLibraryUri(html$.ImageButtonInputElement, "dart:html");
>+dart.setFieldSignature(html$.ImageButtonInputElement, () => ({
>+  __proto__: dart.getFields(html$.ImageButtonInputElement.__proto__),
>+  alt: dart.fieldType(core.String),
>+  formAction: dart.fieldType(core.String),
>+  formEnctype: dart.fieldType(core.String),
>+  formMethod: dart.fieldType(core.String),
>+  formNoValidate: dart.fieldType(core.bool),
>+  formTarget: dart.fieldType(core.String),
>+  height: dart.fieldType(core.int),
>+  src: dart.fieldType(core.String),
>+  width: dart.fieldType(core.int)
>+}));
>+dart.defineExtensionAccessors(html$.ImageButtonInputElement, [
>+  'alt',
>+  'formAction',
>+  'formEnctype',
>+  'formMethod',
>+  'formNoValidate',
>+  'formTarget',
>+  'height',
>+  'src',
>+  'width'
>+]);
>+html$.ResetButtonInputElement = class ResetButtonInputElement extends core.Object {
>+  static new() {
>+    return html$.InputElement.new({type: "reset"});
>+  }
>+};
>+(html$.ResetButtonInputElement[dart.mixinNew] = function() {
>+}).prototype = html$.ResetButtonInputElement.prototype;
>+dart.addTypeTests(html$.ResetButtonInputElement);
>+html$.ResetButtonInputElement[dart.implements] = () => [html$.InputElementBase];
>+dart.setLibraryUri(html$.ResetButtonInputElement, "dart:html");
>+html$.ButtonInputElement = class ButtonInputElement extends core.Object {
>+  static new() {
>+    return html$.InputElement.new({type: "button"});
>+  }
>+};
>+(html$.ButtonInputElement[dart.mixinNew] = function() {
>+}).prototype = html$.ButtonInputElement.prototype;
>+dart.addTypeTests(html$.ButtonInputElement);
>+html$.ButtonInputElement[dart.implements] = () => [html$.InputElementBase];
>+dart.setLibraryUri(html$.ButtonInputElement, "dart:html");
>+const _registerForeignFetch_1 = dart.privateName(html$, "_registerForeignFetch_1");
>+html$.InstallEvent = class InstallEvent$ extends html$.ExtendableEvent {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.InstallEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.InstallEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new InstallEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new InstallEvent(type);
>+  }
>+  [$registerForeignFetch](options) {
>+    let options_1 = html_common.convertDartToNative_Dictionary(options);
>+    this[_registerForeignFetch_1](options_1);
>+    return;
>+  }
>+  [_registerForeignFetch_1](...args) {
>+    return this.registerForeignFetch.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.InstallEvent);
>+dart.setMethodSignature(html$.InstallEvent, () => ({
>+  __proto__: dart.getMethods(html$.InstallEvent.__proto__),
>+  [$registerForeignFetch]: dart.fnType(dart.void, [core.Map]),
>+  [_registerForeignFetch_1]: dart.fnType(dart.void, [dart.dynamic])
>+}));
>+dart.setLibraryUri(html$.InstallEvent, "dart:html");
>+dart.registerExtension("InstallEvent", html$.InstallEvent);
>+html$.IntersectionObserver = class IntersectionObserver$ extends _interceptors.Interceptor {
>+  static new(callback, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let callback_1 = _js_helper.convertDartClosureToJS(ListAndIntersectionObserverTovoid(), callback, 2);
>+      let options_2 = html_common.convertDartToNative_Dictionary(options);
>+      return html$.IntersectionObserver._create_1(callback_1, options_2);
>+    }
>+    let callback_1 = _js_helper.convertDartClosureToJS(ListAndIntersectionObserverTovoid(), callback, 2);
>+    return html$.IntersectionObserver._create_2(callback_1);
>+  }
>+  static _create_1(callback, options) {
>+    return new IntersectionObserver(callback, options);
>+  }
>+  static _create_2(callback) {
>+    return new IntersectionObserver(callback);
>+  }
>+  get [$root]() {
>+    return this.root;
>+  }
>+  get [$rootMargin]() {
>+    return this.rootMargin;
>+  }
>+  get [$thresholds]() {
>+    return this.thresholds;
>+  }
>+  [$disconnect](...args) {
>+    return this.disconnect.apply(this, args);
>+  }
>+  [$observe](...args) {
>+    return this.observe.apply(this, args);
>+  }
>+  [$takeRecords](...args) {
>+    return this.takeRecords.apply(this, args);
>+  }
>+  [$unobserve](...args) {
>+    return this.unobserve.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.IntersectionObserver);
>+const root$ = Symbol("IntersectionObserver.root");
>+const rootMargin = Symbol("IntersectionObserver.rootMargin");
>+const thresholds = Symbol("IntersectionObserver.thresholds");
>+dart.setMethodSignature(html$.IntersectionObserver, () => ({
>+  __proto__: dart.getMethods(html$.IntersectionObserver.__proto__),
>+  [$disconnect]: dart.fnType(dart.void, []),
>+  [$observe]: dart.fnType(dart.void, [html$.Element]),
>+  [$takeRecords]: dart.fnType(core.List$(html$.IntersectionObserverEntry), []),
>+  [$unobserve]: dart.fnType(dart.void, [html$.Element])
>+}));
>+dart.setLibraryUri(html$.IntersectionObserver, "dart:html");
>+dart.setFieldSignature(html$.IntersectionObserver, () => ({
>+  __proto__: dart.getFields(html$.IntersectionObserver.__proto__),
>+  [$root]: dart.finalFieldType(html$.Element),
>+  [$rootMargin]: dart.finalFieldType(core.String),
>+  [$thresholds]: dart.finalFieldType(ListOfnum())
>+}));
>+dart.registerExtension("IntersectionObserver", html$.IntersectionObserver);
>+html$.IntersectionObserverEntry = class IntersectionObserverEntry extends _interceptors.Interceptor {
>+  get [$boundingClientRect]() {
>+    return this.boundingClientRect;
>+  }
>+  get [$intersectionRatio]() {
>+    return this.intersectionRatio;
>+  }
>+  get [$intersectionRect]() {
>+    return this.intersectionRect;
>+  }
>+  get [$isIntersecting]() {
>+    return this.isIntersecting;
>+  }
>+  get [$rootBounds]() {
>+    return this.rootBounds;
>+  }
>+  get [$target]() {
>+    return this.target;
>+  }
>+  get [$time]() {
>+    return this.time;
>+  }
>+};
>+dart.addTypeTests(html$.IntersectionObserverEntry);
>+const boundingClientRect = Symbol("IntersectionObserverEntry.boundingClientRect");
>+const intersectionRatio = Symbol("IntersectionObserverEntry.intersectionRatio");
>+const intersectionRect = Symbol("IntersectionObserverEntry.intersectionRect");
>+const isIntersecting = Symbol("IntersectionObserverEntry.isIntersecting");
>+const rootBounds = Symbol("IntersectionObserverEntry.rootBounds");
>+const target$3 = Symbol("IntersectionObserverEntry.target");
>+const time$ = Symbol("IntersectionObserverEntry.time");
>+dart.setLibraryUri(html$.IntersectionObserverEntry, "dart:html");
>+dart.setFieldSignature(html$.IntersectionObserverEntry, () => ({
>+  __proto__: dart.getFields(html$.IntersectionObserverEntry.__proto__),
>+  [$boundingClientRect]: dart.finalFieldType(html$.DomRectReadOnly),
>+  [$intersectionRatio]: dart.finalFieldType(core.num),
>+  [$intersectionRect]: dart.finalFieldType(html$.DomRectReadOnly),
>+  [$isIntersecting]: dart.finalFieldType(core.bool),
>+  [$rootBounds]: dart.finalFieldType(html$.DomRectReadOnly),
>+  [$target]: dart.finalFieldType(html$.Element),
>+  [$time]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("IntersectionObserverEntry", html$.IntersectionObserverEntry);
>+html$.InterventionReport = class InterventionReport extends html$.ReportBody {
>+  get [$lineNumber]() {
>+    return this.lineNumber;
>+  }
>+  get [$message]() {
>+    return this.message;
>+  }
>+  get [$sourceFile]() {
>+    return this.sourceFile;
>+  }
>+};
>+dart.addTypeTests(html$.InterventionReport);
>+const lineNumber$ = Symbol("InterventionReport.lineNumber");
>+const message$20 = Symbol("InterventionReport.message");
>+const sourceFile$ = Symbol("InterventionReport.sourceFile");
>+dart.setLibraryUri(html$.InterventionReport, "dart:html");
>+dart.setFieldSignature(html$.InterventionReport, () => ({
>+  __proto__: dart.getFields(html$.InterventionReport.__proto__),
>+  [$lineNumber]: dart.finalFieldType(core.int),
>+  [$message]: dart.finalFieldType(core.String),
>+  [$sourceFile]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("InterventionReport", html$.InterventionReport);
>+const _initKeyboardEvent = dart.privateName(html$, "_initKeyboardEvent");
>+const _charCode = dart.privateName(html$, "_charCode");
>+const _keyCode = dart.privateName(html$, "_keyCode");
>+html$.KeyboardEvent = class KeyboardEvent$ extends html$.UIEvent {
>+  static new(type, opts) {
>+    let view = opts && 'view' in opts ? opts.view : null;
>+    let canBubble = opts && 'canBubble' in opts ? opts.canBubble : true;
>+    let cancelable = opts && 'cancelable' in opts ? opts.cancelable : true;
>+    let location = opts && 'location' in opts ? opts.location : null;
>+    let keyLocation = opts && 'keyLocation' in opts ? opts.keyLocation : null;
>+    let ctrlKey = opts && 'ctrlKey' in opts ? opts.ctrlKey : false;
>+    let altKey = opts && 'altKey' in opts ? opts.altKey : false;
>+    let shiftKey = opts && 'shiftKey' in opts ? opts.shiftKey : false;
>+    let metaKey = opts && 'metaKey' in opts ? opts.metaKey : false;
>+    if (view == null) {
>+      view = html$.window;
>+    }
>+    let t = location;
>+    t == null ? location = keyLocation != null ? keyLocation : 1 : t;
>+    let e = html$.KeyboardEvent._check(html$.document[_createEvent]("KeyboardEvent"));
>+    e[_initKeyboardEvent](type, canBubble, cancelable, view, "", location, ctrlKey, altKey, shiftKey, metaKey);
>+    return e;
>+  }
>+  [_initKeyboardEvent](type, canBubble, cancelable, view, keyIdentifier, location, ctrlKey, altKey, shiftKey, metaKey) {
>+    if (typeof this.initKeyEvent == "function") {
>+      this.initKeyEvent(type, canBubble, cancelable, view, ctrlKey, altKey, shiftKey, metaKey, 0, 0);
>+    } else {
>+      this.initKeyboardEvent(type, canBubble, cancelable, view, keyIdentifier, location, ctrlKey, altKey, shiftKey, metaKey);
>+    }
>+  }
>+  get [$keyCode]() {
>+    return this.keyCode;
>+  }
>+  get [$charCode]() {
>+    return this.charCode;
>+  }
>+  get [$which]() {
>+    return this[_which];
>+  }
>+  static __(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.KeyboardEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.KeyboardEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new KeyboardEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new KeyboardEvent(type);
>+  }
>+  get [$altKey]() {
>+    return this.altKey;
>+  }
>+  get [_charCode]() {
>+    return this.charCode;
>+  }
>+  get [$code]() {
>+    return this.code;
>+  }
>+  get [$ctrlKey]() {
>+    return this.ctrlKey;
>+  }
>+  get [$isComposing]() {
>+    return this.isComposing;
>+  }
>+  get [$key]() {
>+    return this.key;
>+  }
>+  get [_keyCode]() {
>+    return this.keyCode;
>+  }
>+  get [$location]() {
>+    return this.location;
>+  }
>+  get [$metaKey]() {
>+    return this.metaKey;
>+  }
>+  get [$repeat]() {
>+    return this.repeat;
>+  }
>+  get [$shiftKey]() {
>+    return this.shiftKey;
>+  }
>+  [$getModifierState](...args) {
>+    return this.getModifierState.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.KeyboardEvent);
>+const keyCode = Symbol("KeyboardEvent.keyCode");
>+const charCode = Symbol("KeyboardEvent.charCode");
>+const altKey = Symbol("KeyboardEvent.altKey");
>+const code$ = Symbol("KeyboardEvent.code");
>+const ctrlKey = Symbol("KeyboardEvent.ctrlKey");
>+const isComposing = Symbol("KeyboardEvent.isComposing");
>+const key$0 = Symbol("KeyboardEvent.key");
>+const location$ = Symbol("KeyboardEvent.location");
>+const metaKey = Symbol("KeyboardEvent.metaKey");
>+const repeat = Symbol("KeyboardEvent.repeat");
>+const shiftKey = Symbol("KeyboardEvent.shiftKey");
>+dart.setMethodSignature(html$.KeyboardEvent, () => ({
>+  __proto__: dart.getMethods(html$.KeyboardEvent.__proto__),
>+  [_initKeyboardEvent]: dart.fnType(dart.void, [core.String, core.bool, core.bool, html$.Window, core.String, core.int, core.bool, core.bool, core.bool, core.bool]),
>+  [$getModifierState]: dart.fnType(core.bool, [core.String])
>+}));
>+dart.setGetterSignature(html$.KeyboardEvent, () => ({
>+  __proto__: dart.getGetters(html$.KeyboardEvent.__proto__),
>+  [$which]: core.int
>+}));
>+dart.setLibraryUri(html$.KeyboardEvent, "dart:html");
>+dart.setFieldSignature(html$.KeyboardEvent, () => ({
>+  __proto__: dart.getFields(html$.KeyboardEvent.__proto__),
>+  [$keyCode]: dart.finalFieldType(core.int),
>+  [$charCode]: dart.finalFieldType(core.int),
>+  [$altKey]: dart.finalFieldType(core.bool),
>+  [_charCode]: dart.finalFieldType(core.int),
>+  [$code]: dart.finalFieldType(core.String),
>+  [$ctrlKey]: dart.finalFieldType(core.bool),
>+  [$isComposing]: dart.finalFieldType(core.bool),
>+  [$key]: dart.finalFieldType(core.String),
>+  [_keyCode]: dart.finalFieldType(core.int),
>+  [$location]: dart.finalFieldType(core.int),
>+  [$metaKey]: dart.finalFieldType(core.bool),
>+  [$repeat]: dart.finalFieldType(core.bool),
>+  [$shiftKey]: dart.finalFieldType(core.bool)
>+}));
>+dart.defineLazy(html$.KeyboardEvent, {
>+  /*html$.KeyboardEvent.DOM_KEY_LOCATION_LEFT*/get DOM_KEY_LOCATION_LEFT() {
>+    return 1;
>+  },
>+  /*html$.KeyboardEvent.DOM_KEY_LOCATION_NUMPAD*/get DOM_KEY_LOCATION_NUMPAD() {
>+    return 3;
>+  },
>+  /*html$.KeyboardEvent.DOM_KEY_LOCATION_RIGHT*/get DOM_KEY_LOCATION_RIGHT() {
>+    return 2;
>+  },
>+  /*html$.KeyboardEvent.DOM_KEY_LOCATION_STANDARD*/get DOM_KEY_LOCATION_STANDARD() {
>+    return 0;
>+  }
>+});
>+dart.registerExtension("KeyboardEvent", html$.KeyboardEvent);
>+html$.KeyframeEffectReadOnly = class KeyframeEffectReadOnly$ extends html$.AnimationEffectReadOnly {
>+  static new(target, effect, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      return html$.KeyframeEffectReadOnly._create_1(target, effect, options);
>+    }
>+    return html$.KeyframeEffectReadOnly._create_2(target, effect);
>+  }
>+  static _create_1(target, effect, options) {
>+    return new KeyframeEffectReadOnly(target, effect, options);
>+  }
>+  static _create_2(target, effect) {
>+    return new KeyframeEffectReadOnly(target, effect);
>+  }
>+};
>+dart.addTypeTests(html$.KeyframeEffectReadOnly);
>+dart.setLibraryUri(html$.KeyframeEffectReadOnly, "dart:html");
>+dart.registerExtension("KeyframeEffectReadOnly", html$.KeyframeEffectReadOnly);
>+html$.KeyframeEffect = class KeyframeEffect$ extends html$.KeyframeEffectReadOnly {
>+  static new(target, effect, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      return html$.KeyframeEffect._create_1(target, effect, options);
>+    }
>+    return html$.KeyframeEffect._create_2(target, effect);
>+  }
>+  static _create_1(target, effect, options) {
>+    return new KeyframeEffect(target, effect, options);
>+  }
>+  static _create_2(target, effect) {
>+    return new KeyframeEffect(target, effect);
>+  }
>+};
>+dart.addTypeTests(html$.KeyframeEffect);
>+dart.setLibraryUri(html$.KeyframeEffect, "dart:html");
>+dart.registerExtension("KeyframeEffect", html$.KeyframeEffect);
>+html$.LIElement = class LIElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("li");
>+  }
>+  get [$value]() {
>+    return this.value;
>+  }
>+  set [$value](value) {
>+    this.value = value;
>+  }
>+};
>+(html$.LIElement.created = function() {
>+  this[value$9] = null;
>+  html$.LIElement.__proto__.created.call(this);
>+}).prototype = html$.LIElement.prototype;
>+dart.addTypeTests(html$.LIElement);
>+const value$9 = Symbol("LIElement.value");
>+dart.setLibraryUri(html$.LIElement, "dart:html");
>+dart.setFieldSignature(html$.LIElement, () => ({
>+  __proto__: dart.getFields(html$.LIElement.__proto__),
>+  [$value]: dart.fieldType(core.int)
>+}));
>+dart.registerExtension("HTMLLIElement", html$.LIElement);
>+html$.LabelElement = class LabelElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("label");
>+  }
>+  get [$control]() {
>+    return this.control;
>+  }
>+  get [$form]() {
>+    return this.form;
>+  }
>+  get [$htmlFor]() {
>+    return this.htmlFor;
>+  }
>+  set [$htmlFor](value) {
>+    this.htmlFor = value;
>+  }
>+};
>+(html$.LabelElement.created = function() {
>+  this[control] = null;
>+  this[form$1] = null;
>+  this[htmlFor] = null;
>+  html$.LabelElement.__proto__.created.call(this);
>+}).prototype = html$.LabelElement.prototype;
>+dart.addTypeTests(html$.LabelElement);
>+const control = Symbol("LabelElement.control");
>+const form$1 = Symbol("LabelElement.form");
>+const htmlFor = Symbol("LabelElement.htmlFor");
>+dart.setLibraryUri(html$.LabelElement, "dart:html");
>+dart.setFieldSignature(html$.LabelElement, () => ({
>+  __proto__: dart.getFields(html$.LabelElement.__proto__),
>+  [$control]: dart.finalFieldType(html$.HtmlElement),
>+  [$form]: dart.finalFieldType(html$.FormElement),
>+  [$htmlFor]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("HTMLLabelElement", html$.LabelElement);
>+html$.LegendElement = class LegendElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("legend");
>+  }
>+  get [$form]() {
>+    return this.form;
>+  }
>+};
>+(html$.LegendElement.created = function() {
>+  this[form$2] = null;
>+  html$.LegendElement.__proto__.created.call(this);
>+}).prototype = html$.LegendElement.prototype;
>+dart.addTypeTests(html$.LegendElement);
>+const form$2 = Symbol("LegendElement.form");
>+dart.setLibraryUri(html$.LegendElement, "dart:html");
>+dart.setFieldSignature(html$.LegendElement, () => ({
>+  __proto__: dart.getFields(html$.LegendElement.__proto__),
>+  [$form]: dart.finalFieldType(html$.FormElement)
>+}));
>+dart.registerExtension("HTMLLegendElement", html$.LegendElement);
>+html$.LinearAccelerationSensor = class LinearAccelerationSensor$ extends html$.Accelerometer {
>+  static new(sensorOptions) {
>+    if (sensorOptions === void 0) sensorOptions = null;
>+    if (sensorOptions != null) {
>+      let sensorOptions_1 = html_common.convertDartToNative_Dictionary(sensorOptions);
>+      return html$.LinearAccelerationSensor._create_1(sensorOptions_1);
>+    }
>+    return html$.LinearAccelerationSensor._create_2();
>+  }
>+  static _create_1(sensorOptions) {
>+    return new LinearAccelerationSensor(sensorOptions);
>+  }
>+  static _create_2() {
>+    return new LinearAccelerationSensor();
>+  }
>+};
>+dart.addTypeTests(html$.LinearAccelerationSensor);
>+dart.setLibraryUri(html$.LinearAccelerationSensor, "dart:html");
>+dart.registerExtension("LinearAccelerationSensor", html$.LinearAccelerationSensor);
>+html$.LinkElement = class LinkElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("link");
>+  }
>+  get [$as]() {
>+    return this.as;
>+  }
>+  set [$as](value) {
>+    this.as = value;
>+  }
>+  get [$crossOrigin]() {
>+    return this.crossOrigin;
>+  }
>+  set [$crossOrigin](value) {
>+    this.crossOrigin = value;
>+  }
>+  get [$disabled]() {
>+    return this.disabled;
>+  }
>+  set [$disabled](value) {
>+    this.disabled = value;
>+  }
>+  get [$href]() {
>+    return this.href;
>+  }
>+  set [$href](value) {
>+    this.href = value;
>+  }
>+  get [$hreflang]() {
>+    return this.hreflang;
>+  }
>+  set [$hreflang](value) {
>+    this.hreflang = value;
>+  }
>+  get [$import]() {
>+    return this.import;
>+  }
>+  get [$integrity]() {
>+    return this.integrity;
>+  }
>+  set [$integrity](value) {
>+    this.integrity = value;
>+  }
>+  get [$media]() {
>+    return this.media;
>+  }
>+  set [$media](value) {
>+    this.media = value;
>+  }
>+  get [$referrerPolicy]() {
>+    return this.referrerPolicy;
>+  }
>+  set [$referrerPolicy](value) {
>+    this.referrerPolicy = value;
>+  }
>+  get [$rel]() {
>+    return this.rel;
>+  }
>+  set [$rel](value) {
>+    this.rel = value;
>+  }
>+  get [$relList]() {
>+    return this.relList;
>+  }
>+  get [$scope]() {
>+    return this.scope;
>+  }
>+  set [$scope](value) {
>+    this.scope = value;
>+  }
>+  get [$sheet]() {
>+    return this.sheet;
>+  }
>+  get [$sizes]() {
>+    return this.sizes;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  set [$type](value) {
>+    this.type = value;
>+  }
>+  get [$supportsImport]() {
>+    return "import" in this;
>+  }
>+};
>+(html$.LinkElement.created = function() {
>+  this[as] = null;
>+  this[crossOrigin$0] = null;
>+  this[disabled$4] = null;
>+  this[href$4] = null;
>+  this[hreflang$] = null;
>+  this[import$] = null;
>+  this[integrity] = null;
>+  this[media$1] = null;
>+  this[referrerPolicy$2] = null;
>+  this[rel$0] = null;
>+  this[relList] = null;
>+  this[scope] = null;
>+  this[sheet] = null;
>+  this[sizes$] = null;
>+  this[type$16] = null;
>+  html$.LinkElement.__proto__.created.call(this);
>+}).prototype = html$.LinkElement.prototype;
>+dart.addTypeTests(html$.LinkElement);
>+const as = Symbol("LinkElement.as");
>+const crossOrigin$0 = Symbol("LinkElement.crossOrigin");
>+const disabled$4 = Symbol("LinkElement.disabled");
>+const href$4 = Symbol("LinkElement.href");
>+const hreflang$ = Symbol("LinkElement.hreflang");
>+const import$ = Symbol("LinkElement.import");
>+const integrity = Symbol("LinkElement.integrity");
>+const media$1 = Symbol("LinkElement.media");
>+const referrerPolicy$2 = Symbol("LinkElement.referrerPolicy");
>+const rel$0 = Symbol("LinkElement.rel");
>+const relList = Symbol("LinkElement.relList");
>+const scope = Symbol("LinkElement.scope");
>+const sheet = Symbol("LinkElement.sheet");
>+const sizes$ = Symbol("LinkElement.sizes");
>+const type$16 = Symbol("LinkElement.type");
>+dart.setGetterSignature(html$.LinkElement, () => ({
>+  __proto__: dart.getGetters(html$.LinkElement.__proto__),
>+  [$supportsImport]: core.bool
>+}));
>+dart.setLibraryUri(html$.LinkElement, "dart:html");
>+dart.setFieldSignature(html$.LinkElement, () => ({
>+  __proto__: dart.getFields(html$.LinkElement.__proto__),
>+  [$as]: dart.fieldType(core.String),
>+  [$crossOrigin]: dart.fieldType(core.String),
>+  [$disabled]: dart.fieldType(core.bool),
>+  [$href]: dart.fieldType(core.String),
>+  [$hreflang]: dart.fieldType(core.String),
>+  [$import]: dart.finalFieldType(html$.Document),
>+  [$integrity]: dart.fieldType(core.String),
>+  [$media]: dart.fieldType(core.String),
>+  [$referrerPolicy]: dart.fieldType(core.String),
>+  [$rel]: dart.fieldType(core.String),
>+  [$relList]: dart.finalFieldType(html$.DomTokenList),
>+  [$scope]: dart.fieldType(core.String),
>+  [$sheet]: dart.finalFieldType(html$.StyleSheet),
>+  [$sizes]: dart.finalFieldType(html$.DomTokenList),
>+  [$type]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("HTMLLinkElement", html$.LinkElement);
>+html$.Location = class Location extends _interceptors.Interceptor {
>+  get [$ancestorOrigins]() {
>+    return this.ancestorOrigins;
>+  }
>+  get [$hash]() {
>+    return this.hash;
>+  }
>+  set [$hash](value) {
>+    this.hash = value;
>+  }
>+  get [$host]() {
>+    return this.host;
>+  }
>+  set [$host](value) {
>+    this.host = value;
>+  }
>+  get [$hostname]() {
>+    return this.hostname;
>+  }
>+  set [$hostname](value) {
>+    this.hostname = value;
>+  }
>+  get [$href]() {
>+    return this.href;
>+  }
>+  set [$href](value) {
>+    this.href = value;
>+  }
>+  get [$pathname]() {
>+    return this.pathname;
>+  }
>+  set [$pathname](value) {
>+    this.pathname = value;
>+  }
>+  get [$port]() {
>+    return this.port;
>+  }
>+  set [$port](value) {
>+    this.port = value;
>+  }
>+  get [$protocol]() {
>+    return this.protocol;
>+  }
>+  set [$protocol](value) {
>+    this.protocol = value;
>+  }
>+  get [$search]() {
>+    return this.search;
>+  }
>+  set [$search](value) {
>+    this.search = value;
>+  }
>+  get [$trustedHref]() {
>+    return this.trustedHref;
>+  }
>+  set [$trustedHref](value) {
>+    this.trustedHref = value;
>+  }
>+  [$assign](...args) {
>+    return this.assign.apply(this, args);
>+  }
>+  [$reload](...args) {
>+    return this.reload.apply(this, args);
>+  }
>+  [$replace](...args) {
>+    return this.replace.apply(this, args);
>+  }
>+  get [$origin]() {
>+    if ("origin" in this) {
>+      return this.origin;
>+    }
>+    return dart.str(this.protocol) + "//" + dart.str(this.host);
>+  }
>+  [$toString]() {
>+    return String(this);
>+  }
>+};
>+dart.addTypeTests(html$.Location);
>+const ancestorOrigins = Symbol("Location.ancestorOrigins");
>+const hash$1 = Symbol("Location.hash");
>+const host$1 = Symbol("Location.host");
>+const hostname$1 = Symbol("Location.hostname");
>+const href$5 = Symbol("Location.href");
>+const pathname$1 = Symbol("Location.pathname");
>+const port$3 = Symbol("Location.port");
>+const protocol$2 = Symbol("Location.protocol");
>+const search$1 = Symbol("Location.search");
>+const trustedHref = Symbol("Location.trustedHref");
>+html$.Location[dart.implements] = () => [html$.LocationBase];
>+dart.setMethodSignature(html$.Location, () => ({
>+  __proto__: dart.getMethods(html$.Location.__proto__),
>+  [$assign]: dart.fnType(dart.void, [], [core.String]),
>+  [$reload]: dart.fnType(dart.void, []),
>+  [$replace]: dart.fnType(dart.void, [core.String])
>+}));
>+dart.setGetterSignature(html$.Location, () => ({
>+  __proto__: dart.getGetters(html$.Location.__proto__),
>+  [$origin]: core.String
>+}));
>+dart.setLibraryUri(html$.Location, "dart:html");
>+dart.setFieldSignature(html$.Location, () => ({
>+  __proto__: dart.getFields(html$.Location.__proto__),
>+  [$ancestorOrigins]: dart.finalFieldType(ListOfString()),
>+  [$hash]: dart.fieldType(core.String),
>+  [$host]: dart.fieldType(core.String),
>+  [$hostname]: dart.fieldType(core.String),
>+  [$href]: dart.fieldType(core.String),
>+  [$pathname]: dart.fieldType(core.String),
>+  [$port]: dart.fieldType(core.String),
>+  [$protocol]: dart.fieldType(core.String),
>+  [$search]: dart.fieldType(core.String),
>+  [$trustedHref]: dart.fieldType(html$.TrustedUrl)
>+}));
>+dart.registerExtension("Location", html$.Location);
>+html$.Magnetometer = class Magnetometer$ extends html$.Sensor {
>+  static new(sensorOptions) {
>+    if (sensorOptions === void 0) sensorOptions = null;
>+    if (sensorOptions != null) {
>+      let sensorOptions_1 = html_common.convertDartToNative_Dictionary(sensorOptions);
>+      return html$.Magnetometer._create_1(sensorOptions_1);
>+    }
>+    return html$.Magnetometer._create_2();
>+  }
>+  static _create_1(sensorOptions) {
>+    return new Magnetometer(sensorOptions);
>+  }
>+  static _create_2() {
>+    return new Magnetometer();
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+  get [$z]() {
>+    return this.z;
>+  }
>+};
>+dart.addTypeTests(html$.Magnetometer);
>+const x$5 = Symbol("Magnetometer.x");
>+const y$5 = Symbol("Magnetometer.y");
>+const z$4 = Symbol("Magnetometer.z");
>+dart.setLibraryUri(html$.Magnetometer, "dart:html");
>+dart.setFieldSignature(html$.Magnetometer, () => ({
>+  __proto__: dart.getFields(html$.Magnetometer.__proto__),
>+  [$x]: dart.finalFieldType(core.num),
>+  [$y]: dart.finalFieldType(core.num),
>+  [$z]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("Magnetometer", html$.Magnetometer);
>+html$.MapElement = class MapElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("map");
>+  }
>+  get [$areas]() {
>+    return this.areas;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+  set [$name](value) {
>+    this.name = value;
>+  }
>+};
>+(html$.MapElement.created = function() {
>+  this[areas] = null;
>+  this[name$21] = null;
>+  html$.MapElement.__proto__.created.call(this);
>+}).prototype = html$.MapElement.prototype;
>+dart.addTypeTests(html$.MapElement);
>+const areas = Symbol("MapElement.areas");
>+const name$21 = Symbol("MapElement.name");
>+dart.setLibraryUri(html$.MapElement, "dart:html");
>+dart.setFieldSignature(html$.MapElement, () => ({
>+  __proto__: dart.getFields(html$.MapElement.__proto__),
>+  [$areas]: dart.finalFieldType(ListOfNode()),
>+  [$name]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("HTMLMapElement", html$.MapElement);
>+html$.MediaCapabilities = class MediaCapabilities extends _interceptors.Interceptor {
>+  [$decodingInfo](configuration) {
>+    let configuration_dict = html_common.convertDartToNative_Dictionary(configuration);
>+    return html$.promiseToFuture(html$.MediaCapabilitiesInfo, this.decodingInfo(configuration_dict));
>+  }
>+  [$encodingInfo](configuration) {
>+    let configuration_dict = html_common.convertDartToNative_Dictionary(configuration);
>+    return html$.promiseToFuture(html$.MediaCapabilitiesInfo, this.encodingInfo(configuration_dict));
>+  }
>+};
>+dart.addTypeTests(html$.MediaCapabilities);
>+dart.setMethodSignature(html$.MediaCapabilities, () => ({
>+  __proto__: dart.getMethods(html$.MediaCapabilities.__proto__),
>+  [$decodingInfo]: dart.fnType(async.Future$(html$.MediaCapabilitiesInfo), [core.Map]),
>+  [$encodingInfo]: dart.fnType(async.Future$(html$.MediaCapabilitiesInfo), [core.Map])
>+}));
>+dart.setLibraryUri(html$.MediaCapabilities, "dart:html");
>+dart.registerExtension("MediaCapabilities", html$.MediaCapabilities);
>+html$.MediaCapabilitiesInfo = class MediaCapabilitiesInfo extends _interceptors.Interceptor {
>+  get [$powerEfficient]() {
>+    return this.powerEfficient;
>+  }
>+  get [$smooth]() {
>+    return this.smooth;
>+  }
>+  get [$supported]() {
>+    return this.supported;
>+  }
>+};
>+dart.addTypeTests(html$.MediaCapabilitiesInfo);
>+const powerEfficient = Symbol("MediaCapabilitiesInfo.powerEfficient");
>+const smooth = Symbol("MediaCapabilitiesInfo.smooth");
>+const supported = Symbol("MediaCapabilitiesInfo.supported");
>+dart.setLibraryUri(html$.MediaCapabilitiesInfo, "dart:html");
>+dart.setFieldSignature(html$.MediaCapabilitiesInfo, () => ({
>+  __proto__: dart.getFields(html$.MediaCapabilitiesInfo.__proto__),
>+  [$powerEfficient]: dart.finalFieldType(core.bool),
>+  [$smooth]: dart.finalFieldType(core.bool),
>+  [$supported]: dart.finalFieldType(core.bool)
>+}));
>+dart.registerExtension("MediaCapabilitiesInfo", html$.MediaCapabilitiesInfo);
>+html$.MediaDeviceInfo = class MediaDeviceInfo extends _interceptors.Interceptor {
>+  get [$deviceId]() {
>+    return this.deviceId;
>+  }
>+  get [$groupId]() {
>+    return this.groupId;
>+  }
>+  get [$kind]() {
>+    return this.kind;
>+  }
>+  get [$label]() {
>+    return this.label;
>+  }
>+};
>+dart.addTypeTests(html$.MediaDeviceInfo);
>+const deviceId = Symbol("MediaDeviceInfo.deviceId");
>+const groupId = Symbol("MediaDeviceInfo.groupId");
>+const kind$0 = Symbol("MediaDeviceInfo.kind");
>+const label$0 = Symbol("MediaDeviceInfo.label");
>+dart.setLibraryUri(html$.MediaDeviceInfo, "dart:html");
>+dart.setFieldSignature(html$.MediaDeviceInfo, () => ({
>+  __proto__: dart.getFields(html$.MediaDeviceInfo.__proto__),
>+  [$deviceId]: dart.finalFieldType(core.String),
>+  [$groupId]: dart.finalFieldType(core.String),
>+  [$kind]: dart.finalFieldType(core.String),
>+  [$label]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("MediaDeviceInfo", html$.MediaDeviceInfo);
>+const _getSupportedConstraints_1 = dart.privateName(html$, "_getSupportedConstraints_1");
>+html$.MediaDevices = class MediaDevices extends html$.EventTarget {
>+  [$enumerateDevices]() {
>+    return html$.promiseToFuture(ListOfMediaDeviceInfo(), this.enumerateDevices());
>+  }
>+  [$getSupportedConstraints]() {
>+    return html_common.convertNativeToDart_Dictionary(this[_getSupportedConstraints_1]());
>+  }
>+  [_getSupportedConstraints_1](...args) {
>+    return this.getSupportedConstraints.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.MediaDevices);
>+dart.setMethodSignature(html$.MediaDevices, () => ({
>+  __proto__: dart.getMethods(html$.MediaDevices.__proto__),
>+  [$enumerateDevices]: dart.fnType(async.Future$(core.List$(html$.MediaDeviceInfo)), []),
>+  [$getSupportedConstraints]: dart.fnType(core.Map, []),
>+  [_getSupportedConstraints_1]: dart.fnType(dart.dynamic, [])
>+}));
>+dart.setLibraryUri(html$.MediaDevices, "dart:html");
>+dart.registerExtension("MediaDevices", html$.MediaDevices);
>+html$.MediaEncryptedEvent = class MediaEncryptedEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.MediaEncryptedEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.MediaEncryptedEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new MediaEncryptedEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new MediaEncryptedEvent(type);
>+  }
>+  get [$initData]() {
>+    return this.initData;
>+  }
>+  get [$initDataType]() {
>+    return this.initDataType;
>+  }
>+};
>+dart.addTypeTests(html$.MediaEncryptedEvent);
>+const initData = Symbol("MediaEncryptedEvent.initData");
>+const initDataType = Symbol("MediaEncryptedEvent.initDataType");
>+dart.setLibraryUri(html$.MediaEncryptedEvent, "dart:html");
>+dart.setFieldSignature(html$.MediaEncryptedEvent, () => ({
>+  __proto__: dart.getFields(html$.MediaEncryptedEvent.__proto__),
>+  [$initData]: dart.finalFieldType(typed_data.ByteBuffer),
>+  [$initDataType]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("MediaEncryptedEvent", html$.MediaEncryptedEvent);
>+html$.MediaError = class MediaError extends _interceptors.Interceptor {
>+  get [$code]() {
>+    return this.code;
>+  }
>+  get [$message]() {
>+    return this.message;
>+  }
>+};
>+dart.addTypeTests(html$.MediaError);
>+const code$0 = Symbol("MediaError.code");
>+const message$21 = Symbol("MediaError.message");
>+dart.setLibraryUri(html$.MediaError, "dart:html");
>+dart.setFieldSignature(html$.MediaError, () => ({
>+  __proto__: dart.getFields(html$.MediaError.__proto__),
>+  [$code]: dart.finalFieldType(core.int),
>+  [$message]: dart.finalFieldType(core.String)
>+}));
>+dart.defineLazy(html$.MediaError, {
>+  /*html$.MediaError.MEDIA_ERR_ABORTED*/get MEDIA_ERR_ABORTED() {
>+    return 1;
>+  },
>+  /*html$.MediaError.MEDIA_ERR_DECODE*/get MEDIA_ERR_DECODE() {
>+    return 3;
>+  },
>+  /*html$.MediaError.MEDIA_ERR_NETWORK*/get MEDIA_ERR_NETWORK() {
>+    return 2;
>+  },
>+  /*html$.MediaError.MEDIA_ERR_SRC_NOT_SUPPORTED*/get MEDIA_ERR_SRC_NOT_SUPPORTED() {
>+    return 4;
>+  }
>+});
>+dart.registerExtension("MediaError", html$.MediaError);
>+html$.MediaKeyMessageEvent = class MediaKeyMessageEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+    return html$.MediaKeyMessageEvent._create_1(type, eventInitDict_1);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new MediaKeyMessageEvent(type, eventInitDict);
>+  }
>+  get [$message]() {
>+    return this.message;
>+  }
>+  get [$messageType]() {
>+    return this.messageType;
>+  }
>+};
>+dart.addTypeTests(html$.MediaKeyMessageEvent);
>+const message$22 = Symbol("MediaKeyMessageEvent.message");
>+const messageType = Symbol("MediaKeyMessageEvent.messageType");
>+dart.setLibraryUri(html$.MediaKeyMessageEvent, "dart:html");
>+dart.setFieldSignature(html$.MediaKeyMessageEvent, () => ({
>+  __proto__: dart.getFields(html$.MediaKeyMessageEvent.__proto__),
>+  [$message]: dart.finalFieldType(typed_data.ByteBuffer),
>+  [$messageType]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("MediaKeyMessageEvent", html$.MediaKeyMessageEvent);
>+const _update$ = dart.privateName(html$, "_update");
>+html$.MediaKeySession = class MediaKeySession extends html$.EventTarget {
>+  get [$closed]() {
>+    return html$.promiseToFuture(dart.void, this.closed);
>+  }
>+  get [$expiration]() {
>+    return this.expiration;
>+  }
>+  get [$keyStatuses]() {
>+    return this.keyStatuses;
>+  }
>+  get [$sessionId]() {
>+    return this.sessionId;
>+  }
>+  [$close]() {
>+    return html$.promiseToFuture(dart.dynamic, this.close());
>+  }
>+  [$generateRequest](initDataType, initData) {
>+    return html$.promiseToFuture(dart.dynamic, this.generateRequest(initDataType, initData));
>+  }
>+  [$load](sessionId) {
>+    return html$.promiseToFuture(dart.dynamic, this.load(sessionId));
>+  }
>+  [$remove]() {
>+    return html$.promiseToFuture(dart.dynamic, this.remove());
>+  }
>+  [_update$](...args) {
>+    return this.update.apply(this, args);
>+  }
>+  get [$onMessage]() {
>+    return html$.MediaKeySession.messageEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.MediaKeySession);
>+const expiration = Symbol("MediaKeySession.expiration");
>+const keyStatuses = Symbol("MediaKeySession.keyStatuses");
>+const sessionId = Symbol("MediaKeySession.sessionId");
>+dart.setMethodSignature(html$.MediaKeySession, () => ({
>+  __proto__: dart.getMethods(html$.MediaKeySession.__proto__),
>+  [$close]: dart.fnType(async.Future, []),
>+  [$generateRequest]: dart.fnType(async.Future, [core.String, dart.dynamic]),
>+  [$load]: dart.fnType(async.Future, [core.String]),
>+  [$remove]: dart.fnType(async.Future, []),
>+  [_update$]: dart.fnType(async.Future, [dart.dynamic])
>+}));
>+dart.setGetterSignature(html$.MediaKeySession, () => ({
>+  __proto__: dart.getGetters(html$.MediaKeySession.__proto__),
>+  [$closed]: async.Future$(dart.void),
>+  [$onMessage]: async.Stream$(html$.MessageEvent)
>+}));
>+dart.setLibraryUri(html$.MediaKeySession, "dart:html");
>+dart.setFieldSignature(html$.MediaKeySession, () => ({
>+  __proto__: dart.getFields(html$.MediaKeySession.__proto__),
>+  [$expiration]: dart.finalFieldType(core.num),
>+  [$keyStatuses]: dart.finalFieldType(html$.MediaKeyStatusMap),
>+  [$sessionId]: dart.finalFieldType(core.String)
>+}));
>+dart.defineLazy(html$.MediaKeySession, {
>+  /*html$.MediaKeySession.messageEvent*/get messageEvent() {
>+    return dart.const(new (EventStreamProviderOfMessageEvent()).new("message"));
>+  }
>+});
>+dart.registerExtension("MediaKeySession", html$.MediaKeySession);
>+html$.MediaKeyStatusMap = class MediaKeyStatusMap extends _interceptors.Interceptor {
>+  get [$size]() {
>+    return this.size;
>+  }
>+  [$get](...args) {
>+    return this.get.apply(this, args);
>+  }
>+  [$has](...args) {
>+    return this.has.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.MediaKeyStatusMap);
>+const size$3 = Symbol("MediaKeyStatusMap.size");
>+dart.setMethodSignature(html$.MediaKeyStatusMap, () => ({
>+  __proto__: dart.getMethods(html$.MediaKeyStatusMap.__proto__),
>+  [$get]: dart.fnType(core.Object, [dart.dynamic]),
>+  [$has]: dart.fnType(core.bool, [dart.dynamic])
>+}));
>+dart.setLibraryUri(html$.MediaKeyStatusMap, "dart:html");
>+dart.setFieldSignature(html$.MediaKeyStatusMap, () => ({
>+  __proto__: dart.getFields(html$.MediaKeyStatusMap.__proto__),
>+  [$size]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("MediaKeyStatusMap", html$.MediaKeyStatusMap);
>+const _getConfiguration_1 = dart.privateName(html$, "_getConfiguration_1");
>+html$.MediaKeySystemAccess = class MediaKeySystemAccess extends _interceptors.Interceptor {
>+  get [$keySystem]() {
>+    return this.keySystem;
>+  }
>+  [$createMediaKeys]() {
>+    return html$.promiseToFuture(dart.dynamic, this.createMediaKeys());
>+  }
>+  [$getConfiguration]() {
>+    return html_common.convertNativeToDart_Dictionary(this[_getConfiguration_1]());
>+  }
>+  [_getConfiguration_1](...args) {
>+    return this.getConfiguration.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.MediaKeySystemAccess);
>+const keySystem = Symbol("MediaKeySystemAccess.keySystem");
>+dart.setMethodSignature(html$.MediaKeySystemAccess, () => ({
>+  __proto__: dart.getMethods(html$.MediaKeySystemAccess.__proto__),
>+  [$createMediaKeys]: dart.fnType(async.Future, []),
>+  [$getConfiguration]: dart.fnType(core.Map, []),
>+  [_getConfiguration_1]: dart.fnType(dart.dynamic, [])
>+}));
>+dart.setLibraryUri(html$.MediaKeySystemAccess, "dart:html");
>+dart.setFieldSignature(html$.MediaKeySystemAccess, () => ({
>+  __proto__: dart.getFields(html$.MediaKeySystemAccess.__proto__),
>+  [$keySystem]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("MediaKeySystemAccess", html$.MediaKeySystemAccess);
>+const _createSession = dart.privateName(html$, "_createSession");
>+html$.MediaKeys = class MediaKeys extends _interceptors.Interceptor {
>+  [_createSession](...args) {
>+    return this.createSession.apply(this, args);
>+  }
>+  [$getStatusForPolicy](policy) {
>+    return html$.promiseToFuture(dart.dynamic, this.getStatusForPolicy(policy));
>+  }
>+  [$setServerCertificate](serverCertificate) {
>+    return html$.promiseToFuture(dart.dynamic, this.setServerCertificate(serverCertificate));
>+  }
>+};
>+dart.addTypeTests(html$.MediaKeys);
>+dart.setMethodSignature(html$.MediaKeys, () => ({
>+  __proto__: dart.getMethods(html$.MediaKeys.__proto__),
>+  [_createSession]: dart.fnType(html$.MediaKeySession, [], [core.String]),
>+  [$getStatusForPolicy]: dart.fnType(async.Future, [html$.MediaKeysPolicy]),
>+  [$setServerCertificate]: dart.fnType(async.Future, [dart.dynamic])
>+}));
>+dart.setLibraryUri(html$.MediaKeys, "dart:html");
>+dart.registerExtension("MediaKeys", html$.MediaKeys);
>+html$.MediaKeysPolicy = class MediaKeysPolicy$ extends _interceptors.Interceptor {
>+  static new(init) {
>+    let init_1 = html_common.convertDartToNative_Dictionary(init);
>+    return html$.MediaKeysPolicy._create_1(init_1);
>+  }
>+  static _create_1(init) {
>+    return new MediaKeysPolicy(init);
>+  }
>+  get [$minHdcpVersion]() {
>+    return this.minHdcpVersion;
>+  }
>+};
>+dart.addTypeTests(html$.MediaKeysPolicy);
>+const minHdcpVersion = Symbol("MediaKeysPolicy.minHdcpVersion");
>+dart.setLibraryUri(html$.MediaKeysPolicy, "dart:html");
>+dart.setFieldSignature(html$.MediaKeysPolicy, () => ({
>+  __proto__: dart.getFields(html$.MediaKeysPolicy.__proto__),
>+  [$minHdcpVersion]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("MediaKeysPolicy", html$.MediaKeysPolicy);
>+html$.MediaList = class MediaList extends _interceptors.Interceptor {
>+  get [$length]() {
>+    return this.length;
>+  }
>+  get [$mediaText]() {
>+    return this.mediaText;
>+  }
>+  set [$mediaText](value) {
>+    this.mediaText = value;
>+  }
>+  [$appendMedium](...args) {
>+    return this.appendMedium.apply(this, args);
>+  }
>+  [$deleteMedium](...args) {
>+    return this.deleteMedium.apply(this, args);
>+  }
>+  [$item](...args) {
>+    return this.item.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.MediaList);
>+const length$10 = Symbol("MediaList.length");
>+const mediaText = Symbol("MediaList.mediaText");
>+dart.setMethodSignature(html$.MediaList, () => ({
>+  __proto__: dart.getMethods(html$.MediaList.__proto__),
>+  [$appendMedium]: dart.fnType(dart.void, [core.String]),
>+  [$deleteMedium]: dart.fnType(dart.void, [core.String]),
>+  [$item]: dart.fnType(core.String, [core.int])
>+}));
>+dart.setLibraryUri(html$.MediaList, "dart:html");
>+dart.setFieldSignature(html$.MediaList, () => ({
>+  __proto__: dart.getFields(html$.MediaList.__proto__),
>+  [$length]: dart.finalFieldType(core.int),
>+  [$mediaText]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("MediaList", html$.MediaList);
>+html$.MediaMetadata = class MediaMetadata$ extends _interceptors.Interceptor {
>+  static new(metadata) {
>+    if (metadata === void 0) metadata = null;
>+    if (metadata != null) {
>+      let metadata_1 = html_common.convertDartToNative_Dictionary(metadata);
>+      return html$.MediaMetadata._create_1(metadata_1);
>+    }
>+    return html$.MediaMetadata._create_2();
>+  }
>+  static _create_1(metadata) {
>+    return new MediaMetadata(metadata);
>+  }
>+  static _create_2() {
>+    return new MediaMetadata();
>+  }
>+  get [$album]() {
>+    return this.album;
>+  }
>+  set [$album](value) {
>+    this.album = value;
>+  }
>+  get [$artist]() {
>+    return this.artist;
>+  }
>+  set [$artist](value) {
>+    this.artist = value;
>+  }
>+  get [$artwork]() {
>+    return this.artwork;
>+  }
>+  set [$artwork](value) {
>+    this.artwork = value;
>+  }
>+  get [$title]() {
>+    return this.title;
>+  }
>+  set [$title](value) {
>+    this.title = value;
>+  }
>+};
>+dart.addTypeTests(html$.MediaMetadata);
>+const album = Symbol("MediaMetadata.album");
>+const artist = Symbol("MediaMetadata.artist");
>+const artwork = Symbol("MediaMetadata.artwork");
>+const title$1 = Symbol("MediaMetadata.title");
>+dart.setLibraryUri(html$.MediaMetadata, "dart:html");
>+dart.setFieldSignature(html$.MediaMetadata, () => ({
>+  __proto__: dart.getFields(html$.MediaMetadata.__proto__),
>+  [$album]: dart.fieldType(core.String),
>+  [$artist]: dart.fieldType(core.String),
>+  [$artwork]: dart.fieldType(core.List),
>+  [$title]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("MediaMetadata", html$.MediaMetadata);
>+html$.MediaQueryList = class MediaQueryList extends html$.EventTarget {
>+  get [$matches]() {
>+    return this.matches;
>+  }
>+  get [$media]() {
>+    return this.media;
>+  }
>+  [$addListener](...args) {
>+    return this.addListener.apply(this, args);
>+  }
>+  [$removeListener](...args) {
>+    return this.removeListener.apply(this, args);
>+  }
>+  get [$onChange]() {
>+    return html$.MediaQueryList.changeEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.MediaQueryList);
>+const matches = Symbol("MediaQueryList.matches");
>+const media$2 = Symbol("MediaQueryList.media");
>+dart.setMethodSignature(html$.MediaQueryList, () => ({
>+  __proto__: dart.getMethods(html$.MediaQueryList.__proto__),
>+  [$addListener]: dart.fnType(dart.void, [dart.fnType(dart.dynamic, [html$.Event])]),
>+  [$removeListener]: dart.fnType(dart.void, [dart.fnType(dart.dynamic, [html$.Event])])
>+}));
>+dart.setGetterSignature(html$.MediaQueryList, () => ({
>+  __proto__: dart.getGetters(html$.MediaQueryList.__proto__),
>+  [$onChange]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.MediaQueryList, "dart:html");
>+dart.setFieldSignature(html$.MediaQueryList, () => ({
>+  __proto__: dart.getFields(html$.MediaQueryList.__proto__),
>+  [$matches]: dart.finalFieldType(core.bool),
>+  [$media]: dart.finalFieldType(core.String)
>+}));
>+dart.defineLazy(html$.MediaQueryList, {
>+  /*html$.MediaQueryList.changeEvent*/get changeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("change"));
>+  }
>+});
>+dart.registerExtension("MediaQueryList", html$.MediaQueryList);
>+html$.MediaQueryListEvent = class MediaQueryListEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.MediaQueryListEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.MediaQueryListEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new MediaQueryListEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new MediaQueryListEvent(type);
>+  }
>+  get [$matches]() {
>+    return this.matches;
>+  }
>+  get [$media]() {
>+    return this.media;
>+  }
>+};
>+dart.addTypeTests(html$.MediaQueryListEvent);
>+const matches$ = Symbol("MediaQueryListEvent.matches");
>+const media$3 = Symbol("MediaQueryListEvent.media");
>+dart.setLibraryUri(html$.MediaQueryListEvent, "dart:html");
>+dart.setFieldSignature(html$.MediaQueryListEvent, () => ({
>+  __proto__: dart.getFields(html$.MediaQueryListEvent.__proto__),
>+  [$matches]: dart.finalFieldType(core.bool),
>+  [$media]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("MediaQueryListEvent", html$.MediaQueryListEvent);
>+html$.MediaRecorder = class MediaRecorder$ extends html$.EventTarget {
>+  static new(stream, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      return html$.MediaRecorder._create_1(stream, options_1);
>+    }
>+    return html$.MediaRecorder._create_2(stream);
>+  }
>+  static _create_1(stream, options) {
>+    return new MediaRecorder(stream, options);
>+  }
>+  static _create_2(stream) {
>+    return new MediaRecorder(stream);
>+  }
>+  get [$audioBitsPerSecond]() {
>+    return this.audioBitsPerSecond;
>+  }
>+  get [$mimeType]() {
>+    return this.mimeType;
>+  }
>+  get [$state]() {
>+    return this.state;
>+  }
>+  get [$stream]() {
>+    return this.stream;
>+  }
>+  get [$videoBitsPerSecond]() {
>+    return this.videoBitsPerSecond;
>+  }
>+  [$pause](...args) {
>+    return this.pause.apply(this, args);
>+  }
>+  [$requestData](...args) {
>+    return this.requestData.apply(this, args);
>+  }
>+  [$resume](...args) {
>+    return this.resume.apply(this, args);
>+  }
>+  [$start](...args) {
>+    return this.start.apply(this, args);
>+  }
>+  [$stop](...args) {
>+    return this.stop.apply(this, args);
>+  }
>+  get [$onError]() {
>+    return html$.MediaRecorder.errorEvent.forTarget(this);
>+  }
>+  get [$onPause]() {
>+    return html$.MediaRecorder.pauseEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.MediaRecorder);
>+const audioBitsPerSecond = Symbol("MediaRecorder.audioBitsPerSecond");
>+const mimeType = Symbol("MediaRecorder.mimeType");
>+const state$0 = Symbol("MediaRecorder.state");
>+const stream = Symbol("MediaRecorder.stream");
>+const videoBitsPerSecond = Symbol("MediaRecorder.videoBitsPerSecond");
>+dart.setMethodSignature(html$.MediaRecorder, () => ({
>+  __proto__: dart.getMethods(html$.MediaRecorder.__proto__),
>+  [$pause]: dart.fnType(dart.void, []),
>+  [$requestData]: dart.fnType(dart.void, []),
>+  [$resume]: dart.fnType(dart.void, []),
>+  [$start]: dart.fnType(dart.void, [], [core.int]),
>+  [$stop]: dart.fnType(dart.void, [])
>+}));
>+dart.setGetterSignature(html$.MediaRecorder, () => ({
>+  __proto__: dart.getGetters(html$.MediaRecorder.__proto__),
>+  [$onError]: async.Stream$(html$.Event),
>+  [$onPause]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.MediaRecorder, "dart:html");
>+dart.setFieldSignature(html$.MediaRecorder, () => ({
>+  __proto__: dart.getFields(html$.MediaRecorder.__proto__),
>+  [$audioBitsPerSecond]: dart.finalFieldType(core.int),
>+  [$mimeType]: dart.finalFieldType(core.String),
>+  [$state]: dart.finalFieldType(core.String),
>+  [$stream]: dart.finalFieldType(html$.MediaStream),
>+  [$videoBitsPerSecond]: dart.finalFieldType(core.int)
>+}));
>+dart.defineLazy(html$.MediaRecorder, {
>+  /*html$.MediaRecorder.errorEvent*/get errorEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("error"));
>+  },
>+  /*html$.MediaRecorder.pauseEvent*/get pauseEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("pause"));
>+  }
>+});
>+dart.registerExtension("MediaRecorder", html$.MediaRecorder);
>+html$.MediaSession = class MediaSession extends _interceptors.Interceptor {
>+  get [$metadata]() {
>+    return this.metadata;
>+  }
>+  set [$metadata](value) {
>+    this.metadata = value;
>+  }
>+  get [$playbackState]() {
>+    return this.playbackState;
>+  }
>+  set [$playbackState](value) {
>+    this.playbackState = value;
>+  }
>+  [$setActionHandler](...args) {
>+    return this.setActionHandler.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.MediaSession);
>+const metadata = Symbol("MediaSession.metadata");
>+const playbackState = Symbol("MediaSession.playbackState");
>+dart.setMethodSignature(html$.MediaSession, () => ({
>+  __proto__: dart.getMethods(html$.MediaSession.__proto__),
>+  [$setActionHandler]: dart.fnType(dart.void, [core.String, dart.fnType(dart.void, [])])
>+}));
>+dart.setLibraryUri(html$.MediaSession, "dart:html");
>+dart.setFieldSignature(html$.MediaSession, () => ({
>+  __proto__: dart.getFields(html$.MediaSession.__proto__),
>+  [$metadata]: dart.fieldType(html$.MediaMetadata),
>+  [$playbackState]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("MediaSession", html$.MediaSession);
>+html$.MediaSettingsRange = class MediaSettingsRange extends _interceptors.Interceptor {
>+  get [$max]() {
>+    return this.max;
>+  }
>+  get [$min]() {
>+    return this.min;
>+  }
>+  get [$step]() {
>+    return this.step;
>+  }
>+};
>+dart.addTypeTests(html$.MediaSettingsRange);
>+const max$1 = Symbol("MediaSettingsRange.max");
>+const min$1 = Symbol("MediaSettingsRange.min");
>+const step$0 = Symbol("MediaSettingsRange.step");
>+dart.setLibraryUri(html$.MediaSettingsRange, "dart:html");
>+dart.setFieldSignature(html$.MediaSettingsRange, () => ({
>+  __proto__: dart.getFields(html$.MediaSettingsRange.__proto__),
>+  [$max]: dart.finalFieldType(core.num),
>+  [$min]: dart.finalFieldType(core.num),
>+  [$step]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("MediaSettingsRange", html$.MediaSettingsRange);
>+html$.MediaSource = class MediaSource$ extends html$.EventTarget {
>+  static new() {
>+    return html$.MediaSource._create_1();
>+  }
>+  static _create_1() {
>+    return new MediaSource();
>+  }
>+  static get supported() {
>+    return !!window.MediaSource;
>+  }
>+  get [$activeSourceBuffers]() {
>+    return this.activeSourceBuffers;
>+  }
>+  get [$duration]() {
>+    return this.duration;
>+  }
>+  set [$duration](value) {
>+    this.duration = value;
>+  }
>+  get [$readyState]() {
>+    return this.readyState;
>+  }
>+  get [$sourceBuffers]() {
>+    return this.sourceBuffers;
>+  }
>+  [$addSourceBuffer](...args) {
>+    return this.addSourceBuffer.apply(this, args);
>+  }
>+  [$clearLiveSeekableRange](...args) {
>+    return this.clearLiveSeekableRange.apply(this, args);
>+  }
>+  [$endOfStream](...args) {
>+    return this.endOfStream.apply(this, args);
>+  }
>+  [$removeSourceBuffer](...args) {
>+    return this.removeSourceBuffer.apply(this, args);
>+  }
>+  [$setLiveSeekableRange](...args) {
>+    return this.setLiveSeekableRange.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.MediaSource);
>+const activeSourceBuffers = Symbol("MediaSource.activeSourceBuffers");
>+const duration$1 = Symbol("MediaSource.duration");
>+const readyState$6 = Symbol("MediaSource.readyState");
>+const sourceBuffers = Symbol("MediaSource.sourceBuffers");
>+dart.setMethodSignature(html$.MediaSource, () => ({
>+  __proto__: dart.getMethods(html$.MediaSource.__proto__),
>+  [$addSourceBuffer]: dart.fnType(html$.SourceBuffer, [core.String]),
>+  [$clearLiveSeekableRange]: dart.fnType(dart.void, []),
>+  [$endOfStream]: dart.fnType(dart.void, [], [core.String]),
>+  [$removeSourceBuffer]: dart.fnType(dart.void, [html$.SourceBuffer]),
>+  [$setLiveSeekableRange]: dart.fnType(dart.void, [core.num, core.num])
>+}));
>+dart.setLibraryUri(html$.MediaSource, "dart:html");
>+dart.setFieldSignature(html$.MediaSource, () => ({
>+  __proto__: dart.getFields(html$.MediaSource.__proto__),
>+  [$activeSourceBuffers]: dart.finalFieldType(html$.SourceBufferList),
>+  [$duration]: dart.fieldType(core.num),
>+  [$readyState]: dart.finalFieldType(core.String),
>+  [$sourceBuffers]: dart.finalFieldType(html$.SourceBufferList)
>+}));
>+dart.registerExtension("MediaSource", html$.MediaSource);
>+html$.MediaStream = class MediaStream$ extends html$.EventTarget {
>+  static new(stream_OR_tracks) {
>+    if (stream_OR_tracks === void 0) stream_OR_tracks = null;
>+    if (stream_OR_tracks == null) {
>+      return html$.MediaStream._create_1();
>+    }
>+    if (html$.MediaStream.is(stream_OR_tracks)) {
>+      return html$.MediaStream._create_2(stream_OR_tracks);
>+    }
>+    if (ListOfMediaStreamTrack().is(stream_OR_tracks)) {
>+      return html$.MediaStream._create_3(stream_OR_tracks);
>+    }
>+    dart.throw(new core.ArgumentError.new("Incorrect number or type of arguments"));
>+  }
>+  static _create_1() {
>+    return new MediaStream();
>+  }
>+  static _create_2(stream_OR_tracks) {
>+    return new MediaStream(stream_OR_tracks);
>+  }
>+  static _create_3(stream_OR_tracks) {
>+    return new MediaStream(stream_OR_tracks);
>+  }
>+  get [$active]() {
>+    return this.active;
>+  }
>+  get [$id]() {
>+    return this.id;
>+  }
>+  [$addTrack](...args) {
>+    return this.addTrack.apply(this, args);
>+  }
>+  [$clone](...args) {
>+    return this.clone.apply(this, args);
>+  }
>+  [$getAudioTracks](...args) {
>+    return this.getAudioTracks.apply(this, args);
>+  }
>+  [$getTrackById](...args) {
>+    return this.getTrackById.apply(this, args);
>+  }
>+  [$getTracks](...args) {
>+    return this.getTracks.apply(this, args);
>+  }
>+  [$getVideoTracks](...args) {
>+    return this.getVideoTracks.apply(this, args);
>+  }
>+  [$removeTrack](...args) {
>+    return this.removeTrack.apply(this, args);
>+  }
>+  get [$onAddTrack]() {
>+    return html$.MediaStream.addTrackEvent.forTarget(this);
>+  }
>+  get [$onRemoveTrack]() {
>+    return html$.MediaStream.removeTrackEvent.forTarget(this);
>+  }
>+  static get supported() {
>+    return !!(html$.window.navigator.getUserMedia || html$.window.navigator.webkitGetUserMedia || html$.window.navigator.mozGetUserMedia || html$.window.navigator.msGetUserMedia);
>+  }
>+};
>+dart.addTypeTests(html$.MediaStream);
>+const active = Symbol("MediaStream.active");
>+const id$7 = Symbol("MediaStream.id");
>+dart.setMethodSignature(html$.MediaStream, () => ({
>+  __proto__: dart.getMethods(html$.MediaStream.__proto__),
>+  [$addTrack]: dart.fnType(dart.void, [html$.MediaStreamTrack]),
>+  [$clone]: dart.fnType(html$.MediaStream, []),
>+  [$getAudioTracks]: dart.fnType(core.List$(html$.MediaStreamTrack), []),
>+  [$getTrackById]: dart.fnType(html$.MediaStreamTrack, [core.String]),
>+  [$getTracks]: dart.fnType(core.List$(html$.MediaStreamTrack), []),
>+  [$getVideoTracks]: dart.fnType(core.List$(html$.MediaStreamTrack), []),
>+  [$removeTrack]: dart.fnType(dart.void, [html$.MediaStreamTrack])
>+}));
>+dart.setGetterSignature(html$.MediaStream, () => ({
>+  __proto__: dart.getGetters(html$.MediaStream.__proto__),
>+  [$onAddTrack]: async.Stream$(html$.Event),
>+  [$onRemoveTrack]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.MediaStream, "dart:html");
>+dart.setFieldSignature(html$.MediaStream, () => ({
>+  __proto__: dart.getFields(html$.MediaStream.__proto__),
>+  [$active]: dart.finalFieldType(core.bool),
>+  [$id]: dart.finalFieldType(core.String)
>+}));
>+dart.defineLazy(html$.MediaStream, {
>+  /*html$.MediaStream.addTrackEvent*/get addTrackEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("addtrack"));
>+  },
>+  /*html$.MediaStream.removeTrackEvent*/get removeTrackEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("removetrack"));
>+  }
>+});
>+dart.registerExtension("MediaStream", html$.MediaStream);
>+html$.MediaStreamEvent = class MediaStreamEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.MediaStreamEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.MediaStreamEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new MediaStreamEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new MediaStreamEvent(type);
>+  }
>+  static get supported() {
>+    return html_common.Device.isEventTypeSupported("MediaStreamEvent");
>+  }
>+  get [$stream]() {
>+    return this.stream;
>+  }
>+};
>+dart.addTypeTests(html$.MediaStreamEvent);
>+const stream$ = Symbol("MediaStreamEvent.stream");
>+dart.setLibraryUri(html$.MediaStreamEvent, "dart:html");
>+dart.setFieldSignature(html$.MediaStreamEvent, () => ({
>+  __proto__: dart.getFields(html$.MediaStreamEvent.__proto__),
>+  [$stream]: dart.finalFieldType(html$.MediaStream)
>+}));
>+dart.registerExtension("MediaStreamEvent", html$.MediaStreamEvent);
>+html$.MediaStreamTrackEvent = class MediaStreamTrackEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+    return html$.MediaStreamTrackEvent._create_1(type, eventInitDict_1);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new MediaStreamTrackEvent(type, eventInitDict);
>+  }
>+  static get supported() {
>+    return html_common.Device.isEventTypeSupported("MediaStreamTrackEvent");
>+  }
>+  get [$track]() {
>+    return this.track;
>+  }
>+};
>+dart.addTypeTests(html$.MediaStreamTrackEvent);
>+const track$ = Symbol("MediaStreamTrackEvent.track");
>+dart.setLibraryUri(html$.MediaStreamTrackEvent, "dart:html");
>+dart.setFieldSignature(html$.MediaStreamTrackEvent, () => ({
>+  __proto__: dart.getFields(html$.MediaStreamTrackEvent.__proto__),
>+  [$track]: dart.finalFieldType(html$.MediaStreamTrack)
>+}));
>+dart.registerExtension("MediaStreamTrackEvent", html$.MediaStreamTrackEvent);
>+html$.MemoryInfo = class MemoryInfo extends _interceptors.Interceptor {
>+  get [$jsHeapSizeLimit]() {
>+    return this.jsHeapSizeLimit;
>+  }
>+  get [$totalJSHeapSize]() {
>+    return this.totalJSHeapSize;
>+  }
>+  get [$usedJSHeapSize]() {
>+    return this.usedJSHeapSize;
>+  }
>+};
>+dart.addTypeTests(html$.MemoryInfo);
>+const jsHeapSizeLimit = Symbol("MemoryInfo.jsHeapSizeLimit");
>+const totalJSHeapSize = Symbol("MemoryInfo.totalJSHeapSize");
>+const usedJSHeapSize = Symbol("MemoryInfo.usedJSHeapSize");
>+dart.setLibraryUri(html$.MemoryInfo, "dart:html");
>+dart.setFieldSignature(html$.MemoryInfo, () => ({
>+  __proto__: dart.getFields(html$.MemoryInfo.__proto__),
>+  [$jsHeapSizeLimit]: dart.finalFieldType(core.int),
>+  [$totalJSHeapSize]: dart.finalFieldType(core.int),
>+  [$usedJSHeapSize]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("MemoryInfo", html$.MemoryInfo);
>+html$.MenuElement = class MenuElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("menu");
>+  }
>+};
>+(html$.MenuElement.created = function() {
>+  html$.MenuElement.__proto__.created.call(this);
>+}).prototype = html$.MenuElement.prototype;
>+dart.addTypeTests(html$.MenuElement);
>+dart.setLibraryUri(html$.MenuElement, "dart:html");
>+dart.registerExtension("HTMLMenuElement", html$.MenuElement);
>+html$.MessageChannel = class MessageChannel$ extends _interceptors.Interceptor {
>+  static new() {
>+    return html$.MessageChannel._create_1();
>+  }
>+  static _create_1() {
>+    return new MessageChannel();
>+  }
>+  get [$port1]() {
>+    return this.port1;
>+  }
>+  get [$port2]() {
>+    return this.port2;
>+  }
>+};
>+dart.addTypeTests(html$.MessageChannel);
>+const port1 = Symbol("MessageChannel.port1");
>+const port2 = Symbol("MessageChannel.port2");
>+dart.setLibraryUri(html$.MessageChannel, "dart:html");
>+dart.setFieldSignature(html$.MessageChannel, () => ({
>+  __proto__: dart.getFields(html$.MessageChannel.__proto__),
>+  [$port1]: dart.finalFieldType(html$.MessagePort),
>+  [$port2]: dart.finalFieldType(html$.MessagePort)
>+}));
>+dart.registerExtension("MessageChannel", html$.MessageChannel);
>+let const$78;
>+const _initMessageEvent = dart.privateName(html$, "_initMessageEvent");
>+const _get_data = dart.privateName(html$, "_get_data");
>+const _get_source = dart.privateName(html$, "_get_source");
>+const _initMessageEvent_1 = dart.privateName(html$, "_initMessageEvent_1");
>+html$.MessageEvent = class MessageEvent$ extends html$.Event {
>+  static new(type, opts) {
>+    let canBubble = opts && 'canBubble' in opts ? opts.canBubble : false;
>+    let cancelable = opts && 'cancelable' in opts ? opts.cancelable : false;
>+    let data = opts && 'data' in opts ? opts.data : null;
>+    let origin = opts && 'origin' in opts ? opts.origin : null;
>+    let lastEventId = opts && 'lastEventId' in opts ? opts.lastEventId : null;
>+    let source = opts && 'source' in opts ? opts.source : null;
>+    let messagePorts = opts && 'messagePorts' in opts ? opts.messagePorts : const$78 || (const$78 = dart.constList([], html$.MessagePort));
>+    if (source == null) {
>+      source = html$.window;
>+    }
>+    if (!dart.test(html_common.Device.isIE)) {
>+      return new MessageEvent(type, {bubbles: canBubble, cancelable: cancelable, data: data, origin: origin, lastEventId: lastEventId, source: source, ports: messagePorts});
>+    }
>+    let event = html$.MessageEvent._check(html$.document[_createEvent]("MessageEvent"));
>+    event[_initMessageEvent](type, canBubble, cancelable, data, origin, lastEventId, source, messagePorts);
>+    return event;
>+  }
>+  get [$data]() {
>+    return html_common.convertNativeToDart_SerializedScriptValue(this[_get_data]);
>+  }
>+  get [_get_data]() {
>+    return this.data;
>+  }
>+  static __(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.MessageEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.MessageEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new MessageEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new MessageEvent(type);
>+  }
>+  get [$lastEventId]() {
>+    return this.lastEventId;
>+  }
>+  get [$origin]() {
>+    return this.origin;
>+  }
>+  get [$ports]() {
>+    return this.ports;
>+  }
>+  get [$source]() {
>+    return html$._convertNativeToDart_EventTarget(this[_get_source]);
>+  }
>+  get [_get_source]() {
>+    return this.source;
>+  }
>+  get [$suborigin]() {
>+    return this.suborigin;
>+  }
>+  [_initMessageEvent](typeArg, canBubbleArg, cancelableArg, dataArg, originArg, lastEventIdArg, sourceArg, portsArg) {
>+    let sourceArg_1 = html$._convertDartToNative_EventTarget(sourceArg);
>+    this[_initMessageEvent_1](typeArg, canBubbleArg, cancelableArg, dataArg, originArg, lastEventIdArg, sourceArg_1, portsArg);
>+    return;
>+  }
>+  [_initMessageEvent_1](...args) {
>+    return this.initMessageEvent.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.MessageEvent);
>+const lastEventId$ = Symbol("MessageEvent.lastEventId");
>+const origin$5 = Symbol("MessageEvent.origin");
>+const ports$ = Symbol("MessageEvent.ports");
>+const suborigin$ = Symbol("MessageEvent.suborigin");
>+dart.setMethodSignature(html$.MessageEvent, () => ({
>+  __proto__: dart.getMethods(html$.MessageEvent.__proto__),
>+  [_initMessageEvent]: dart.fnType(dart.void, [core.String, core.bool, core.bool, core.Object, core.String, core.String, html$.EventTarget, core.List$(html$.MessagePort)]),
>+  [_initMessageEvent_1]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, core.List$(html$.MessagePort)])
>+}));
>+dart.setGetterSignature(html$.MessageEvent, () => ({
>+  __proto__: dart.getGetters(html$.MessageEvent.__proto__),
>+  [$data]: dart.dynamic,
>+  [$source]: html$.EventTarget
>+}));
>+dart.setLibraryUri(html$.MessageEvent, "dart:html");
>+dart.setFieldSignature(html$.MessageEvent, () => ({
>+  __proto__: dart.getFields(html$.MessageEvent.__proto__),
>+  [_get_data]: dart.finalFieldType(dart.dynamic),
>+  [$lastEventId]: dart.finalFieldType(core.String),
>+  [$origin]: dart.finalFieldType(core.String),
>+  [$ports]: dart.finalFieldType(ListOfMessagePort()),
>+  [_get_source]: dart.finalFieldType(dart.dynamic),
>+  [$suborigin]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("MessageEvent", html$.MessageEvent);
>+const _start$3 = dart.privateName(html$, "_start");
>+html$.MessagePort = class MessagePort extends html$.EventTarget {
>+  [$addEventListener](type, listener, useCapture) {
>+    if (useCapture === void 0) useCapture = null;
>+    if (type === "message") {
>+      this[_start$3]();
>+    }
>+    super[$addEventListener](type, listener, useCapture);
>+  }
>+  [$close](...args) {
>+    return this.close.apply(this, args);
>+  }
>+  [$postMessage](message, transfer) {
>+    if (transfer === void 0) transfer = null;
>+    if (transfer != null) {
>+      let message_1 = html_common.convertDartToNative_SerializedScriptValue(message);
>+      this[_postMessage_1](message_1, transfer);
>+      return;
>+    }
>+    let message_1 = html_common.convertDartToNative_SerializedScriptValue(message);
>+    this[_postMessage_2](message_1);
>+    return;
>+  }
>+  [_postMessage_1](...args) {
>+    return this.postMessage.apply(this, args);
>+  }
>+  [_postMessage_2](...args) {
>+    return this.postMessage.apply(this, args);
>+  }
>+  [_start$3](...args) {
>+    return this.start.apply(this, args);
>+  }
>+  get [$onMessage]() {
>+    return html$.MessagePort.messageEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.MessagePort);
>+dart.setMethodSignature(html$.MessagePort, () => ({
>+  __proto__: dart.getMethods(html$.MessagePort.__proto__),
>+  [$close]: dart.fnType(dart.void, []),
>+  [$postMessage]: dart.fnType(dart.void, [dart.dynamic], [core.List$(core.Object)]),
>+  [_postMessage_1]: dart.fnType(dart.void, [dart.dynamic, core.List$(core.Object)]),
>+  [_postMessage_2]: dart.fnType(dart.void, [dart.dynamic]),
>+  [_start$3]: dart.fnType(dart.void, [])
>+}));
>+dart.setGetterSignature(html$.MessagePort, () => ({
>+  __proto__: dart.getGetters(html$.MessagePort.__proto__),
>+  [$onMessage]: async.Stream$(html$.MessageEvent)
>+}));
>+dart.setLibraryUri(html$.MessagePort, "dart:html");
>+dart.defineLazy(html$.MessagePort, {
>+  /*html$.MessagePort.messageEvent*/get messageEvent() {
>+    return dart.const(new (EventStreamProviderOfMessageEvent()).new("message"));
>+  }
>+});
>+dart.registerExtension("MessagePort", html$.MessagePort);
>+html$.MetaElement = class MetaElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("meta");
>+  }
>+  get [$content]() {
>+    return this.content;
>+  }
>+  set [$content](value) {
>+    this.content = value;
>+  }
>+  get [$httpEquiv]() {
>+    return this.httpEquiv;
>+  }
>+  set [$httpEquiv](value) {
>+    this.httpEquiv = value;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+  set [$name](value) {
>+    this.name = value;
>+  }
>+};
>+(html$.MetaElement.created = function() {
>+  this[content] = null;
>+  this[httpEquiv] = null;
>+  this[name$22] = null;
>+  html$.MetaElement.__proto__.created.call(this);
>+}).prototype = html$.MetaElement.prototype;
>+dart.addTypeTests(html$.MetaElement);
>+const content = Symbol("MetaElement.content");
>+const httpEquiv = Symbol("MetaElement.httpEquiv");
>+const name$22 = Symbol("MetaElement.name");
>+dart.setLibraryUri(html$.MetaElement, "dart:html");
>+dart.setFieldSignature(html$.MetaElement, () => ({
>+  __proto__: dart.getFields(html$.MetaElement.__proto__),
>+  [$content]: dart.fieldType(core.String),
>+  [$httpEquiv]: dart.fieldType(core.String),
>+  [$name]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("HTMLMetaElement", html$.MetaElement);
>+const _get_modificationTime = dart.privateName(html$, "_get_modificationTime");
>+html$.Metadata = class Metadata extends _interceptors.Interceptor {
>+  get [$modificationTime]() {
>+    return html_common.convertNativeToDart_DateTime(this[_get_modificationTime]);
>+  }
>+  get [_get_modificationTime]() {
>+    return this.modificationTime;
>+  }
>+  get [$size]() {
>+    return this.size;
>+  }
>+};
>+dart.addTypeTests(html$.Metadata);
>+const size$4 = Symbol("Metadata.size");
>+dart.setGetterSignature(html$.Metadata, () => ({
>+  __proto__: dart.getGetters(html$.Metadata.__proto__),
>+  [$modificationTime]: core.DateTime
>+}));
>+dart.setLibraryUri(html$.Metadata, "dart:html");
>+dart.setFieldSignature(html$.Metadata, () => ({
>+  __proto__: dart.getFields(html$.Metadata.__proto__),
>+  [_get_modificationTime]: dart.finalFieldType(dart.dynamic),
>+  [$size]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("Metadata", html$.Metadata);
>+html$.MeterElement = class MeterElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.MeterElement._check(html$.document[$createElement]("meter"));
>+  }
>+  static get supported() {
>+    return html$.Element.isTagSupported("meter");
>+  }
>+  get [$high]() {
>+    return this.high;
>+  }
>+  set [$high](value) {
>+    this.high = value;
>+  }
>+  get [$labels]() {
>+    return this.labels;
>+  }
>+  get [$low]() {
>+    return this.low;
>+  }
>+  set [$low](value) {
>+    this.low = value;
>+  }
>+  get [$max]() {
>+    return this.max;
>+  }
>+  set [$max](value) {
>+    this.max = value;
>+  }
>+  get [$min]() {
>+    return this.min;
>+  }
>+  set [$min](value) {
>+    this.min = value;
>+  }
>+  get [$optimum]() {
>+    return this.optimum;
>+  }
>+  set [$optimum](value) {
>+    this.optimum = value;
>+  }
>+  get [$value]() {
>+    return this.value;
>+  }
>+  set [$value](value) {
>+    this.value = value;
>+  }
>+};
>+(html$.MeterElement.created = function() {
>+  this[high] = null;
>+  this[labels$0] = null;
>+  this[low] = null;
>+  this[max$2] = null;
>+  this[min$2] = null;
>+  this[optimum] = null;
>+  this[value$10] = null;
>+  html$.MeterElement.__proto__.created.call(this);
>+}).prototype = html$.MeterElement.prototype;
>+dart.addTypeTests(html$.MeterElement);
>+const high = Symbol("MeterElement.high");
>+const labels$0 = Symbol("MeterElement.labels");
>+const low = Symbol("MeterElement.low");
>+const max$2 = Symbol("MeterElement.max");
>+const min$2 = Symbol("MeterElement.min");
>+const optimum = Symbol("MeterElement.optimum");
>+const value$10 = Symbol("MeterElement.value");
>+dart.setLibraryUri(html$.MeterElement, "dart:html");
>+dart.setFieldSignature(html$.MeterElement, () => ({
>+  __proto__: dart.getFields(html$.MeterElement.__proto__),
>+  [$high]: dart.fieldType(core.num),
>+  [$labels]: dart.finalFieldType(ListOfNode()),
>+  [$low]: dart.fieldType(core.num),
>+  [$max]: dart.fieldType(core.num),
>+  [$min]: dart.fieldType(core.num),
>+  [$optimum]: dart.fieldType(core.num),
>+  [$value]: dart.fieldType(core.num)
>+}));
>+dart.registerExtension("HTMLMeterElement", html$.MeterElement);
>+html$.MidiAccess = class MidiAccess extends html$.EventTarget {
>+  get [$inputs]() {
>+    return this.inputs;
>+  }
>+  get [$outputs]() {
>+    return this.outputs;
>+  }
>+  get [$sysexEnabled]() {
>+    return this.sysexEnabled;
>+  }
>+};
>+dart.addTypeTests(html$.MidiAccess);
>+const inputs = Symbol("MidiAccess.inputs");
>+const outputs = Symbol("MidiAccess.outputs");
>+const sysexEnabled = Symbol("MidiAccess.sysexEnabled");
>+dart.setLibraryUri(html$.MidiAccess, "dart:html");
>+dart.setFieldSignature(html$.MidiAccess, () => ({
>+  __proto__: dart.getFields(html$.MidiAccess.__proto__),
>+  [$inputs]: dart.finalFieldType(html$.MidiInputMap),
>+  [$outputs]: dart.finalFieldType(html$.MidiOutputMap),
>+  [$sysexEnabled]: dart.finalFieldType(core.bool)
>+}));
>+dart.registerExtension("MIDIAccess", html$.MidiAccess);
>+html$.MidiConnectionEvent = class MidiConnectionEvent extends html$.Event {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.MidiConnectionEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.MidiConnectionEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new MIDIConnectionEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new MIDIConnectionEvent(type);
>+  }
>+  get [$port]() {
>+    return this.port;
>+  }
>+};
>+dart.addTypeTests(html$.MidiConnectionEvent);
>+const port$4 = Symbol("MidiConnectionEvent.port");
>+dart.setLibraryUri(html$.MidiConnectionEvent, "dart:html");
>+dart.setFieldSignature(html$.MidiConnectionEvent, () => ({
>+  __proto__: dart.getFields(html$.MidiConnectionEvent.__proto__),
>+  [$port]: dart.finalFieldType(html$.MidiPort)
>+}));
>+dart.registerExtension("MIDIConnectionEvent", html$.MidiConnectionEvent);
>+html$.MidiPort = class MidiPort extends html$.EventTarget {
>+  get [$connection]() {
>+    return this.connection;
>+  }
>+  get [$id]() {
>+    return this.id;
>+  }
>+  get [$manufacturer]() {
>+    return this.manufacturer;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+  get [$state]() {
>+    return this.state;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  get [$version]() {
>+    return this.version;
>+  }
>+  [$close]() {
>+    return html$.promiseToFuture(dart.dynamic, this.close());
>+  }
>+  [$open]() {
>+    return html$.promiseToFuture(dart.dynamic, this.open());
>+  }
>+};
>+dart.addTypeTests(html$.MidiPort);
>+const connection = Symbol("MidiPort.connection");
>+const id$8 = Symbol("MidiPort.id");
>+const manufacturer = Symbol("MidiPort.manufacturer");
>+const name$23 = Symbol("MidiPort.name");
>+const state$1 = Symbol("MidiPort.state");
>+const type$17 = Symbol("MidiPort.type");
>+const version$0 = Symbol("MidiPort.version");
>+dart.setMethodSignature(html$.MidiPort, () => ({
>+  __proto__: dart.getMethods(html$.MidiPort.__proto__),
>+  [$close]: dart.fnType(async.Future, []),
>+  [$open]: dart.fnType(async.Future, [])
>+}));
>+dart.setLibraryUri(html$.MidiPort, "dart:html");
>+dart.setFieldSignature(html$.MidiPort, () => ({
>+  __proto__: dart.getFields(html$.MidiPort.__proto__),
>+  [$connection]: dart.finalFieldType(core.String),
>+  [$id]: dart.finalFieldType(core.String),
>+  [$manufacturer]: dart.finalFieldType(core.String),
>+  [$name]: dart.finalFieldType(core.String),
>+  [$state]: dart.finalFieldType(core.String),
>+  [$type]: dart.finalFieldType(core.String),
>+  [$version]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("MIDIPort", html$.MidiPort);
>+html$.MidiInput = class MidiInput extends html$.MidiPort {
>+  get [$onMidiMessage]() {
>+    return html$.MidiInput.midiMessageEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.MidiInput);
>+dart.setGetterSignature(html$.MidiInput, () => ({
>+  __proto__: dart.getGetters(html$.MidiInput.__proto__),
>+  [$onMidiMessage]: async.Stream$(html$.MidiMessageEvent)
>+}));
>+dart.setLibraryUri(html$.MidiInput, "dart:html");
>+dart.defineLazy(html$.MidiInput, {
>+  /*html$.MidiInput.midiMessageEvent*/get midiMessageEvent() {
>+    return dart.const(new (EventStreamProviderOfMidiMessageEvent()).new("midimessage"));
>+  }
>+});
>+dart.registerExtension("MIDIInput", html$.MidiInput);
>+const _getItem = dart.privateName(html$, "_getItem");
>+const Interceptor_MapMixin$ = class Interceptor_MapMixin extends _interceptors.Interceptor {};
>+(Interceptor_MapMixin$.new = function() {
>+  Interceptor_MapMixin$.__proto__.new.call(this);
>+}).prototype = Interceptor_MapMixin$.prototype;
>+dart.applyMixin(Interceptor_MapMixin$, collection.MapMixin$(core.String, dart.dynamic));
>+html$.MidiInputMap = class MidiInputMap extends Interceptor_MapMixin$ {
>+  [_getItem](key) {
>+    return html_common.convertNativeToDart_Dictionary(this.get(key));
>+  }
>+  [$addAll](other) {
>+    MapOfString$dynamic()._check(other);
>+    dart.throw(new core.UnsupportedError.new("Not supported"));
>+  }
>+  [$containsValue](value) {
>+    return this[$values][$any](dart.fn(e => dart.equals(e, value), MapTobool()));
>+  }
>+  [$containsKey](key) {
>+    return this[_getItem](core.String._check(key)) != null;
>+  }
>+  [$_get](key) {
>+    return this[_getItem](core.String._check(key));
>+  }
>+  [$forEach](f) {
>+    let entries = this.entries();
>+    while (true) {
>+      let entry = entries.next();
>+      if (entry.done) return;
>+      f(entry.value[0], html_common.convertNativeToDart_Dictionary(entry.value[1]));
>+    }
>+  }
>+  get [$keys]() {
>+    let keys = JSArrayOfString().of([]);
>+    this[$forEach](dart.fn((k, v) => keys[$add](k), StringAnddynamicTovoid()));
>+    return keys;
>+  }
>+  get [$values]() {
>+    let values = JSArrayOfMap().of([]);
>+    this[$forEach](dart.fn((k, v) => values[$add](core.Map._check(v)), StringAnddynamicTovoid()));
>+    return values;
>+  }
>+  get [$length]() {
>+    return this.size;
>+  }
>+  get [$isEmpty]() {
>+    return this[$length] === 0;
>+  }
>+  get [$isNotEmpty]() {
>+    return !dart.test(this[$isEmpty]);
>+  }
>+  [$_set](key, value) {
>+    core.String._check(key);
>+    dart.throw(new core.UnsupportedError.new("Not supported"));
>+    return value;
>+  }
>+  [$putIfAbsent](key, ifAbsent) {
>+    core.String._check(key);
>+    dart.throw(new core.UnsupportedError.new("Not supported"));
>+  }
>+  [$remove](key) {
>+    dart.throw(new core.UnsupportedError.new("Not supported"));
>+  }
>+  [$clear]() {
>+    dart.throw(new core.UnsupportedError.new("Not supported"));
>+  }
>+};
>+dart.addTypeTests(html$.MidiInputMap);
>+dart.setMethodSignature(html$.MidiInputMap, () => ({
>+  __proto__: dart.getMethods(html$.MidiInputMap.__proto__),
>+  [_getItem]: dart.fnType(core.Map, [core.String]),
>+  [$addAll]: dart.fnType(dart.void, [core.Object]),
>+  [$containsValue]: dart.fnType(core.bool, [dart.dynamic]),
>+  [$containsKey]: dart.fnType(core.bool, [dart.dynamic]),
>+  [$_get]: dart.fnType(core.Map, [dart.dynamic]),
>+  [$forEach]: dart.fnType(dart.void, [dart.fnType(dart.void, [core.String, dart.dynamic])]),
>+  [$_set]: dart.fnType(dart.void, [core.Object, dart.dynamic]),
>+  [$putIfAbsent]: dart.fnType(dart.dynamic, [core.Object, dart.fnType(dart.dynamic, [])]),
>+  [$remove]: dart.fnType(core.String, [dart.dynamic]),
>+  [$clear]: dart.fnType(dart.void, [])
>+}));
>+dart.setGetterSignature(html$.MidiInputMap, () => ({
>+  __proto__: dart.getGetters(html$.MidiInputMap.__proto__),
>+  [$keys]: core.Iterable$(core.String),
>+  [$values]: core.Iterable$(core.Map),
>+  [$length]: core.int,
>+  [$isEmpty]: core.bool,
>+  [$isNotEmpty]: core.bool
>+}));
>+dart.setLibraryUri(html$.MidiInputMap, "dart:html");
>+dart.registerExtension("MIDIInputMap", html$.MidiInputMap);
>+html$.MidiMessageEvent = class MidiMessageEvent extends html$.Event {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.MidiMessageEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.MidiMessageEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new MIDIMessageEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new MIDIMessageEvent(type);
>+  }
>+  get [$data]() {
>+    return this.data;
>+  }
>+};
>+dart.addTypeTests(html$.MidiMessageEvent);
>+const data$4 = Symbol("MidiMessageEvent.data");
>+dart.setLibraryUri(html$.MidiMessageEvent, "dart:html");
>+dart.setFieldSignature(html$.MidiMessageEvent, () => ({
>+  __proto__: dart.getFields(html$.MidiMessageEvent.__proto__),
>+  [$data]: dart.finalFieldType(typed_data.Uint8List)
>+}));
>+dart.registerExtension("MIDIMessageEvent", html$.MidiMessageEvent);
>+html$.MidiOutput = class MidiOutput extends html$.MidiPort {
>+  [$send](...args) {
>+    return this.send.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.MidiOutput);
>+dart.setMethodSignature(html$.MidiOutput, () => ({
>+  __proto__: dart.getMethods(html$.MidiOutput.__proto__),
>+  [$send]: dart.fnType(dart.void, [typed_data.Uint8List], [core.num])
>+}));
>+dart.setLibraryUri(html$.MidiOutput, "dart:html");
>+dart.registerExtension("MIDIOutput", html$.MidiOutput);
>+const Interceptor_MapMixin$$ = class Interceptor_MapMixin extends _interceptors.Interceptor {};
>+(Interceptor_MapMixin$$.new = function() {
>+  Interceptor_MapMixin$$.__proto__.new.call(this);
>+}).prototype = Interceptor_MapMixin$$.prototype;
>+dart.applyMixin(Interceptor_MapMixin$$, collection.MapMixin$(core.String, dart.dynamic));
>+html$.MidiOutputMap = class MidiOutputMap extends Interceptor_MapMixin$$ {
>+  [_getItem](key) {
>+    return html_common.convertNativeToDart_Dictionary(this.get(key));
>+  }
>+  [$addAll](other) {
>+    MapOfString$dynamic()._check(other);
>+    dart.throw(new core.UnsupportedError.new("Not supported"));
>+  }
>+  [$containsValue](value) {
>+    return this[$values][$any](dart.fn(e => dart.equals(e, value), MapTobool()));
>+  }
>+  [$containsKey](key) {
>+    return this[_getItem](core.String._check(key)) != null;
>+  }
>+  [$_get](key) {
>+    return this[_getItem](core.String._check(key));
>+  }
>+  [$forEach](f) {
>+    let entries = this.entries();
>+    while (true) {
>+      let entry = entries.next();
>+      if (entry.done) return;
>+      f(entry.value[0], html_common.convertNativeToDart_Dictionary(entry.value[1]));
>+    }
>+  }
>+  get [$keys]() {
>+    let keys = JSArrayOfString().of([]);
>+    this[$forEach](dart.fn((k, v) => keys[$add](k), StringAnddynamicTovoid()));
>+    return keys;
>+  }
>+  get [$values]() {
>+    let values = JSArrayOfMap().of([]);
>+    this[$forEach](dart.fn((k, v) => values[$add](core.Map._check(v)), StringAnddynamicTovoid()));
>+    return values;
>+  }
>+  get [$length]() {
>+    return this.size;
>+  }
>+  get [$isEmpty]() {
>+    return this[$length] === 0;
>+  }
>+  get [$isNotEmpty]() {
>+    return !dart.test(this[$isEmpty]);
>+  }
>+  [$_set](key, value) {
>+    core.String._check(key);
>+    dart.throw(new core.UnsupportedError.new("Not supported"));
>+    return value;
>+  }
>+  [$putIfAbsent](key, ifAbsent) {
>+    core.String._check(key);
>+    dart.throw(new core.UnsupportedError.new("Not supported"));
>+  }
>+  [$remove](key) {
>+    dart.throw(new core.UnsupportedError.new("Not supported"));
>+  }
>+  [$clear]() {
>+    dart.throw(new core.UnsupportedError.new("Not supported"));
>+  }
>+};
>+dart.addTypeTests(html$.MidiOutputMap);
>+dart.setMethodSignature(html$.MidiOutputMap, () => ({
>+  __proto__: dart.getMethods(html$.MidiOutputMap.__proto__),
>+  [_getItem]: dart.fnType(core.Map, [core.String]),
>+  [$addAll]: dart.fnType(dart.void, [core.Object]),
>+  [$containsValue]: dart.fnType(core.bool, [dart.dynamic]),
>+  [$containsKey]: dart.fnType(core.bool, [dart.dynamic]),
>+  [$_get]: dart.fnType(core.Map, [dart.dynamic]),
>+  [$forEach]: dart.fnType(dart.void, [dart.fnType(dart.void, [core.String, dart.dynamic])]),
>+  [$_set]: dart.fnType(dart.void, [core.Object, dart.dynamic]),
>+  [$putIfAbsent]: dart.fnType(dart.dynamic, [core.Object, dart.fnType(dart.dynamic, [])]),
>+  [$remove]: dart.fnType(core.String, [dart.dynamic]),
>+  [$clear]: dart.fnType(dart.void, [])
>+}));
>+dart.setGetterSignature(html$.MidiOutputMap, () => ({
>+  __proto__: dart.getGetters(html$.MidiOutputMap.__proto__),
>+  [$keys]: core.Iterable$(core.String),
>+  [$values]: core.Iterable$(core.Map),
>+  [$length]: core.int,
>+  [$isEmpty]: core.bool,
>+  [$isNotEmpty]: core.bool
>+}));
>+dart.setLibraryUri(html$.MidiOutputMap, "dart:html");
>+dart.registerExtension("MIDIOutputMap", html$.MidiOutputMap);
>+html$.MimeType = class MimeType extends _interceptors.Interceptor {
>+  get [$description]() {
>+    return this.description;
>+  }
>+  get [$enabledPlugin]() {
>+    return this.enabledPlugin;
>+  }
>+  get [$suffixes]() {
>+    return this.suffixes;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+};
>+dart.addTypeTests(html$.MimeType);
>+const description = Symbol("MimeType.description");
>+const enabledPlugin = Symbol("MimeType.enabledPlugin");
>+const suffixes = Symbol("MimeType.suffixes");
>+const type$18 = Symbol("MimeType.type");
>+dart.setLibraryUri(html$.MimeType, "dart:html");
>+dart.setFieldSignature(html$.MimeType, () => ({
>+  __proto__: dart.getFields(html$.MimeType.__proto__),
>+  [$description]: dart.finalFieldType(core.String),
>+  [$enabledPlugin]: dart.finalFieldType(html$.Plugin),
>+  [$suffixes]: dart.finalFieldType(core.String),
>+  [$type]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("MimeType", html$.MimeType);
>+const Interceptor_ListMixin$$2 = class Interceptor_ListMixin extends _interceptors.Interceptor {};
>+(Interceptor_ListMixin$$2.new = function() {
>+  Interceptor_ListMixin$$2.__proto__.new.call(this);
>+}).prototype = Interceptor_ListMixin$$2.prototype;
>+dart.applyMixin(Interceptor_ListMixin$$2, collection.ListMixin$(html$.MimeType));
>+const Interceptor_ImmutableListMixin$$2 = class Interceptor_ImmutableListMixin extends Interceptor_ListMixin$$2 {};
>+(Interceptor_ImmutableListMixin$$2.new = function() {
>+  Interceptor_ImmutableListMixin$$2.__proto__.new.call(this);
>+}).prototype = Interceptor_ImmutableListMixin$$2.prototype;
>+dart.applyMixin(Interceptor_ImmutableListMixin$$2, html$.ImmutableListMixin$(html$.MimeType));
>+html$.MimeTypeArray = class MimeTypeArray extends Interceptor_ImmutableListMixin$$2 {
>+  get [$length]() {
>+    return this.length;
>+  }
>+  [$_get](index) {
>+    if (index >>> 0 !== index || index >= this[$length]) dart.throw(core.RangeError.index(index, this));
>+    return this[index];
>+  }
>+  [$_set](index, value) {
>+    html$.MimeType._check(value);
>+    dart.throw(new core.UnsupportedError.new("Cannot assign element of immutable List."));
>+    return value;
>+  }
>+  set [$length](value) {
>+    dart.throw(new core.UnsupportedError.new("Cannot resize immutable List."));
>+  }
>+  get [$first]() {
>+    if (dart.notNull(this[$length]) > 0) {
>+      return this[0];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$first](value) {
>+    super[$first] = value;
>+  }
>+  get [$last]() {
>+    let len = this[$length];
>+    if (dart.notNull(len) > 0) {
>+      return this[dart.notNull(len) - 1];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$last](value) {
>+    super[$last] = value;
>+  }
>+  get [$single]() {
>+    let len = this[$length];
>+    if (len === 1) {
>+      return this[0];
>+    }
>+    if (len === 0) dart.throw(new core.StateError.new("No elements"));
>+    dart.throw(new core.StateError.new("More than one element"));
>+  }
>+  [$elementAt](index) {
>+    return this[$_get](index);
>+  }
>+  [$item](...args) {
>+    return this.item.apply(this, args);
>+  }
>+  [$namedItem](...args) {
>+    return this.namedItem.apply(this, args);
>+  }
>+};
>+html$.MimeTypeArray.prototype[dart.isList] = true;
>+dart.addTypeTests(html$.MimeTypeArray);
>+html$.MimeTypeArray[dart.implements] = () => [ListOfMimeType(), JavaScriptIndexingBehaviorOfMimeType()];
>+dart.setMethodSignature(html$.MimeTypeArray, () => ({
>+  __proto__: dart.getMethods(html$.MimeTypeArray.__proto__),
>+  [$_get]: dart.fnType(html$.MimeType, [core.int]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$elementAt]: dart.fnType(html$.MimeType, [core.int]),
>+  [$item]: dart.fnType(html$.MimeType, [core.int]),
>+  [$namedItem]: dart.fnType(html$.MimeType, [core.String])
>+}));
>+dart.setGetterSignature(html$.MimeTypeArray, () => ({
>+  __proto__: dart.getGetters(html$.MimeTypeArray.__proto__),
>+  [$length]: core.int,
>+  [$first]: html$.MimeType,
>+  [$last]: html$.MimeType,
>+  [$single]: html$.MimeType
>+}));
>+dart.setSetterSignature(html$.MimeTypeArray, () => ({
>+  __proto__: dart.getSetters(html$.MimeTypeArray.__proto__),
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(html$.MimeTypeArray, "dart:html");
>+dart.registerExtension("MimeTypeArray", html$.MimeTypeArray);
>+html$.ModElement = class ModElement extends html$.HtmlElement {
>+  get [$cite]() {
>+    return this.cite;
>+  }
>+  set [$cite](value) {
>+    this.cite = value;
>+  }
>+  get [$dateTime]() {
>+    return this.dateTime;
>+  }
>+  set [$dateTime](value) {
>+    this.dateTime = value;
>+  }
>+};
>+(html$.ModElement.created = function() {
>+  this[cite] = null;
>+  this[dateTime] = null;
>+  html$.ModElement.__proto__.created.call(this);
>+}).prototype = html$.ModElement.prototype;
>+dart.addTypeTests(html$.ModElement);
>+const cite = Symbol("ModElement.cite");
>+const dateTime = Symbol("ModElement.dateTime");
>+dart.setLibraryUri(html$.ModElement, "dart:html");
>+dart.setFieldSignature(html$.ModElement, () => ({
>+  __proto__: dart.getFields(html$.ModElement.__proto__),
>+  [$cite]: dart.fieldType(core.String),
>+  [$dateTime]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("HTMLModElement", html$.ModElement);
>+const _initMouseEvent = dart.privateName(html$, "_initMouseEvent");
>+const _clientX = dart.privateName(html$, "_clientX");
>+const _clientY = dart.privateName(html$, "_clientY");
>+const _layerX = dart.privateName(html$, "_layerX");
>+const _layerY = dart.privateName(html$, "_layerY");
>+const _movementX = dart.privateName(html$, "_movementX");
>+const _movementY = dart.privateName(html$, "_movementY");
>+const _pageX = dart.privateName(html$, "_pageX");
>+const _pageY = dart.privateName(html$, "_pageY");
>+const _screenX = dart.privateName(html$, "_screenX");
>+const _screenY = dart.privateName(html$, "_screenY");
>+const _initMouseEvent_1 = dart.privateName(html$, "_initMouseEvent_1");
>+html$.MouseEvent = class MouseEvent$ extends html$.UIEvent {
>+  static new(type, opts) {
>+    let view = opts && 'view' in opts ? opts.view : null;
>+    let detail = opts && 'detail' in opts ? opts.detail : 0;
>+    let screenX = opts && 'screenX' in opts ? opts.screenX : 0;
>+    let screenY = opts && 'screenY' in opts ? opts.screenY : 0;
>+    let clientX = opts && 'clientX' in opts ? opts.clientX : 0;
>+    let clientY = opts && 'clientY' in opts ? opts.clientY : 0;
>+    let button = opts && 'button' in opts ? opts.button : 0;
>+    let canBubble = opts && 'canBubble' in opts ? opts.canBubble : true;
>+    let cancelable = opts && 'cancelable' in opts ? opts.cancelable : true;
>+    let ctrlKey = opts && 'ctrlKey' in opts ? opts.ctrlKey : false;
>+    let altKey = opts && 'altKey' in opts ? opts.altKey : false;
>+    let shiftKey = opts && 'shiftKey' in opts ? opts.shiftKey : false;
>+    let metaKey = opts && 'metaKey' in opts ? opts.metaKey : false;
>+    let relatedTarget = opts && 'relatedTarget' in opts ? opts.relatedTarget : null;
>+    if (view == null) {
>+      view = html$.window;
>+    }
>+    let event = html$.MouseEvent._check(html$.document[_createEvent]("MouseEvent"));
>+    event[_initMouseEvent](type, canBubble, cancelable, view, detail, screenX, screenY, clientX, clientY, ctrlKey, altKey, shiftKey, metaKey, button, relatedTarget);
>+    return event;
>+  }
>+  static __(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.MouseEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.MouseEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new MouseEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new MouseEvent(type);
>+  }
>+  get [$altKey]() {
>+    return this.altKey;
>+  }
>+  get [$button]() {
>+    return this.button;
>+  }
>+  get [$buttons]() {
>+    return this.buttons;
>+  }
>+  get [_clientX]() {
>+    return this.clientX;
>+  }
>+  get [_clientY]() {
>+    return this.clientY;
>+  }
>+  get [$ctrlKey]() {
>+    return this.ctrlKey;
>+  }
>+  get [$fromElement]() {
>+    return this.fromElement;
>+  }
>+  get [_layerX]() {
>+    return this.layerX;
>+  }
>+  get [_layerY]() {
>+    return this.layerY;
>+  }
>+  get [$metaKey]() {
>+    return this.metaKey;
>+  }
>+  get [_movementX]() {
>+    return this.movementX;
>+  }
>+  get [_movementY]() {
>+    return this.movementY;
>+  }
>+  get [_pageX]() {
>+    return this.pageX;
>+  }
>+  get [_pageY]() {
>+    return this.pageY;
>+  }
>+  get [$region]() {
>+    return this.region;
>+  }
>+  get [$relatedTarget]() {
>+    return html$._convertNativeToDart_EventTarget(this[_get_relatedTarget]);
>+  }
>+  get [_get_relatedTarget]() {
>+    return this.relatedTarget;
>+  }
>+  get [_screenX]() {
>+    return this.screenX;
>+  }
>+  get [_screenY]() {
>+    return this.screenY;
>+  }
>+  get [$shiftKey]() {
>+    return this.shiftKey;
>+  }
>+  get [$toElement]() {
>+    return this.toElement;
>+  }
>+  [$getModifierState](...args) {
>+    return this.getModifierState.apply(this, args);
>+  }
>+  [_initMouseEvent](type, bubbles, cancelable, view, detail, screenX, screenY, clientX, clientY, ctrlKey, altKey, shiftKey, metaKey, button, relatedTarget) {
>+    let relatedTarget_1 = html$._convertDartToNative_EventTarget(relatedTarget);
>+    this[_initMouseEvent_1](type, bubbles, cancelable, view, detail, screenX, screenY, clientX, clientY, ctrlKey, altKey, shiftKey, metaKey, button, relatedTarget_1);
>+    return;
>+  }
>+  [_initMouseEvent_1](...args) {
>+    return this.initMouseEvent.apply(this, args);
>+  }
>+  get [$client]() {
>+    return new (PointOfnum()).new(this[_clientX], this[_clientY]);
>+  }
>+  get [$movement]() {
>+    return new (PointOfnum()).new(this[_movementX], this[_movementY]);
>+  }
>+  get [$offset]() {
>+    if (!!this.offsetX) {
>+      let x = this.offsetX;
>+      let y = this.offsetY;
>+      return new (PointOfnum()).new(x, y);
>+    } else {
>+      if (!html$.Element.is(this[$target])) {
>+        dart.throw(new core.UnsupportedError.new("offsetX is only supported on elements"));
>+      }
>+      let target = html$.Element._check(this[$target]);
>+      let point = this[$client]['-'](target.getBoundingClientRect()[$topLeft]);
>+      return new (PointOfnum()).new(point.x[$toInt](), point.y[$toInt]());
>+    }
>+  }
>+  get [$screen]() {
>+    return new (PointOfnum()).new(this[_screenX], this[_screenY]);
>+  }
>+  get [$layer]() {
>+    return new (PointOfnum()).new(this[_layerX], this[_layerY]);
>+  }
>+  get [$page]() {
>+    return new (PointOfnum()).new(this[_pageX], this[_pageY]);
>+  }
>+  get [$dataTransfer]() {
>+    return this.dataTransfer;
>+  }
>+};
>+dart.addTypeTests(html$.MouseEvent);
>+const altKey$ = Symbol("MouseEvent.altKey");
>+const button = Symbol("MouseEvent.button");
>+const buttons$ = Symbol("MouseEvent.buttons");
>+const ctrlKey$ = Symbol("MouseEvent.ctrlKey");
>+const fromElement = Symbol("MouseEvent.fromElement");
>+const metaKey$ = Symbol("MouseEvent.metaKey");
>+const region = Symbol("MouseEvent.region");
>+const shiftKey$ = Symbol("MouseEvent.shiftKey");
>+const toElement = Symbol("MouseEvent.toElement");
>+dart.setMethodSignature(html$.MouseEvent, () => ({
>+  __proto__: dart.getMethods(html$.MouseEvent.__proto__),
>+  [$getModifierState]: dart.fnType(core.bool, [core.String]),
>+  [_initMouseEvent]: dart.fnType(dart.void, [core.String, core.bool, core.bool, html$.Window, core.int, core.int, core.int, core.int, core.int, core.bool, core.bool, core.bool, core.bool, core.int, html$.EventTarget]),
>+  [_initMouseEvent_1]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, html$.Window, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic])
>+}));
>+dart.setGetterSignature(html$.MouseEvent, () => ({
>+  __proto__: dart.getGetters(html$.MouseEvent.__proto__),
>+  [$relatedTarget]: html$.EventTarget,
>+  [$client]: math.Point$(core.num),
>+  [$movement]: math.Point$(core.num),
>+  [$offset]: math.Point$(core.num),
>+  [$screen]: math.Point$(core.num),
>+  [$layer]: math.Point$(core.num),
>+  [$page]: math.Point$(core.num),
>+  [$dataTransfer]: html$.DataTransfer
>+}));
>+dart.setLibraryUri(html$.MouseEvent, "dart:html");
>+dart.setFieldSignature(html$.MouseEvent, () => ({
>+  __proto__: dart.getFields(html$.MouseEvent.__proto__),
>+  [$altKey]: dart.finalFieldType(core.bool),
>+  [$button]: dart.finalFieldType(core.int),
>+  [$buttons]: dart.finalFieldType(core.int),
>+  [_clientX]: dart.finalFieldType(core.num),
>+  [_clientY]: dart.finalFieldType(core.num),
>+  [$ctrlKey]: dart.finalFieldType(core.bool),
>+  [$fromElement]: dart.finalFieldType(html$.Node),
>+  [_layerX]: dart.finalFieldType(core.int),
>+  [_layerY]: dart.finalFieldType(core.int),
>+  [$metaKey]: dart.finalFieldType(core.bool),
>+  [_movementX]: dart.finalFieldType(core.int),
>+  [_movementY]: dart.finalFieldType(core.int),
>+  [_pageX]: dart.finalFieldType(core.num),
>+  [_pageY]: dart.finalFieldType(core.num),
>+  [$region]: dart.finalFieldType(core.String),
>+  [_get_relatedTarget]: dart.finalFieldType(dart.dynamic),
>+  [_screenX]: dart.finalFieldType(core.num),
>+  [_screenY]: dart.finalFieldType(core.num),
>+  [$shiftKey]: dart.finalFieldType(core.bool),
>+  [$toElement]: dart.finalFieldType(html$.Node)
>+}));
>+dart.registerExtension("MouseEvent", html$.MouseEvent);
>+dart.registerExtension("DragEvent", html$.MouseEvent);
>+html$.MutationEvent = class MutationEvent extends html$.Event {
>+  get [$attrChange]() {
>+    return this.attrChange;
>+  }
>+  get [$attrName]() {
>+    return this.attrName;
>+  }
>+  get [$newValue]() {
>+    return this.newValue;
>+  }
>+  get [$prevValue]() {
>+    return this.prevValue;
>+  }
>+  get [$relatedNode]() {
>+    return this.relatedNode;
>+  }
>+  [$initMutationEvent](...args) {
>+    return this.initMutationEvent.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.MutationEvent);
>+const attrChange = Symbol("MutationEvent.attrChange");
>+const attrName = Symbol("MutationEvent.attrName");
>+const newValue = Symbol("MutationEvent.newValue");
>+const prevValue = Symbol("MutationEvent.prevValue");
>+const relatedNode = Symbol("MutationEvent.relatedNode");
>+dart.setMethodSignature(html$.MutationEvent, () => ({
>+  __proto__: dart.getMethods(html$.MutationEvent.__proto__),
>+  [$initMutationEvent]: dart.fnType(dart.void, [core.String, core.bool, core.bool, html$.Node, core.String, core.String, core.String, core.int])
>+}));
>+dart.setLibraryUri(html$.MutationEvent, "dart:html");
>+dart.setFieldSignature(html$.MutationEvent, () => ({
>+  __proto__: dart.getFields(html$.MutationEvent.__proto__),
>+  [$attrChange]: dart.finalFieldType(core.int),
>+  [$attrName]: dart.finalFieldType(core.String),
>+  [$newValue]: dart.finalFieldType(core.String),
>+  [$prevValue]: dart.finalFieldType(core.String),
>+  [$relatedNode]: dart.finalFieldType(html$.Node)
>+}));
>+dart.defineLazy(html$.MutationEvent, {
>+  /*html$.MutationEvent.ADDITION*/get ADDITION() {
>+    return 2;
>+  },
>+  /*html$.MutationEvent.MODIFICATION*/get MODIFICATION() {
>+    return 1;
>+  },
>+  /*html$.MutationEvent.REMOVAL*/get REMOVAL() {
>+    return 3;
>+  }
>+});
>+dart.registerExtension("MutationEvent", html$.MutationEvent);
>+const _observe_1$ = dart.privateName(html$, "_observe_1");
>+const _observe_2 = dart.privateName(html$, "_observe_2");
>+const _observe = dart.privateName(html$, "_observe");
>+const _call = dart.privateName(html$, "_call");
>+html$.MutationObserver = class MutationObserver extends _interceptors.Interceptor {
>+  [$disconnect](...args) {
>+    return this.disconnect.apply(this, args);
>+  }
>+  [_observe](target, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      this[_observe_1$](target, options_1);
>+      return;
>+    }
>+    this[_observe_2](target);
>+    return;
>+  }
>+  [_observe_1$](...args) {
>+    return this.observe.apply(this, args);
>+  }
>+  [_observe_2](...args) {
>+    return this.observe.apply(this, args);
>+  }
>+  [$takeRecords](...args) {
>+    return this.takeRecords.apply(this, args);
>+  }
>+  static get supported() {
>+    return !!(window.MutationObserver || window.WebKitMutationObserver);
>+  }
>+  [$observe](target, opts) {
>+    let childList = opts && 'childList' in opts ? opts.childList : null;
>+    let attributes = opts && 'attributes' in opts ? opts.attributes : null;
>+    let characterData = opts && 'characterData' in opts ? opts.characterData : null;
>+    let subtree = opts && 'subtree' in opts ? opts.subtree : null;
>+    let attributeOldValue = opts && 'attributeOldValue' in opts ? opts.attributeOldValue : null;
>+    let characterDataOldValue = opts && 'characterDataOldValue' in opts ? opts.characterDataOldValue : null;
>+    let attributeFilter = opts && 'attributeFilter' in opts ? opts.attributeFilter : null;
>+    let parsedOptions = html$.MutationObserver._createDict();
>+    function override(key, value) {
>+      if (value != null) html$.MutationObserver._add(parsedOptions, core.String._check(key), value);
>+    }
>+    dart.fn(override, dynamicAnddynamicToNull());
>+    override("childList", childList);
>+    override("attributes", attributes);
>+    override("characterData", characterData);
>+    override("subtree", subtree);
>+    override("attributeOldValue", attributeOldValue);
>+    override("characterDataOldValue", characterDataOldValue);
>+    if (attributeFilter != null) {
>+      override("attributeFilter", html$.MutationObserver._fixupList(attributeFilter));
>+    }
>+    this[_call](target, parsedOptions);
>+  }
>+  static _createDict() {
>+    return {};
>+  }
>+  static _add(m, key, value) {
>+    m[key] = value;
>+  }
>+  static _fixupList(list) {
>+    return list;
>+  }
>+  [_call](...args) {
>+    return this.observe.apply(this, args);
>+  }
>+  static new(callback) {
>+    0;
>+    return new (window.MutationObserver || window.WebKitMutationObserver || window.MozMutationObserver)(_js_helper.convertDartClosureToJS(ListAndMutationObserverTovoid(), html$._wrapBinaryZone(core.List, html$.MutationObserver, callback), 2));
>+  }
>+};
>+dart.addTypeTests(html$.MutationObserver);
>+dart.setMethodSignature(html$.MutationObserver, () => ({
>+  __proto__: dart.getMethods(html$.MutationObserver.__proto__),
>+  [$disconnect]: dart.fnType(dart.void, []),
>+  [_observe]: dart.fnType(dart.void, [html$.Node], [core.Map]),
>+  [_observe_1$]: dart.fnType(dart.void, [html$.Node, dart.dynamic]),
>+  [_observe_2]: dart.fnType(dart.void, [html$.Node]),
>+  [$takeRecords]: dart.fnType(core.List$(html$.MutationRecord), []),
>+  [$observe]: dart.fnType(dart.void, [html$.Node], {childList: core.bool, attributes: core.bool, characterData: core.bool, subtree: core.bool, attributeOldValue: core.bool, characterDataOldValue: core.bool, attributeFilter: core.List$(core.String)}),
>+  [_call]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic])
>+}));
>+dart.setLibraryUri(html$.MutationObserver, "dart:html");
>+dart.defineLazy(html$.MutationObserver, {
>+  /*html$.MutationObserver._boolKeys*/get _boolKeys() {
>+    return dart.constMap(core.String, core.bool, ["childList", true, "attributes", true, "characterData", true, "subtree", true, "attributeOldValue", true, "characterDataOldValue", true]);
>+  }
>+});
>+dart.registerExtension("MutationObserver", html$.MutationObserver);
>+dart.registerExtension("WebKitMutationObserver", html$.MutationObserver);
>+html$.MutationRecord = class MutationRecord extends _interceptors.Interceptor {
>+  get [$addedNodes]() {
>+    return this.addedNodes;
>+  }
>+  get [$attributeName]() {
>+    return this.attributeName;
>+  }
>+  get [$attributeNamespace]() {
>+    return this.attributeNamespace;
>+  }
>+  get [$nextSibling]() {
>+    return this.nextSibling;
>+  }
>+  get [$oldValue]() {
>+    return this.oldValue;
>+  }
>+  get [$previousSibling]() {
>+    return this.previousSibling;
>+  }
>+  get [$removedNodes]() {
>+    return this.removedNodes;
>+  }
>+  get [$target]() {
>+    return this.target;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+};
>+dart.addTypeTests(html$.MutationRecord);
>+const addedNodes = Symbol("MutationRecord.addedNodes");
>+const attributeName = Symbol("MutationRecord.attributeName");
>+const attributeNamespace = Symbol("MutationRecord.attributeNamespace");
>+const nextSibling = Symbol("MutationRecord.nextSibling");
>+const oldValue = Symbol("MutationRecord.oldValue");
>+const previousSibling = Symbol("MutationRecord.previousSibling");
>+const removedNodes = Symbol("MutationRecord.removedNodes");
>+const target$4 = Symbol("MutationRecord.target");
>+const type$19 = Symbol("MutationRecord.type");
>+dart.setLibraryUri(html$.MutationRecord, "dart:html");
>+dart.setFieldSignature(html$.MutationRecord, () => ({
>+  __proto__: dart.getFields(html$.MutationRecord.__proto__),
>+  [$addedNodes]: dart.finalFieldType(ListOfNode()),
>+  [$attributeName]: dart.finalFieldType(core.String),
>+  [$attributeNamespace]: dart.finalFieldType(core.String),
>+  [$nextSibling]: dart.finalFieldType(html$.Node),
>+  [$oldValue]: dart.finalFieldType(core.String),
>+  [$previousSibling]: dart.finalFieldType(html$.Node),
>+  [$removedNodes]: dart.finalFieldType(ListOfNode()),
>+  [$target]: dart.finalFieldType(html$.Node),
>+  [$type]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("MutationRecord", html$.MutationRecord);
>+html$.NavigationPreloadManager = class NavigationPreloadManager extends _interceptors.Interceptor {
>+  [$disable]() {
>+    return html$.promiseToFuture(dart.dynamic, this.disable());
>+  }
>+  [$enable]() {
>+    return html$.promiseToFuture(dart.dynamic, this.enable());
>+  }
>+  [$getState]() {
>+    return html$.promiseToFutureAsMap(this.getState());
>+  }
>+};
>+dart.addTypeTests(html$.NavigationPreloadManager);
>+dart.setMethodSignature(html$.NavigationPreloadManager, () => ({
>+  __proto__: dart.getMethods(html$.NavigationPreloadManager.__proto__),
>+  [$disable]: dart.fnType(async.Future, []),
>+  [$enable]: dart.fnType(async.Future, []),
>+  [$getState]: dart.fnType(async.Future$(core.Map$(core.String, dart.dynamic)), [])
>+}));
>+dart.setLibraryUri(html$.NavigationPreloadManager, "dart:html");
>+dart.registerExtension("NavigationPreloadManager", html$.NavigationPreloadManager);
>+const _getGamepads = dart.privateName(html$, "_getGamepads");
>+const _ensureGetUserMedia = dart.privateName(html$, "_ensureGetUserMedia");
>+const _getUserMedia = dart.privateName(html$, "_getUserMedia");
>+const _requestKeyboardLock_1 = dart.privateName(html$, "_requestKeyboardLock_1");
>+const _requestKeyboardLock_2 = dart.privateName(html$, "_requestKeyboardLock_2");
>+html$.NavigatorConcurrentHardware = class NavigatorConcurrentHardware extends _interceptors.Interceptor {
>+  get [$hardwareConcurrency]() {
>+    return this.hardwareConcurrency;
>+  }
>+};
>+dart.addTypeTests(html$.NavigatorConcurrentHardware);
>+const hardwareConcurrency = Symbol("NavigatorConcurrentHardware.hardwareConcurrency");
>+dart.setLibraryUri(html$.NavigatorConcurrentHardware, "dart:html");
>+dart.setFieldSignature(html$.NavigatorConcurrentHardware, () => ({
>+  __proto__: dart.getFields(html$.NavigatorConcurrentHardware.__proto__),
>+  [$hardwareConcurrency]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("NavigatorConcurrentHardware", html$.NavigatorConcurrentHardware);
>+html$.Navigator = class Navigator extends html$.NavigatorConcurrentHardware {
>+  [$getGamepads]() {
>+    let gamepadList = this[_getGamepads]();
>+    let jsProto = gamepadList.prototype;
>+    if (jsProto == null) {
>+      gamepadList.prototype = Object.create(null);
>+    }
>+    _js_helper.applyExtension("GamepadList", gamepadList);
>+    return gamepadList;
>+  }
>+  get [$language]() {
>+    return this.language || this.userLanguage;
>+  }
>+  [$getUserMedia](opts) {
>+    let audio = opts && 'audio' in opts ? opts.audio : false;
>+    let video = opts && 'video' in opts ? opts.video : false;
>+    let completer = CompleterOfMediaStream().new();
>+    let options = new (IdentityMapOfString$dynamic()).from(["audio", audio, "video", video]);
>+    this[_ensureGetUserMedia]();
>+    this[_getUserMedia](html_common.convertDartToNative_SerializedScriptValue(options), dart.fn(stream => {
>+      completer.complete(stream);
>+    }, MediaStreamToNull()), dart.fn(error => {
>+      completer.completeError(error);
>+    }, NavigatorUserMediaErrorToNull()));
>+    return completer.future;
>+  }
>+  [_ensureGetUserMedia]() {
>+    if (!this.getUserMedia) {
>+      this.getUserMedia = this.getUserMedia || this.webkitGetUserMedia || this.mozGetUserMedia || this.msGetUserMedia;
>+    }
>+  }
>+  [_getUserMedia](...args) {
>+    return this.getUserMedia.apply(this, args);
>+  }
>+  get [$budget]() {
>+    return this.budget;
>+  }
>+  get [$clipboard]() {
>+    return this.clipboard;
>+  }
>+  get [$connection]() {
>+    return this.connection;
>+  }
>+  get [$credentials]() {
>+    return this.credentials;
>+  }
>+  get [$deviceMemory]() {
>+    return this.deviceMemory;
>+  }
>+  get [$doNotTrack]() {
>+    return this.doNotTrack;
>+  }
>+  get [$geolocation]() {
>+    return this.geolocation;
>+  }
>+  get [$maxTouchPoints]() {
>+    return this.maxTouchPoints;
>+  }
>+  get [$mediaCapabilities]() {
>+    return this.mediaCapabilities;
>+  }
>+  get [$mediaDevices]() {
>+    return this.mediaDevices;
>+  }
>+  get [$mediaSession]() {
>+    return this.mediaSession;
>+  }
>+  get [$mimeTypes]() {
>+    return this.mimeTypes;
>+  }
>+  get [$nfc]() {
>+    return this.nfc;
>+  }
>+  get [$permissions]() {
>+    return this.permissions;
>+  }
>+  get [$presentation]() {
>+    return this.presentation;
>+  }
>+  get [$productSub]() {
>+    return this.productSub;
>+  }
>+  get [$serviceWorker]() {
>+    return this.serviceWorker;
>+  }
>+  get [$storage]() {
>+    return this.storage;
>+  }
>+  get [$vendor]() {
>+    return this.vendor;
>+  }
>+  get [$vendorSub]() {
>+    return this.vendorSub;
>+  }
>+  get [$vr]() {
>+    return this.vr;
>+  }
>+  get [$persistentStorage]() {
>+    return this.webkitPersistentStorage;
>+  }
>+  get [$temporaryStorage]() {
>+    return this.webkitTemporaryStorage;
>+  }
>+  [$cancelKeyboardLock](...args) {
>+    return this.cancelKeyboardLock.apply(this, args);
>+  }
>+  [$getBattery]() {
>+    return html$.promiseToFuture(dart.dynamic, this.getBattery());
>+  }
>+  [_getGamepads](...args) {
>+    return this.getGamepads.apply(this, args);
>+  }
>+  [$getInstalledRelatedApps]() {
>+    return html$.promiseToFuture(html$.RelatedApplication, this.getInstalledRelatedApps());
>+  }
>+  [$getVRDisplays]() {
>+    return html$.promiseToFuture(dart.dynamic, this.getVRDisplays());
>+  }
>+  [$registerProtocolHandler](...args) {
>+    return this.registerProtocolHandler.apply(this, args);
>+  }
>+  [$requestKeyboardLock](keyCodes) {
>+    if (keyCodes === void 0) keyCodes = null;
>+    if (keyCodes != null) {
>+      let keyCodes_1 = html_common.convertDartToNative_StringArray(keyCodes);
>+      return this[_requestKeyboardLock_1](keyCodes_1);
>+    }
>+    return this[_requestKeyboardLock_2]();
>+  }
>+  [_requestKeyboardLock_1](keyCodes) {
>+    return html$.promiseToFuture(dart.dynamic, this.requestKeyboardLock(keyCodes));
>+  }
>+  [_requestKeyboardLock_2]() {
>+    return html$.promiseToFuture(dart.dynamic, this.requestKeyboardLock());
>+  }
>+  [$requestMidiAccess](options) {
>+    if (options === void 0) options = null;
>+    let options_dict = null;
>+    if (options != null) {
>+      options_dict = html_common.convertDartToNative_Dictionary(options);
>+    }
>+    return html$.promiseToFuture(dart.dynamic, this.requestMidiAccess(options_dict));
>+  }
>+  [$requestMediaKeySystemAccess](keySystem, supportedConfigurations) {
>+    return html$.promiseToFuture(dart.dynamic, this.requestMediaKeySystemAccess(keySystem, supportedConfigurations));
>+  }
>+  [$sendBeacon](...args) {
>+    return this.sendBeacon.apply(this, args);
>+  }
>+  [$share](data) {
>+    if (data === void 0) data = null;
>+    let data_dict = null;
>+    if (data != null) {
>+      data_dict = html_common.convertDartToNative_Dictionary(data);
>+    }
>+    return html$.promiseToFuture(dart.dynamic, this.share(data_dict));
>+  }
>+  get [$webdriver]() {
>+    return this.webdriver;
>+  }
>+  get [$cookieEnabled]() {
>+    return this.cookieEnabled;
>+  }
>+  get [$appCodeName]() {
>+    return this.appCodeName;
>+  }
>+  get [$appName]() {
>+    return this.appName;
>+  }
>+  get [$appVersion]() {
>+    return this.appVersion;
>+  }
>+  get [$dartEnabled]() {
>+    return this.dartEnabled;
>+  }
>+  get [$platform]() {
>+    return this.platform;
>+  }
>+  get [$product]() {
>+    return this.product;
>+  }
>+  get [$userAgent]() {
>+    return this.userAgent;
>+  }
>+  get [$languages]() {
>+    return this.languages;
>+  }
>+  get [$onLine]() {
>+    return this.onLine;
>+  }
>+};
>+dart.addTypeTests(html$.Navigator);
>+const budget = Symbol("Navigator.budget");
>+const clipboard = Symbol("Navigator.clipboard");
>+const connection$ = Symbol("Navigator.connection");
>+const credentials = Symbol("Navigator.credentials");
>+const deviceMemory = Symbol("Navigator.deviceMemory");
>+const doNotTrack = Symbol("Navigator.doNotTrack");
>+const geolocation = Symbol("Navigator.geolocation");
>+const maxTouchPoints = Symbol("Navigator.maxTouchPoints");
>+const mediaCapabilities = Symbol("Navigator.mediaCapabilities");
>+const mediaDevices = Symbol("Navigator.mediaDevices");
>+const mediaSession = Symbol("Navigator.mediaSession");
>+const mimeTypes = Symbol("Navigator.mimeTypes");
>+const nfc = Symbol("Navigator.nfc");
>+const permissions = Symbol("Navigator.permissions");
>+const presentation = Symbol("Navigator.presentation");
>+const productSub = Symbol("Navigator.productSub");
>+const serviceWorker = Symbol("Navigator.serviceWorker");
>+const storage = Symbol("Navigator.storage");
>+const vendor = Symbol("Navigator.vendor");
>+const vendorSub = Symbol("Navigator.vendorSub");
>+const vr = Symbol("Navigator.vr");
>+const persistentStorage = Symbol("Navigator.persistentStorage");
>+const temporaryStorage = Symbol("Navigator.temporaryStorage");
>+const webdriver = Symbol("Navigator.webdriver");
>+const cookieEnabled = Symbol("Navigator.cookieEnabled");
>+const appCodeName = Symbol("Navigator.appCodeName");
>+const appName = Symbol("Navigator.appName");
>+const appVersion = Symbol("Navigator.appVersion");
>+const dartEnabled = Symbol("Navigator.dartEnabled");
>+const platform = Symbol("Navigator.platform");
>+const product = Symbol("Navigator.product");
>+const userAgent = Symbol("Navigator.userAgent");
>+const languages = Symbol("Navigator.languages");
>+const onLine = Symbol("Navigator.onLine");
>+html$.Navigator[dart.implements] = () => [html$.NavigatorCookies, html$.NavigatorLanguage, html$.NavigatorOnLine, html$.NavigatorAutomationInformation, html$.NavigatorID];
>+dart.setMethodSignature(html$.Navigator, () => ({
>+  __proto__: dart.getMethods(html$.Navigator.__proto__),
>+  [$getGamepads]: dart.fnType(core.List$(html$.Gamepad), []),
>+  [$getUserMedia]: dart.fnType(async.Future$(html$.MediaStream), [], {audio: dart.dynamic, video: dart.dynamic}),
>+  [_ensureGetUserMedia]: dart.fnType(dart.dynamic, []),
>+  [_getUserMedia]: dart.fnType(dart.void, [dart.dynamic, dart.fnType(dart.void, [html$.MediaStream]), dart.fnType(dart.void, [html$.NavigatorUserMediaError])]),
>+  [$cancelKeyboardLock]: dart.fnType(dart.void, []),
>+  [$getBattery]: dart.fnType(async.Future, []),
>+  [_getGamepads]: dart.fnType(core.List$(html$.Gamepad), []),
>+  [$getInstalledRelatedApps]: dart.fnType(async.Future$(html$.RelatedApplication), []),
>+  [$getVRDisplays]: dart.fnType(async.Future, []),
>+  [$registerProtocolHandler]: dart.fnType(dart.void, [core.String, core.String, core.String]),
>+  [$requestKeyboardLock]: dart.fnType(async.Future, [], [core.List$(core.String)]),
>+  [_requestKeyboardLock_1]: dart.fnType(async.Future, [core.List]),
>+  [_requestKeyboardLock_2]: dart.fnType(async.Future, []),
>+  [$requestMidiAccess]: dart.fnType(async.Future, [], [core.Map]),
>+  [$requestMediaKeySystemAccess]: dart.fnType(async.Future, [core.String, core.List$(core.Map)]),
>+  [$sendBeacon]: dart.fnType(core.bool, [core.String, core.Object]),
>+  [$share]: dart.fnType(async.Future, [], [core.Map])
>+}));
>+dart.setGetterSignature(html$.Navigator, () => ({
>+  __proto__: dart.getGetters(html$.Navigator.__proto__),
>+  [$language]: core.String
>+}));
>+dart.setLibraryUri(html$.Navigator, "dart:html");
>+dart.setFieldSignature(html$.Navigator, () => ({
>+  __proto__: dart.getFields(html$.Navigator.__proto__),
>+  [$budget]: dart.finalFieldType(html$._BudgetService),
>+  [$clipboard]: dart.finalFieldType(html$._Clipboard),
>+  [$connection]: dart.finalFieldType(html$.NetworkInformation),
>+  [$credentials]: dart.finalFieldType(html$.CredentialsContainer),
>+  [$deviceMemory]: dart.finalFieldType(core.num),
>+  [$doNotTrack]: dart.finalFieldType(core.String),
>+  [$geolocation]: dart.finalFieldType(html$.Geolocation),
>+  [$maxTouchPoints]: dart.finalFieldType(core.int),
>+  [$mediaCapabilities]: dart.finalFieldType(html$.MediaCapabilities),
>+  [$mediaDevices]: dart.finalFieldType(html$.MediaDevices),
>+  [$mediaSession]: dart.finalFieldType(html$.MediaSession),
>+  [$mimeTypes]: dart.finalFieldType(html$.MimeTypeArray),
>+  [$nfc]: dart.finalFieldType(html$._NFC),
>+  [$permissions]: dart.finalFieldType(html$.Permissions),
>+  [$presentation]: dart.finalFieldType(html$.Presentation),
>+  [$productSub]: dart.finalFieldType(core.String),
>+  [$serviceWorker]: dart.finalFieldType(html$.ServiceWorkerContainer),
>+  [$storage]: dart.finalFieldType(html$.StorageManager),
>+  [$vendor]: dart.finalFieldType(core.String),
>+  [$vendorSub]: dart.finalFieldType(core.String),
>+  [$vr]: dart.finalFieldType(html$.VR),
>+  [$persistentStorage]: dart.finalFieldType(html$.DeprecatedStorageQuota),
>+  [$temporaryStorage]: dart.finalFieldType(html$.DeprecatedStorageQuota),
>+  [$webdriver]: dart.finalFieldType(core.bool),
>+  [$cookieEnabled]: dart.finalFieldType(core.bool),
>+  [$appCodeName]: dart.finalFieldType(core.String),
>+  [$appName]: dart.finalFieldType(core.String),
>+  [$appVersion]: dart.finalFieldType(core.String),
>+  [$dartEnabled]: dart.finalFieldType(core.bool),
>+  [$platform]: dart.finalFieldType(core.String),
>+  [$product]: dart.finalFieldType(core.String),
>+  [$userAgent]: dart.finalFieldType(core.String),
>+  [$languages]: dart.finalFieldType(ListOfString()),
>+  [$onLine]: dart.finalFieldType(core.bool)
>+}));
>+dart.registerExtension("Navigator", html$.Navigator);
>+html$.NavigatorAutomationInformation = class NavigatorAutomationInformation extends _interceptors.Interceptor {
>+  get [$webdriver]() {
>+    return this.webdriver;
>+  }
>+};
>+dart.addTypeTests(html$.NavigatorAutomationInformation);
>+const webdriver$ = Symbol("NavigatorAutomationInformation.webdriver");
>+dart.setLibraryUri(html$.NavigatorAutomationInformation, "dart:html");
>+dart.setFieldSignature(html$.NavigatorAutomationInformation, () => ({
>+  __proto__: dart.getFields(html$.NavigatorAutomationInformation.__proto__),
>+  [$webdriver]: dart.finalFieldType(core.bool)
>+}));
>+dart.registerExtension("NavigatorAutomationInformation", html$.NavigatorAutomationInformation);
>+html$.NavigatorCookies = class NavigatorCookies extends _interceptors.Interceptor {
>+  get [$cookieEnabled]() {
>+    return this.cookieEnabled;
>+  }
>+};
>+dart.addTypeTests(html$.NavigatorCookies);
>+const cookieEnabled$ = Symbol("NavigatorCookies.cookieEnabled");
>+dart.setLibraryUri(html$.NavigatorCookies, "dart:html");
>+dart.setFieldSignature(html$.NavigatorCookies, () => ({
>+  __proto__: dart.getFields(html$.NavigatorCookies.__proto__),
>+  [$cookieEnabled]: dart.finalFieldType(core.bool)
>+}));
>+dart.registerExtension("NavigatorCookies", html$.NavigatorCookies);
>+html$.NavigatorID = class NavigatorID extends _interceptors.Interceptor {
>+  get appCodeName() {
>+    return this[appCodeName$];
>+  }
>+  set appCodeName(value) {
>+    super.appCodeName = value;
>+  }
>+  get appName() {
>+    return this[appName$];
>+  }
>+  set appName(value) {
>+    super.appName = value;
>+  }
>+  get appVersion() {
>+    return this[appVersion$];
>+  }
>+  set appVersion(value) {
>+    super.appVersion = value;
>+  }
>+  get dartEnabled() {
>+    return this[dartEnabled$];
>+  }
>+  set dartEnabled(value) {
>+    super.dartEnabled = value;
>+  }
>+  get platform() {
>+    return this[platform$];
>+  }
>+  set platform(value) {
>+    super.platform = value;
>+  }
>+  get product() {
>+    return this[product$];
>+  }
>+  set product(value) {
>+    super.product = value;
>+  }
>+  get userAgent() {
>+    return this[userAgent$];
>+  }
>+  set userAgent(value) {
>+    super.userAgent = value;
>+  }
>+};
>+dart.addTypeTests(html$.NavigatorID);
>+const appCodeName$ = Symbol("NavigatorID.appCodeName");
>+const appName$ = Symbol("NavigatorID.appName");
>+const appVersion$ = Symbol("NavigatorID.appVersion");
>+const dartEnabled$ = Symbol("NavigatorID.dartEnabled");
>+const platform$ = Symbol("NavigatorID.platform");
>+const product$ = Symbol("NavigatorID.product");
>+const userAgent$ = Symbol("NavigatorID.userAgent");
>+dart.setLibraryUri(html$.NavigatorID, "dart:html");
>+dart.setFieldSignature(html$.NavigatorID, () => ({
>+  __proto__: dart.getFields(html$.NavigatorID.__proto__),
>+  appCodeName: dart.finalFieldType(core.String),
>+  appName: dart.finalFieldType(core.String),
>+  appVersion: dart.finalFieldType(core.String),
>+  dartEnabled: dart.finalFieldType(core.bool),
>+  platform: dart.finalFieldType(core.String),
>+  product: dart.finalFieldType(core.String),
>+  userAgent: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionAccessors(html$.NavigatorID, [
>+  'appCodeName',
>+  'appName',
>+  'appVersion',
>+  'dartEnabled',
>+  'platform',
>+  'product',
>+  'userAgent'
>+]);
>+html$.NavigatorLanguage = class NavigatorLanguage extends _interceptors.Interceptor {
>+  get language() {
>+    return this[language];
>+  }
>+  set language(value) {
>+    super.language = value;
>+  }
>+  get languages() {
>+    return this[languages$];
>+  }
>+  set languages(value) {
>+    super.languages = value;
>+  }
>+};
>+dart.addTypeTests(html$.NavigatorLanguage);
>+const language = Symbol("NavigatorLanguage.language");
>+const languages$ = Symbol("NavigatorLanguage.languages");
>+dart.setLibraryUri(html$.NavigatorLanguage, "dart:html");
>+dart.setFieldSignature(html$.NavigatorLanguage, () => ({
>+  __proto__: dart.getFields(html$.NavigatorLanguage.__proto__),
>+  language: dart.finalFieldType(core.String),
>+  languages: dart.finalFieldType(ListOfString())
>+}));
>+dart.defineExtensionAccessors(html$.NavigatorLanguage, ['language', 'languages']);
>+html$.NavigatorOnLine = class NavigatorOnLine extends _interceptors.Interceptor {
>+  get onLine() {
>+    return this[onLine$];
>+  }
>+  set onLine(value) {
>+    super.onLine = value;
>+  }
>+};
>+dart.addTypeTests(html$.NavigatorOnLine);
>+const onLine$ = Symbol("NavigatorOnLine.onLine");
>+dart.setLibraryUri(html$.NavigatorOnLine, "dart:html");
>+dart.setFieldSignature(html$.NavigatorOnLine, () => ({
>+  __proto__: dart.getFields(html$.NavigatorOnLine.__proto__),
>+  onLine: dart.finalFieldType(core.bool)
>+}));
>+dart.defineExtensionAccessors(html$.NavigatorOnLine, ['onLine']);
>+html$.NavigatorUserMediaError = class NavigatorUserMediaError extends _interceptors.Interceptor {
>+  get [$constraintName]() {
>+    return this.constraintName;
>+  }
>+  get [$message]() {
>+    return this.message;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+};
>+dart.addTypeTests(html$.NavigatorUserMediaError);
>+const constraintName = Symbol("NavigatorUserMediaError.constraintName");
>+const message$23 = Symbol("NavigatorUserMediaError.message");
>+const name$24 = Symbol("NavigatorUserMediaError.name");
>+dart.setLibraryUri(html$.NavigatorUserMediaError, "dart:html");
>+dart.setFieldSignature(html$.NavigatorUserMediaError, () => ({
>+  __proto__: dart.getFields(html$.NavigatorUserMediaError.__proto__),
>+  [$constraintName]: dart.finalFieldType(core.String),
>+  [$message]: dart.finalFieldType(core.String),
>+  [$name]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("NavigatorUserMediaError", html$.NavigatorUserMediaError);
>+html$.NetworkInformation = class NetworkInformation extends html$.EventTarget {
>+  get [$downlink]() {
>+    return this.downlink;
>+  }
>+  get [$downlinkMax]() {
>+    return this.downlinkMax;
>+  }
>+  get [$effectiveType]() {
>+    return this.effectiveType;
>+  }
>+  get [$rtt]() {
>+    return this.rtt;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  get [$onChange]() {
>+    return html$.NetworkInformation.changeEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.NetworkInformation);
>+const downlink = Symbol("NetworkInformation.downlink");
>+const downlinkMax = Symbol("NetworkInformation.downlinkMax");
>+const effectiveType = Symbol("NetworkInformation.effectiveType");
>+const rtt = Symbol("NetworkInformation.rtt");
>+const type$20 = Symbol("NetworkInformation.type");
>+dart.setGetterSignature(html$.NetworkInformation, () => ({
>+  __proto__: dart.getGetters(html$.NetworkInformation.__proto__),
>+  [$onChange]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.NetworkInformation, "dart:html");
>+dart.setFieldSignature(html$.NetworkInformation, () => ({
>+  __proto__: dart.getFields(html$.NetworkInformation.__proto__),
>+  [$downlink]: dart.finalFieldType(core.num),
>+  [$downlinkMax]: dart.finalFieldType(core.num),
>+  [$effectiveType]: dart.finalFieldType(core.String),
>+  [$rtt]: dart.finalFieldType(core.int),
>+  [$type]: dart.finalFieldType(core.String)
>+}));
>+dart.defineLazy(html$.NetworkInformation, {
>+  /*html$.NetworkInformation.changeEvent*/get changeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("change"));
>+  }
>+});
>+dart.registerExtension("NetworkInformation", html$.NetworkInformation);
>+html$._ChildNodeListLazy = class _ChildNodeListLazy extends collection.ListBase$(html$.Node) {
>+  get first() {
>+    let result = this[_this].firstChild;
>+    if (result == null) dart.throw(new core.StateError.new("No elements"));
>+    return result;
>+  }
>+  set first(value) {
>+    super.first = value;
>+  }
>+  get last() {
>+    let result = this[_this].lastChild;
>+    if (result == null) dart.throw(new core.StateError.new("No elements"));
>+    return result;
>+  }
>+  set last(value) {
>+    super.last = value;
>+  }
>+  get single() {
>+    let l = this.length;
>+    if (l === 0) dart.throw(new core.StateError.new("No elements"));
>+    if (dart.notNull(l) > 1) dart.throw(new core.StateError.new("More than one element"));
>+    return this[_this].firstChild;
>+  }
>+  add(value) {
>+    html$.Node._check(value);
>+    this[_this][$append](value);
>+  }
>+  addAll(iterable) {
>+    IterableOfNode()._check(iterable);
>+    if (html$._ChildNodeListLazy.is(iterable)) {
>+      let otherList = iterable;
>+      if (!(otherList[_this] == this[_this])) {
>+        for (let i = 0, len = otherList.length; i < dart.notNull(len); ++i) {
>+          this[_this][$append](otherList[_this].firstChild);
>+        }
>+      }
>+      return;
>+    }
>+    for (let node of iterable) {
>+      this[_this][$append](node);
>+    }
>+  }
>+  insert(index, node) {
>+    html$.Node._check(node);
>+    if (dart.notNull(index) < 0 || dart.notNull(index) > dart.notNull(this.length)) {
>+      dart.throw(new core.RangeError.range(index, 0, this.length));
>+    }
>+    if (index == this.length) {
>+      this[_this][$append](node);
>+    } else {
>+      this[_this].insertBefore(node, this._get(index));
>+    }
>+  }
>+  insertAll(index, iterable) {
>+    IterableOfNode()._check(iterable);
>+    if (index == this.length) {
>+      this.addAll(iterable);
>+    } else {
>+      let item = this._get(index);
>+      this[_this][$insertAllBefore](iterable, item);
>+    }
>+  }
>+  setAll(index, iterable) {
>+    IterableOfNode()._check(iterable);
>+    dart.throw(new core.UnsupportedError.new("Cannot setAll on Node list"));
>+  }
>+  removeLast() {
>+    let result = this.last;
>+    if (result != null) {
>+      this[_this][_removeChild](result);
>+    }
>+    return result;
>+  }
>+  removeAt(index) {
>+    let result = this._get(index);
>+    if (result != null) {
>+      this[_this][_removeChild](result);
>+    }
>+    return result;
>+  }
>+  remove(object) {
>+    if (!html$.Node.is(object)) return false;
>+    let node = html$.Node._check(object);
>+    if (!(this[_this] == node.parentNode)) return false;
>+    this[_this][_removeChild](node);
>+    return true;
>+  }
>+  [_filter$0](test, removeMatching) {
>+    let child = this[_this].firstChild;
>+    while (child != null) {
>+      let nextChild = child[$nextNode];
>+      if (test(child) == removeMatching) {
>+        this[_this][_removeChild](child);
>+      }
>+      child = nextChild;
>+    }
>+  }
>+  removeWhere(test) {
>+    this[_filter$0](test, true);
>+  }
>+  retainWhere(test) {
>+    this[_filter$0](test, false);
>+  }
>+  clear() {
>+    this[_this][_clearChildren]();
>+  }
>+  _set(index, value) {
>+    html$.Node._check(value);
>+    this[_this][_replaceChild](value, this._get(index));
>+    return value;
>+  }
>+  get iterator() {
>+    return this[_this].childNodes[$iterator];
>+  }
>+  sort(compare) {
>+    if (compare === void 0) compare = null;
>+    dart.throw(new core.UnsupportedError.new("Cannot sort Node list"));
>+  }
>+  shuffle(random) {
>+    if (random === void 0) random = null;
>+    dart.throw(new core.UnsupportedError.new("Cannot shuffle Node list"));
>+  }
>+  setRange(start, end, iterable, skipCount) {
>+    IterableOfNode()._check(iterable);
>+    if (skipCount === void 0) skipCount = 0;
>+    dart.throw(new core.UnsupportedError.new("Cannot setRange on Node list"));
>+  }
>+  fillRange(start, end, fill) {
>+    if (fill === void 0) fill = null;
>+    html$.Node._check(fill);
>+    dart.throw(new core.UnsupportedError.new("Cannot fillRange on Node list"));
>+  }
>+  removeRange(start, end) {
>+    dart.throw(new core.UnsupportedError.new("Cannot removeRange on Node list"));
>+  }
>+  get length() {
>+    return this[_this].childNodes[$length];
>+  }
>+  set length(value) {
>+    dart.throw(new core.UnsupportedError.new("Cannot set length on immutable List."));
>+  }
>+  _get(index) {
>+    return this[_this].childNodes[$_get](index);
>+  }
>+  get rawList() {
>+    return this[_this].childNodes;
>+  }
>+};
>+(html$._ChildNodeListLazy.new = function(this$) {
>+  this[_this] = this$;
>+}).prototype = html$._ChildNodeListLazy.prototype;
>+dart.addTypeTests(html$._ChildNodeListLazy);
>+html$._ChildNodeListLazy[dart.implements] = () => [html_common.NodeListWrapper];
>+dart.setMethodSignature(html$._ChildNodeListLazy, () => ({
>+  __proto__: dart.getMethods(html$._ChildNodeListLazy.__proto__),
>+  add: dart.fnType(dart.void, [core.Object]),
>+  [$add]: dart.fnType(dart.void, [core.Object]),
>+  addAll: dart.fnType(dart.void, [core.Object]),
>+  [$addAll]: dart.fnType(dart.void, [core.Object]),
>+  insert: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$insert]: dart.fnType(dart.void, [core.int, core.Object]),
>+  insertAll: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$insertAll]: dart.fnType(dart.void, [core.int, core.Object]),
>+  setAll: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$setAll]: dart.fnType(dart.void, [core.int, core.Object]),
>+  removeLast: dart.fnType(html$.Node, []),
>+  [$removeLast]: dart.fnType(html$.Node, []),
>+  removeAt: dart.fnType(html$.Node, [core.int]),
>+  [$removeAt]: dart.fnType(html$.Node, [core.int]),
>+  remove: dart.fnType(core.bool, [core.Object]),
>+  [$remove]: dart.fnType(core.bool, [core.Object]),
>+  [_filter$0]: dart.fnType(dart.void, [dart.fnType(core.bool, [html$.Node]), core.bool]),
>+  removeWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [html$.Node])]),
>+  [$removeWhere]: dart.fnType(dart.void, [dart.fnType(core.bool, [html$.Node])]),
>+  retainWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [html$.Node])]),
>+  [$retainWhere]: dart.fnType(dart.void, [dart.fnType(core.bool, [html$.Node])]),
>+  clear: dart.fnType(dart.void, []),
>+  [$clear]: dart.fnType(dart.void, []),
>+  _set: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  sort: dart.fnType(dart.void, [], [dart.fnType(core.int, [html$.Node, html$.Node])]),
>+  [$sort]: dart.fnType(dart.void, [], [dart.fnType(core.int, [html$.Node, html$.Node])]),
>+  shuffle: dart.fnType(dart.void, [], [math.Random]),
>+  [$shuffle]: dart.fnType(dart.void, [], [math.Random]),
>+  setRange: dart.fnType(dart.void, [core.int, core.int, core.Object], [core.int]),
>+  [$setRange]: dart.fnType(dart.void, [core.int, core.int, core.Object], [core.int]),
>+  fillRange: dart.fnType(dart.void, [core.int, core.int], [core.Object]),
>+  [$fillRange]: dart.fnType(dart.void, [core.int, core.int], [core.Object]),
>+  removeRange: dart.fnType(dart.void, [core.int, core.int]),
>+  [$removeRange]: dart.fnType(dart.void, [core.int, core.int]),
>+  _get: dart.fnType(html$.Node, [core.int]),
>+  [$_get]: dart.fnType(html$.Node, [core.int])
>+}));
>+dart.setGetterSignature(html$._ChildNodeListLazy, () => ({
>+  __proto__: dart.getGetters(html$._ChildNodeListLazy.__proto__),
>+  first: html$.Node,
>+  [$first]: html$.Node,
>+  last: html$.Node,
>+  [$last]: html$.Node,
>+  single: html$.Node,
>+  [$single]: html$.Node,
>+  iterator: core.Iterator$(html$.Node),
>+  [$iterator]: core.Iterator$(html$.Node),
>+  length: core.int,
>+  [$length]: core.int,
>+  rawList: core.List$(html$.Node)
>+}));
>+dart.setSetterSignature(html$._ChildNodeListLazy, () => ({
>+  __proto__: dart.getSetters(html$._ChildNodeListLazy.__proto__),
>+  length: core.int,
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(html$._ChildNodeListLazy, "dart:html");
>+dart.setFieldSignature(html$._ChildNodeListLazy, () => ({
>+  __proto__: dart.getFields(html$._ChildNodeListLazy.__proto__),
>+  [_this]: dart.finalFieldType(html$.Node)
>+}));
>+dart.defineExtensionMethods(html$._ChildNodeListLazy, [
>+  'add',
>+  'addAll',
>+  'insert',
>+  'insertAll',
>+  'setAll',
>+  'removeLast',
>+  'removeAt',
>+  'remove',
>+  'removeWhere',
>+  'retainWhere',
>+  'clear',
>+  '_set',
>+  'sort',
>+  'shuffle',
>+  'setRange',
>+  'fillRange',
>+  'removeRange',
>+  '_get'
>+]);
>+dart.defineExtensionAccessors(html$._ChildNodeListLazy, [
>+  'first',
>+  'last',
>+  'single',
>+  'iterator',
>+  'length'
>+]);
>+html$.NodeFilter = class NodeFilter extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$.NodeFilter);
>+dart.setLibraryUri(html$.NodeFilter, "dart:html");
>+dart.defineLazy(html$.NodeFilter, {
>+  /*html$.NodeFilter.FILTER_ACCEPT*/get FILTER_ACCEPT() {
>+    return 1;
>+  },
>+  /*html$.NodeFilter.FILTER_REJECT*/get FILTER_REJECT() {
>+    return 2;
>+  },
>+  /*html$.NodeFilter.FILTER_SKIP*/get FILTER_SKIP() {
>+    return 3;
>+  },
>+  /*html$.NodeFilter.SHOW_ALL*/get SHOW_ALL() {
>+    return 4294967295;
>+  },
>+  /*html$.NodeFilter.SHOW_COMMENT*/get SHOW_COMMENT() {
>+    return 128;
>+  },
>+  /*html$.NodeFilter.SHOW_DOCUMENT*/get SHOW_DOCUMENT() {
>+    return 256;
>+  },
>+  /*html$.NodeFilter.SHOW_DOCUMENT_FRAGMENT*/get SHOW_DOCUMENT_FRAGMENT() {
>+    return 1024;
>+  },
>+  /*html$.NodeFilter.SHOW_DOCUMENT_TYPE*/get SHOW_DOCUMENT_TYPE() {
>+    return 512;
>+  },
>+  /*html$.NodeFilter.SHOW_ELEMENT*/get SHOW_ELEMENT() {
>+    return 1;
>+  },
>+  /*html$.NodeFilter.SHOW_PROCESSING_INSTRUCTION*/get SHOW_PROCESSING_INSTRUCTION() {
>+    return 64;
>+  },
>+  /*html$.NodeFilter.SHOW_TEXT*/get SHOW_TEXT() {
>+    return 4;
>+  }
>+});
>+dart.registerExtension("NodeFilter", html$.NodeFilter);
>+html$.NodeIterator = class NodeIterator extends _interceptors.Interceptor {
>+  static new(root, whatToShow) {
>+    return html$.document[_createNodeIterator](root, whatToShow, null);
>+  }
>+  get [$pointerBeforeReferenceNode]() {
>+    return this.pointerBeforeReferenceNode;
>+  }
>+  get [$referenceNode]() {
>+    return this.referenceNode;
>+  }
>+  get [$root]() {
>+    return this.root;
>+  }
>+  get [$whatToShow]() {
>+    return this.whatToShow;
>+  }
>+  [$detach](...args) {
>+    return this.detach.apply(this, args);
>+  }
>+  [$nextNode](...args) {
>+    return this.nextNode.apply(this, args);
>+  }
>+  [$previousNode](...args) {
>+    return this.previousNode.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.NodeIterator);
>+const pointerBeforeReferenceNode = Symbol("NodeIterator.pointerBeforeReferenceNode");
>+const referenceNode = Symbol("NodeIterator.referenceNode");
>+const root$0 = Symbol("NodeIterator.root");
>+const whatToShow = Symbol("NodeIterator.whatToShow");
>+dart.setMethodSignature(html$.NodeIterator, () => ({
>+  __proto__: dart.getMethods(html$.NodeIterator.__proto__),
>+  [$detach]: dart.fnType(dart.void, []),
>+  [$nextNode]: dart.fnType(html$.Node, []),
>+  [$previousNode]: dart.fnType(html$.Node, [])
>+}));
>+dart.setLibraryUri(html$.NodeIterator, "dart:html");
>+dart.setFieldSignature(html$.NodeIterator, () => ({
>+  __proto__: dart.getFields(html$.NodeIterator.__proto__),
>+  [$pointerBeforeReferenceNode]: dart.finalFieldType(core.bool),
>+  [$referenceNode]: dart.finalFieldType(html$.Node),
>+  [$root]: dart.finalFieldType(html$.Node),
>+  [$whatToShow]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("NodeIterator", html$.NodeIterator);
>+const Interceptor_ListMixin$$3 = class Interceptor_ListMixin extends _interceptors.Interceptor {};
>+(Interceptor_ListMixin$$3.new = function() {
>+  Interceptor_ListMixin$$3.__proto__.new.call(this);
>+}).prototype = Interceptor_ListMixin$$3.prototype;
>+dart.applyMixin(Interceptor_ListMixin$$3, collection.ListMixin$(html$.Node));
>+const Interceptor_ImmutableListMixin$$3 = class Interceptor_ImmutableListMixin extends Interceptor_ListMixin$$3 {};
>+(Interceptor_ImmutableListMixin$$3.new = function() {
>+  Interceptor_ImmutableListMixin$$3.__proto__.new.call(this);
>+}).prototype = Interceptor_ImmutableListMixin$$3.prototype;
>+dart.applyMixin(Interceptor_ImmutableListMixin$$3, html$.ImmutableListMixin$(html$.Node));
>+html$.NodeList = class NodeList extends Interceptor_ImmutableListMixin$$3 {
>+  get [$length]() {
>+    return this.length;
>+  }
>+  [$_get](index) {
>+    if (index >>> 0 !== index || index >= this[$length]) dart.throw(core.RangeError.index(index, this));
>+    return this[index];
>+  }
>+  [$_set](index, value) {
>+    html$.Node._check(value);
>+    dart.throw(new core.UnsupportedError.new("Cannot assign element of immutable List."));
>+    return value;
>+  }
>+  set [$length](value) {
>+    dart.throw(new core.UnsupportedError.new("Cannot resize immutable List."));
>+  }
>+  get [$first]() {
>+    if (dart.notNull(this[$length]) > 0) {
>+      return this[0];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$first](value) {
>+    super[$first] = value;
>+  }
>+  get [$last]() {
>+    let len = this[$length];
>+    if (dart.notNull(len) > 0) {
>+      return this[dart.notNull(len) - 1];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$last](value) {
>+    super[$last] = value;
>+  }
>+  get [$single]() {
>+    let len = this[$length];
>+    if (len === 1) {
>+      return this[0];
>+    }
>+    if (len === 0) dart.throw(new core.StateError.new("No elements"));
>+    dart.throw(new core.StateError.new("More than one element"));
>+  }
>+  [$elementAt](index) {
>+    return this[$_get](index);
>+  }
>+  [_item](...args) {
>+    return this.item.apply(this, args);
>+  }
>+};
>+html$.NodeList.prototype[dart.isList] = true;
>+dart.addTypeTests(html$.NodeList);
>+html$.NodeList[dart.implements] = () => [JavaScriptIndexingBehaviorOfNode(), ListOfNode()];
>+dart.setMethodSignature(html$.NodeList, () => ({
>+  __proto__: dart.getMethods(html$.NodeList.__proto__),
>+  [$_get]: dart.fnType(html$.Node, [core.int]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$elementAt]: dart.fnType(html$.Node, [core.int]),
>+  [_item]: dart.fnType(html$.Node, [core.int])
>+}));
>+dart.setGetterSignature(html$.NodeList, () => ({
>+  __proto__: dart.getGetters(html$.NodeList.__proto__),
>+  [$length]: core.int,
>+  [$first]: html$.Node,
>+  [$last]: html$.Node,
>+  [$single]: html$.Node
>+}));
>+dart.setSetterSignature(html$.NodeList, () => ({
>+  __proto__: dart.getSetters(html$.NodeList.__proto__),
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(html$.NodeList, "dart:html");
>+dart.registerExtension("NodeList", html$.NodeList);
>+dart.registerExtension("RadioNodeList", html$.NodeList);
>+html$.NonDocumentTypeChildNode = class NonDocumentTypeChildNode extends _interceptors.Interceptor {
>+  get [$nextElementSibling]() {
>+    return this.nextElementSibling;
>+  }
>+  get [$previousElementSibling]() {
>+    return this.previousElementSibling;
>+  }
>+};
>+dart.addTypeTests(html$.NonDocumentTypeChildNode);
>+const nextElementSibling$0 = Symbol("NonDocumentTypeChildNode.nextElementSibling");
>+const previousElementSibling$0 = Symbol("NonDocumentTypeChildNode.previousElementSibling");
>+dart.setLibraryUri(html$.NonDocumentTypeChildNode, "dart:html");
>+dart.setFieldSignature(html$.NonDocumentTypeChildNode, () => ({
>+  __proto__: dart.getFields(html$.NonDocumentTypeChildNode.__proto__),
>+  [$nextElementSibling]: dart.finalFieldType(html$.Element),
>+  [$previousElementSibling]: dart.finalFieldType(html$.Element)
>+}));
>+dart.registerExtension("NonDocumentTypeChildNode", html$.NonDocumentTypeChildNode);
>+html$.NonElementParentNode = class NonElementParentNode extends _interceptors.Interceptor {
>+  [$getElementById](...args) {
>+    return this.getElementById.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.NonElementParentNode);
>+dart.setMethodSignature(html$.NonElementParentNode, () => ({
>+  __proto__: dart.getMethods(html$.NonElementParentNode.__proto__),
>+  [$getElementById]: dart.fnType(html$.Element, [core.String])
>+}));
>+dart.setLibraryUri(html$.NonElementParentNode, "dart:html");
>+dart.registerExtension("NonElementParentNode", html$.NonElementParentNode);
>+html$.NoncedElement = class NoncedElement extends _interceptors.Interceptor {
>+  get [$nonce]() {
>+    return this.nonce;
>+  }
>+  set [$nonce](value) {
>+    this.nonce = value;
>+  }
>+};
>+dart.addTypeTests(html$.NoncedElement);
>+const nonce$ = Symbol("NoncedElement.nonce");
>+dart.setLibraryUri(html$.NoncedElement, "dart:html");
>+dart.setFieldSignature(html$.NoncedElement, () => ({
>+  __proto__: dart.getFields(html$.NoncedElement.__proto__),
>+  [$nonce]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("NoncedElement", html$.NoncedElement);
>+html$.Notification = class Notification$ extends html$.EventTarget {
>+  static new(title, opts) {
>+    let dir = opts && 'dir' in opts ? opts.dir : null;
>+    let body = opts && 'body' in opts ? opts.body : null;
>+    let lang = opts && 'lang' in opts ? opts.lang : null;
>+    let tag = opts && 'tag' in opts ? opts.tag : null;
>+    let icon = opts && 'icon' in opts ? opts.icon : null;
>+    let parsedOptions = new _js_helper.LinkedMap.new();
>+    if (dir != null) parsedOptions[$_set]("dir", dir);
>+    if (body != null) parsedOptions[$_set]("body", body);
>+    if (lang != null) parsedOptions[$_set]("lang", lang);
>+    if (tag != null) parsedOptions[$_set]("tag", tag);
>+    if (icon != null) parsedOptions[$_set]("icon", icon);
>+    return html$.Notification._factoryNotification(title, parsedOptions);
>+  }
>+  static _factoryNotification(title, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      return html$.Notification._create_1(title, options_1);
>+    }
>+    return html$.Notification._create_2(title);
>+  }
>+  static _create_1(title, options) {
>+    return new Notification(title, options);
>+  }
>+  static _create_2(title) {
>+    return new Notification(title);
>+  }
>+  static get supported() {
>+    return !!window.Notification;
>+  }
>+  get [$actions]() {
>+    return this.actions;
>+  }
>+  get [$badge]() {
>+    return this.badge;
>+  }
>+  get [$body]() {
>+    return this.body;
>+  }
>+  get [$data]() {
>+    return this.data;
>+  }
>+  get [$dir]() {
>+    return this.dir;
>+  }
>+  get [$icon]() {
>+    return this.icon;
>+  }
>+  get [$image]() {
>+    return this.image;
>+  }
>+  get [$lang]() {
>+    return this.lang;
>+  }
>+  get [$renotify]() {
>+    return this.renotify;
>+  }
>+  get [$requireInteraction]() {
>+    return this.requireInteraction;
>+  }
>+  get [$silent]() {
>+    return this.silent;
>+  }
>+  get [$tag]() {
>+    return this.tag;
>+  }
>+  get [$timestamp]() {
>+    return this.timestamp;
>+  }
>+  get [$title]() {
>+    return this.title;
>+  }
>+  get [$vibrate]() {
>+    return this.vibrate;
>+  }
>+  [$close](...args) {
>+    return this.close.apply(this, args);
>+  }
>+  static requestPermission() {
>+    let completer = CompleterOfString().new();
>+    dart.global.Notification.requestPermission(dart.fn(value => {
>+      completer.complete(value);
>+    }, StringToNull()));
>+    return completer.future;
>+  }
>+  get [$onClick]() {
>+    return html$.Notification.clickEvent.forTarget(this);
>+  }
>+  get [$onClose]() {
>+    return html$.Notification.closeEvent.forTarget(this);
>+  }
>+  get [$onError]() {
>+    return html$.Notification.errorEvent.forTarget(this);
>+  }
>+  get [$onShow]() {
>+    return html$.Notification.showEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.Notification);
>+const actions = Symbol("Notification.actions");
>+const badge = Symbol("Notification.badge");
>+const body$ = Symbol("Notification.body");
>+const data$5 = Symbol("Notification.data");
>+const dir$ = Symbol("Notification.dir");
>+const icon = Symbol("Notification.icon");
>+const image = Symbol("Notification.image");
>+const lang$ = Symbol("Notification.lang");
>+const renotify = Symbol("Notification.renotify");
>+const requireInteraction = Symbol("Notification.requireInteraction");
>+const silent = Symbol("Notification.silent");
>+const tag = Symbol("Notification.tag");
>+const timestamp$1 = Symbol("Notification.timestamp");
>+const title$2 = Symbol("Notification.title");
>+const vibrate = Symbol("Notification.vibrate");
>+dart.setMethodSignature(html$.Notification, () => ({
>+  __proto__: dart.getMethods(html$.Notification.__proto__),
>+  [$close]: dart.fnType(dart.void, [])
>+}));
>+dart.setGetterSignature(html$.Notification, () => ({
>+  __proto__: dart.getGetters(html$.Notification.__proto__),
>+  [$onClick]: async.Stream$(html$.Event),
>+  [$onClose]: async.Stream$(html$.Event),
>+  [$onError]: async.Stream$(html$.Event),
>+  [$onShow]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.Notification, "dart:html");
>+dart.setFieldSignature(html$.Notification, () => ({
>+  __proto__: dart.getFields(html$.Notification.__proto__),
>+  [$actions]: dart.finalFieldType(core.List),
>+  [$badge]: dart.finalFieldType(core.String),
>+  [$body]: dart.finalFieldType(core.String),
>+  [$data]: dart.finalFieldType(core.Object),
>+  [$dir]: dart.finalFieldType(core.String),
>+  [$icon]: dart.finalFieldType(core.String),
>+  [$image]: dart.finalFieldType(core.String),
>+  [$lang]: dart.finalFieldType(core.String),
>+  [$renotify]: dart.finalFieldType(core.bool),
>+  [$requireInteraction]: dart.finalFieldType(core.bool),
>+  [$silent]: dart.finalFieldType(core.bool),
>+  [$tag]: dart.finalFieldType(core.String),
>+  [$timestamp]: dart.finalFieldType(core.int),
>+  [$title]: dart.finalFieldType(core.String),
>+  [$vibrate]: dart.finalFieldType(ListOfint())
>+}));
>+dart.defineLazy(html$.Notification, {
>+  /*html$.Notification.clickEvent*/get clickEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("click"));
>+  },
>+  /*html$.Notification.closeEvent*/get closeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("close"));
>+  },
>+  /*html$.Notification.errorEvent*/get errorEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("error"));
>+  },
>+  /*html$.Notification.showEvent*/get showEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("show"));
>+  },
>+  /*html$.Notification.maxActions*/get maxActions() {
>+    return null;
>+  },
>+  /*html$.Notification.permission*/get permission() {
>+    return null;
>+  }
>+});
>+dart.registerExtension("Notification", html$.Notification);
>+html$.NotificationEvent = class NotificationEvent$ extends html$.ExtendableEvent {
>+  static new(type, eventInitDict) {
>+    let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+    return html$.NotificationEvent._create_1(type, eventInitDict_1);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new NotificationEvent(type, eventInitDict);
>+  }
>+  get [$action]() {
>+    return this.action;
>+  }
>+  get [$notification]() {
>+    return this.notification;
>+  }
>+  get [$reply]() {
>+    return this.reply;
>+  }
>+};
>+dart.addTypeTests(html$.NotificationEvent);
>+const action$ = Symbol("NotificationEvent.action");
>+const notification = Symbol("NotificationEvent.notification");
>+const reply = Symbol("NotificationEvent.reply");
>+dart.setLibraryUri(html$.NotificationEvent, "dart:html");
>+dart.setFieldSignature(html$.NotificationEvent, () => ({
>+  __proto__: dart.getFields(html$.NotificationEvent.__proto__),
>+  [$action]: dart.finalFieldType(core.String),
>+  [$notification]: dart.finalFieldType(html$.Notification),
>+  [$reply]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("NotificationEvent", html$.NotificationEvent);
>+html$.OListElement = class OListElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("ol");
>+  }
>+  get [$reversed]() {
>+    return this.reversed;
>+  }
>+  set [$reversed](value) {
>+    this.reversed = value;
>+  }
>+  get [$start]() {
>+    return this.start;
>+  }
>+  set [$start](value) {
>+    this.start = value;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  set [$type](value) {
>+    this.type = value;
>+  }
>+};
>+(html$.OListElement.created = function() {
>+  this[reversed] = null;
>+  this[start$] = null;
>+  this[type$21] = null;
>+  html$.OListElement.__proto__.created.call(this);
>+}).prototype = html$.OListElement.prototype;
>+dart.addTypeTests(html$.OListElement);
>+const reversed = Symbol("OListElement.reversed");
>+const start$ = Symbol("OListElement.start");
>+const type$21 = Symbol("OListElement.type");
>+dart.setLibraryUri(html$.OListElement, "dart:html");
>+dart.setFieldSignature(html$.OListElement, () => ({
>+  __proto__: dart.getFields(html$.OListElement.__proto__),
>+  [$reversed]: dart.fieldType(core.bool),
>+  [$start]: dart.fieldType(core.int),
>+  [$type]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("HTMLOListElement", html$.OListElement);
>+html$.ObjectElement = class ObjectElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.ObjectElement._check(html$.document[$createElement]("object"));
>+  }
>+  static get supported() {
>+    return html$.Element.isTagSupported("object");
>+  }
>+  get [$contentWindow]() {
>+    return html$._convertNativeToDart_Window(this[_get_contentWindow]);
>+  }
>+  get [_get_contentWindow]() {
>+    return this.contentWindow;
>+  }
>+  get [$data]() {
>+    return this.data;
>+  }
>+  set [$data](value) {
>+    this.data = value;
>+  }
>+  get [$form]() {
>+    return this.form;
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  set [$height](value) {
>+    this.height = value;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+  set [$name](value) {
>+    this.name = value;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  set [$type](value) {
>+    this.type = value;
>+  }
>+  get [$useMap]() {
>+    return this.useMap;
>+  }
>+  set [$useMap](value) {
>+    this.useMap = value;
>+  }
>+  get [$validationMessage]() {
>+    return this.validationMessage;
>+  }
>+  get [$validity]() {
>+    return this.validity;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  set [$width](value) {
>+    this.width = value;
>+  }
>+  get [$willValidate]() {
>+    return this.willValidate;
>+  }
>+  [__getter__](...args) {
>+    return this.__getter__.apply(this, args);
>+  }
>+  [__setter__](...args) {
>+    return this.__setter__.apply(this, args);
>+  }
>+  [$checkValidity](...args) {
>+    return this.checkValidity.apply(this, args);
>+  }
>+  [$reportValidity](...args) {
>+    return this.reportValidity.apply(this, args);
>+  }
>+  [$setCustomValidity](...args) {
>+    return this.setCustomValidity.apply(this, args);
>+  }
>+};
>+(html$.ObjectElement.created = function() {
>+  this[_get_contentWindow] = null;
>+  this[data$6] = null;
>+  this[form$3] = null;
>+  this[height$6] = null;
>+  this[name$25] = null;
>+  this[type$22] = null;
>+  this[useMap$] = null;
>+  this[validationMessage$1] = null;
>+  this[validity$1] = null;
>+  this[width$6] = null;
>+  this[willValidate$1] = null;
>+  html$.ObjectElement.__proto__.created.call(this);
>+}).prototype = html$.ObjectElement.prototype;
>+dart.addTypeTests(html$.ObjectElement);
>+const data$6 = Symbol("ObjectElement.data");
>+const form$3 = Symbol("ObjectElement.form");
>+const height$6 = Symbol("ObjectElement.height");
>+const name$25 = Symbol("ObjectElement.name");
>+const type$22 = Symbol("ObjectElement.type");
>+const useMap$ = Symbol("ObjectElement.useMap");
>+const validationMessage$1 = Symbol("ObjectElement.validationMessage");
>+const validity$1 = Symbol("ObjectElement.validity");
>+const width$6 = Symbol("ObjectElement.width");
>+const willValidate$1 = Symbol("ObjectElement.willValidate");
>+dart.setMethodSignature(html$.ObjectElement, () => ({
>+  __proto__: dart.getMethods(html$.ObjectElement.__proto__),
>+  [__getter__]: dart.fnType(html$.Node, [core.String]),
>+  [__setter__]: dart.fnType(dart.void, [core.String, html$.Node]),
>+  [$checkValidity]: dart.fnType(core.bool, []),
>+  [$reportValidity]: dart.fnType(core.bool, []),
>+  [$setCustomValidity]: dart.fnType(dart.void, [core.String])
>+}));
>+dart.setGetterSignature(html$.ObjectElement, () => ({
>+  __proto__: dart.getGetters(html$.ObjectElement.__proto__),
>+  [$contentWindow]: html$.WindowBase
>+}));
>+dart.setLibraryUri(html$.ObjectElement, "dart:html");
>+dart.setFieldSignature(html$.ObjectElement, () => ({
>+  __proto__: dart.getFields(html$.ObjectElement.__proto__),
>+  [_get_contentWindow]: dart.finalFieldType(dart.dynamic),
>+  [$data]: dart.fieldType(core.String),
>+  [$form]: dart.finalFieldType(html$.FormElement),
>+  [$height]: dart.fieldType(core.String),
>+  [$name]: dart.fieldType(core.String),
>+  [$type]: dart.fieldType(core.String),
>+  [$useMap]: dart.fieldType(core.String),
>+  [$validationMessage]: dart.finalFieldType(core.String),
>+  [$validity]: dart.finalFieldType(html$.ValidityState),
>+  [$width]: dart.fieldType(core.String),
>+  [$willValidate]: dart.finalFieldType(core.bool)
>+}));
>+dart.registerExtension("HTMLObjectElement", html$.ObjectElement);
>+html$.OffscreenCanvas = class OffscreenCanvas$ extends html$.EventTarget {
>+  static new(width, height) {
>+    return html$.OffscreenCanvas._create_1(width, height);
>+  }
>+  static _create_1(width, height) {
>+    return new OffscreenCanvas(width, height);
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  set [$height](value) {
>+    this.height = value;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  set [$width](value) {
>+    this.width = value;
>+  }
>+  [$convertToBlob](options) {
>+    if (options === void 0) options = null;
>+    let options_dict = null;
>+    if (options != null) {
>+      options_dict = html_common.convertDartToNative_Dictionary(options);
>+    }
>+    return html$.promiseToFuture(html$.Blob, this.convertToBlob(options_dict));
>+  }
>+  [$getContext](contextType, attributes) {
>+    if (attributes === void 0) attributes = null;
>+    if (attributes != null) {
>+      let attributes_1 = html_common.convertDartToNative_Dictionary(attributes);
>+      return this[_getContext_1](contextType, attributes_1);
>+    }
>+    return this[_getContext_2](contextType);
>+  }
>+  [_getContext_1](...args) {
>+    return this.getContext.apply(this, args);
>+  }
>+  [_getContext_2](...args) {
>+    return this.getContext.apply(this, args);
>+  }
>+  [$transferToImageBitmap](...args) {
>+    return this.transferToImageBitmap.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.OffscreenCanvas);
>+const height$7 = Symbol("OffscreenCanvas.height");
>+const width$7 = Symbol("OffscreenCanvas.width");
>+dart.setMethodSignature(html$.OffscreenCanvas, () => ({
>+  __proto__: dart.getMethods(html$.OffscreenCanvas.__proto__),
>+  [$convertToBlob]: dart.fnType(async.Future$(html$.Blob), [], [core.Map]),
>+  [$getContext]: dart.fnType(core.Object, [core.String], [core.Map]),
>+  [_getContext_1]: dart.fnType(core.Object, [dart.dynamic, dart.dynamic]),
>+  [_getContext_2]: dart.fnType(core.Object, [dart.dynamic]),
>+  [$transferToImageBitmap]: dart.fnType(html$.ImageBitmap, [])
>+}));
>+dart.setLibraryUri(html$.OffscreenCanvas, "dart:html");
>+dart.setFieldSignature(html$.OffscreenCanvas, () => ({
>+  __proto__: dart.getFields(html$.OffscreenCanvas.__proto__),
>+  [$height]: dart.fieldType(core.int),
>+  [$width]: dart.fieldType(core.int)
>+}));
>+dart.registerExtension("OffscreenCanvas", html$.OffscreenCanvas);
>+html$.OffscreenCanvasRenderingContext2D = class OffscreenCanvasRenderingContext2D extends _interceptors.Interceptor {
>+  get [$canvas]() {
>+    return this.canvas;
>+  }
>+  get [$direction]() {
>+    return this.direction;
>+  }
>+  set [$direction](value) {
>+    this.direction = value;
>+  }
>+  get [$fillStyle]() {
>+    return this.fillStyle;
>+  }
>+  set [$fillStyle](value) {
>+    this.fillStyle = value;
>+  }
>+  get [$filter]() {
>+    return this.filter;
>+  }
>+  set [$filter](value) {
>+    this.filter = value;
>+  }
>+  get [$font]() {
>+    return this.font;
>+  }
>+  set [$font](value) {
>+    this.font = value;
>+  }
>+  get [$globalAlpha]() {
>+    return this.globalAlpha;
>+  }
>+  set [$globalAlpha](value) {
>+    this.globalAlpha = value;
>+  }
>+  get [$globalCompositeOperation]() {
>+    return this.globalCompositeOperation;
>+  }
>+  set [$globalCompositeOperation](value) {
>+    this.globalCompositeOperation = value;
>+  }
>+  get [$imageSmoothingEnabled]() {
>+    return this.imageSmoothingEnabled;
>+  }
>+  set [$imageSmoothingEnabled](value) {
>+    this.imageSmoothingEnabled = value;
>+  }
>+  get [$imageSmoothingQuality]() {
>+    return this.imageSmoothingQuality;
>+  }
>+  set [$imageSmoothingQuality](value) {
>+    this.imageSmoothingQuality = value;
>+  }
>+  get [$lineCap]() {
>+    return this.lineCap;
>+  }
>+  set [$lineCap](value) {
>+    this.lineCap = value;
>+  }
>+  get [$lineDashOffset]() {
>+    return this.lineDashOffset;
>+  }
>+  set [$lineDashOffset](value) {
>+    this.lineDashOffset = value;
>+  }
>+  get [$lineJoin]() {
>+    return this.lineJoin;
>+  }
>+  set [$lineJoin](value) {
>+    this.lineJoin = value;
>+  }
>+  get [$lineWidth]() {
>+    return this.lineWidth;
>+  }
>+  set [$lineWidth](value) {
>+    this.lineWidth = value;
>+  }
>+  get [$miterLimit]() {
>+    return this.miterLimit;
>+  }
>+  set [$miterLimit](value) {
>+    this.miterLimit = value;
>+  }
>+  get [$shadowBlur]() {
>+    return this.shadowBlur;
>+  }
>+  set [$shadowBlur](value) {
>+    this.shadowBlur = value;
>+  }
>+  get [$shadowColor]() {
>+    return this.shadowColor;
>+  }
>+  set [$shadowColor](value) {
>+    this.shadowColor = value;
>+  }
>+  get [$shadowOffsetX]() {
>+    return this.shadowOffsetX;
>+  }
>+  set [$shadowOffsetX](value) {
>+    this.shadowOffsetX = value;
>+  }
>+  get [$shadowOffsetY]() {
>+    return this.shadowOffsetY;
>+  }
>+  set [$shadowOffsetY](value) {
>+    this.shadowOffsetY = value;
>+  }
>+  get [$strokeStyle]() {
>+    return this.strokeStyle;
>+  }
>+  set [$strokeStyle](value) {
>+    this.strokeStyle = value;
>+  }
>+  get [$textAlign]() {
>+    return this.textAlign;
>+  }
>+  set [$textAlign](value) {
>+    this.textAlign = value;
>+  }
>+  get [$textBaseline]() {
>+    return this.textBaseline;
>+  }
>+  set [$textBaseline](value) {
>+    this.textBaseline = value;
>+  }
>+  [$beginPath](...args) {
>+    return this.beginPath.apply(this, args);
>+  }
>+  [$clearRect](...args) {
>+    return this.clearRect.apply(this, args);
>+  }
>+  [$clip](...args) {
>+    return this.clip.apply(this, args);
>+  }
>+  [$commit]() {
>+    return html$.promiseToFuture(dart.dynamic, this.commit());
>+  }
>+  [$createImageData](data_OR_imagedata_OR_sw, sh_OR_sw, imageDataColorSettings_OR_sh, imageDataColorSettings) {
>+    if (sh_OR_sw === void 0) sh_OR_sw = null;
>+    if (imageDataColorSettings_OR_sh === void 0) imageDataColorSettings_OR_sh = null;
>+    if (imageDataColorSettings === void 0) imageDataColorSettings = null;
>+    if (html$.ImageData.is(data_OR_imagedata_OR_sw) && sh_OR_sw == null && imageDataColorSettings_OR_sh == null && imageDataColorSettings == null) {
>+      let imagedata_1 = html_common.convertDartToNative_ImageData(data_OR_imagedata_OR_sw);
>+      return html_common.convertNativeToDart_ImageData(this[_createImageData_1](imagedata_1));
>+    }
>+    if (sh_OR_sw != null && core.int.is(data_OR_imagedata_OR_sw) && imageDataColorSettings_OR_sh == null && imageDataColorSettings == null) {
>+      return html_common.convertNativeToDart_ImageData(this[_createImageData_2](data_OR_imagedata_OR_sw, sh_OR_sw));
>+    }
>+    if (core.Map.is(imageDataColorSettings_OR_sh) && sh_OR_sw != null && core.int.is(data_OR_imagedata_OR_sw) && imageDataColorSettings == null) {
>+      let imageDataColorSettings_1 = html_common.convertDartToNative_Dictionary(imageDataColorSettings_OR_sh);
>+      return html_common.convertNativeToDart_ImageData(this[_createImageData_3](data_OR_imagedata_OR_sw, sh_OR_sw, imageDataColorSettings_1));
>+    }
>+    if (imageDataColorSettings != null && core.int.is(imageDataColorSettings_OR_sh) && sh_OR_sw != null && data_OR_imagedata_OR_sw != null) {
>+      let imageDataColorSettings_1 = html_common.convertDartToNative_Dictionary(imageDataColorSettings);
>+      return html_common.convertNativeToDart_ImageData(this[_createImageData_4](data_OR_imagedata_OR_sw, sh_OR_sw, imageDataColorSettings_OR_sh, imageDataColorSettings_1));
>+    }
>+    dart.throw(new core.ArgumentError.new("Incorrect number or type of arguments"));
>+  }
>+  [_createImageData_1](...args) {
>+    return this.createImageData.apply(this, args);
>+  }
>+  [_createImageData_2](...args) {
>+    return this.createImageData.apply(this, args);
>+  }
>+  [_createImageData_3](...args) {
>+    return this.createImageData.apply(this, args);
>+  }
>+  [_createImageData_4](...args) {
>+    return this.createImageData.apply(this, args);
>+  }
>+  [$createLinearGradient](...args) {
>+    return this.createLinearGradient.apply(this, args);
>+  }
>+  [$createPattern](...args) {
>+    return this.createPattern.apply(this, args);
>+  }
>+  [$createRadialGradient](...args) {
>+    return this.createRadialGradient.apply(this, args);
>+  }
>+  [$drawImage](...args) {
>+    return this.drawImage.apply(this, args);
>+  }
>+  [$fill](...args) {
>+    return this.fill.apply(this, args);
>+  }
>+  [$fillRect](...args) {
>+    return this.fillRect.apply(this, args);
>+  }
>+  [$fillText](...args) {
>+    return this.fillText.apply(this, args);
>+  }
>+  [$getImageData](sx, sy, sw, sh) {
>+    return html_common.convertNativeToDart_ImageData(this[_getImageData_1](sx, sy, sw, sh));
>+  }
>+  [_getImageData_1](...args) {
>+    return this.getImageData.apply(this, args);
>+  }
>+  [$getLineDash](...args) {
>+    return this.getLineDash.apply(this, args);
>+  }
>+  [$isPointInPath](...args) {
>+    return this.isPointInPath.apply(this, args);
>+  }
>+  [$isPointInStroke](...args) {
>+    return this.isPointInStroke.apply(this, args);
>+  }
>+  [$measureText](...args) {
>+    return this.measureText.apply(this, args);
>+  }
>+  [$putImageData](imagedata, dx, dy, dirtyX, dirtyY, dirtyWidth, dirtyHeight) {
>+    if (dirtyX === void 0) dirtyX = null;
>+    if (dirtyY === void 0) dirtyY = null;
>+    if (dirtyWidth === void 0) dirtyWidth = null;
>+    if (dirtyHeight === void 0) dirtyHeight = null;
>+    if (dirtyX == null && dirtyY == null && dirtyWidth == null && dirtyHeight == null) {
>+      let imagedata_1 = html_common.convertDartToNative_ImageData(imagedata);
>+      this[_putImageData_1](imagedata_1, dx, dy);
>+      return;
>+    }
>+    if (dirtyHeight != null && dirtyWidth != null && dirtyY != null && dirtyX != null) {
>+      let imagedata_1 = html_common.convertDartToNative_ImageData(imagedata);
>+      this[_putImageData_2](imagedata_1, dx, dy, dirtyX, dirtyY, dirtyWidth, dirtyHeight);
>+      return;
>+    }
>+    dart.throw(new core.ArgumentError.new("Incorrect number or type of arguments"));
>+  }
>+  [_putImageData_1](...args) {
>+    return this.putImageData.apply(this, args);
>+  }
>+  [_putImageData_2](...args) {
>+    return this.putImageData.apply(this, args);
>+  }
>+  [$resetTransform](...args) {
>+    return this.resetTransform.apply(this, args);
>+  }
>+  [$restore](...args) {
>+    return this.restore.apply(this, args);
>+  }
>+  [$rotate](...args) {
>+    return this.rotate.apply(this, args);
>+  }
>+  [$save](...args) {
>+    return this.save.apply(this, args);
>+  }
>+  [$scale](...args) {
>+    return this.scale.apply(this, args);
>+  }
>+  [$setLineDash](...args) {
>+    return this.setLineDash.apply(this, args);
>+  }
>+  [$setTransform](...args) {
>+    return this.setTransform.apply(this, args);
>+  }
>+  [$stroke](...args) {
>+    return this.stroke.apply(this, args);
>+  }
>+  [$strokeRect](...args) {
>+    return this.strokeRect.apply(this, args);
>+  }
>+  [$strokeText](...args) {
>+    return this.strokeText.apply(this, args);
>+  }
>+  [$transform](...args) {
>+    return this.transform.apply(this, args);
>+  }
>+  [$translate](...args) {
>+    return this.translate.apply(this, args);
>+  }
>+  [$arc](...args) {
>+    return this.arc.apply(this, args);
>+  }
>+  [$arcTo](...args) {
>+    return this.arcTo.apply(this, args);
>+  }
>+  [$bezierCurveTo](...args) {
>+    return this.bezierCurveTo.apply(this, args);
>+  }
>+  [$closePath](...args) {
>+    return this.closePath.apply(this, args);
>+  }
>+  [$ellipse](...args) {
>+    return this.ellipse.apply(this, args);
>+  }
>+  [$lineTo](...args) {
>+    return this.lineTo.apply(this, args);
>+  }
>+  [$moveTo](...args) {
>+    return this.moveTo.apply(this, args);
>+  }
>+  [$quadraticCurveTo](...args) {
>+    return this.quadraticCurveTo.apply(this, args);
>+  }
>+  [$rect](...args) {
>+    return this.rect.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.OffscreenCanvasRenderingContext2D);
>+const canvas$1 = Symbol("OffscreenCanvasRenderingContext2D.canvas");
>+const direction$1 = Symbol("OffscreenCanvasRenderingContext2D.direction");
>+const fillStyle$ = Symbol("OffscreenCanvasRenderingContext2D.fillStyle");
>+const filter$ = Symbol("OffscreenCanvasRenderingContext2D.filter");
>+const font$ = Symbol("OffscreenCanvasRenderingContext2D.font");
>+const globalAlpha$ = Symbol("OffscreenCanvasRenderingContext2D.globalAlpha");
>+const globalCompositeOperation$ = Symbol("OffscreenCanvasRenderingContext2D.globalCompositeOperation");
>+const imageSmoothingEnabled$ = Symbol("OffscreenCanvasRenderingContext2D.imageSmoothingEnabled");
>+const imageSmoothingQuality$ = Symbol("OffscreenCanvasRenderingContext2D.imageSmoothingQuality");
>+const lineCap$ = Symbol("OffscreenCanvasRenderingContext2D.lineCap");
>+const lineDashOffset = Symbol("OffscreenCanvasRenderingContext2D.lineDashOffset");
>+const lineJoin$ = Symbol("OffscreenCanvasRenderingContext2D.lineJoin");
>+const lineWidth$ = Symbol("OffscreenCanvasRenderingContext2D.lineWidth");
>+const miterLimit$ = Symbol("OffscreenCanvasRenderingContext2D.miterLimit");
>+const shadowBlur$ = Symbol("OffscreenCanvasRenderingContext2D.shadowBlur");
>+const shadowColor$ = Symbol("OffscreenCanvasRenderingContext2D.shadowColor");
>+const shadowOffsetX$ = Symbol("OffscreenCanvasRenderingContext2D.shadowOffsetX");
>+const shadowOffsetY$ = Symbol("OffscreenCanvasRenderingContext2D.shadowOffsetY");
>+const strokeStyle$ = Symbol("OffscreenCanvasRenderingContext2D.strokeStyle");
>+const textAlign$ = Symbol("OffscreenCanvasRenderingContext2D.textAlign");
>+const textBaseline$ = Symbol("OffscreenCanvasRenderingContext2D.textBaseline");
>+html$.OffscreenCanvasRenderingContext2D[dart.implements] = () => [html$._CanvasPath];
>+dart.setMethodSignature(html$.OffscreenCanvasRenderingContext2D, () => ({
>+  __proto__: dart.getMethods(html$.OffscreenCanvasRenderingContext2D.__proto__),
>+  [$beginPath]: dart.fnType(dart.void, []),
>+  [$clearRect]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num]),
>+  [$clip]: dart.fnType(dart.void, [], [html$.Path2D]),
>+  [$commit]: dart.fnType(async.Future, []),
>+  [$createImageData]: dart.fnType(html$.ImageData, [dart.dynamic], [core.int, dart.dynamic, core.Map]),
>+  [_createImageData_1]: dart.fnType(dart.dynamic, [dart.dynamic]),
>+  [_createImageData_2]: dart.fnType(dart.dynamic, [core.int, dart.dynamic]),
>+  [_createImageData_3]: dart.fnType(dart.dynamic, [core.int, dart.dynamic, dart.dynamic]),
>+  [_createImageData_4]: dart.fnType(dart.dynamic, [dart.dynamic, dart.dynamic, core.int, dart.dynamic]),
>+  [$createLinearGradient]: dart.fnType(html$.CanvasGradient, [core.num, core.num, core.num, core.num]),
>+  [$createPattern]: dart.fnType(html$.CanvasPattern, [dart.dynamic, core.String]),
>+  [$createRadialGradient]: dart.fnType(html$.CanvasGradient, [core.num, core.num, core.num, core.num, core.num, core.num]),
>+  [$drawImage]: dart.fnType(dart.void, [dart.dynamic, core.num, core.num], [core.num, core.num, core.num, core.num, core.num, core.num]),
>+  [$fill]: dart.fnType(dart.void, [], [dart.dynamic, core.String]),
>+  [$fillRect]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num]),
>+  [$fillText]: dart.fnType(dart.void, [core.String, core.num, core.num], [core.num]),
>+  [$getImageData]: dart.fnType(html$.ImageData, [core.int, core.int, core.int, core.int]),
>+  [_getImageData_1]: dart.fnType(dart.dynamic, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic]),
>+  [$getLineDash]: dart.fnType(core.List$(core.num), []),
>+  [$isPointInPath]: dart.fnType(core.bool, [dart.dynamic, core.num], [dart.dynamic, core.String]),
>+  [$isPointInStroke]: dart.fnType(core.bool, [dart.dynamic, core.num], [core.num]),
>+  [$measureText]: dart.fnType(html$.TextMetrics, [core.String]),
>+  [$putImageData]: dart.fnType(dart.void, [html$.ImageData, core.int, core.int], [core.int, core.int, core.int, core.int]),
>+  [_putImageData_1]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic]),
>+  [_putImageData_2]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic]),
>+  [$resetTransform]: dart.fnType(dart.void, []),
>+  [$restore]: dart.fnType(dart.void, []),
>+  [$rotate]: dart.fnType(dart.void, [core.num]),
>+  [$save]: dart.fnType(dart.void, []),
>+  [$scale]: dart.fnType(dart.void, [core.num, core.num]),
>+  [$setLineDash]: dart.fnType(dart.void, [core.List$(core.num)]),
>+  [$setTransform]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num, core.num, core.num]),
>+  [$stroke]: dart.fnType(dart.void, [], [html$.Path2D]),
>+  [$strokeRect]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num]),
>+  [$strokeText]: dart.fnType(dart.void, [core.String, core.num, core.num], [core.num]),
>+  [$transform]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num, core.num, core.num]),
>+  [$translate]: dart.fnType(dart.void, [core.num, core.num]),
>+  [$arc]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num, core.num, core.bool]),
>+  [$arcTo]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num, core.num]),
>+  [$bezierCurveTo]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num, core.num, core.num]),
>+  [$closePath]: dart.fnType(dart.void, []),
>+  [$ellipse]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num, core.num, core.num, core.num, core.bool]),
>+  [$lineTo]: dart.fnType(dart.void, [core.num, core.num]),
>+  [$moveTo]: dart.fnType(dart.void, [core.num, core.num]),
>+  [$quadraticCurveTo]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num]),
>+  [$rect]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num])
>+}));
>+dart.setLibraryUri(html$.OffscreenCanvasRenderingContext2D, "dart:html");
>+dart.setFieldSignature(html$.OffscreenCanvasRenderingContext2D, () => ({
>+  __proto__: dart.getFields(html$.OffscreenCanvasRenderingContext2D.__proto__),
>+  [$canvas]: dart.finalFieldType(html$.OffscreenCanvas),
>+  [$direction]: dart.fieldType(core.String),
>+  [$fillStyle]: dart.fieldType(core.Object),
>+  [$filter]: dart.fieldType(core.String),
>+  [$font]: dart.fieldType(core.String),
>+  [$globalAlpha]: dart.fieldType(core.num),
>+  [$globalCompositeOperation]: dart.fieldType(core.String),
>+  [$imageSmoothingEnabled]: dart.fieldType(core.bool),
>+  [$imageSmoothingQuality]: dart.fieldType(core.String),
>+  [$lineCap]: dart.fieldType(core.String),
>+  [$lineDashOffset]: dart.fieldType(core.num),
>+  [$lineJoin]: dart.fieldType(core.String),
>+  [$lineWidth]: dart.fieldType(core.num),
>+  [$miterLimit]: dart.fieldType(core.num),
>+  [$shadowBlur]: dart.fieldType(core.num),
>+  [$shadowColor]: dart.fieldType(core.String),
>+  [$shadowOffsetX]: dart.fieldType(core.num),
>+  [$shadowOffsetY]: dart.fieldType(core.num),
>+  [$strokeStyle]: dart.fieldType(core.Object),
>+  [$textAlign]: dart.fieldType(core.String),
>+  [$textBaseline]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("OffscreenCanvasRenderingContext2D", html$.OffscreenCanvasRenderingContext2D);
>+html$.OptGroupElement = class OptGroupElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("optgroup");
>+  }
>+  get [$disabled]() {
>+    return this.disabled;
>+  }
>+  set [$disabled](value) {
>+    this.disabled = value;
>+  }
>+  get [$label]() {
>+    return this.label;
>+  }
>+  set [$label](value) {
>+    this.label = value;
>+  }
>+};
>+(html$.OptGroupElement.created = function() {
>+  this[disabled$5] = null;
>+  this[label$1] = null;
>+  html$.OptGroupElement.__proto__.created.call(this);
>+}).prototype = html$.OptGroupElement.prototype;
>+dart.addTypeTests(html$.OptGroupElement);
>+const disabled$5 = Symbol("OptGroupElement.disabled");
>+const label$1 = Symbol("OptGroupElement.label");
>+dart.setLibraryUri(html$.OptGroupElement, "dart:html");
>+dart.setFieldSignature(html$.OptGroupElement, () => ({
>+  __proto__: dart.getFields(html$.OptGroupElement.__proto__),
>+  [$disabled]: dart.fieldType(core.bool),
>+  [$label]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("HTMLOptGroupElement", html$.OptGroupElement);
>+html$.OptionElement = class OptionElement extends html$.HtmlElement {
>+  static new(opts) {
>+    let data = opts && 'data' in opts ? opts.data : "";
>+    let value = opts && 'value' in opts ? opts.value : "";
>+    let selected = opts && 'selected' in opts ? opts.selected : false;
>+    return html$.OptionElement.__(data, value, null, selected);
>+  }
>+  static __(data, value, defaultSelected, selected) {
>+    if (data === void 0) data = null;
>+    if (value === void 0) value = null;
>+    if (defaultSelected === void 0) defaultSelected = null;
>+    if (selected === void 0) selected = null;
>+    if (selected != null) {
>+      return html$.OptionElement._create_1(data, value, defaultSelected, selected);
>+    }
>+    if (defaultSelected != null) {
>+      return html$.OptionElement._create_2(data, value, defaultSelected);
>+    }
>+    if (value != null) {
>+      return html$.OptionElement._create_3(data, value);
>+    }
>+    if (data != null) {
>+      return html$.OptionElement._create_4(data);
>+    }
>+    return html$.OptionElement._create_5();
>+  }
>+  static _create_1(data, value, defaultSelected, selected) {
>+    return new Option(data, value, defaultSelected, selected);
>+  }
>+  static _create_2(data, value, defaultSelected) {
>+    return new Option(data, value, defaultSelected);
>+  }
>+  static _create_3(data, value) {
>+    return new Option(data, value);
>+  }
>+  static _create_4(data) {
>+    return new Option(data);
>+  }
>+  static _create_5() {
>+    return new Option();
>+  }
>+  get [$defaultSelected]() {
>+    return this.defaultSelected;
>+  }
>+  set [$defaultSelected](value) {
>+    this.defaultSelected = value;
>+  }
>+  get [$disabled]() {
>+    return this.disabled;
>+  }
>+  set [$disabled](value) {
>+    this.disabled = value;
>+  }
>+  get [$form]() {
>+    return this.form;
>+  }
>+  get [$index]() {
>+    return this.index;
>+  }
>+  get [$label]() {
>+    return this.label;
>+  }
>+  set [$label](value) {
>+    this.label = value;
>+  }
>+  get [$selected]() {
>+    return this.selected;
>+  }
>+  set [$selected](value) {
>+    this.selected = value;
>+  }
>+  get [$value]() {
>+    return this.value;
>+  }
>+  set [$value](value) {
>+    this.value = value;
>+  }
>+};
>+(html$.OptionElement.created = function() {
>+  this[defaultSelected] = null;
>+  this[disabled$6] = null;
>+  this[form$4] = null;
>+  this[index$] = null;
>+  this[label$2] = null;
>+  this[selected$] = null;
>+  this[value$11] = null;
>+  html$.OptionElement.__proto__.created.call(this);
>+}).prototype = html$.OptionElement.prototype;
>+dart.addTypeTests(html$.OptionElement);
>+const defaultSelected = Symbol("OptionElement.defaultSelected");
>+const disabled$6 = Symbol("OptionElement.disabled");
>+const form$4 = Symbol("OptionElement.form");
>+const index$ = Symbol("OptionElement.index");
>+const label$2 = Symbol("OptionElement.label");
>+const selected$ = Symbol("OptionElement.selected");
>+const value$11 = Symbol("OptionElement.value");
>+dart.setLibraryUri(html$.OptionElement, "dart:html");
>+dart.setFieldSignature(html$.OptionElement, () => ({
>+  __proto__: dart.getFields(html$.OptionElement.__proto__),
>+  [$defaultSelected]: dart.fieldType(core.bool),
>+  [$disabled]: dart.fieldType(core.bool),
>+  [$form]: dart.finalFieldType(html$.FormElement),
>+  [$index]: dart.finalFieldType(core.int),
>+  [$label]: dart.fieldType(core.String),
>+  [$selected]: dart.fieldType(core.bool),
>+  [$value]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("HTMLOptionElement", html$.OptionElement);
>+html$.OutputElement = class OutputElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.OutputElement._check(html$.document[$createElement]("output"));
>+  }
>+  static get supported() {
>+    return html$.Element.isTagSupported("output");
>+  }
>+  get [$defaultValue]() {
>+    return this.defaultValue;
>+  }
>+  set [$defaultValue](value) {
>+    this.defaultValue = value;
>+  }
>+  get [$form]() {
>+    return this.form;
>+  }
>+  get [$htmlFor]() {
>+    return this.htmlFor;
>+  }
>+  get [$labels]() {
>+    return this.labels;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+  set [$name](value) {
>+    this.name = value;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  get [$validationMessage]() {
>+    return this.validationMessage;
>+  }
>+  get [$validity]() {
>+    return this.validity;
>+  }
>+  get [$value]() {
>+    return this.value;
>+  }
>+  set [$value](value) {
>+    this.value = value;
>+  }
>+  get [$willValidate]() {
>+    return this.willValidate;
>+  }
>+  [$checkValidity](...args) {
>+    return this.checkValidity.apply(this, args);
>+  }
>+  [$reportValidity](...args) {
>+    return this.reportValidity.apply(this, args);
>+  }
>+  [$setCustomValidity](...args) {
>+    return this.setCustomValidity.apply(this, args);
>+  }
>+};
>+(html$.OutputElement.created = function() {
>+  this[defaultValue$] = null;
>+  this[form$5] = null;
>+  this[htmlFor$] = null;
>+  this[labels$1] = null;
>+  this[name$26] = null;
>+  this[type$23] = null;
>+  this[validationMessage$2] = null;
>+  this[validity$2] = null;
>+  this[value$12] = null;
>+  this[willValidate$2] = null;
>+  html$.OutputElement.__proto__.created.call(this);
>+}).prototype = html$.OutputElement.prototype;
>+dart.addTypeTests(html$.OutputElement);
>+const defaultValue$ = Symbol("OutputElement.defaultValue");
>+const form$5 = Symbol("OutputElement.form");
>+const htmlFor$ = Symbol("OutputElement.htmlFor");
>+const labels$1 = Symbol("OutputElement.labels");
>+const name$26 = Symbol("OutputElement.name");
>+const type$23 = Symbol("OutputElement.type");
>+const validationMessage$2 = Symbol("OutputElement.validationMessage");
>+const validity$2 = Symbol("OutputElement.validity");
>+const value$12 = Symbol("OutputElement.value");
>+const willValidate$2 = Symbol("OutputElement.willValidate");
>+dart.setMethodSignature(html$.OutputElement, () => ({
>+  __proto__: dart.getMethods(html$.OutputElement.__proto__),
>+  [$checkValidity]: dart.fnType(core.bool, []),
>+  [$reportValidity]: dart.fnType(core.bool, []),
>+  [$setCustomValidity]: dart.fnType(dart.void, [core.String])
>+}));
>+dart.setLibraryUri(html$.OutputElement, "dart:html");
>+dart.setFieldSignature(html$.OutputElement, () => ({
>+  __proto__: dart.getFields(html$.OutputElement.__proto__),
>+  [$defaultValue]: dart.fieldType(core.String),
>+  [$form]: dart.finalFieldType(html$.FormElement),
>+  [$htmlFor]: dart.finalFieldType(html$.DomTokenList),
>+  [$labels]: dart.finalFieldType(ListOfNode()),
>+  [$name]: dart.fieldType(core.String),
>+  [$type]: dart.finalFieldType(core.String),
>+  [$validationMessage]: dart.finalFieldType(core.String),
>+  [$validity]: dart.finalFieldType(html$.ValidityState),
>+  [$value]: dart.fieldType(core.String),
>+  [$willValidate]: dart.finalFieldType(core.bool)
>+}));
>+dart.registerExtension("HTMLOutputElement", html$.OutputElement);
>+html$.OverconstrainedError = class OverconstrainedError$ extends _interceptors.Interceptor {
>+  static new(constraint, message) {
>+    return html$.OverconstrainedError._create_1(constraint, message);
>+  }
>+  static _create_1(constraint, message) {
>+    return new OverconstrainedError(constraint, message);
>+  }
>+  get [$constraint]() {
>+    return this.constraint;
>+  }
>+  get [$message]() {
>+    return this.message;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+};
>+dart.addTypeTests(html$.OverconstrainedError);
>+const constraint = Symbol("OverconstrainedError.constraint");
>+const message$24 = Symbol("OverconstrainedError.message");
>+const name$27 = Symbol("OverconstrainedError.name");
>+dart.setLibraryUri(html$.OverconstrainedError, "dart:html");
>+dart.setFieldSignature(html$.OverconstrainedError, () => ({
>+  __proto__: dart.getFields(html$.OverconstrainedError.__proto__),
>+  [$constraint]: dart.finalFieldType(core.String),
>+  [$message]: dart.finalFieldType(core.String),
>+  [$name]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("OverconstrainedError", html$.OverconstrainedError);
>+html$.PageTransitionEvent = class PageTransitionEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.PageTransitionEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.PageTransitionEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new PageTransitionEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new PageTransitionEvent(type);
>+  }
>+  get [$persisted]() {
>+    return this.persisted;
>+  }
>+};
>+dart.addTypeTests(html$.PageTransitionEvent);
>+const persisted = Symbol("PageTransitionEvent.persisted");
>+dart.setLibraryUri(html$.PageTransitionEvent, "dart:html");
>+dart.setFieldSignature(html$.PageTransitionEvent, () => ({
>+  __proto__: dart.getFields(html$.PageTransitionEvent.__proto__),
>+  [$persisted]: dart.finalFieldType(core.bool)
>+}));
>+dart.registerExtension("PageTransitionEvent", html$.PageTransitionEvent);
>+html$.PaintRenderingContext2D = class PaintRenderingContext2D extends _interceptors.Interceptor {
>+  get [$currentTransform]() {
>+    return this.currentTransform;
>+  }
>+  set [$currentTransform](value) {
>+    this.currentTransform = value;
>+  }
>+  get [$fillStyle]() {
>+    return this.fillStyle;
>+  }
>+  set [$fillStyle](value) {
>+    this.fillStyle = value;
>+  }
>+  get [$filter]() {
>+    return this.filter;
>+  }
>+  set [$filter](value) {
>+    this.filter = value;
>+  }
>+  get [$globalAlpha]() {
>+    return this.globalAlpha;
>+  }
>+  set [$globalAlpha](value) {
>+    this.globalAlpha = value;
>+  }
>+  get [$globalCompositeOperation]() {
>+    return this.globalCompositeOperation;
>+  }
>+  set [$globalCompositeOperation](value) {
>+    this.globalCompositeOperation = value;
>+  }
>+  get [$imageSmoothingEnabled]() {
>+    return this.imageSmoothingEnabled;
>+  }
>+  set [$imageSmoothingEnabled](value) {
>+    this.imageSmoothingEnabled = value;
>+  }
>+  get [$imageSmoothingQuality]() {
>+    return this.imageSmoothingQuality;
>+  }
>+  set [$imageSmoothingQuality](value) {
>+    this.imageSmoothingQuality = value;
>+  }
>+  get [$lineCap]() {
>+    return this.lineCap;
>+  }
>+  set [$lineCap](value) {
>+    this.lineCap = value;
>+  }
>+  get [$lineDashOffset]() {
>+    return this.lineDashOffset;
>+  }
>+  set [$lineDashOffset](value) {
>+    this.lineDashOffset = value;
>+  }
>+  get [$lineJoin]() {
>+    return this.lineJoin;
>+  }
>+  set [$lineJoin](value) {
>+    this.lineJoin = value;
>+  }
>+  get [$lineWidth]() {
>+    return this.lineWidth;
>+  }
>+  set [$lineWidth](value) {
>+    this.lineWidth = value;
>+  }
>+  get [$miterLimit]() {
>+    return this.miterLimit;
>+  }
>+  set [$miterLimit](value) {
>+    this.miterLimit = value;
>+  }
>+  get [$shadowBlur]() {
>+    return this.shadowBlur;
>+  }
>+  set [$shadowBlur](value) {
>+    this.shadowBlur = value;
>+  }
>+  get [$shadowColor]() {
>+    return this.shadowColor;
>+  }
>+  set [$shadowColor](value) {
>+    this.shadowColor = value;
>+  }
>+  get [$shadowOffsetX]() {
>+    return this.shadowOffsetX;
>+  }
>+  set [$shadowOffsetX](value) {
>+    this.shadowOffsetX = value;
>+  }
>+  get [$shadowOffsetY]() {
>+    return this.shadowOffsetY;
>+  }
>+  set [$shadowOffsetY](value) {
>+    this.shadowOffsetY = value;
>+  }
>+  get [$strokeStyle]() {
>+    return this.strokeStyle;
>+  }
>+  set [$strokeStyle](value) {
>+    this.strokeStyle = value;
>+  }
>+  [$beginPath](...args) {
>+    return this.beginPath.apply(this, args);
>+  }
>+  [$clearRect](...args) {
>+    return this.clearRect.apply(this, args);
>+  }
>+  [$clip](...args) {
>+    return this.clip.apply(this, args);
>+  }
>+  [$createLinearGradient](...args) {
>+    return this.createLinearGradient.apply(this, args);
>+  }
>+  [$createPattern](...args) {
>+    return this.createPattern.apply(this, args);
>+  }
>+  [$createRadialGradient](...args) {
>+    return this.createRadialGradient.apply(this, args);
>+  }
>+  [$drawImage](...args) {
>+    return this.drawImage.apply(this, args);
>+  }
>+  [$fill](...args) {
>+    return this.fill.apply(this, args);
>+  }
>+  [$fillRect](...args) {
>+    return this.fillRect.apply(this, args);
>+  }
>+  [$getLineDash](...args) {
>+    return this.getLineDash.apply(this, args);
>+  }
>+  [$isPointInPath](...args) {
>+    return this.isPointInPath.apply(this, args);
>+  }
>+  [$isPointInStroke](...args) {
>+    return this.isPointInStroke.apply(this, args);
>+  }
>+  [$resetTransform](...args) {
>+    return this.resetTransform.apply(this, args);
>+  }
>+  [$restore](...args) {
>+    return this.restore.apply(this, args);
>+  }
>+  [$rotate](...args) {
>+    return this.rotate.apply(this, args);
>+  }
>+  [$save](...args) {
>+    return this.save.apply(this, args);
>+  }
>+  [$scale](...args) {
>+    return this.scale.apply(this, args);
>+  }
>+  [$setLineDash](...args) {
>+    return this.setLineDash.apply(this, args);
>+  }
>+  [$setTransform](...args) {
>+    return this.setTransform.apply(this, args);
>+  }
>+  [$stroke](...args) {
>+    return this.stroke.apply(this, args);
>+  }
>+  [$strokeRect](...args) {
>+    return this.strokeRect.apply(this, args);
>+  }
>+  [$transform](...args) {
>+    return this.transform.apply(this, args);
>+  }
>+  [$translate](...args) {
>+    return this.translate.apply(this, args);
>+  }
>+  [$arc](...args) {
>+    return this.arc.apply(this, args);
>+  }
>+  [$arcTo](...args) {
>+    return this.arcTo.apply(this, args);
>+  }
>+  [$bezierCurveTo](...args) {
>+    return this.bezierCurveTo.apply(this, args);
>+  }
>+  [$closePath](...args) {
>+    return this.closePath.apply(this, args);
>+  }
>+  [$ellipse](...args) {
>+    return this.ellipse.apply(this, args);
>+  }
>+  [$lineTo](...args) {
>+    return this.lineTo.apply(this, args);
>+  }
>+  [$moveTo](...args) {
>+    return this.moveTo.apply(this, args);
>+  }
>+  [$quadraticCurveTo](...args) {
>+    return this.quadraticCurveTo.apply(this, args);
>+  }
>+  [$rect](...args) {
>+    return this.rect.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.PaintRenderingContext2D);
>+const currentTransform$ = Symbol("PaintRenderingContext2D.currentTransform");
>+const fillStyle$0 = Symbol("PaintRenderingContext2D.fillStyle");
>+const filter$0 = Symbol("PaintRenderingContext2D.filter");
>+const globalAlpha$0 = Symbol("PaintRenderingContext2D.globalAlpha");
>+const globalCompositeOperation$0 = Symbol("PaintRenderingContext2D.globalCompositeOperation");
>+const imageSmoothingEnabled$0 = Symbol("PaintRenderingContext2D.imageSmoothingEnabled");
>+const imageSmoothingQuality$0 = Symbol("PaintRenderingContext2D.imageSmoothingQuality");
>+const lineCap$0 = Symbol("PaintRenderingContext2D.lineCap");
>+const lineDashOffset$ = Symbol("PaintRenderingContext2D.lineDashOffset");
>+const lineJoin$0 = Symbol("PaintRenderingContext2D.lineJoin");
>+const lineWidth$0 = Symbol("PaintRenderingContext2D.lineWidth");
>+const miterLimit$0 = Symbol("PaintRenderingContext2D.miterLimit");
>+const shadowBlur$0 = Symbol("PaintRenderingContext2D.shadowBlur");
>+const shadowColor$0 = Symbol("PaintRenderingContext2D.shadowColor");
>+const shadowOffsetX$0 = Symbol("PaintRenderingContext2D.shadowOffsetX");
>+const shadowOffsetY$0 = Symbol("PaintRenderingContext2D.shadowOffsetY");
>+const strokeStyle$0 = Symbol("PaintRenderingContext2D.strokeStyle");
>+html$.PaintRenderingContext2D[dart.implements] = () => [html$._CanvasPath];
>+dart.setMethodSignature(html$.PaintRenderingContext2D, () => ({
>+  __proto__: dart.getMethods(html$.PaintRenderingContext2D.__proto__),
>+  [$beginPath]: dart.fnType(dart.void, []),
>+  [$clearRect]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num]),
>+  [$clip]: dart.fnType(dart.void, [], [dart.dynamic, core.String]),
>+  [$createLinearGradient]: dart.fnType(html$.CanvasGradient, [core.num, core.num, core.num, core.num]),
>+  [$createPattern]: dart.fnType(html$.CanvasPattern, [dart.dynamic, core.String]),
>+  [$createRadialGradient]: dart.fnType(html$.CanvasGradient, [core.num, core.num, core.num, core.num, core.num, core.num]),
>+  [$drawImage]: dart.fnType(dart.void, [dart.dynamic, core.num, core.num], [core.num, core.num, core.num, core.num, core.num, core.num]),
>+  [$fill]: dart.fnType(dart.void, [], [dart.dynamic, core.String]),
>+  [$fillRect]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num]),
>+  [$getLineDash]: dart.fnType(core.List$(core.num), []),
>+  [$isPointInPath]: dart.fnType(core.bool, [dart.dynamic, core.num], [dart.dynamic, core.String]),
>+  [$isPointInStroke]: dart.fnType(core.bool, [dart.dynamic, core.num], [core.num]),
>+  [$resetTransform]: dart.fnType(dart.void, []),
>+  [$restore]: dart.fnType(dart.void, []),
>+  [$rotate]: dart.fnType(dart.void, [core.num]),
>+  [$save]: dart.fnType(dart.void, []),
>+  [$scale]: dart.fnType(dart.void, [core.num, core.num]),
>+  [$setLineDash]: dart.fnType(dart.void, [core.List$(core.num)]),
>+  [$setTransform]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num, core.num, core.num]),
>+  [$stroke]: dart.fnType(dart.void, [], [html$.Path2D]),
>+  [$strokeRect]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num]),
>+  [$transform]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num, core.num, core.num]),
>+  [$translate]: dart.fnType(dart.void, [core.num, core.num]),
>+  [$arc]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num, core.num, core.bool]),
>+  [$arcTo]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num, core.num]),
>+  [$bezierCurveTo]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num, core.num, core.num]),
>+  [$closePath]: dart.fnType(dart.void, []),
>+  [$ellipse]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num, core.num, core.num, core.num, core.bool]),
>+  [$lineTo]: dart.fnType(dart.void, [core.num, core.num]),
>+  [$moveTo]: dart.fnType(dart.void, [core.num, core.num]),
>+  [$quadraticCurveTo]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num]),
>+  [$rect]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num])
>+}));
>+dart.setLibraryUri(html$.PaintRenderingContext2D, "dart:html");
>+dart.setFieldSignature(html$.PaintRenderingContext2D, () => ({
>+  __proto__: dart.getFields(html$.PaintRenderingContext2D.__proto__),
>+  [$currentTransform]: dart.fieldType(svg$.Matrix),
>+  [$fillStyle]: dart.fieldType(core.Object),
>+  [$filter]: dart.fieldType(core.String),
>+  [$globalAlpha]: dart.fieldType(core.num),
>+  [$globalCompositeOperation]: dart.fieldType(core.String),
>+  [$imageSmoothingEnabled]: dart.fieldType(core.bool),
>+  [$imageSmoothingQuality]: dart.fieldType(core.String),
>+  [$lineCap]: dart.fieldType(core.String),
>+  [$lineDashOffset]: dart.fieldType(core.num),
>+  [$lineJoin]: dart.fieldType(core.String),
>+  [$lineWidth]: dart.fieldType(core.num),
>+  [$miterLimit]: dart.fieldType(core.num),
>+  [$shadowBlur]: dart.fieldType(core.num),
>+  [$shadowColor]: dart.fieldType(core.String),
>+  [$shadowOffsetX]: dart.fieldType(core.num),
>+  [$shadowOffsetY]: dart.fieldType(core.num),
>+  [$strokeStyle]: dart.fieldType(core.Object)
>+}));
>+dart.registerExtension("PaintRenderingContext2D", html$.PaintRenderingContext2D);
>+html$.PaintSize = class PaintSize extends _interceptors.Interceptor {
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+};
>+dart.addTypeTests(html$.PaintSize);
>+const height$8 = Symbol("PaintSize.height");
>+const width$8 = Symbol("PaintSize.width");
>+dart.setLibraryUri(html$.PaintSize, "dart:html");
>+dart.setFieldSignature(html$.PaintSize, () => ({
>+  __proto__: dart.getFields(html$.PaintSize.__proto__),
>+  [$height]: dart.finalFieldType(core.num),
>+  [$width]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("PaintSize", html$.PaintSize);
>+html$.PaintWorkletGlobalScope = class PaintWorkletGlobalScope extends html$.WorkletGlobalScope {
>+  get [$devicePixelRatio]() {
>+    return this.devicePixelRatio;
>+  }
>+  [$registerPaint](...args) {
>+    return this.registerPaint.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.PaintWorkletGlobalScope);
>+const devicePixelRatio = Symbol("PaintWorkletGlobalScope.devicePixelRatio");
>+dart.setMethodSignature(html$.PaintWorkletGlobalScope, () => ({
>+  __proto__: dart.getMethods(html$.PaintWorkletGlobalScope.__proto__),
>+  [$registerPaint]: dart.fnType(dart.void, [core.String, core.Object])
>+}));
>+dart.setLibraryUri(html$.PaintWorkletGlobalScope, "dart:html");
>+dart.setFieldSignature(html$.PaintWorkletGlobalScope, () => ({
>+  __proto__: dart.getFields(html$.PaintWorkletGlobalScope.__proto__),
>+  [$devicePixelRatio]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("PaintWorkletGlobalScope", html$.PaintWorkletGlobalScope);
>+html$.ParagraphElement = class ParagraphElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("p");
>+  }
>+};
>+(html$.ParagraphElement.created = function() {
>+  html$.ParagraphElement.__proto__.created.call(this);
>+}).prototype = html$.ParagraphElement.prototype;
>+dart.addTypeTests(html$.ParagraphElement);
>+dart.setLibraryUri(html$.ParagraphElement, "dart:html");
>+dart.registerExtension("HTMLParagraphElement", html$.ParagraphElement);
>+html$.ParamElement = class ParamElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("param");
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+  set [$name](value) {
>+    this.name = value;
>+  }
>+  get [$value]() {
>+    return this.value;
>+  }
>+  set [$value](value) {
>+    this.value = value;
>+  }
>+};
>+(html$.ParamElement.created = function() {
>+  this[name$28] = null;
>+  this[value$13] = null;
>+  html$.ParamElement.__proto__.created.call(this);
>+}).prototype = html$.ParamElement.prototype;
>+dart.addTypeTests(html$.ParamElement);
>+const name$28 = Symbol("ParamElement.name");
>+const value$13 = Symbol("ParamElement.value");
>+dart.setLibraryUri(html$.ParamElement, "dart:html");
>+dart.setFieldSignature(html$.ParamElement, () => ({
>+  __proto__: dart.getFields(html$.ParamElement.__proto__),
>+  [$name]: dart.fieldType(core.String),
>+  [$value]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("HTMLParamElement", html$.ParamElement);
>+html$.ParentNode = class ParentNode extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$.ParentNode);
>+dart.setLibraryUri(html$.ParentNode, "dart:html");
>+dart.setFieldSignature(html$.ParentNode, () => ({
>+  __proto__: dart.getFields(html$.ParentNode.__proto__),
>+  [_childElementCount]: dart.finalFieldType(core.int),
>+  [_children]: dart.finalFieldType(ListOfNode()),
>+  [_firstElementChild]: dart.finalFieldType(html$.Element),
>+  [_lastElementChild]: dart.finalFieldType(html$.Element)
>+}));
>+html$.PasswordCredential = class PasswordCredential$ extends html$.Credential {
>+  static new(data_OR_form) {
>+    if (core.Map.is(data_OR_form)) {
>+      let data_1 = html_common.convertDartToNative_Dictionary(data_OR_form);
>+      return html$.PasswordCredential._create_1(data_1);
>+    }
>+    if (html$.FormElement.is(data_OR_form)) {
>+      return html$.PasswordCredential._create_2(data_OR_form);
>+    }
>+    dart.throw(new core.ArgumentError.new("Incorrect number or type of arguments"));
>+  }
>+  static _create_1(data_OR_form) {
>+    return new PasswordCredential(data_OR_form);
>+  }
>+  static _create_2(data_OR_form) {
>+    return new PasswordCredential(data_OR_form);
>+  }
>+  get [$additionalData]() {
>+    return this.additionalData;
>+  }
>+  set [$additionalData](value) {
>+    this.additionalData = value;
>+  }
>+  get [$idName]() {
>+    return this.idName;
>+  }
>+  set [$idName](value) {
>+    this.idName = value;
>+  }
>+  get [$password]() {
>+    return this.password;
>+  }
>+  get [$passwordName]() {
>+    return this.passwordName;
>+  }
>+  set [$passwordName](value) {
>+    this.passwordName = value;
>+  }
>+  get [$iconUrl]() {
>+    return this.iconURL;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+};
>+dart.addTypeTests(html$.PasswordCredential);
>+const additionalData = Symbol("PasswordCredential.additionalData");
>+const idName = Symbol("PasswordCredential.idName");
>+const password$1 = Symbol("PasswordCredential.password");
>+const passwordName = Symbol("PasswordCredential.passwordName");
>+const iconUrl$0 = Symbol("PasswordCredential.iconUrl");
>+const name$29 = Symbol("PasswordCredential.name");
>+html$.PasswordCredential[dart.implements] = () => [html$.CredentialUserData];
>+dart.setLibraryUri(html$.PasswordCredential, "dart:html");
>+dart.setFieldSignature(html$.PasswordCredential, () => ({
>+  __proto__: dart.getFields(html$.PasswordCredential.__proto__),
>+  [$additionalData]: dart.fieldType(core.Object),
>+  [$idName]: dart.fieldType(core.String),
>+  [$password]: dart.finalFieldType(core.String),
>+  [$passwordName]: dart.fieldType(core.String),
>+  [$iconUrl]: dart.finalFieldType(core.String),
>+  [$name]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("PasswordCredential", html$.PasswordCredential);
>+html$.Path2D = class Path2D$ extends _interceptors.Interceptor {
>+  static new(path_OR_text) {
>+    if (path_OR_text === void 0) path_OR_text = null;
>+    if (path_OR_text == null) {
>+      return html$.Path2D._create_1();
>+    }
>+    if (html$.Path2D.is(path_OR_text)) {
>+      return html$.Path2D._create_2(path_OR_text);
>+    }
>+    if (typeof path_OR_text == 'string') {
>+      return html$.Path2D._create_3(path_OR_text);
>+    }
>+    dart.throw(new core.ArgumentError.new("Incorrect number or type of arguments"));
>+  }
>+  static _create_1() {
>+    return new Path2D();
>+  }
>+  static _create_2(path_OR_text) {
>+    return new Path2D(path_OR_text);
>+  }
>+  static _create_3(path_OR_text) {
>+    return new Path2D(path_OR_text);
>+  }
>+  [$addPath](...args) {
>+    return this.addPath.apply(this, args);
>+  }
>+  [$arc](...args) {
>+    return this.arc.apply(this, args);
>+  }
>+  [$arcTo](...args) {
>+    return this.arcTo.apply(this, args);
>+  }
>+  [$bezierCurveTo](...args) {
>+    return this.bezierCurveTo.apply(this, args);
>+  }
>+  [$closePath](...args) {
>+    return this.closePath.apply(this, args);
>+  }
>+  [$ellipse](...args) {
>+    return this.ellipse.apply(this, args);
>+  }
>+  [$lineTo](...args) {
>+    return this.lineTo.apply(this, args);
>+  }
>+  [$moveTo](...args) {
>+    return this.moveTo.apply(this, args);
>+  }
>+  [$quadraticCurveTo](...args) {
>+    return this.quadraticCurveTo.apply(this, args);
>+  }
>+  [$rect](...args) {
>+    return this.rect.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.Path2D);
>+html$.Path2D[dart.implements] = () => [html$._CanvasPath];
>+dart.setMethodSignature(html$.Path2D, () => ({
>+  __proto__: dart.getMethods(html$.Path2D.__proto__),
>+  [$addPath]: dart.fnType(dart.void, [html$.Path2D], [svg$.Matrix]),
>+  [$arc]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num, core.num, core.bool]),
>+  [$arcTo]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num, core.num]),
>+  [$bezierCurveTo]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num, core.num, core.num]),
>+  [$closePath]: dart.fnType(dart.void, []),
>+  [$ellipse]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num, core.num, core.num, core.num, core.bool]),
>+  [$lineTo]: dart.fnType(dart.void, [core.num, core.num]),
>+  [$moveTo]: dart.fnType(dart.void, [core.num, core.num]),
>+  [$quadraticCurveTo]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num]),
>+  [$rect]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num])
>+}));
>+dart.setLibraryUri(html$.Path2D, "dart:html");
>+dart.registerExtension("Path2D", html$.Path2D);
>+html$.PaymentAddress = class PaymentAddress extends _interceptors.Interceptor {
>+  get [$addressLine]() {
>+    return this.addressLine;
>+  }
>+  get [$city]() {
>+    return this.city;
>+  }
>+  get [$country]() {
>+    return this.country;
>+  }
>+  get [$dependentLocality]() {
>+    return this.dependentLocality;
>+  }
>+  get [$languageCode]() {
>+    return this.languageCode;
>+  }
>+  get [$organization]() {
>+    return this.organization;
>+  }
>+  get [$phone]() {
>+    return this.phone;
>+  }
>+  get [$postalCode]() {
>+    return this.postalCode;
>+  }
>+  get [$recipient]() {
>+    return this.recipient;
>+  }
>+  get [$region]() {
>+    return this.region;
>+  }
>+  get [$sortingCode]() {
>+    return this.sortingCode;
>+  }
>+};
>+dart.addTypeTests(html$.PaymentAddress);
>+const addressLine = Symbol("PaymentAddress.addressLine");
>+const city = Symbol("PaymentAddress.city");
>+const country = Symbol("PaymentAddress.country");
>+const dependentLocality = Symbol("PaymentAddress.dependentLocality");
>+const languageCode = Symbol("PaymentAddress.languageCode");
>+const organization = Symbol("PaymentAddress.organization");
>+const phone = Symbol("PaymentAddress.phone");
>+const postalCode = Symbol("PaymentAddress.postalCode");
>+const recipient = Symbol("PaymentAddress.recipient");
>+const region$ = Symbol("PaymentAddress.region");
>+const sortingCode = Symbol("PaymentAddress.sortingCode");
>+dart.setLibraryUri(html$.PaymentAddress, "dart:html");
>+dart.setFieldSignature(html$.PaymentAddress, () => ({
>+  __proto__: dart.getFields(html$.PaymentAddress.__proto__),
>+  [$addressLine]: dart.finalFieldType(ListOfString()),
>+  [$city]: dart.finalFieldType(core.String),
>+  [$country]: dart.finalFieldType(core.String),
>+  [$dependentLocality]: dart.finalFieldType(core.String),
>+  [$languageCode]: dart.finalFieldType(core.String),
>+  [$organization]: dart.finalFieldType(core.String),
>+  [$phone]: dart.finalFieldType(core.String),
>+  [$postalCode]: dart.finalFieldType(core.String),
>+  [$recipient]: dart.finalFieldType(core.String),
>+  [$region]: dart.finalFieldType(core.String),
>+  [$sortingCode]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("PaymentAddress", html$.PaymentAddress);
>+html$.PaymentInstruments = class PaymentInstruments extends _interceptors.Interceptor {
>+  [$clear]() {
>+    return html$.promiseToFuture(dart.dynamic, this.clear());
>+  }
>+  [$delete](instrumentKey) {
>+    return html$.promiseToFuture(core.bool, this.delete(instrumentKey));
>+  }
>+  [$get](instrumentKey) {
>+    return html$.promiseToFutureAsMap(this.get(instrumentKey));
>+  }
>+  [$has](instrumentKey) {
>+    return html$.promiseToFuture(dart.dynamic, this.has(instrumentKey));
>+  }
>+  [$keys]() {
>+    return html$.promiseToFuture(ListOfString(), this.keys());
>+  }
>+  [$set](instrumentKey, details) {
>+    let details_dict = html_common.convertDartToNative_Dictionary(details);
>+    return html$.promiseToFuture(dart.dynamic, this.set(instrumentKey, details_dict));
>+  }
>+};
>+dart.addTypeTests(html$.PaymentInstruments);
>+dart.setMethodSignature(html$.PaymentInstruments, () => ({
>+  __proto__: dart.getMethods(html$.PaymentInstruments.__proto__),
>+  [$clear]: dart.fnType(async.Future, []),
>+  [$delete]: dart.fnType(async.Future$(core.bool), [core.String]),
>+  [$get]: dart.fnType(async.Future$(core.Map$(core.String, dart.dynamic)), [core.String]),
>+  [$has]: dart.fnType(async.Future, [core.String]),
>+  [$keys]: dart.fnType(async.Future$(core.List$(core.String)), []),
>+  [$set]: dart.fnType(async.Future, [core.String, core.Map])
>+}));
>+dart.setLibraryUri(html$.PaymentInstruments, "dart:html");
>+dart.registerExtension("PaymentInstruments", html$.PaymentInstruments);
>+html$.PaymentManager = class PaymentManager extends _interceptors.Interceptor {
>+  get [$instruments]() {
>+    return this.instruments;
>+  }
>+  get [$userHint]() {
>+    return this.userHint;
>+  }
>+  set [$userHint](value) {
>+    this.userHint = value;
>+  }
>+};
>+dart.addTypeTests(html$.PaymentManager);
>+const instruments = Symbol("PaymentManager.instruments");
>+const userHint = Symbol("PaymentManager.userHint");
>+dart.setLibraryUri(html$.PaymentManager, "dart:html");
>+dart.setFieldSignature(html$.PaymentManager, () => ({
>+  __proto__: dart.getFields(html$.PaymentManager.__proto__),
>+  [$instruments]: dart.finalFieldType(html$.PaymentInstruments),
>+  [$userHint]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("PaymentManager", html$.PaymentManager);
>+html$.PaymentRequest = class PaymentRequest$ extends html$.EventTarget {
>+  static new(methodData, details, options) {
>+    if (options === void 0) options = null;
>+    let methodData_1 = [];
>+    for (let i of methodData) {
>+      methodData_1[$add](html_common.convertDartToNative_Dictionary(i));
>+    }
>+    if (options != null) {
>+      let details_1 = html_common.convertDartToNative_Dictionary(details);
>+      let options_2 = html_common.convertDartToNative_Dictionary(options);
>+      return html$.PaymentRequest._create_1(methodData_1, details_1, options_2);
>+    }
>+    let details_1 = html_common.convertDartToNative_Dictionary(details);
>+    return html$.PaymentRequest._create_2(methodData_1, details_1);
>+  }
>+  static _create_1(methodData, details, options) {
>+    return new PaymentRequest(methodData, details, options);
>+  }
>+  static _create_2(methodData, details) {
>+    return new PaymentRequest(methodData, details);
>+  }
>+  get [$id]() {
>+    return this.id;
>+  }
>+  get [$shippingAddress]() {
>+    return this.shippingAddress;
>+  }
>+  get [$shippingOption]() {
>+    return this.shippingOption;
>+  }
>+  get [$shippingType]() {
>+    return this.shippingType;
>+  }
>+  [$abort]() {
>+    return html$.promiseToFuture(dart.dynamic, this.abort());
>+  }
>+  [$canMakePayment]() {
>+    return html$.promiseToFuture(core.bool, this.canMakePayment());
>+  }
>+  [$show]() {
>+    return html$.promiseToFuture(html$.PaymentResponse, this.show());
>+  }
>+};
>+dart.addTypeTests(html$.PaymentRequest);
>+const id$9 = Symbol("PaymentRequest.id");
>+const shippingAddress = Symbol("PaymentRequest.shippingAddress");
>+const shippingOption = Symbol("PaymentRequest.shippingOption");
>+const shippingType = Symbol("PaymentRequest.shippingType");
>+dart.setMethodSignature(html$.PaymentRequest, () => ({
>+  __proto__: dart.getMethods(html$.PaymentRequest.__proto__),
>+  [$abort]: dart.fnType(async.Future, []),
>+  [$canMakePayment]: dart.fnType(async.Future$(core.bool), []),
>+  [$show]: dart.fnType(async.Future$(html$.PaymentResponse), [])
>+}));
>+dart.setLibraryUri(html$.PaymentRequest, "dart:html");
>+dart.setFieldSignature(html$.PaymentRequest, () => ({
>+  __proto__: dart.getFields(html$.PaymentRequest.__proto__),
>+  [$id]: dart.finalFieldType(core.String),
>+  [$shippingAddress]: dart.finalFieldType(html$.PaymentAddress),
>+  [$shippingOption]: dart.finalFieldType(core.String),
>+  [$shippingType]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("PaymentRequest", html$.PaymentRequest);
>+html$.PaymentRequestEvent = class PaymentRequestEvent$ extends html$.ExtendableEvent {
>+  static new(type, eventInitDict) {
>+    let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+    return html$.PaymentRequestEvent._create_1(type, eventInitDict_1);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new PaymentRequestEvent(type, eventInitDict);
>+  }
>+  get [$instrumentKey]() {
>+    return this.instrumentKey;
>+  }
>+  get [$methodData]() {
>+    return this.methodData;
>+  }
>+  get [$modifiers]() {
>+    return this.modifiers;
>+  }
>+  get [$paymentRequestId]() {
>+    return this.paymentRequestId;
>+  }
>+  get [$paymentRequestOrigin]() {
>+    return this.paymentRequestOrigin;
>+  }
>+  get [$topLevelOrigin]() {
>+    return this.topLevelOrigin;
>+  }
>+  get [$total]() {
>+    return this.total;
>+  }
>+  [$openWindow](url) {
>+    return html$.promiseToFuture(html$.WindowClient, this.openWindow(url));
>+  }
>+  [$respondWith](...args) {
>+    return this.respondWith.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.PaymentRequestEvent);
>+const instrumentKey = Symbol("PaymentRequestEvent.instrumentKey");
>+const methodData$ = Symbol("PaymentRequestEvent.methodData");
>+const modifiers$ = Symbol("PaymentRequestEvent.modifiers");
>+const paymentRequestId = Symbol("PaymentRequestEvent.paymentRequestId");
>+const paymentRequestOrigin$ = Symbol("PaymentRequestEvent.paymentRequestOrigin");
>+const topLevelOrigin$ = Symbol("PaymentRequestEvent.topLevelOrigin");
>+const total = Symbol("PaymentRequestEvent.total");
>+dart.setMethodSignature(html$.PaymentRequestEvent, () => ({
>+  __proto__: dart.getMethods(html$.PaymentRequestEvent.__proto__),
>+  [$openWindow]: dart.fnType(async.Future$(html$.WindowClient), [core.String]),
>+  [$respondWith]: dart.fnType(dart.void, [async.Future])
>+}));
>+dart.setLibraryUri(html$.PaymentRequestEvent, "dart:html");
>+dart.setFieldSignature(html$.PaymentRequestEvent, () => ({
>+  __proto__: dart.getFields(html$.PaymentRequestEvent.__proto__),
>+  [$instrumentKey]: dart.finalFieldType(core.String),
>+  [$methodData]: dart.finalFieldType(core.List),
>+  [$modifiers]: dart.finalFieldType(core.List),
>+  [$paymentRequestId]: dart.finalFieldType(core.String),
>+  [$paymentRequestOrigin]: dart.finalFieldType(core.String),
>+  [$topLevelOrigin]: dart.finalFieldType(core.String),
>+  [$total]: dart.finalFieldType(core.Object)
>+}));
>+dart.registerExtension("PaymentRequestEvent", html$.PaymentRequestEvent);
>+html$.PaymentRequestUpdateEvent = class PaymentRequestUpdateEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.PaymentRequestUpdateEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.PaymentRequestUpdateEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new PaymentRequestUpdateEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new PaymentRequestUpdateEvent(type);
>+  }
>+  [$updateWith](...args) {
>+    return this.updateWith.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.PaymentRequestUpdateEvent);
>+dart.setMethodSignature(html$.PaymentRequestUpdateEvent, () => ({
>+  __proto__: dart.getMethods(html$.PaymentRequestUpdateEvent.__proto__),
>+  [$updateWith]: dart.fnType(dart.void, [async.Future])
>+}));
>+dart.setLibraryUri(html$.PaymentRequestUpdateEvent, "dart:html");
>+dart.registerExtension("PaymentRequestUpdateEvent", html$.PaymentRequestUpdateEvent);
>+html$.PaymentResponse = class PaymentResponse extends _interceptors.Interceptor {
>+  get [$details]() {
>+    return this.details;
>+  }
>+  get [$methodName]() {
>+    return this.methodName;
>+  }
>+  get [$payerEmail]() {
>+    return this.payerEmail;
>+  }
>+  get [$payerName]() {
>+    return this.payerName;
>+  }
>+  get [$payerPhone]() {
>+    return this.payerPhone;
>+  }
>+  get [$requestId]() {
>+    return this.requestId;
>+  }
>+  get [$shippingAddress]() {
>+    return this.shippingAddress;
>+  }
>+  get [$shippingOption]() {
>+    return this.shippingOption;
>+  }
>+  [$complete](paymentResult) {
>+    if (paymentResult === void 0) paymentResult = null;
>+    return html$.promiseToFuture(dart.dynamic, this.complete(paymentResult));
>+  }
>+};
>+dart.addTypeTests(html$.PaymentResponse);
>+const details$ = Symbol("PaymentResponse.details");
>+const methodName = Symbol("PaymentResponse.methodName");
>+const payerEmail = Symbol("PaymentResponse.payerEmail");
>+const payerName = Symbol("PaymentResponse.payerName");
>+const payerPhone = Symbol("PaymentResponse.payerPhone");
>+const requestId = Symbol("PaymentResponse.requestId");
>+const shippingAddress$ = Symbol("PaymentResponse.shippingAddress");
>+const shippingOption$ = Symbol("PaymentResponse.shippingOption");
>+dart.setMethodSignature(html$.PaymentResponse, () => ({
>+  __proto__: dart.getMethods(html$.PaymentResponse.__proto__),
>+  [$complete]: dart.fnType(async.Future, [], [core.String])
>+}));
>+dart.setLibraryUri(html$.PaymentResponse, "dart:html");
>+dart.setFieldSignature(html$.PaymentResponse, () => ({
>+  __proto__: dart.getFields(html$.PaymentResponse.__proto__),
>+  [$details]: dart.finalFieldType(core.Object),
>+  [$methodName]: dart.finalFieldType(core.String),
>+  [$payerEmail]: dart.finalFieldType(core.String),
>+  [$payerName]: dart.finalFieldType(core.String),
>+  [$payerPhone]: dart.finalFieldType(core.String),
>+  [$requestId]: dart.finalFieldType(core.String),
>+  [$shippingAddress]: dart.finalFieldType(html$.PaymentAddress),
>+  [$shippingOption]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("PaymentResponse", html$.PaymentResponse);
>+html$.Performance = class Performance extends html$.EventTarget {
>+  static get supported() {
>+    return !!window.performance;
>+  }
>+  get [$memory]() {
>+    return this.memory;
>+  }
>+  get [$navigation]() {
>+    return this.navigation;
>+  }
>+  get [$timeOrigin]() {
>+    return this.timeOrigin;
>+  }
>+  get [$timing]() {
>+    return this.timing;
>+  }
>+  [$clearMarks](...args) {
>+    return this.clearMarks.apply(this, args);
>+  }
>+  [$clearMeasures](...args) {
>+    return this.clearMeasures.apply(this, args);
>+  }
>+  [$clearResourceTimings](...args) {
>+    return this.clearResourceTimings.apply(this, args);
>+  }
>+  [$getEntries](...args) {
>+    return this.getEntries.apply(this, args);
>+  }
>+  [$getEntriesByName](...args) {
>+    return this.getEntriesByName.apply(this, args);
>+  }
>+  [$getEntriesByType](...args) {
>+    return this.getEntriesByType.apply(this, args);
>+  }
>+  [$mark](...args) {
>+    return this.mark.apply(this, args);
>+  }
>+  [$measure](...args) {
>+    return this.measure.apply(this, args);
>+  }
>+  [$now](...args) {
>+    return this.now.apply(this, args);
>+  }
>+  [$setResourceTimingBufferSize](...args) {
>+    return this.setResourceTimingBufferSize.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.Performance);
>+const memory = Symbol("Performance.memory");
>+const navigation = Symbol("Performance.navigation");
>+const timeOrigin = Symbol("Performance.timeOrigin");
>+const timing$ = Symbol("Performance.timing");
>+dart.setMethodSignature(html$.Performance, () => ({
>+  __proto__: dart.getMethods(html$.Performance.__proto__),
>+  [$clearMarks]: dart.fnType(dart.void, [core.String]),
>+  [$clearMeasures]: dart.fnType(dart.void, [core.String]),
>+  [$clearResourceTimings]: dart.fnType(dart.void, []),
>+  [$getEntries]: dart.fnType(core.List$(html$.PerformanceEntry), []),
>+  [$getEntriesByName]: dart.fnType(core.List$(html$.PerformanceEntry), [core.String, core.String]),
>+  [$getEntriesByType]: dart.fnType(core.List$(html$.PerformanceEntry), [core.String]),
>+  [$mark]: dart.fnType(dart.void, [core.String]),
>+  [$measure]: dart.fnType(dart.void, [core.String, core.String, core.String]),
>+  [$now]: dart.fnType(core.double, []),
>+  [$setResourceTimingBufferSize]: dart.fnType(dart.void, [core.int])
>+}));
>+dart.setLibraryUri(html$.Performance, "dart:html");
>+dart.setFieldSignature(html$.Performance, () => ({
>+  __proto__: dart.getFields(html$.Performance.__proto__),
>+  [$memory]: dart.finalFieldType(html$.MemoryInfo),
>+  [$navigation]: dart.finalFieldType(html$.PerformanceNavigation),
>+  [$timeOrigin]: dart.finalFieldType(core.num),
>+  [$timing]: dart.finalFieldType(html$.PerformanceTiming)
>+}));
>+dart.registerExtension("Performance", html$.Performance);
>+html$.PerformanceEntry = class PerformanceEntry extends _interceptors.Interceptor {
>+  get [$duration]() {
>+    return this.duration;
>+  }
>+  get [$entryType]() {
>+    return this.entryType;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+  get [$startTime]() {
>+    return this.startTime;
>+  }
>+};
>+dart.addTypeTests(html$.PerformanceEntry);
>+const duration$2 = Symbol("PerformanceEntry.duration");
>+const entryType = Symbol("PerformanceEntry.entryType");
>+const name$30 = Symbol("PerformanceEntry.name");
>+const startTime$ = Symbol("PerformanceEntry.startTime");
>+dart.setLibraryUri(html$.PerformanceEntry, "dart:html");
>+dart.setFieldSignature(html$.PerformanceEntry, () => ({
>+  __proto__: dart.getFields(html$.PerformanceEntry.__proto__),
>+  [$duration]: dart.finalFieldType(core.num),
>+  [$entryType]: dart.finalFieldType(core.String),
>+  [$name]: dart.finalFieldType(core.String),
>+  [$startTime]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("PerformanceEntry", html$.PerformanceEntry);
>+html$.PerformanceLongTaskTiming = class PerformanceLongTaskTiming extends html$.PerformanceEntry {
>+  get [$attribution]() {
>+    return this.attribution;
>+  }
>+};
>+dart.addTypeTests(html$.PerformanceLongTaskTiming);
>+const attribution = Symbol("PerformanceLongTaskTiming.attribution");
>+dart.setLibraryUri(html$.PerformanceLongTaskTiming, "dart:html");
>+dart.setFieldSignature(html$.PerformanceLongTaskTiming, () => ({
>+  __proto__: dart.getFields(html$.PerformanceLongTaskTiming.__proto__),
>+  [$attribution]: dart.finalFieldType(ListOfTaskAttributionTiming())
>+}));
>+dart.registerExtension("PerformanceLongTaskTiming", html$.PerformanceLongTaskTiming);
>+html$.PerformanceMark = class PerformanceMark extends html$.PerformanceEntry {};
>+dart.addTypeTests(html$.PerformanceMark);
>+dart.setLibraryUri(html$.PerformanceMark, "dart:html");
>+dart.registerExtension("PerformanceMark", html$.PerformanceMark);
>+html$.PerformanceMeasure = class PerformanceMeasure extends html$.PerformanceEntry {};
>+dart.addTypeTests(html$.PerformanceMeasure);
>+dart.setLibraryUri(html$.PerformanceMeasure, "dart:html");
>+dart.registerExtension("PerformanceMeasure", html$.PerformanceMeasure);
>+html$.PerformanceNavigation = class PerformanceNavigation extends _interceptors.Interceptor {
>+  get [$redirectCount]() {
>+    return this.redirectCount;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+};
>+dart.addTypeTests(html$.PerformanceNavigation);
>+const redirectCount = Symbol("PerformanceNavigation.redirectCount");
>+const type$24 = Symbol("PerformanceNavigation.type");
>+dart.setLibraryUri(html$.PerformanceNavigation, "dart:html");
>+dart.setFieldSignature(html$.PerformanceNavigation, () => ({
>+  __proto__: dart.getFields(html$.PerformanceNavigation.__proto__),
>+  [$redirectCount]: dart.finalFieldType(core.int),
>+  [$type]: dart.finalFieldType(core.int)
>+}));
>+dart.defineLazy(html$.PerformanceNavigation, {
>+  /*html$.PerformanceNavigation.TYPE_BACK_FORWARD*/get TYPE_BACK_FORWARD() {
>+    return 2;
>+  },
>+  /*html$.PerformanceNavigation.TYPE_NAVIGATE*/get TYPE_NAVIGATE() {
>+    return 0;
>+  },
>+  /*html$.PerformanceNavigation.TYPE_RELOAD*/get TYPE_RELOAD() {
>+    return 1;
>+  },
>+  /*html$.PerformanceNavigation.TYPE_RESERVED*/get TYPE_RESERVED() {
>+    return 255;
>+  }
>+});
>+dart.registerExtension("PerformanceNavigation", html$.PerformanceNavigation);
>+html$.PerformanceResourceTiming = class PerformanceResourceTiming extends html$.PerformanceEntry {
>+  get [$connectEnd]() {
>+    return this.connectEnd;
>+  }
>+  get [$connectStart]() {
>+    return this.connectStart;
>+  }
>+  get [$decodedBodySize]() {
>+    return this.decodedBodySize;
>+  }
>+  get [$domainLookupEnd]() {
>+    return this.domainLookupEnd;
>+  }
>+  get [$domainLookupStart]() {
>+    return this.domainLookupStart;
>+  }
>+  get [$encodedBodySize]() {
>+    return this.encodedBodySize;
>+  }
>+  get [$fetchStart]() {
>+    return this.fetchStart;
>+  }
>+  get [$initiatorType]() {
>+    return this.initiatorType;
>+  }
>+  get [$nextHopProtocol]() {
>+    return this.nextHopProtocol;
>+  }
>+  get [$redirectEnd]() {
>+    return this.redirectEnd;
>+  }
>+  get [$redirectStart]() {
>+    return this.redirectStart;
>+  }
>+  get [$requestStart]() {
>+    return this.requestStart;
>+  }
>+  get [$responseEnd]() {
>+    return this.responseEnd;
>+  }
>+  get [$responseStart]() {
>+    return this.responseStart;
>+  }
>+  get [$secureConnectionStart]() {
>+    return this.secureConnectionStart;
>+  }
>+  get [$serverTiming]() {
>+    return this.serverTiming;
>+  }
>+  get [$transferSize]() {
>+    return this.transferSize;
>+  }
>+  get [$workerStart]() {
>+    return this.workerStart;
>+  }
>+};
>+dart.addTypeTests(html$.PerformanceResourceTiming);
>+const connectEnd = Symbol("PerformanceResourceTiming.connectEnd");
>+const connectStart = Symbol("PerformanceResourceTiming.connectStart");
>+const decodedBodySize = Symbol("PerformanceResourceTiming.decodedBodySize");
>+const domainLookupEnd = Symbol("PerformanceResourceTiming.domainLookupEnd");
>+const domainLookupStart = Symbol("PerformanceResourceTiming.domainLookupStart");
>+const encodedBodySize = Symbol("PerformanceResourceTiming.encodedBodySize");
>+const fetchStart = Symbol("PerformanceResourceTiming.fetchStart");
>+const initiatorType = Symbol("PerformanceResourceTiming.initiatorType");
>+const nextHopProtocol = Symbol("PerformanceResourceTiming.nextHopProtocol");
>+const redirectEnd = Symbol("PerformanceResourceTiming.redirectEnd");
>+const redirectStart = Symbol("PerformanceResourceTiming.redirectStart");
>+const requestStart = Symbol("PerformanceResourceTiming.requestStart");
>+const responseEnd = Symbol("PerformanceResourceTiming.responseEnd");
>+const responseStart = Symbol("PerformanceResourceTiming.responseStart");
>+const secureConnectionStart = Symbol("PerformanceResourceTiming.secureConnectionStart");
>+const serverTiming = Symbol("PerformanceResourceTiming.serverTiming");
>+const transferSize = Symbol("PerformanceResourceTiming.transferSize");
>+const workerStart = Symbol("PerformanceResourceTiming.workerStart");
>+dart.setLibraryUri(html$.PerformanceResourceTiming, "dart:html");
>+dart.setFieldSignature(html$.PerformanceResourceTiming, () => ({
>+  __proto__: dart.getFields(html$.PerformanceResourceTiming.__proto__),
>+  [$connectEnd]: dart.finalFieldType(core.num),
>+  [$connectStart]: dart.finalFieldType(core.num),
>+  [$decodedBodySize]: dart.finalFieldType(core.int),
>+  [$domainLookupEnd]: dart.finalFieldType(core.num),
>+  [$domainLookupStart]: dart.finalFieldType(core.num),
>+  [$encodedBodySize]: dart.finalFieldType(core.int),
>+  [$fetchStart]: dart.finalFieldType(core.num),
>+  [$initiatorType]: dart.finalFieldType(core.String),
>+  [$nextHopProtocol]: dart.finalFieldType(core.String),
>+  [$redirectEnd]: dart.finalFieldType(core.num),
>+  [$redirectStart]: dart.finalFieldType(core.num),
>+  [$requestStart]: dart.finalFieldType(core.num),
>+  [$responseEnd]: dart.finalFieldType(core.num),
>+  [$responseStart]: dart.finalFieldType(core.num),
>+  [$secureConnectionStart]: dart.finalFieldType(core.num),
>+  [$serverTiming]: dart.finalFieldType(ListOfPerformanceServerTiming()),
>+  [$transferSize]: dart.finalFieldType(core.int),
>+  [$workerStart]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("PerformanceResourceTiming", html$.PerformanceResourceTiming);
>+html$.PerformanceNavigationTiming = class PerformanceNavigationTiming extends html$.PerformanceResourceTiming {
>+  get [$domComplete]() {
>+    return this.domComplete;
>+  }
>+  get [$domContentLoadedEventEnd]() {
>+    return this.domContentLoadedEventEnd;
>+  }
>+  get [$domContentLoadedEventStart]() {
>+    return this.domContentLoadedEventStart;
>+  }
>+  get [$domInteractive]() {
>+    return this.domInteractive;
>+  }
>+  get [$loadEventEnd]() {
>+    return this.loadEventEnd;
>+  }
>+  get [$loadEventStart]() {
>+    return this.loadEventStart;
>+  }
>+  get [$redirectCount]() {
>+    return this.redirectCount;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  get [$unloadEventEnd]() {
>+    return this.unloadEventEnd;
>+  }
>+  get [$unloadEventStart]() {
>+    return this.unloadEventStart;
>+  }
>+};
>+dart.addTypeTests(html$.PerformanceNavigationTiming);
>+const domComplete = Symbol("PerformanceNavigationTiming.domComplete");
>+const domContentLoadedEventEnd = Symbol("PerformanceNavigationTiming.domContentLoadedEventEnd");
>+const domContentLoadedEventStart = Symbol("PerformanceNavigationTiming.domContentLoadedEventStart");
>+const domInteractive = Symbol("PerformanceNavigationTiming.domInteractive");
>+const loadEventEnd = Symbol("PerformanceNavigationTiming.loadEventEnd");
>+const loadEventStart = Symbol("PerformanceNavigationTiming.loadEventStart");
>+const redirectCount$ = Symbol("PerformanceNavigationTiming.redirectCount");
>+const type$25 = Symbol("PerformanceNavigationTiming.type");
>+const unloadEventEnd = Symbol("PerformanceNavigationTiming.unloadEventEnd");
>+const unloadEventStart = Symbol("PerformanceNavigationTiming.unloadEventStart");
>+dart.setLibraryUri(html$.PerformanceNavigationTiming, "dart:html");
>+dart.setFieldSignature(html$.PerformanceNavigationTiming, () => ({
>+  __proto__: dart.getFields(html$.PerformanceNavigationTiming.__proto__),
>+  [$domComplete]: dart.finalFieldType(core.num),
>+  [$domContentLoadedEventEnd]: dart.finalFieldType(core.num),
>+  [$domContentLoadedEventStart]: dart.finalFieldType(core.num),
>+  [$domInteractive]: dart.finalFieldType(core.num),
>+  [$loadEventEnd]: dart.finalFieldType(core.num),
>+  [$loadEventStart]: dart.finalFieldType(core.num),
>+  [$redirectCount]: dart.finalFieldType(core.int),
>+  [$type]: dart.finalFieldType(core.String),
>+  [$unloadEventEnd]: dart.finalFieldType(core.num),
>+  [$unloadEventStart]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("PerformanceNavigationTiming", html$.PerformanceNavigationTiming);
>+html$.PerformanceObserver = class PerformanceObserver$ extends _interceptors.Interceptor {
>+  static new(callback) {
>+    let callback_1 = _js_helper.convertDartClosureToJS(PerformanceObserverEntryListAndPerformanceObserverTovoid(), callback, 2);
>+    return html$.PerformanceObserver._create_1(callback_1);
>+  }
>+  static _create_1(callback) {
>+    return new PerformanceObserver(callback);
>+  }
>+  [$disconnect](...args) {
>+    return this.disconnect.apply(this, args);
>+  }
>+  [$observe](options) {
>+    let options_1 = html_common.convertDartToNative_Dictionary(options);
>+    this[_observe_1$](options_1);
>+    return;
>+  }
>+  [_observe_1$](...args) {
>+    return this.observe.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.PerformanceObserver);
>+dart.setMethodSignature(html$.PerformanceObserver, () => ({
>+  __proto__: dart.getMethods(html$.PerformanceObserver.__proto__),
>+  [$disconnect]: dart.fnType(dart.void, []),
>+  [$observe]: dart.fnType(dart.void, [core.Map]),
>+  [_observe_1$]: dart.fnType(dart.void, [dart.dynamic])
>+}));
>+dart.setLibraryUri(html$.PerformanceObserver, "dart:html");
>+dart.registerExtension("PerformanceObserver", html$.PerformanceObserver);
>+html$.PerformanceObserverEntryList = class PerformanceObserverEntryList extends _interceptors.Interceptor {
>+  [$getEntries](...args) {
>+    return this.getEntries.apply(this, args);
>+  }
>+  [$getEntriesByName](...args) {
>+    return this.getEntriesByName.apply(this, args);
>+  }
>+  [$getEntriesByType](...args) {
>+    return this.getEntriesByType.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.PerformanceObserverEntryList);
>+dart.setMethodSignature(html$.PerformanceObserverEntryList, () => ({
>+  __proto__: dart.getMethods(html$.PerformanceObserverEntryList.__proto__),
>+  [$getEntries]: dart.fnType(core.List$(html$.PerformanceEntry), []),
>+  [$getEntriesByName]: dart.fnType(core.List$(html$.PerformanceEntry), [core.String, core.String]),
>+  [$getEntriesByType]: dart.fnType(core.List$(html$.PerformanceEntry), [core.String])
>+}));
>+dart.setLibraryUri(html$.PerformanceObserverEntryList, "dart:html");
>+dart.registerExtension("PerformanceObserverEntryList", html$.PerformanceObserverEntryList);
>+html$.PerformancePaintTiming = class PerformancePaintTiming extends html$.PerformanceEntry {};
>+dart.addTypeTests(html$.PerformancePaintTiming);
>+dart.setLibraryUri(html$.PerformancePaintTiming, "dart:html");
>+dart.registerExtension("PerformancePaintTiming", html$.PerformancePaintTiming);
>+html$.PerformanceServerTiming = class PerformanceServerTiming extends _interceptors.Interceptor {
>+  get [$description]() {
>+    return this.description;
>+  }
>+  get [$duration]() {
>+    return this.duration;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+};
>+dart.addTypeTests(html$.PerformanceServerTiming);
>+const description$0 = Symbol("PerformanceServerTiming.description");
>+const duration$3 = Symbol("PerformanceServerTiming.duration");
>+const name$31 = Symbol("PerformanceServerTiming.name");
>+dart.setLibraryUri(html$.PerformanceServerTiming, "dart:html");
>+dart.setFieldSignature(html$.PerformanceServerTiming, () => ({
>+  __proto__: dart.getFields(html$.PerformanceServerTiming.__proto__),
>+  [$description]: dart.finalFieldType(core.String),
>+  [$duration]: dart.finalFieldType(core.num),
>+  [$name]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("PerformanceServerTiming", html$.PerformanceServerTiming);
>+html$.PerformanceTiming = class PerformanceTiming extends _interceptors.Interceptor {
>+  get [$connectEnd]() {
>+    return this.connectEnd;
>+  }
>+  get [$connectStart]() {
>+    return this.connectStart;
>+  }
>+  get [$domComplete]() {
>+    return this.domComplete;
>+  }
>+  get [$domContentLoadedEventEnd]() {
>+    return this.domContentLoadedEventEnd;
>+  }
>+  get [$domContentLoadedEventStart]() {
>+    return this.domContentLoadedEventStart;
>+  }
>+  get [$domInteractive]() {
>+    return this.domInteractive;
>+  }
>+  get [$domLoading]() {
>+    return this.domLoading;
>+  }
>+  get [$domainLookupEnd]() {
>+    return this.domainLookupEnd;
>+  }
>+  get [$domainLookupStart]() {
>+    return this.domainLookupStart;
>+  }
>+  get [$fetchStart]() {
>+    return this.fetchStart;
>+  }
>+  get [$loadEventEnd]() {
>+    return this.loadEventEnd;
>+  }
>+  get [$loadEventStart]() {
>+    return this.loadEventStart;
>+  }
>+  get [$navigationStart]() {
>+    return this.navigationStart;
>+  }
>+  get [$redirectEnd]() {
>+    return this.redirectEnd;
>+  }
>+  get [$redirectStart]() {
>+    return this.redirectStart;
>+  }
>+  get [$requestStart]() {
>+    return this.requestStart;
>+  }
>+  get [$responseEnd]() {
>+    return this.responseEnd;
>+  }
>+  get [$responseStart]() {
>+    return this.responseStart;
>+  }
>+  get [$secureConnectionStart]() {
>+    return this.secureConnectionStart;
>+  }
>+  get [$unloadEventEnd]() {
>+    return this.unloadEventEnd;
>+  }
>+  get [$unloadEventStart]() {
>+    return this.unloadEventStart;
>+  }
>+};
>+dart.addTypeTests(html$.PerformanceTiming);
>+const connectEnd$ = Symbol("PerformanceTiming.connectEnd");
>+const connectStart$ = Symbol("PerformanceTiming.connectStart");
>+const domComplete$ = Symbol("PerformanceTiming.domComplete");
>+const domContentLoadedEventEnd$ = Symbol("PerformanceTiming.domContentLoadedEventEnd");
>+const domContentLoadedEventStart$ = Symbol("PerformanceTiming.domContentLoadedEventStart");
>+const domInteractive$ = Symbol("PerformanceTiming.domInteractive");
>+const domLoading = Symbol("PerformanceTiming.domLoading");
>+const domainLookupEnd$ = Symbol("PerformanceTiming.domainLookupEnd");
>+const domainLookupStart$ = Symbol("PerformanceTiming.domainLookupStart");
>+const fetchStart$ = Symbol("PerformanceTiming.fetchStart");
>+const loadEventEnd$ = Symbol("PerformanceTiming.loadEventEnd");
>+const loadEventStart$ = Symbol("PerformanceTiming.loadEventStart");
>+const navigationStart = Symbol("PerformanceTiming.navigationStart");
>+const redirectEnd$ = Symbol("PerformanceTiming.redirectEnd");
>+const redirectStart$ = Symbol("PerformanceTiming.redirectStart");
>+const requestStart$ = Symbol("PerformanceTiming.requestStart");
>+const responseEnd$ = Symbol("PerformanceTiming.responseEnd");
>+const responseStart$ = Symbol("PerformanceTiming.responseStart");
>+const secureConnectionStart$ = Symbol("PerformanceTiming.secureConnectionStart");
>+const unloadEventEnd$ = Symbol("PerformanceTiming.unloadEventEnd");
>+const unloadEventStart$ = Symbol("PerformanceTiming.unloadEventStart");
>+dart.setLibraryUri(html$.PerformanceTiming, "dart:html");
>+dart.setFieldSignature(html$.PerformanceTiming, () => ({
>+  __proto__: dart.getFields(html$.PerformanceTiming.__proto__),
>+  [$connectEnd]: dart.finalFieldType(core.int),
>+  [$connectStart]: dart.finalFieldType(core.int),
>+  [$domComplete]: dart.finalFieldType(core.int),
>+  [$domContentLoadedEventEnd]: dart.finalFieldType(core.int),
>+  [$domContentLoadedEventStart]: dart.finalFieldType(core.int),
>+  [$domInteractive]: dart.finalFieldType(core.int),
>+  [$domLoading]: dart.finalFieldType(core.int),
>+  [$domainLookupEnd]: dart.finalFieldType(core.int),
>+  [$domainLookupStart]: dart.finalFieldType(core.int),
>+  [$fetchStart]: dart.finalFieldType(core.int),
>+  [$loadEventEnd]: dart.finalFieldType(core.int),
>+  [$loadEventStart]: dart.finalFieldType(core.int),
>+  [$navigationStart]: dart.finalFieldType(core.int),
>+  [$redirectEnd]: dart.finalFieldType(core.int),
>+  [$redirectStart]: dart.finalFieldType(core.int),
>+  [$requestStart]: dart.finalFieldType(core.int),
>+  [$responseEnd]: dart.finalFieldType(core.int),
>+  [$responseStart]: dart.finalFieldType(core.int),
>+  [$secureConnectionStart]: dart.finalFieldType(core.int),
>+  [$unloadEventEnd]: dart.finalFieldType(core.int),
>+  [$unloadEventStart]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("PerformanceTiming", html$.PerformanceTiming);
>+html$.PermissionStatus = class PermissionStatus extends html$.EventTarget {
>+  get [$state]() {
>+    return this.state;
>+  }
>+  get [$onChange]() {
>+    return html$.PermissionStatus.changeEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.PermissionStatus);
>+const state$2 = Symbol("PermissionStatus.state");
>+dart.setGetterSignature(html$.PermissionStatus, () => ({
>+  __proto__: dart.getGetters(html$.PermissionStatus.__proto__),
>+  [$onChange]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.PermissionStatus, "dart:html");
>+dart.setFieldSignature(html$.PermissionStatus, () => ({
>+  __proto__: dart.getFields(html$.PermissionStatus.__proto__),
>+  [$state]: dart.finalFieldType(core.String)
>+}));
>+dart.defineLazy(html$.PermissionStatus, {
>+  /*html$.PermissionStatus.changeEvent*/get changeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("change"));
>+  }
>+});
>+dart.registerExtension("PermissionStatus", html$.PermissionStatus);
>+html$.Permissions = class Permissions extends _interceptors.Interceptor {
>+  [$query](permission) {
>+    let permission_dict = html_common.convertDartToNative_Dictionary(permission);
>+    return html$.promiseToFuture(html$.PermissionStatus, this.query(permission_dict));
>+  }
>+  [$request](permissions) {
>+    let permissions_dict = html_common.convertDartToNative_Dictionary(permissions);
>+    return html$.promiseToFuture(html$.PermissionStatus, this.request(permissions_dict));
>+  }
>+  [$requestAll](permissions) {
>+    return html$.promiseToFuture(html$.PermissionStatus, this.requestAll(permissions));
>+  }
>+  [$revoke](permission) {
>+    let permission_dict = html_common.convertDartToNative_Dictionary(permission);
>+    return html$.promiseToFuture(html$.PermissionStatus, this.revoke(permission_dict));
>+  }
>+};
>+dart.addTypeTests(html$.Permissions);
>+dart.setMethodSignature(html$.Permissions, () => ({
>+  __proto__: dart.getMethods(html$.Permissions.__proto__),
>+  [$query]: dart.fnType(async.Future$(html$.PermissionStatus), [core.Map]),
>+  [$request]: dart.fnType(async.Future$(html$.PermissionStatus), [core.Map]),
>+  [$requestAll]: dart.fnType(async.Future$(html$.PermissionStatus), [core.List$(core.Map)]),
>+  [$revoke]: dart.fnType(async.Future$(html$.PermissionStatus), [core.Map])
>+}));
>+dart.setLibraryUri(html$.Permissions, "dart:html");
>+dart.registerExtension("Permissions", html$.Permissions);
>+html$.PhotoCapabilities = class PhotoCapabilities extends _interceptors.Interceptor {
>+  get [$fillLightMode]() {
>+    return this.fillLightMode;
>+  }
>+  get [$imageHeight]() {
>+    return this.imageHeight;
>+  }
>+  get [$imageWidth]() {
>+    return this.imageWidth;
>+  }
>+  get [$redEyeReduction]() {
>+    return this.redEyeReduction;
>+  }
>+};
>+dart.addTypeTests(html$.PhotoCapabilities);
>+const fillLightMode = Symbol("PhotoCapabilities.fillLightMode");
>+const imageHeight = Symbol("PhotoCapabilities.imageHeight");
>+const imageWidth = Symbol("PhotoCapabilities.imageWidth");
>+const redEyeReduction = Symbol("PhotoCapabilities.redEyeReduction");
>+dart.setLibraryUri(html$.PhotoCapabilities, "dart:html");
>+dart.setFieldSignature(html$.PhotoCapabilities, () => ({
>+  __proto__: dart.getFields(html$.PhotoCapabilities.__proto__),
>+  [$fillLightMode]: dart.finalFieldType(core.List),
>+  [$imageHeight]: dart.finalFieldType(html$.MediaSettingsRange),
>+  [$imageWidth]: dart.finalFieldType(html$.MediaSettingsRange),
>+  [$redEyeReduction]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("PhotoCapabilities", html$.PhotoCapabilities);
>+html$.PictureElement = class PictureElement extends html$.HtmlElement {};
>+(html$.PictureElement.created = function() {
>+  html$.PictureElement.__proto__.created.call(this);
>+}).prototype = html$.PictureElement.prototype;
>+dart.addTypeTests(html$.PictureElement);
>+dart.setLibraryUri(html$.PictureElement, "dart:html");
>+dart.registerExtension("HTMLPictureElement", html$.PictureElement);
>+html$.Plugin = class Plugin extends _interceptors.Interceptor {
>+  get [$description]() {
>+    return this.description;
>+  }
>+  get [$filename]() {
>+    return this.filename;
>+  }
>+  get [$length]() {
>+    return this.length;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+  [$item](...args) {
>+    return this.item.apply(this, args);
>+  }
>+  [$namedItem](...args) {
>+    return this.namedItem.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.Plugin);
>+const description$1 = Symbol("Plugin.description");
>+const filename$ = Symbol("Plugin.filename");
>+const length$11 = Symbol("Plugin.length");
>+const name$32 = Symbol("Plugin.name");
>+dart.setMethodSignature(html$.Plugin, () => ({
>+  __proto__: dart.getMethods(html$.Plugin.__proto__),
>+  [$item]: dart.fnType(html$.MimeType, [core.int]),
>+  [$namedItem]: dart.fnType(html$.MimeType, [core.String])
>+}));
>+dart.setLibraryUri(html$.Plugin, "dart:html");
>+dart.setFieldSignature(html$.Plugin, () => ({
>+  __proto__: dart.getFields(html$.Plugin.__proto__),
>+  [$description]: dart.finalFieldType(core.String),
>+  [$filename]: dart.finalFieldType(core.String),
>+  [$length]: dart.finalFieldType(core.int),
>+  [$name]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("Plugin", html$.Plugin);
>+const Interceptor_ListMixin$$4 = class Interceptor_ListMixin extends _interceptors.Interceptor {};
>+(Interceptor_ListMixin$$4.new = function() {
>+  Interceptor_ListMixin$$4.__proto__.new.call(this);
>+}).prototype = Interceptor_ListMixin$$4.prototype;
>+dart.applyMixin(Interceptor_ListMixin$$4, collection.ListMixin$(html$.Plugin));
>+const Interceptor_ImmutableListMixin$$4 = class Interceptor_ImmutableListMixin extends Interceptor_ListMixin$$4 {};
>+(Interceptor_ImmutableListMixin$$4.new = function() {
>+  Interceptor_ImmutableListMixin$$4.__proto__.new.call(this);
>+}).prototype = Interceptor_ImmutableListMixin$$4.prototype;
>+dart.applyMixin(Interceptor_ImmutableListMixin$$4, html$.ImmutableListMixin$(html$.Plugin));
>+html$.PluginArray = class PluginArray extends Interceptor_ImmutableListMixin$$4 {
>+  get [$length]() {
>+    return this.length;
>+  }
>+  [$_get](index) {
>+    if (index >>> 0 !== index || index >= this[$length]) dart.throw(core.RangeError.index(index, this));
>+    return this[index];
>+  }
>+  [$_set](index, value) {
>+    html$.Plugin._check(value);
>+    dart.throw(new core.UnsupportedError.new("Cannot assign element of immutable List."));
>+    return value;
>+  }
>+  set [$length](value) {
>+    dart.throw(new core.UnsupportedError.new("Cannot resize immutable List."));
>+  }
>+  get [$first]() {
>+    if (dart.notNull(this[$length]) > 0) {
>+      return this[0];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$first](value) {
>+    super[$first] = value;
>+  }
>+  get [$last]() {
>+    let len = this[$length];
>+    if (dart.notNull(len) > 0) {
>+      return this[dart.notNull(len) - 1];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$last](value) {
>+    super[$last] = value;
>+  }
>+  get [$single]() {
>+    let len = this[$length];
>+    if (len === 1) {
>+      return this[0];
>+    }
>+    if (len === 0) dart.throw(new core.StateError.new("No elements"));
>+    dart.throw(new core.StateError.new("More than one element"));
>+  }
>+  [$elementAt](index) {
>+    return this[$_get](index);
>+  }
>+  [$item](...args) {
>+    return this.item.apply(this, args);
>+  }
>+  [$namedItem](...args) {
>+    return this.namedItem.apply(this, args);
>+  }
>+  [$refresh](...args) {
>+    return this.refresh.apply(this, args);
>+  }
>+};
>+html$.PluginArray.prototype[dart.isList] = true;
>+dart.addTypeTests(html$.PluginArray);
>+html$.PluginArray[dart.implements] = () => [JavaScriptIndexingBehaviorOfPlugin(), ListOfPlugin()];
>+dart.setMethodSignature(html$.PluginArray, () => ({
>+  __proto__: dart.getMethods(html$.PluginArray.__proto__),
>+  [$_get]: dart.fnType(html$.Plugin, [core.int]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$elementAt]: dart.fnType(html$.Plugin, [core.int]),
>+  [$item]: dart.fnType(html$.Plugin, [core.int]),
>+  [$namedItem]: dart.fnType(html$.Plugin, [core.String]),
>+  [$refresh]: dart.fnType(dart.void, [core.bool])
>+}));
>+dart.setGetterSignature(html$.PluginArray, () => ({
>+  __proto__: dart.getGetters(html$.PluginArray.__proto__),
>+  [$length]: core.int,
>+  [$first]: html$.Plugin,
>+  [$last]: html$.Plugin,
>+  [$single]: html$.Plugin
>+}));
>+dart.setSetterSignature(html$.PluginArray, () => ({
>+  __proto__: dart.getSetters(html$.PluginArray.__proto__),
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(html$.PluginArray, "dart:html");
>+dart.registerExtension("PluginArray", html$.PluginArray);
>+html$.PointerEvent = class PointerEvent$ extends html$.MouseEvent {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.PointerEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.PointerEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new PointerEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new PointerEvent(type);
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$isPrimary]() {
>+    return this.isPrimary;
>+  }
>+  get [$pointerId]() {
>+    return this.pointerId;
>+  }
>+  get [$pointerType]() {
>+    return this.pointerType;
>+  }
>+  get [$pressure]() {
>+    return this.pressure;
>+  }
>+  get [$tangentialPressure]() {
>+    return this.tangentialPressure;
>+  }
>+  get [$tiltX]() {
>+    return this.tiltX;
>+  }
>+  get [$tiltY]() {
>+    return this.tiltY;
>+  }
>+  get [$twist]() {
>+    return this.twist;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  [$getCoalescedEvents](...args) {
>+    return this.getCoalescedEvents.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.PointerEvent);
>+const height$9 = Symbol("PointerEvent.height");
>+const isPrimary = Symbol("PointerEvent.isPrimary");
>+const pointerId = Symbol("PointerEvent.pointerId");
>+const pointerType = Symbol("PointerEvent.pointerType");
>+const pressure = Symbol("PointerEvent.pressure");
>+const tangentialPressure = Symbol("PointerEvent.tangentialPressure");
>+const tiltX = Symbol("PointerEvent.tiltX");
>+const tiltY = Symbol("PointerEvent.tiltY");
>+const twist = Symbol("PointerEvent.twist");
>+const width$9 = Symbol("PointerEvent.width");
>+dart.setMethodSignature(html$.PointerEvent, () => ({
>+  __proto__: dart.getMethods(html$.PointerEvent.__proto__),
>+  [$getCoalescedEvents]: dart.fnType(core.List$(html$.PointerEvent), [])
>+}));
>+dart.setLibraryUri(html$.PointerEvent, "dart:html");
>+dart.setFieldSignature(html$.PointerEvent, () => ({
>+  __proto__: dart.getFields(html$.PointerEvent.__proto__),
>+  [$height]: dart.finalFieldType(core.num),
>+  [$isPrimary]: dart.finalFieldType(core.bool),
>+  [$pointerId]: dart.finalFieldType(core.int),
>+  [$pointerType]: dart.finalFieldType(core.String),
>+  [$pressure]: dart.finalFieldType(core.num),
>+  [$tangentialPressure]: dart.finalFieldType(core.num),
>+  [$tiltX]: dart.finalFieldType(core.int),
>+  [$tiltY]: dart.finalFieldType(core.int),
>+  [$twist]: dart.finalFieldType(core.int),
>+  [$width]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("PointerEvent", html$.PointerEvent);
>+html$.PopStateEvent = class PopStateEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.PopStateEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.PopStateEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new PopStateEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new PopStateEvent(type);
>+  }
>+  get [$state]() {
>+    return html_common.convertNativeToDart_SerializedScriptValue(this[_get_state]);
>+  }
>+  get [_get_state]() {
>+    return this.state;
>+  }
>+};
>+dart.addTypeTests(html$.PopStateEvent);
>+dart.setGetterSignature(html$.PopStateEvent, () => ({
>+  __proto__: dart.getGetters(html$.PopStateEvent.__proto__),
>+  [$state]: dart.dynamic
>+}));
>+dart.setLibraryUri(html$.PopStateEvent, "dart:html");
>+dart.setFieldSignature(html$.PopStateEvent, () => ({
>+  __proto__: dart.getFields(html$.PopStateEvent.__proto__),
>+  [_get_state]: dart.finalFieldType(dart.dynamic)
>+}));
>+dart.registerExtension("PopStateEvent", html$.PopStateEvent);
>+html$.PositionError = class PositionError extends _interceptors.Interceptor {
>+  get [$code]() {
>+    return this.code;
>+  }
>+  get [$message]() {
>+    return this.message;
>+  }
>+};
>+dart.addTypeTests(html$.PositionError);
>+const code$1 = Symbol("PositionError.code");
>+const message$25 = Symbol("PositionError.message");
>+dart.setLibraryUri(html$.PositionError, "dart:html");
>+dart.setFieldSignature(html$.PositionError, () => ({
>+  __proto__: dart.getFields(html$.PositionError.__proto__),
>+  [$code]: dart.finalFieldType(core.int),
>+  [$message]: dart.finalFieldType(core.String)
>+}));
>+dart.defineLazy(html$.PositionError, {
>+  /*html$.PositionError.PERMISSION_DENIED*/get PERMISSION_DENIED() {
>+    return 1;
>+  },
>+  /*html$.PositionError.POSITION_UNAVAILABLE*/get POSITION_UNAVAILABLE() {
>+    return 2;
>+  },
>+  /*html$.PositionError.TIMEOUT*/get TIMEOUT() {
>+    return 3;
>+  }
>+});
>+dart.registerExtension("PositionError", html$.PositionError);
>+html$.PreElement = class PreElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("pre");
>+  }
>+};
>+(html$.PreElement.created = function() {
>+  html$.PreElement.__proto__.created.call(this);
>+}).prototype = html$.PreElement.prototype;
>+dart.addTypeTests(html$.PreElement);
>+dart.setLibraryUri(html$.PreElement, "dart:html");
>+dart.registerExtension("HTMLPreElement", html$.PreElement);
>+html$.Presentation = class Presentation extends _interceptors.Interceptor {
>+  get [$defaultRequest]() {
>+    return this.defaultRequest;
>+  }
>+  set [$defaultRequest](value) {
>+    this.defaultRequest = value;
>+  }
>+  get [$receiver]() {
>+    return this.receiver;
>+  }
>+};
>+dart.addTypeTests(html$.Presentation);
>+const defaultRequest = Symbol("Presentation.defaultRequest");
>+const receiver = Symbol("Presentation.receiver");
>+dart.setLibraryUri(html$.Presentation, "dart:html");
>+dart.setFieldSignature(html$.Presentation, () => ({
>+  __proto__: dart.getFields(html$.Presentation.__proto__),
>+  [$defaultRequest]: dart.fieldType(html$.PresentationRequest),
>+  [$receiver]: dart.finalFieldType(html$.PresentationReceiver)
>+}));
>+dart.registerExtension("Presentation", html$.Presentation);
>+html$.PresentationAvailability = class PresentationAvailability extends html$.EventTarget {
>+  get [$value]() {
>+    return this.value;
>+  }
>+  get [$onChange]() {
>+    return html$.PresentationAvailability.changeEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.PresentationAvailability);
>+const value$14 = Symbol("PresentationAvailability.value");
>+dart.setGetterSignature(html$.PresentationAvailability, () => ({
>+  __proto__: dart.getGetters(html$.PresentationAvailability.__proto__),
>+  [$onChange]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.PresentationAvailability, "dart:html");
>+dart.setFieldSignature(html$.PresentationAvailability, () => ({
>+  __proto__: dart.getFields(html$.PresentationAvailability.__proto__),
>+  [$value]: dart.finalFieldType(core.bool)
>+}));
>+dart.defineLazy(html$.PresentationAvailability, {
>+  /*html$.PresentationAvailability.changeEvent*/get changeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("change"));
>+  }
>+});
>+dart.registerExtension("PresentationAvailability", html$.PresentationAvailability);
>+html$.PresentationConnection = class PresentationConnection extends html$.EventTarget {
>+  get [$binaryType]() {
>+    return this.binaryType;
>+  }
>+  set [$binaryType](value) {
>+    this.binaryType = value;
>+  }
>+  get [$id]() {
>+    return this.id;
>+  }
>+  get [$state]() {
>+    return this.state;
>+  }
>+  get [$url]() {
>+    return this.url;
>+  }
>+  [$close](...args) {
>+    return this.close.apply(this, args);
>+  }
>+  [$send](...args) {
>+    return this.send.apply(this, args);
>+  }
>+  [$terminate](...args) {
>+    return this.terminate.apply(this, args);
>+  }
>+  get [$onMessage]() {
>+    return html$.PresentationConnection.messageEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.PresentationConnection);
>+const binaryType = Symbol("PresentationConnection.binaryType");
>+const id$10 = Symbol("PresentationConnection.id");
>+const state$3 = Symbol("PresentationConnection.state");
>+const url$2 = Symbol("PresentationConnection.url");
>+dart.setMethodSignature(html$.PresentationConnection, () => ({
>+  __proto__: dart.getMethods(html$.PresentationConnection.__proto__),
>+  [$close]: dart.fnType(dart.void, []),
>+  [$send]: dart.fnType(dart.void, [dart.dynamic]),
>+  [$terminate]: dart.fnType(dart.void, [])
>+}));
>+dart.setGetterSignature(html$.PresentationConnection, () => ({
>+  __proto__: dart.getGetters(html$.PresentationConnection.__proto__),
>+  [$onMessage]: async.Stream$(html$.MessageEvent)
>+}));
>+dart.setLibraryUri(html$.PresentationConnection, "dart:html");
>+dart.setFieldSignature(html$.PresentationConnection, () => ({
>+  __proto__: dart.getFields(html$.PresentationConnection.__proto__),
>+  [$binaryType]: dart.fieldType(core.String),
>+  [$id]: dart.finalFieldType(core.String),
>+  [$state]: dart.finalFieldType(core.String),
>+  [$url]: dart.finalFieldType(core.String)
>+}));
>+dart.defineLazy(html$.PresentationConnection, {
>+  /*html$.PresentationConnection.messageEvent*/get messageEvent() {
>+    return dart.const(new (EventStreamProviderOfMessageEvent()).new("message"));
>+  }
>+});
>+dart.registerExtension("PresentationConnection", html$.PresentationConnection);
>+html$.PresentationConnectionAvailableEvent = class PresentationConnectionAvailableEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+    return html$.PresentationConnectionAvailableEvent._create_1(type, eventInitDict_1);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new PresentationConnectionAvailableEvent(type, eventInitDict);
>+  }
>+  get [$connection]() {
>+    return this.connection;
>+  }
>+};
>+dart.addTypeTests(html$.PresentationConnectionAvailableEvent);
>+const connection$0 = Symbol("PresentationConnectionAvailableEvent.connection");
>+dart.setLibraryUri(html$.PresentationConnectionAvailableEvent, "dart:html");
>+dart.setFieldSignature(html$.PresentationConnectionAvailableEvent, () => ({
>+  __proto__: dart.getFields(html$.PresentationConnectionAvailableEvent.__proto__),
>+  [$connection]: dart.finalFieldType(html$.PresentationConnection)
>+}));
>+dart.registerExtension("PresentationConnectionAvailableEvent", html$.PresentationConnectionAvailableEvent);
>+html$.PresentationConnectionCloseEvent = class PresentationConnectionCloseEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+    return html$.PresentationConnectionCloseEvent._create_1(type, eventInitDict_1);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new PresentationConnectionCloseEvent(type, eventInitDict);
>+  }
>+  get [$message]() {
>+    return this.message;
>+  }
>+  get [$reason]() {
>+    return this.reason;
>+  }
>+};
>+dart.addTypeTests(html$.PresentationConnectionCloseEvent);
>+const message$26 = Symbol("PresentationConnectionCloseEvent.message");
>+const reason$0 = Symbol("PresentationConnectionCloseEvent.reason");
>+dart.setLibraryUri(html$.PresentationConnectionCloseEvent, "dart:html");
>+dart.setFieldSignature(html$.PresentationConnectionCloseEvent, () => ({
>+  __proto__: dart.getFields(html$.PresentationConnectionCloseEvent.__proto__),
>+  [$message]: dart.finalFieldType(core.String),
>+  [$reason]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("PresentationConnectionCloseEvent", html$.PresentationConnectionCloseEvent);
>+html$.PresentationConnectionList = class PresentationConnectionList extends html$.EventTarget {
>+  get [$connections]() {
>+    return this.connections;
>+  }
>+};
>+dart.addTypeTests(html$.PresentationConnectionList);
>+const connections = Symbol("PresentationConnectionList.connections");
>+dart.setLibraryUri(html$.PresentationConnectionList, "dart:html");
>+dart.setFieldSignature(html$.PresentationConnectionList, () => ({
>+  __proto__: dart.getFields(html$.PresentationConnectionList.__proto__),
>+  [$connections]: dart.finalFieldType(ListOfPresentationConnection())
>+}));
>+dart.registerExtension("PresentationConnectionList", html$.PresentationConnectionList);
>+html$.PresentationReceiver = class PresentationReceiver extends _interceptors.Interceptor {
>+  get [$connectionList]() {
>+    return html$.promiseToFuture(html$.PresentationConnectionList, this.connectionList);
>+  }
>+};
>+dart.addTypeTests(html$.PresentationReceiver);
>+dart.setGetterSignature(html$.PresentationReceiver, () => ({
>+  __proto__: dart.getGetters(html$.PresentationReceiver.__proto__),
>+  [$connectionList]: async.Future$(html$.PresentationConnectionList)
>+}));
>+dart.setLibraryUri(html$.PresentationReceiver, "dart:html");
>+dart.registerExtension("PresentationReceiver", html$.PresentationReceiver);
>+html$.PresentationRequest = class PresentationRequest$ extends html$.EventTarget {
>+  static new(url_OR_urls) {
>+    if (typeof url_OR_urls == 'string') {
>+      return html$.PresentationRequest._create_1(url_OR_urls);
>+    }
>+    if (ListOfString().is(url_OR_urls)) {
>+      let urls_1 = html_common.convertDartToNative_StringArray(url_OR_urls);
>+      return html$.PresentationRequest._create_2(urls_1);
>+    }
>+    dart.throw(new core.ArgumentError.new("Incorrect number or type of arguments"));
>+  }
>+  static _create_1(url_OR_urls) {
>+    return new PresentationRequest(url_OR_urls);
>+  }
>+  static _create_2(url_OR_urls) {
>+    return new PresentationRequest(url_OR_urls);
>+  }
>+  [$getAvailability]() {
>+    return html$.promiseToFuture(html$.PresentationAvailability, this.getAvailability());
>+  }
>+  [$reconnect](id) {
>+    return html$.promiseToFuture(html$.PresentationConnection, this.reconnect(id));
>+  }
>+  [$start]() {
>+    return html$.promiseToFuture(html$.PresentationConnection, this.start());
>+  }
>+};
>+dart.addTypeTests(html$.PresentationRequest);
>+dart.setMethodSignature(html$.PresentationRequest, () => ({
>+  __proto__: dart.getMethods(html$.PresentationRequest.__proto__),
>+  [$getAvailability]: dart.fnType(async.Future$(html$.PresentationAvailability), []),
>+  [$reconnect]: dart.fnType(async.Future$(html$.PresentationConnection), [core.String]),
>+  [$start]: dart.fnType(async.Future$(html$.PresentationConnection), [])
>+}));
>+dart.setLibraryUri(html$.PresentationRequest, "dart:html");
>+dart.registerExtension("PresentationRequest", html$.PresentationRequest);
>+html$.ProcessingInstruction = class ProcessingInstruction extends html$.CharacterData {
>+  get [$sheet]() {
>+    return this.sheet;
>+  }
>+  get [$target]() {
>+    return this.target;
>+  }
>+};
>+dart.addTypeTests(html$.ProcessingInstruction);
>+const sheet$ = Symbol("ProcessingInstruction.sheet");
>+const target$5 = Symbol("ProcessingInstruction.target");
>+dart.setLibraryUri(html$.ProcessingInstruction, "dart:html");
>+dart.setFieldSignature(html$.ProcessingInstruction, () => ({
>+  __proto__: dart.getFields(html$.ProcessingInstruction.__proto__),
>+  [$sheet]: dart.finalFieldType(html$.StyleSheet),
>+  [$target]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("ProcessingInstruction", html$.ProcessingInstruction);
>+html$.ProgressElement = class ProgressElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.ProgressElement._check(html$.document[$createElement]("progress"));
>+  }
>+  static get supported() {
>+    return html$.Element.isTagSupported("progress");
>+  }
>+  get [$labels]() {
>+    return this.labels;
>+  }
>+  get [$max]() {
>+    return this.max;
>+  }
>+  set [$max](value) {
>+    this.max = value;
>+  }
>+  get [$position]() {
>+    return this.position;
>+  }
>+  get [$value]() {
>+    return this.value;
>+  }
>+  set [$value](value) {
>+    this.value = value;
>+  }
>+};
>+(html$.ProgressElement.created = function() {
>+  this[labels$2] = null;
>+  this[max$3] = null;
>+  this[position$0] = null;
>+  this[value$15] = null;
>+  html$.ProgressElement.__proto__.created.call(this);
>+}).prototype = html$.ProgressElement.prototype;
>+dart.addTypeTests(html$.ProgressElement);
>+const labels$2 = Symbol("ProgressElement.labels");
>+const max$3 = Symbol("ProgressElement.max");
>+const position$0 = Symbol("ProgressElement.position");
>+const value$15 = Symbol("ProgressElement.value");
>+dart.setLibraryUri(html$.ProgressElement, "dart:html");
>+dart.setFieldSignature(html$.ProgressElement, () => ({
>+  __proto__: dart.getFields(html$.ProgressElement.__proto__),
>+  [$labels]: dart.finalFieldType(ListOfNode()),
>+  [$max]: dart.fieldType(core.num),
>+  [$position]: dart.finalFieldType(core.num),
>+  [$value]: dart.fieldType(core.num)
>+}));
>+dart.registerExtension("HTMLProgressElement", html$.ProgressElement);
>+html$.ProgressEvent = class ProgressEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.ProgressEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.ProgressEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new ProgressEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new ProgressEvent(type);
>+  }
>+  get [$lengthComputable]() {
>+    return this.lengthComputable;
>+  }
>+  get [$loaded]() {
>+    return this.loaded;
>+  }
>+  get [$total]() {
>+    return this.total;
>+  }
>+};
>+dart.addTypeTests(html$.ProgressEvent);
>+const lengthComputable = Symbol("ProgressEvent.lengthComputable");
>+const loaded = Symbol("ProgressEvent.loaded");
>+const total$ = Symbol("ProgressEvent.total");
>+dart.setLibraryUri(html$.ProgressEvent, "dart:html");
>+dart.setFieldSignature(html$.ProgressEvent, () => ({
>+  __proto__: dart.getFields(html$.ProgressEvent.__proto__),
>+  [$lengthComputable]: dart.finalFieldType(core.bool),
>+  [$loaded]: dart.finalFieldType(core.int),
>+  [$total]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("ProgressEvent", html$.ProgressEvent);
>+html$.PromiseRejectionEvent = class PromiseRejectionEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+    return html$.PromiseRejectionEvent._create_1(type, eventInitDict_1);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new PromiseRejectionEvent(type, eventInitDict);
>+  }
>+  get [$promise]() {
>+    return html$.promiseToFuture(dart.dynamic, this.promise);
>+  }
>+  get [$reason]() {
>+    return this.reason;
>+  }
>+};
>+dart.addTypeTests(html$.PromiseRejectionEvent);
>+const reason$1 = Symbol("PromiseRejectionEvent.reason");
>+dart.setGetterSignature(html$.PromiseRejectionEvent, () => ({
>+  __proto__: dart.getGetters(html$.PromiseRejectionEvent.__proto__),
>+  [$promise]: async.Future
>+}));
>+dart.setLibraryUri(html$.PromiseRejectionEvent, "dart:html");
>+dart.setFieldSignature(html$.PromiseRejectionEvent, () => ({
>+  __proto__: dart.getFields(html$.PromiseRejectionEvent.__proto__),
>+  [$reason]: dart.finalFieldType(core.Object)
>+}));
>+dart.registerExtension("PromiseRejectionEvent", html$.PromiseRejectionEvent);
>+html$.PublicKeyCredential = class PublicKeyCredential extends html$.Credential {
>+  get [$rawId]() {
>+    return this.rawId;
>+  }
>+  get [$response]() {
>+    return this.response;
>+  }
>+};
>+dart.addTypeTests(html$.PublicKeyCredential);
>+const rawId = Symbol("PublicKeyCredential.rawId");
>+const response$ = Symbol("PublicKeyCredential.response");
>+dart.setLibraryUri(html$.PublicKeyCredential, "dart:html");
>+dart.setFieldSignature(html$.PublicKeyCredential, () => ({
>+  __proto__: dart.getFields(html$.PublicKeyCredential.__proto__),
>+  [$rawId]: dart.finalFieldType(typed_data.ByteBuffer),
>+  [$response]: dart.finalFieldType(html$.AuthenticatorResponse)
>+}));
>+dart.registerExtension("PublicKeyCredential", html$.PublicKeyCredential);
>+html$.PushEvent = class PushEvent$ extends html$.ExtendableEvent {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.PushEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.PushEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new PushEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new PushEvent(type);
>+  }
>+  get [$data]() {
>+    return this.data;
>+  }
>+};
>+dart.addTypeTests(html$.PushEvent);
>+const data$7 = Symbol("PushEvent.data");
>+dart.setLibraryUri(html$.PushEvent, "dart:html");
>+dart.setFieldSignature(html$.PushEvent, () => ({
>+  __proto__: dart.getFields(html$.PushEvent.__proto__),
>+  [$data]: dart.finalFieldType(html$.PushMessageData)
>+}));
>+dart.registerExtension("PushEvent", html$.PushEvent);
>+html$.PushManager = class PushManager extends _interceptors.Interceptor {
>+  [$getSubscription]() {
>+    return html$.promiseToFuture(html$.PushSubscription, this.getSubscription());
>+  }
>+  [$permissionState](options) {
>+    if (options === void 0) options = null;
>+    let options_dict = null;
>+    if (options != null) {
>+      options_dict = html_common.convertDartToNative_Dictionary(options);
>+    }
>+    return html$.promiseToFuture(dart.dynamic, this.permissionState(options_dict));
>+  }
>+  [$subscribe](options) {
>+    if (options === void 0) options = null;
>+    let options_dict = null;
>+    if (options != null) {
>+      options_dict = html_common.convertDartToNative_Dictionary(options);
>+    }
>+    return html$.promiseToFuture(html$.PushSubscription, this.subscribe(options_dict));
>+  }
>+};
>+dart.addTypeTests(html$.PushManager);
>+dart.setMethodSignature(html$.PushManager, () => ({
>+  __proto__: dart.getMethods(html$.PushManager.__proto__),
>+  [$getSubscription]: dart.fnType(async.Future$(html$.PushSubscription), []),
>+  [$permissionState]: dart.fnType(async.Future, [], [core.Map]),
>+  [$subscribe]: dart.fnType(async.Future$(html$.PushSubscription), [], [core.Map])
>+}));
>+dart.setLibraryUri(html$.PushManager, "dart:html");
>+dart.defineLazy(html$.PushManager, {
>+  /*html$.PushManager.supportedContentEncodings*/get supportedContentEncodings() {
>+    return null;
>+  }
>+});
>+dart.registerExtension("PushManager", html$.PushManager);
>+html$.PushMessageData = class PushMessageData extends _interceptors.Interceptor {
>+  [$arrayBuffer](...args) {
>+    return this.arrayBuffer.apply(this, args);
>+  }
>+  [$blob](...args) {
>+    return this.blob.apply(this, args);
>+  }
>+  [$json](...args) {
>+    return this.json.apply(this, args);
>+  }
>+  [$text](...args) {
>+    return this.text.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.PushMessageData);
>+dart.setMethodSignature(html$.PushMessageData, () => ({
>+  __proto__: dart.getMethods(html$.PushMessageData.__proto__),
>+  [$arrayBuffer]: dart.fnType(typed_data.ByteBuffer, []),
>+  [$blob]: dart.fnType(html$.Blob, []),
>+  [$json]: dart.fnType(core.Object, []),
>+  [$text]: dart.fnType(core.String, [])
>+}));
>+dart.setLibraryUri(html$.PushMessageData, "dart:html");
>+dart.registerExtension("PushMessageData", html$.PushMessageData);
>+html$.PushSubscription = class PushSubscription extends _interceptors.Interceptor {
>+  get [$endpoint]() {
>+    return this.endpoint;
>+  }
>+  get [$expirationTime]() {
>+    return this.expirationTime;
>+  }
>+  get [$options]() {
>+    return this.options;
>+  }
>+  [$getKey](...args) {
>+    return this.getKey.apply(this, args);
>+  }
>+  [$unsubscribe]() {
>+    return html$.promiseToFuture(core.bool, this.unsubscribe());
>+  }
>+};
>+dart.addTypeTests(html$.PushSubscription);
>+const endpoint = Symbol("PushSubscription.endpoint");
>+const expirationTime = Symbol("PushSubscription.expirationTime");
>+const options$0 = Symbol("PushSubscription.options");
>+dart.setMethodSignature(html$.PushSubscription, () => ({
>+  __proto__: dart.getMethods(html$.PushSubscription.__proto__),
>+  [$getKey]: dart.fnType(typed_data.ByteBuffer, [core.String]),
>+  [$unsubscribe]: dart.fnType(async.Future$(core.bool), [])
>+}));
>+dart.setLibraryUri(html$.PushSubscription, "dart:html");
>+dart.setFieldSignature(html$.PushSubscription, () => ({
>+  __proto__: dart.getFields(html$.PushSubscription.__proto__),
>+  [$endpoint]: dart.finalFieldType(core.String),
>+  [$expirationTime]: dart.finalFieldType(core.int),
>+  [$options]: dart.finalFieldType(html$.PushSubscriptionOptions)
>+}));
>+dart.registerExtension("PushSubscription", html$.PushSubscription);
>+html$.PushSubscriptionOptions = class PushSubscriptionOptions extends _interceptors.Interceptor {
>+  get [$applicationServerKey]() {
>+    return this.applicationServerKey;
>+  }
>+  get [$userVisibleOnly]() {
>+    return this.userVisibleOnly;
>+  }
>+};
>+dart.addTypeTests(html$.PushSubscriptionOptions);
>+const applicationServerKey = Symbol("PushSubscriptionOptions.applicationServerKey");
>+const userVisibleOnly = Symbol("PushSubscriptionOptions.userVisibleOnly");
>+dart.setLibraryUri(html$.PushSubscriptionOptions, "dart:html");
>+dart.setFieldSignature(html$.PushSubscriptionOptions, () => ({
>+  __proto__: dart.getFields(html$.PushSubscriptionOptions.__proto__),
>+  [$applicationServerKey]: dart.finalFieldType(typed_data.ByteBuffer),
>+  [$userVisibleOnly]: dart.finalFieldType(core.bool)
>+}));
>+dart.registerExtension("PushSubscriptionOptions", html$.PushSubscriptionOptions);
>+html$.QuoteElement = class QuoteElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("q");
>+  }
>+  get [$cite]() {
>+    return this.cite;
>+  }
>+  set [$cite](value) {
>+    this.cite = value;
>+  }
>+};
>+(html$.QuoteElement.created = function() {
>+  this[cite$] = null;
>+  html$.QuoteElement.__proto__.created.call(this);
>+}).prototype = html$.QuoteElement.prototype;
>+dart.addTypeTests(html$.QuoteElement);
>+const cite$ = Symbol("QuoteElement.cite");
>+dart.setLibraryUri(html$.QuoteElement, "dart:html");
>+dart.setFieldSignature(html$.QuoteElement, () => ({
>+  __proto__: dart.getFields(html$.QuoteElement.__proto__),
>+  [$cite]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("HTMLQuoteElement", html$.QuoteElement);
>+html$.Range = class Range extends _interceptors.Interceptor {
>+  static new() {
>+    return html$.document.createRange();
>+  }
>+  static fromPoint(point) {
>+    return html$.document[_caretRangeFromPoint](dart.asInt(point.x), dart.asInt(point.y));
>+  }
>+  get [$collapsed]() {
>+    return this.collapsed;
>+  }
>+  get [$commonAncestorContainer]() {
>+    return this.commonAncestorContainer;
>+  }
>+  get [$endContainer]() {
>+    return this.endContainer;
>+  }
>+  get [$endOffset]() {
>+    return this.endOffset;
>+  }
>+  get [$startContainer]() {
>+    return this.startContainer;
>+  }
>+  get [$startOffset]() {
>+    return this.startOffset;
>+  }
>+  [$cloneContents](...args) {
>+    return this.cloneContents.apply(this, args);
>+  }
>+  [$cloneRange](...args) {
>+    return this.cloneRange.apply(this, args);
>+  }
>+  [$collapse](...args) {
>+    return this.collapse.apply(this, args);
>+  }
>+  [$compareBoundaryPoints](...args) {
>+    return this.compareBoundaryPoints.apply(this, args);
>+  }
>+  [$comparePoint](...args) {
>+    return this.comparePoint.apply(this, args);
>+  }
>+  [$createContextualFragment](...args) {
>+    return this.createContextualFragment.apply(this, args);
>+  }
>+  [$deleteContents](...args) {
>+    return this.deleteContents.apply(this, args);
>+  }
>+  [$detach](...args) {
>+    return this.detach.apply(this, args);
>+  }
>+  [$expand](...args) {
>+    return this.expand.apply(this, args);
>+  }
>+  [$extractContents](...args) {
>+    return this.extractContents.apply(this, args);
>+  }
>+  [$getBoundingClientRect](...args) {
>+    return this.getBoundingClientRect.apply(this, args);
>+  }
>+  [_getClientRects](...args) {
>+    return this.getClientRects.apply(this, args);
>+  }
>+  [$insertNode](...args) {
>+    return this.insertNode.apply(this, args);
>+  }
>+  [$isPointInRange](...args) {
>+    return this.isPointInRange.apply(this, args);
>+  }
>+  [$selectNode](...args) {
>+    return this.selectNode.apply(this, args);
>+  }
>+  [$selectNodeContents](...args) {
>+    return this.selectNodeContents.apply(this, args);
>+  }
>+  [$setEnd](...args) {
>+    return this.setEnd.apply(this, args);
>+  }
>+  [$setEndAfter](...args) {
>+    return this.setEndAfter.apply(this, args);
>+  }
>+  [$setEndBefore](...args) {
>+    return this.setEndBefore.apply(this, args);
>+  }
>+  [$setStart](...args) {
>+    return this.setStart.apply(this, args);
>+  }
>+  [$setStartAfter](...args) {
>+    return this.setStartAfter.apply(this, args);
>+  }
>+  [$setStartBefore](...args) {
>+    return this.setStartBefore.apply(this, args);
>+  }
>+  [$surroundContents](...args) {
>+    return this.surroundContents.apply(this, args);
>+  }
>+  [$getClientRects]() {
>+    let value = this[_getClientRects]();
>+    let jsProto = value.prototype;
>+    if (jsProto == null) {
>+      value.prototype = Object.create(null);
>+    }
>+    _js_helper.applyExtension("DOMRectList", value);
>+    return value;
>+  }
>+  static get supportsCreateContextualFragment() {
>+    return "createContextualFragment" in window.Range.prototype;
>+  }
>+};
>+dart.addTypeTests(html$.Range);
>+const collapsed = Symbol("Range.collapsed");
>+const commonAncestorContainer = Symbol("Range.commonAncestorContainer");
>+const endContainer = Symbol("Range.endContainer");
>+const endOffset = Symbol("Range.endOffset");
>+const startContainer = Symbol("Range.startContainer");
>+const startOffset = Symbol("Range.startOffset");
>+dart.setMethodSignature(html$.Range, () => ({
>+  __proto__: dart.getMethods(html$.Range.__proto__),
>+  [$cloneContents]: dart.fnType(html$.DocumentFragment, []),
>+  [$cloneRange]: dart.fnType(html$.Range, []),
>+  [$collapse]: dart.fnType(dart.void, [], [core.bool]),
>+  [$compareBoundaryPoints]: dart.fnType(core.int, [core.int, html$.Range]),
>+  [$comparePoint]: dart.fnType(core.int, [html$.Node, core.int]),
>+  [$createContextualFragment]: dart.fnType(html$.DocumentFragment, [core.String]),
>+  [$deleteContents]: dart.fnType(dart.void, []),
>+  [$detach]: dart.fnType(dart.void, []),
>+  [$expand]: dart.fnType(dart.void, [core.String]),
>+  [$extractContents]: dart.fnType(html$.DocumentFragment, []),
>+  [$getBoundingClientRect]: dart.fnType(math.Rectangle$(core.num), []),
>+  [_getClientRects]: dart.fnType(core.List$(math.Rectangle$(core.num)), []),
>+  [$insertNode]: dart.fnType(dart.void, [html$.Node]),
>+  [$isPointInRange]: dart.fnType(core.bool, [html$.Node, core.int]),
>+  [$selectNode]: dart.fnType(dart.void, [html$.Node]),
>+  [$selectNodeContents]: dart.fnType(dart.void, [html$.Node]),
>+  [$setEnd]: dart.fnType(dart.void, [html$.Node, core.int]),
>+  [$setEndAfter]: dart.fnType(dart.void, [html$.Node]),
>+  [$setEndBefore]: dart.fnType(dart.void, [html$.Node]),
>+  [$setStart]: dart.fnType(dart.void, [html$.Node, core.int]),
>+  [$setStartAfter]: dart.fnType(dart.void, [html$.Node]),
>+  [$setStartBefore]: dart.fnType(dart.void, [html$.Node]),
>+  [$surroundContents]: dart.fnType(dart.void, [html$.Node]),
>+  [$getClientRects]: dart.fnType(core.List$(math.Rectangle$(core.num)), [])
>+}));
>+dart.setLibraryUri(html$.Range, "dart:html");
>+dart.setFieldSignature(html$.Range, () => ({
>+  __proto__: dart.getFields(html$.Range.__proto__),
>+  [$collapsed]: dart.finalFieldType(core.bool),
>+  [$commonAncestorContainer]: dart.finalFieldType(html$.Node),
>+  [$endContainer]: dart.finalFieldType(html$.Node),
>+  [$endOffset]: dart.finalFieldType(core.int),
>+  [$startContainer]: dart.finalFieldType(html$.Node),
>+  [$startOffset]: dart.finalFieldType(core.int)
>+}));
>+dart.defineLazy(html$.Range, {
>+  /*html$.Range.END_TO_END*/get END_TO_END() {
>+    return 2;
>+  },
>+  /*html$.Range.END_TO_START*/get END_TO_START() {
>+    return 3;
>+  },
>+  /*html$.Range.START_TO_END*/get START_TO_END() {
>+    return 1;
>+  },
>+  /*html$.Range.START_TO_START*/get START_TO_START() {
>+    return 0;
>+  }
>+});
>+dart.registerExtension("Range", html$.Range);
>+html$.RelatedApplication = class RelatedApplication extends _interceptors.Interceptor {
>+  get [$id]() {
>+    return this.id;
>+  }
>+  get [$platform]() {
>+    return this.platform;
>+  }
>+  get [$url]() {
>+    return this.url;
>+  }
>+};
>+dart.addTypeTests(html$.RelatedApplication);
>+const id$11 = Symbol("RelatedApplication.id");
>+const platform$0 = Symbol("RelatedApplication.platform");
>+const url$3 = Symbol("RelatedApplication.url");
>+dart.setLibraryUri(html$.RelatedApplication, "dart:html");
>+dart.setFieldSignature(html$.RelatedApplication, () => ({
>+  __proto__: dart.getFields(html$.RelatedApplication.__proto__),
>+  [$id]: dart.finalFieldType(core.String),
>+  [$platform]: dart.finalFieldType(core.String),
>+  [$url]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("RelatedApplication", html$.RelatedApplication);
>+html$.RelativeOrientationSensor = class RelativeOrientationSensor$ extends html$.OrientationSensor {
>+  static new(sensorOptions) {
>+    if (sensorOptions === void 0) sensorOptions = null;
>+    if (sensorOptions != null) {
>+      let sensorOptions_1 = html_common.convertDartToNative_Dictionary(sensorOptions);
>+      return html$.RelativeOrientationSensor._create_1(sensorOptions_1);
>+    }
>+    return html$.RelativeOrientationSensor._create_2();
>+  }
>+  static _create_1(sensorOptions) {
>+    return new RelativeOrientationSensor(sensorOptions);
>+  }
>+  static _create_2() {
>+    return new RelativeOrientationSensor();
>+  }
>+};
>+dart.addTypeTests(html$.RelativeOrientationSensor);
>+dart.setLibraryUri(html$.RelativeOrientationSensor, "dart:html");
>+dart.registerExtension("RelativeOrientationSensor", html$.RelativeOrientationSensor);
>+html$.RemotePlayback = class RemotePlayback extends html$.EventTarget {
>+  get [$state]() {
>+    return this.state;
>+  }
>+  [$cancelWatchAvailability](id) {
>+    if (id === void 0) id = null;
>+    return html$.promiseToFuture(dart.dynamic, this.cancelWatchAvailability(id));
>+  }
>+  [$prompt]() {
>+    return html$.promiseToFuture(dart.dynamic, this.prompt());
>+  }
>+  [$watchAvailability](callback) {
>+    return html$.promiseToFuture(core.int, this.watchAvailability(callback));
>+  }
>+};
>+dart.addTypeTests(html$.RemotePlayback);
>+const state$4 = Symbol("RemotePlayback.state");
>+dart.setMethodSignature(html$.RemotePlayback, () => ({
>+  __proto__: dart.getMethods(html$.RemotePlayback.__proto__),
>+  [$cancelWatchAvailability]: dart.fnType(async.Future, [], [core.int]),
>+  [$prompt]: dart.fnType(async.Future, []),
>+  [$watchAvailability]: dart.fnType(async.Future$(core.int), [dart.fnType(dart.void, [core.bool])])
>+}));
>+dart.setLibraryUri(html$.RemotePlayback, "dart:html");
>+dart.setFieldSignature(html$.RemotePlayback, () => ({
>+  __proto__: dart.getFields(html$.RemotePlayback.__proto__),
>+  [$state]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("RemotePlayback", html$.RemotePlayback);
>+html$.ReportingObserver = class ReportingObserver$ extends _interceptors.Interceptor {
>+  static new(callback) {
>+    let callback_1 = _js_helper.convertDartClosureToJS(ListAndReportingObserverTovoid(), callback, 2);
>+    return html$.ReportingObserver._create_1(callback_1);
>+  }
>+  static _create_1(callback) {
>+    return new ReportingObserver(callback);
>+  }
>+  [$disconnect](...args) {
>+    return this.disconnect.apply(this, args);
>+  }
>+  [$observe](...args) {
>+    return this.observe.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.ReportingObserver);
>+dart.setMethodSignature(html$.ReportingObserver, () => ({
>+  __proto__: dart.getMethods(html$.ReportingObserver.__proto__),
>+  [$disconnect]: dart.fnType(dart.void, []),
>+  [$observe]: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(html$.ReportingObserver, "dart:html");
>+dart.registerExtension("ReportingObserver", html$.ReportingObserver);
>+html$.ResizeObserver = class ResizeObserver$ extends _interceptors.Interceptor {
>+  static new(callback) {
>+    let callback_1 = _js_helper.convertDartClosureToJS(ListOfResizeObserverEntryAndResizeObserverTovoid(), callback, 2);
>+    return html$.ResizeObserver._create_1(callback_1);
>+  }
>+  static _create_1(callback) {
>+    return new ResizeObserver(callback);
>+  }
>+  [$disconnect](...args) {
>+    return this.disconnect.apply(this, args);
>+  }
>+  [$observe](...args) {
>+    return this.observe.apply(this, args);
>+  }
>+  [$unobserve](...args) {
>+    return this.unobserve.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.ResizeObserver);
>+dart.setMethodSignature(html$.ResizeObserver, () => ({
>+  __proto__: dart.getMethods(html$.ResizeObserver.__proto__),
>+  [$disconnect]: dart.fnType(dart.void, []),
>+  [$observe]: dart.fnType(dart.void, [html$.Element]),
>+  [$unobserve]: dart.fnType(dart.void, [html$.Element])
>+}));
>+dart.setLibraryUri(html$.ResizeObserver, "dart:html");
>+dart.registerExtension("ResizeObserver", html$.ResizeObserver);
>+html$.ResizeObserverEntry = class ResizeObserverEntry extends _interceptors.Interceptor {
>+  get [$contentRect]() {
>+    return this.contentRect;
>+  }
>+  get [$target]() {
>+    return this.target;
>+  }
>+};
>+dart.addTypeTests(html$.ResizeObserverEntry);
>+const contentRect = Symbol("ResizeObserverEntry.contentRect");
>+const target$6 = Symbol("ResizeObserverEntry.target");
>+dart.setLibraryUri(html$.ResizeObserverEntry, "dart:html");
>+dart.setFieldSignature(html$.ResizeObserverEntry, () => ({
>+  __proto__: dart.getFields(html$.ResizeObserverEntry.__proto__),
>+  [$contentRect]: dart.finalFieldType(html$.DomRectReadOnly),
>+  [$target]: dart.finalFieldType(html$.Element)
>+}));
>+dart.registerExtension("ResizeObserverEntry", html$.ResizeObserverEntry);
>+html$.RtcCertificate = class RtcCertificate extends _interceptors.Interceptor {
>+  get [$expires]() {
>+    return this.expires;
>+  }
>+  [$getFingerprints](...args) {
>+    return this.getFingerprints.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.RtcCertificate);
>+const expires = Symbol("RtcCertificate.expires");
>+dart.setMethodSignature(html$.RtcCertificate, () => ({
>+  __proto__: dart.getMethods(html$.RtcCertificate.__proto__),
>+  [$getFingerprints]: dart.fnType(core.List$(core.Map), [])
>+}));
>+dart.setLibraryUri(html$.RtcCertificate, "dart:html");
>+dart.setFieldSignature(html$.RtcCertificate, () => ({
>+  __proto__: dart.getFields(html$.RtcCertificate.__proto__),
>+  [$expires]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("RTCCertificate", html$.RtcCertificate);
>+html$.RtcDataChannel = class RtcDataChannel extends html$.EventTarget {
>+  get [$binaryType]() {
>+    return this.binaryType;
>+  }
>+  set [$binaryType](value) {
>+    this.binaryType = value;
>+  }
>+  get [$bufferedAmount]() {
>+    return this.bufferedAmount;
>+  }
>+  get [$bufferedAmountLowThreshold]() {
>+    return this.bufferedAmountLowThreshold;
>+  }
>+  set [$bufferedAmountLowThreshold](value) {
>+    this.bufferedAmountLowThreshold = value;
>+  }
>+  get [$id]() {
>+    return this.id;
>+  }
>+  get [$label]() {
>+    return this.label;
>+  }
>+  get [$maxRetransmitTime]() {
>+    return this.maxRetransmitTime;
>+  }
>+  get [$maxRetransmits]() {
>+    return this.maxRetransmits;
>+  }
>+  get [$negotiated]() {
>+    return this.negotiated;
>+  }
>+  get [$ordered]() {
>+    return this.ordered;
>+  }
>+  get [$protocol]() {
>+    return this.protocol;
>+  }
>+  get [$readyState]() {
>+    return this.readyState;
>+  }
>+  get [$reliable]() {
>+    return this.reliable;
>+  }
>+  [$close](...args) {
>+    return this.close.apply(this, args);
>+  }
>+  [$send](...args) {
>+    return this.send.apply(this, args);
>+  }
>+  [$sendBlob](...args) {
>+    return this.send.apply(this, args);
>+  }
>+  [$sendByteBuffer](...args) {
>+    return this.send.apply(this, args);
>+  }
>+  [$sendString](...args) {
>+    return this.send.apply(this, args);
>+  }
>+  [$sendTypedData](...args) {
>+    return this.send.apply(this, args);
>+  }
>+  get [$onClose]() {
>+    return html$.RtcDataChannel.closeEvent.forTarget(this);
>+  }
>+  get [$onError]() {
>+    return html$.RtcDataChannel.errorEvent.forTarget(this);
>+  }
>+  get [$onMessage]() {
>+    return html$.RtcDataChannel.messageEvent.forTarget(this);
>+  }
>+  get [$onOpen]() {
>+    return html$.RtcDataChannel.openEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.RtcDataChannel);
>+const binaryType$ = Symbol("RtcDataChannel.binaryType");
>+const bufferedAmount = Symbol("RtcDataChannel.bufferedAmount");
>+const bufferedAmountLowThreshold = Symbol("RtcDataChannel.bufferedAmountLowThreshold");
>+const id$12 = Symbol("RtcDataChannel.id");
>+const label$3 = Symbol("RtcDataChannel.label");
>+const maxRetransmitTime = Symbol("RtcDataChannel.maxRetransmitTime");
>+const maxRetransmits = Symbol("RtcDataChannel.maxRetransmits");
>+const negotiated = Symbol("RtcDataChannel.negotiated");
>+const ordered = Symbol("RtcDataChannel.ordered");
>+const protocol$3 = Symbol("RtcDataChannel.protocol");
>+const readyState$7 = Symbol("RtcDataChannel.readyState");
>+const reliable = Symbol("RtcDataChannel.reliable");
>+dart.setMethodSignature(html$.RtcDataChannel, () => ({
>+  __proto__: dart.getMethods(html$.RtcDataChannel.__proto__),
>+  [$close]: dart.fnType(dart.void, []),
>+  [$send]: dart.fnType(dart.void, [dart.dynamic]),
>+  [$sendBlob]: dart.fnType(dart.void, [html$.Blob]),
>+  [$sendByteBuffer]: dart.fnType(dart.void, [typed_data.ByteBuffer]),
>+  [$sendString]: dart.fnType(dart.void, [core.String]),
>+  [$sendTypedData]: dart.fnType(dart.void, [typed_data.TypedData])
>+}));
>+dart.setGetterSignature(html$.RtcDataChannel, () => ({
>+  __proto__: dart.getGetters(html$.RtcDataChannel.__proto__),
>+  [$onClose]: async.Stream$(html$.Event),
>+  [$onError]: async.Stream$(html$.Event),
>+  [$onMessage]: async.Stream$(html$.MessageEvent),
>+  [$onOpen]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.RtcDataChannel, "dart:html");
>+dart.setFieldSignature(html$.RtcDataChannel, () => ({
>+  __proto__: dart.getFields(html$.RtcDataChannel.__proto__),
>+  [$binaryType]: dart.fieldType(core.String),
>+  [$bufferedAmount]: dart.finalFieldType(core.int),
>+  [$bufferedAmountLowThreshold]: dart.fieldType(core.int),
>+  [$id]: dart.finalFieldType(core.int),
>+  [$label]: dart.finalFieldType(core.String),
>+  [$maxRetransmitTime]: dart.finalFieldType(core.int),
>+  [$maxRetransmits]: dart.finalFieldType(core.int),
>+  [$negotiated]: dart.finalFieldType(core.bool),
>+  [$ordered]: dart.finalFieldType(core.bool),
>+  [$protocol]: dart.finalFieldType(core.String),
>+  [$readyState]: dart.finalFieldType(core.String),
>+  [$reliable]: dart.finalFieldType(core.bool)
>+}));
>+dart.defineLazy(html$.RtcDataChannel, {
>+  /*html$.RtcDataChannel.closeEvent*/get closeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("close"));
>+  },
>+  /*html$.RtcDataChannel.errorEvent*/get errorEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("error"));
>+  },
>+  /*html$.RtcDataChannel.messageEvent*/get messageEvent() {
>+    return dart.const(new (EventStreamProviderOfMessageEvent()).new("message"));
>+  },
>+  /*html$.RtcDataChannel.openEvent*/get openEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("open"));
>+  }
>+});
>+dart.registerExtension("RTCDataChannel", html$.RtcDataChannel);
>+dart.registerExtension("DataChannel", html$.RtcDataChannel);
>+html$.RtcDataChannelEvent = class RtcDataChannelEvent extends html$.Event {
>+  static new(type, eventInitDict) {
>+    let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+    return html$.RtcDataChannelEvent._create_1(type, eventInitDict_1);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new RTCDataChannelEvent(type, eventInitDict);
>+  }
>+  get [$channel]() {
>+    return this.channel;
>+  }
>+};
>+dart.addTypeTests(html$.RtcDataChannelEvent);
>+const channel = Symbol("RtcDataChannelEvent.channel");
>+dart.setLibraryUri(html$.RtcDataChannelEvent, "dart:html");
>+dart.setFieldSignature(html$.RtcDataChannelEvent, () => ({
>+  __proto__: dart.getFields(html$.RtcDataChannelEvent.__proto__),
>+  [$channel]: dart.finalFieldType(html$.RtcDataChannel)
>+}));
>+dart.registerExtension("RTCDataChannelEvent", html$.RtcDataChannelEvent);
>+html$.RtcDtmfSender = class RtcDtmfSender extends html$.EventTarget {
>+  get [$canInsertDtmf]() {
>+    return this.canInsertDTMF;
>+  }
>+  get [$duration]() {
>+    return this.duration;
>+  }
>+  get [$interToneGap]() {
>+    return this.interToneGap;
>+  }
>+  get [$toneBuffer]() {
>+    return this.toneBuffer;
>+  }
>+  get [$track]() {
>+    return this.track;
>+  }
>+  [$insertDtmf](...args) {
>+    return this.insertDTMF.apply(this, args);
>+  }
>+  get [$onToneChange]() {
>+    return html$.RtcDtmfSender.toneChangeEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.RtcDtmfSender);
>+const canInsertDtmf = Symbol("RtcDtmfSender.canInsertDtmf");
>+const duration$4 = Symbol("RtcDtmfSender.duration");
>+const interToneGap = Symbol("RtcDtmfSender.interToneGap");
>+const toneBuffer = Symbol("RtcDtmfSender.toneBuffer");
>+const track$0 = Symbol("RtcDtmfSender.track");
>+dart.setMethodSignature(html$.RtcDtmfSender, () => ({
>+  __proto__: dart.getMethods(html$.RtcDtmfSender.__proto__),
>+  [$insertDtmf]: dart.fnType(dart.void, [core.String], [core.int, core.int])
>+}));
>+dart.setGetterSignature(html$.RtcDtmfSender, () => ({
>+  __proto__: dart.getGetters(html$.RtcDtmfSender.__proto__),
>+  [$onToneChange]: async.Stream$(html$.RtcDtmfToneChangeEvent)
>+}));
>+dart.setLibraryUri(html$.RtcDtmfSender, "dart:html");
>+dart.setFieldSignature(html$.RtcDtmfSender, () => ({
>+  __proto__: dart.getFields(html$.RtcDtmfSender.__proto__),
>+  [$canInsertDtmf]: dart.finalFieldType(core.bool),
>+  [$duration]: dart.finalFieldType(core.int),
>+  [$interToneGap]: dart.finalFieldType(core.int),
>+  [$toneBuffer]: dart.finalFieldType(core.String),
>+  [$track]: dart.finalFieldType(html$.MediaStreamTrack)
>+}));
>+dart.defineLazy(html$.RtcDtmfSender, {
>+  /*html$.RtcDtmfSender.toneChangeEvent*/get toneChangeEvent() {
>+    return dart.const(new (EventStreamProviderOfRtcDtmfToneChangeEvent()).new("tonechange"));
>+  }
>+});
>+dart.registerExtension("RTCDTMFSender", html$.RtcDtmfSender);
>+html$.RtcDtmfToneChangeEvent = class RtcDtmfToneChangeEvent extends html$.Event {
>+  static new(type, eventInitDict) {
>+    let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+    return html$.RtcDtmfToneChangeEvent._create_1(type, eventInitDict_1);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new RTCDTMFToneChangeEvent(type, eventInitDict);
>+  }
>+  get [$tone]() {
>+    return this.tone;
>+  }
>+};
>+dart.addTypeTests(html$.RtcDtmfToneChangeEvent);
>+const tone = Symbol("RtcDtmfToneChangeEvent.tone");
>+dart.setLibraryUri(html$.RtcDtmfToneChangeEvent, "dart:html");
>+dart.setFieldSignature(html$.RtcDtmfToneChangeEvent, () => ({
>+  __proto__: dart.getFields(html$.RtcDtmfToneChangeEvent.__proto__),
>+  [$tone]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("RTCDTMFToneChangeEvent", html$.RtcDtmfToneChangeEvent);
>+html$.RtcIceCandidate = class RtcIceCandidate extends _interceptors.Interceptor {
>+  static new(dictionary) {
>+    let constructorName = window[dart.test(html_common.Device.isFirefox) ? dart.str(html_common.Device.propertyPrefix) + "RTCIceCandidate" : "RTCIceCandidate"];
>+    return new constructorName(html_common.convertDartToNative_SerializedScriptValue(dictionary));
>+  }
>+  get [$candidate]() {
>+    return this.candidate;
>+  }
>+  set [$candidate](value) {
>+    this.candidate = value;
>+  }
>+  get [$sdpMLineIndex]() {
>+    return this.sdpMLineIndex;
>+  }
>+  set [$sdpMLineIndex](value) {
>+    this.sdpMLineIndex = value;
>+  }
>+  get [$sdpMid]() {
>+    return this.sdpMid;
>+  }
>+  set [$sdpMid](value) {
>+    this.sdpMid = value;
>+  }
>+};
>+dart.addTypeTests(html$.RtcIceCandidate);
>+const candidate = Symbol("RtcIceCandidate.candidate");
>+const sdpMLineIndex = Symbol("RtcIceCandidate.sdpMLineIndex");
>+const sdpMid = Symbol("RtcIceCandidate.sdpMid");
>+dart.setLibraryUri(html$.RtcIceCandidate, "dart:html");
>+dart.setFieldSignature(html$.RtcIceCandidate, () => ({
>+  __proto__: dart.getFields(html$.RtcIceCandidate.__proto__),
>+  [$candidate]: dart.fieldType(core.String),
>+  [$sdpMLineIndex]: dart.fieldType(core.int),
>+  [$sdpMid]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("RTCIceCandidate", html$.RtcIceCandidate);
>+dart.registerExtension("mozRTCIceCandidate", html$.RtcIceCandidate);
>+const _get_timestamp = dart.privateName(html$, "_get_timestamp");
>+html$.RtcLegacyStatsReport = class RtcLegacyStatsReport extends _interceptors.Interceptor {
>+  get [$id]() {
>+    return this.id;
>+  }
>+  get [$timestamp]() {
>+    return html_common.convertNativeToDart_DateTime(this[_get_timestamp]);
>+  }
>+  get [_get_timestamp]() {
>+    return this.timestamp;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  [$names](...args) {
>+    return this.names.apply(this, args);
>+  }
>+  [$stat](...args) {
>+    return this.stat.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.RtcLegacyStatsReport);
>+const id$13 = Symbol("RtcLegacyStatsReport.id");
>+const type$26 = Symbol("RtcLegacyStatsReport.type");
>+dart.setMethodSignature(html$.RtcLegacyStatsReport, () => ({
>+  __proto__: dart.getMethods(html$.RtcLegacyStatsReport.__proto__),
>+  [$names]: dart.fnType(core.List$(core.String), []),
>+  [$stat]: dart.fnType(core.String, [core.String])
>+}));
>+dart.setGetterSignature(html$.RtcLegacyStatsReport, () => ({
>+  __proto__: dart.getGetters(html$.RtcLegacyStatsReport.__proto__),
>+  [$timestamp]: core.DateTime
>+}));
>+dart.setLibraryUri(html$.RtcLegacyStatsReport, "dart:html");
>+dart.setFieldSignature(html$.RtcLegacyStatsReport, () => ({
>+  __proto__: dart.getFields(html$.RtcLegacyStatsReport.__proto__),
>+  [$id]: dart.finalFieldType(core.String),
>+  [_get_timestamp]: dart.finalFieldType(dart.dynamic),
>+  [$type]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("RTCLegacyStatsReport", html$.RtcLegacyStatsReport);
>+const _getStats = dart.privateName(html$, "_getStats");
>+const _addStream_1 = dart.privateName(html$, "_addStream_1");
>+const _addStream_2 = dart.privateName(html$, "_addStream_2");
>+const _createDataChannel_1 = dart.privateName(html$, "_createDataChannel_1");
>+const _createDataChannel_2 = dart.privateName(html$, "_createDataChannel_2");
>+const _setConfiguration_1 = dart.privateName(html$, "_setConfiguration_1");
>+html$.RtcPeerConnection = class RtcPeerConnection extends html$.EventTarget {
>+  static new(rtcIceServers, mediaConstraints) {
>+    if (mediaConstraints === void 0) mediaConstraints = null;
>+    let constructorName = window[dart.str(html_common.Device.propertyPrefix) + "RTCPeerConnection"];
>+    if (mediaConstraints != null) {
>+      return new constructorName(html_common.convertDartToNative_SerializedScriptValue(rtcIceServers), html_common.convertDartToNative_SerializedScriptValue(mediaConstraints));
>+    } else {
>+      return new constructorName(html_common.convertDartToNative_SerializedScriptValue(rtcIceServers));
>+    }
>+  }
>+  static get supported() {
>+    try {
>+      html$.RtcPeerConnection.new(new _js_helper.LinkedMap.from(["iceServers", JSArrayOfMapOfString$String().of([new (IdentityMapOfString$String()).from(["url", "stun:localhost"])])]));
>+      return true;
>+    } catch (e) {
>+      let _ = dart.getThrown(e);
>+      return false;
>+    }
>+    return false;
>+  }
>+  [$getLegacyStats](selector) {
>+    if (selector === void 0) selector = null;
>+    let completer = CompleterOfRtcStatsResponse().new();
>+    this[_getStats](dart.fn(value => {
>+      completer.complete(value);
>+    }, RtcStatsResponseToNull()), selector);
>+    return completer.future;
>+  }
>+  [_getStats](...args) {
>+    return this.getStats.apply(this, args);
>+  }
>+  static generateCertificate(keygenAlgorithm) {
>+    return generateCertificate(keygenAlgorithm);
>+  }
>+  get [$iceConnectionState]() {
>+    return this.iceConnectionState;
>+  }
>+  get [$iceGatheringState]() {
>+    return this.iceGatheringState;
>+  }
>+  get [$localDescription]() {
>+    return this.localDescription;
>+  }
>+  get [$remoteDescription]() {
>+    return this.remoteDescription;
>+  }
>+  get [$signalingState]() {
>+    return this.signalingState;
>+  }
>+  [$addIceCandidate](candidate, successCallback, failureCallback) {
>+    if (successCallback === void 0) successCallback = null;
>+    if (failureCallback === void 0) failureCallback = null;
>+    return html$.promiseToFuture(dart.dynamic, this.addIceCandidate(candidate, successCallback, failureCallback));
>+  }
>+  [$addStream](stream, mediaConstraints) {
>+    if (mediaConstraints === void 0) mediaConstraints = null;
>+    if (mediaConstraints != null) {
>+      let mediaConstraints_1 = html_common.convertDartToNative_Dictionary(mediaConstraints);
>+      this[_addStream_1](stream, mediaConstraints_1);
>+      return;
>+    }
>+    this[_addStream_2](stream);
>+    return;
>+  }
>+  [_addStream_1](...args) {
>+    return this.addStream.apply(this, args);
>+  }
>+  [_addStream_2](...args) {
>+    return this.addStream.apply(this, args);
>+  }
>+  [$addTrack](...args) {
>+    return this.addTrack.apply(this, args);
>+  }
>+  [$close](...args) {
>+    return this.close.apply(this, args);
>+  }
>+  [$createAnswer](options) {
>+    if (options === void 0) options = null;
>+    let options_dict = null;
>+    if (options != null) {
>+      options_dict = html_common.convertDartToNative_Dictionary(options);
>+    }
>+    return html$.promiseToFuture(html$.RtcSessionDescription, this.createAnswer(options_dict));
>+  }
>+  [$createDtmfSender](...args) {
>+    return this.createDTMFSender.apply(this, args);
>+  }
>+  [$createDataChannel](label, dataChannelDict) {
>+    if (dataChannelDict === void 0) dataChannelDict = null;
>+    if (dataChannelDict != null) {
>+      let dataChannelDict_1 = html_common.convertDartToNative_Dictionary(dataChannelDict);
>+      return this[_createDataChannel_1](label, dataChannelDict_1);
>+    }
>+    return this[_createDataChannel_2](label);
>+  }
>+  [_createDataChannel_1](...args) {
>+    return this.createDataChannel.apply(this, args);
>+  }
>+  [_createDataChannel_2](...args) {
>+    return this.createDataChannel.apply(this, args);
>+  }
>+  [$createOffer](options) {
>+    if (options === void 0) options = null;
>+    let options_dict = null;
>+    if (options != null) {
>+      options_dict = html_common.convertDartToNative_Dictionary(options);
>+    }
>+    return html$.promiseToFuture(html$.RtcSessionDescription, this.createOffer(options_dict));
>+  }
>+  [$getLocalStreams](...args) {
>+    return this.getLocalStreams.apply(this, args);
>+  }
>+  [$getReceivers](...args) {
>+    return this.getReceivers.apply(this, args);
>+  }
>+  [$getRemoteStreams](...args) {
>+    return this.getRemoteStreams.apply(this, args);
>+  }
>+  [$getSenders](...args) {
>+    return this.getSenders.apply(this, args);
>+  }
>+  [$getStats]() {
>+    return html$.promiseToFuture(html$.RtcStatsReport, this.getStats());
>+  }
>+  [$removeStream](...args) {
>+    return this.removeStream.apply(this, args);
>+  }
>+  [$removeTrack](...args) {
>+    return this.removeTrack.apply(this, args);
>+  }
>+  [$setConfiguration](configuration) {
>+    let configuration_1 = html_common.convertDartToNative_Dictionary(configuration);
>+    this[_setConfiguration_1](configuration_1);
>+    return;
>+  }
>+  [_setConfiguration_1](...args) {
>+    return this.setConfiguration.apply(this, args);
>+  }
>+  [$setLocalDescription](description) {
>+    let description_dict = html_common.convertDartToNative_Dictionary(description);
>+    return html$.promiseToFuture(dart.dynamic, this.setLocalDescription(description_dict));
>+  }
>+  [$setRemoteDescription](description) {
>+    let description_dict = html_common.convertDartToNative_Dictionary(description);
>+    return html$.promiseToFuture(dart.dynamic, this.setRemoteDescription(description_dict));
>+  }
>+  get [$onAddStream]() {
>+    return html$.RtcPeerConnection.addStreamEvent.forTarget(this);
>+  }
>+  get [$onDataChannel]() {
>+    return html$.RtcPeerConnection.dataChannelEvent.forTarget(this);
>+  }
>+  get [$onIceCandidate]() {
>+    return html$.RtcPeerConnection.iceCandidateEvent.forTarget(this);
>+  }
>+  get [$onIceConnectionStateChange]() {
>+    return html$.RtcPeerConnection.iceConnectionStateChangeEvent.forTarget(this);
>+  }
>+  get [$onNegotiationNeeded]() {
>+    return html$.RtcPeerConnection.negotiationNeededEvent.forTarget(this);
>+  }
>+  get [$onRemoveStream]() {
>+    return html$.RtcPeerConnection.removeStreamEvent.forTarget(this);
>+  }
>+  get [$onSignalingStateChange]() {
>+    return html$.RtcPeerConnection.signalingStateChangeEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.RtcPeerConnection);
>+const iceConnectionState = Symbol("RtcPeerConnection.iceConnectionState");
>+const iceGatheringState = Symbol("RtcPeerConnection.iceGatheringState");
>+const localDescription = Symbol("RtcPeerConnection.localDescription");
>+const remoteDescription = Symbol("RtcPeerConnection.remoteDescription");
>+const signalingState = Symbol("RtcPeerConnection.signalingState");
>+dart.setMethodSignature(html$.RtcPeerConnection, () => ({
>+  __proto__: dart.getMethods(html$.RtcPeerConnection.__proto__),
>+  [$getLegacyStats]: dart.fnType(async.Future$(html$.RtcStatsResponse), [], [html$.MediaStreamTrack]),
>+  [_getStats]: dart.fnType(async.Future, [], [dart.fnType(dart.void, [html$.RtcStatsResponse]), html$.MediaStreamTrack]),
>+  [$addIceCandidate]: dart.fnType(async.Future, [core.Object], [dart.fnType(dart.void, []), dart.fnType(dart.void, [html$.DomException])]),
>+  [$addStream]: dart.fnType(dart.void, [html$.MediaStream], [core.Map]),
>+  [_addStream_1]: dart.fnType(dart.void, [html$.MediaStream, dart.dynamic]),
>+  [_addStream_2]: dart.fnType(dart.void, [html$.MediaStream]),
>+  [$addTrack]: dart.fnType(html$.RtcRtpSender, [html$.MediaStreamTrack, html$.MediaStream]),
>+  [$close]: dart.fnType(dart.void, []),
>+  [$createAnswer]: dart.fnType(async.Future$(html$.RtcSessionDescription), [], [core.Map]),
>+  [$createDtmfSender]: dart.fnType(html$.RtcDtmfSender, [html$.MediaStreamTrack]),
>+  [$createDataChannel]: dart.fnType(html$.RtcDataChannel, [core.String], [core.Map]),
>+  [_createDataChannel_1]: dart.fnType(html$.RtcDataChannel, [dart.dynamic, dart.dynamic]),
>+  [_createDataChannel_2]: dart.fnType(html$.RtcDataChannel, [dart.dynamic]),
>+  [$createOffer]: dart.fnType(async.Future$(html$.RtcSessionDescription), [], [core.Map]),
>+  [$getLocalStreams]: dart.fnType(core.List$(html$.MediaStream), []),
>+  [$getReceivers]: dart.fnType(core.List$(html$.RtcRtpReceiver), []),
>+  [$getRemoteStreams]: dart.fnType(core.List$(html$.MediaStream), []),
>+  [$getSenders]: dart.fnType(core.List$(html$.RtcRtpSender), []),
>+  [$getStats]: dart.fnType(async.Future$(html$.RtcStatsReport), []),
>+  [$removeStream]: dart.fnType(dart.void, [html$.MediaStream]),
>+  [$removeTrack]: dart.fnType(dart.void, [html$.RtcRtpSender]),
>+  [$setConfiguration]: dart.fnType(dart.void, [core.Map]),
>+  [_setConfiguration_1]: dart.fnType(dart.void, [dart.dynamic]),
>+  [$setLocalDescription]: dart.fnType(async.Future, [core.Map]),
>+  [$setRemoteDescription]: dart.fnType(async.Future, [core.Map])
>+}));
>+dart.setGetterSignature(html$.RtcPeerConnection, () => ({
>+  __proto__: dart.getGetters(html$.RtcPeerConnection.__proto__),
>+  [$onAddStream]: async.Stream$(html$.MediaStreamEvent),
>+  [$onDataChannel]: async.Stream$(html$.RtcDataChannelEvent),
>+  [$onIceCandidate]: async.Stream$(html$.RtcPeerConnectionIceEvent),
>+  [$onIceConnectionStateChange]: async.Stream$(html$.Event),
>+  [$onNegotiationNeeded]: async.Stream$(html$.Event),
>+  [$onRemoveStream]: async.Stream$(html$.MediaStreamEvent),
>+  [$onSignalingStateChange]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.RtcPeerConnection, "dart:html");
>+dart.setFieldSignature(html$.RtcPeerConnection, () => ({
>+  __proto__: dart.getFields(html$.RtcPeerConnection.__proto__),
>+  [$iceConnectionState]: dart.finalFieldType(core.String),
>+  [$iceGatheringState]: dart.finalFieldType(core.String),
>+  [$localDescription]: dart.finalFieldType(html$.RtcSessionDescription),
>+  [$remoteDescription]: dart.finalFieldType(html$.RtcSessionDescription),
>+  [$signalingState]: dart.finalFieldType(core.String)
>+}));
>+dart.defineLazy(html$.RtcPeerConnection, {
>+  /*html$.RtcPeerConnection.addStreamEvent*/get addStreamEvent() {
>+    return dart.const(new (EventStreamProviderOfMediaStreamEvent()).new("addstream"));
>+  },
>+  /*html$.RtcPeerConnection.dataChannelEvent*/get dataChannelEvent() {
>+    return dart.const(new (EventStreamProviderOfRtcDataChannelEvent()).new("datachannel"));
>+  },
>+  /*html$.RtcPeerConnection.iceCandidateEvent*/get iceCandidateEvent() {
>+    return dart.const(new (EventStreamProviderOfRtcPeerConnectionIceEvent()).new("icecandidate"));
>+  },
>+  /*html$.RtcPeerConnection.iceConnectionStateChangeEvent*/get iceConnectionStateChangeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("iceconnectionstatechange"));
>+  },
>+  /*html$.RtcPeerConnection.negotiationNeededEvent*/get negotiationNeededEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("negotiationneeded"));
>+  },
>+  /*html$.RtcPeerConnection.removeStreamEvent*/get removeStreamEvent() {
>+    return dart.const(new (EventStreamProviderOfMediaStreamEvent()).new("removestream"));
>+  },
>+  /*html$.RtcPeerConnection.signalingStateChangeEvent*/get signalingStateChangeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("signalingstatechange"));
>+  }
>+});
>+dart.registerExtension("RTCPeerConnection", html$.RtcPeerConnection);
>+dart.registerExtension("webkitRTCPeerConnection", html$.RtcPeerConnection);
>+dart.registerExtension("mozRTCPeerConnection", html$.RtcPeerConnection);
>+html$.RtcPeerConnectionIceEvent = class RtcPeerConnectionIceEvent extends html$.Event {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.RtcPeerConnectionIceEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.RtcPeerConnectionIceEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new RTCPeerConnectionIceEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new RTCPeerConnectionIceEvent(type);
>+  }
>+  get [$candidate]() {
>+    return this.candidate;
>+  }
>+};
>+dart.addTypeTests(html$.RtcPeerConnectionIceEvent);
>+const candidate$ = Symbol("RtcPeerConnectionIceEvent.candidate");
>+dart.setLibraryUri(html$.RtcPeerConnectionIceEvent, "dart:html");
>+dart.setFieldSignature(html$.RtcPeerConnectionIceEvent, () => ({
>+  __proto__: dart.getFields(html$.RtcPeerConnectionIceEvent.__proto__),
>+  [$candidate]: dart.finalFieldType(html$.RtcIceCandidate)
>+}));
>+dart.registerExtension("RTCPeerConnectionIceEvent", html$.RtcPeerConnectionIceEvent);
>+html$.RtcRtpContributingSource = class RtcRtpContributingSource extends _interceptors.Interceptor {
>+  get [$source]() {
>+    return this.source;
>+  }
>+  get [$timestamp]() {
>+    return this.timestamp;
>+  }
>+};
>+dart.addTypeTests(html$.RtcRtpContributingSource);
>+const source$2 = Symbol("RtcRtpContributingSource.source");
>+const timestamp$2 = Symbol("RtcRtpContributingSource.timestamp");
>+dart.setLibraryUri(html$.RtcRtpContributingSource, "dart:html");
>+dart.setFieldSignature(html$.RtcRtpContributingSource, () => ({
>+  __proto__: dart.getFields(html$.RtcRtpContributingSource.__proto__),
>+  [$source]: dart.finalFieldType(core.int),
>+  [$timestamp]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("RTCRtpContributingSource", html$.RtcRtpContributingSource);
>+html$.RtcRtpReceiver = class RtcRtpReceiver extends _interceptors.Interceptor {
>+  get [$track]() {
>+    return this.track;
>+  }
>+  [$getContributingSources](...args) {
>+    return this.getContributingSources.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.RtcRtpReceiver);
>+const track$1 = Symbol("RtcRtpReceiver.track");
>+dart.setMethodSignature(html$.RtcRtpReceiver, () => ({
>+  __proto__: dart.getMethods(html$.RtcRtpReceiver.__proto__),
>+  [$getContributingSources]: dart.fnType(core.List$(html$.RtcRtpContributingSource), [])
>+}));
>+dart.setLibraryUri(html$.RtcRtpReceiver, "dart:html");
>+dart.setFieldSignature(html$.RtcRtpReceiver, () => ({
>+  __proto__: dart.getFields(html$.RtcRtpReceiver.__proto__),
>+  [$track]: dart.finalFieldType(html$.MediaStreamTrack)
>+}));
>+dart.registerExtension("RTCRtpReceiver", html$.RtcRtpReceiver);
>+html$.RtcRtpSender = class RtcRtpSender extends _interceptors.Interceptor {
>+  get [$track]() {
>+    return this.track;
>+  }
>+};
>+dart.addTypeTests(html$.RtcRtpSender);
>+const track$2 = Symbol("RtcRtpSender.track");
>+dart.setLibraryUri(html$.RtcRtpSender, "dart:html");
>+dart.setFieldSignature(html$.RtcRtpSender, () => ({
>+  __proto__: dart.getFields(html$.RtcRtpSender.__proto__),
>+  [$track]: dart.finalFieldType(html$.MediaStreamTrack)
>+}));
>+dart.registerExtension("RTCRtpSender", html$.RtcRtpSender);
>+html$.RtcSessionDescription = class RtcSessionDescription extends _interceptors.Interceptor {
>+  static new(dictionary) {
>+    let constructorName = window[dart.test(html_common.Device.isFirefox) ? dart.str(html_common.Device.propertyPrefix) + "RTCSessionDescription" : "RTCSessionDescription"];
>+    return new constructorName(html_common.convertDartToNative_SerializedScriptValue(dictionary));
>+  }
>+  get [$sdp]() {
>+    return this.sdp;
>+  }
>+  set [$sdp](value) {
>+    this.sdp = value;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  set [$type](value) {
>+    this.type = value;
>+  }
>+};
>+dart.addTypeTests(html$.RtcSessionDescription);
>+const sdp = Symbol("RtcSessionDescription.sdp");
>+const type$27 = Symbol("RtcSessionDescription.type");
>+dart.setLibraryUri(html$.RtcSessionDescription, "dart:html");
>+dart.setFieldSignature(html$.RtcSessionDescription, () => ({
>+  __proto__: dart.getFields(html$.RtcSessionDescription.__proto__),
>+  [$sdp]: dart.fieldType(core.String),
>+  [$type]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("RTCSessionDescription", html$.RtcSessionDescription);
>+dart.registerExtension("mozRTCSessionDescription", html$.RtcSessionDescription);
>+const Interceptor_MapMixin$$0 = class Interceptor_MapMixin extends _interceptors.Interceptor {};
>+(Interceptor_MapMixin$$0.new = function() {
>+  Interceptor_MapMixin$$0.__proto__.new.call(this);
>+}).prototype = Interceptor_MapMixin$$0.prototype;
>+dart.applyMixin(Interceptor_MapMixin$$0, collection.MapMixin$(core.String, dart.dynamic));
>+html$.RtcStatsReport = class RtcStatsReport extends Interceptor_MapMixin$$0 {
>+  [_getItem](key) {
>+    return html_common.convertNativeToDart_Dictionary(this.get(key));
>+  }
>+  [$addAll](other) {
>+    MapOfString$dynamic()._check(other);
>+    dart.throw(new core.UnsupportedError.new("Not supported"));
>+  }
>+  [$containsValue](value) {
>+    return this[$values][$any](dart.fn(e => dart.equals(e, value), MapTobool()));
>+  }
>+  [$containsKey](key) {
>+    return this[_getItem](core.String._check(key)) != null;
>+  }
>+  [$_get](key) {
>+    return this[_getItem](core.String._check(key));
>+  }
>+  [$forEach](f) {
>+    let entries = this.entries();
>+    while (true) {
>+      let entry = entries.next();
>+      if (entry.done) return;
>+      f(entry.value[0], html_common.convertNativeToDart_Dictionary(entry.value[1]));
>+    }
>+  }
>+  get [$keys]() {
>+    let keys = JSArrayOfString().of([]);
>+    this[$forEach](dart.fn((k, v) => keys[$add](k), StringAnddynamicTovoid()));
>+    return keys;
>+  }
>+  get [$values]() {
>+    let values = JSArrayOfMap().of([]);
>+    this[$forEach](dart.fn((k, v) => values[$add](core.Map._check(v)), StringAnddynamicTovoid()));
>+    return values;
>+  }
>+  get [$length]() {
>+    return this.size;
>+  }
>+  get [$isEmpty]() {
>+    return this[$length] === 0;
>+  }
>+  get [$isNotEmpty]() {
>+    return !dart.test(this[$isEmpty]);
>+  }
>+  [$_set](key, value) {
>+    core.String._check(key);
>+    dart.throw(new core.UnsupportedError.new("Not supported"));
>+    return value;
>+  }
>+  [$putIfAbsent](key, ifAbsent) {
>+    core.String._check(key);
>+    dart.throw(new core.UnsupportedError.new("Not supported"));
>+  }
>+  [$remove](key) {
>+    dart.throw(new core.UnsupportedError.new("Not supported"));
>+  }
>+  [$clear]() {
>+    dart.throw(new core.UnsupportedError.new("Not supported"));
>+  }
>+};
>+dart.addTypeTests(html$.RtcStatsReport);
>+dart.setMethodSignature(html$.RtcStatsReport, () => ({
>+  __proto__: dart.getMethods(html$.RtcStatsReport.__proto__),
>+  [_getItem]: dart.fnType(core.Map, [core.String]),
>+  [$addAll]: dart.fnType(dart.void, [core.Object]),
>+  [$containsValue]: dart.fnType(core.bool, [dart.dynamic]),
>+  [$containsKey]: dart.fnType(core.bool, [dart.dynamic]),
>+  [$_get]: dart.fnType(core.Map, [dart.dynamic]),
>+  [$forEach]: dart.fnType(dart.void, [dart.fnType(dart.void, [core.String, dart.dynamic])]),
>+  [$_set]: dart.fnType(dart.void, [core.Object, dart.dynamic]),
>+  [$putIfAbsent]: dart.fnType(dart.dynamic, [core.Object, dart.fnType(dart.dynamic, [])]),
>+  [$remove]: dart.fnType(core.String, [dart.dynamic]),
>+  [$clear]: dart.fnType(dart.void, [])
>+}));
>+dart.setGetterSignature(html$.RtcStatsReport, () => ({
>+  __proto__: dart.getGetters(html$.RtcStatsReport.__proto__),
>+  [$keys]: core.Iterable$(core.String),
>+  [$values]: core.Iterable$(core.Map),
>+  [$length]: core.int,
>+  [$isEmpty]: core.bool,
>+  [$isNotEmpty]: core.bool
>+}));
>+dart.setLibraryUri(html$.RtcStatsReport, "dart:html");
>+dart.registerExtension("RTCStatsReport", html$.RtcStatsReport);
>+html$.RtcStatsResponse = class RtcStatsResponse extends _interceptors.Interceptor {
>+  [$namedItem](...args) {
>+    return this.namedItem.apply(this, args);
>+  }
>+  [$result](...args) {
>+    return this.result.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.RtcStatsResponse);
>+dart.setMethodSignature(html$.RtcStatsResponse, () => ({
>+  __proto__: dart.getMethods(html$.RtcStatsResponse.__proto__),
>+  [$namedItem]: dart.fnType(html$.RtcLegacyStatsReport, [core.String]),
>+  [$result]: dart.fnType(core.List$(html$.RtcLegacyStatsReport), [])
>+}));
>+dart.setLibraryUri(html$.RtcStatsResponse, "dart:html");
>+dart.registerExtension("RTCStatsResponse", html$.RtcStatsResponse);
>+html$.RtcTrackEvent = class RtcTrackEvent extends html$.Event {
>+  static new(type, eventInitDict) {
>+    let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+    return html$.RtcTrackEvent._create_1(type, eventInitDict_1);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new RTCTrackEvent(type, eventInitDict);
>+  }
>+  get [$receiver]() {
>+    return this.receiver;
>+  }
>+  get [$streams]() {
>+    return this.streams;
>+  }
>+  get [$track]() {
>+    return this.track;
>+  }
>+};
>+dart.addTypeTests(html$.RtcTrackEvent);
>+const receiver$ = Symbol("RtcTrackEvent.receiver");
>+const streams = Symbol("RtcTrackEvent.streams");
>+const track$3 = Symbol("RtcTrackEvent.track");
>+dart.setLibraryUri(html$.RtcTrackEvent, "dart:html");
>+dart.setFieldSignature(html$.RtcTrackEvent, () => ({
>+  __proto__: dart.getFields(html$.RtcTrackEvent.__proto__),
>+  [$receiver]: dart.finalFieldType(html$.RtcRtpReceiver),
>+  [$streams]: dart.finalFieldType(ListOfMediaStream()),
>+  [$track]: dart.finalFieldType(html$.MediaStreamTrack)
>+}));
>+dart.registerExtension("RTCTrackEvent", html$.RtcTrackEvent);
>+const _availLeft = dart.privateName(html$, "_availLeft");
>+const _availTop = dart.privateName(html$, "_availTop");
>+const _availWidth = dart.privateName(html$, "_availWidth");
>+const _availHeight = dart.privateName(html$, "_availHeight");
>+html$.Screen = class Screen extends _interceptors.Interceptor {
>+  get [$available]() {
>+    return new (RectangleOfnum()).new(this[_availLeft], this[_availTop], this[_availWidth], this[_availHeight]);
>+  }
>+  get [_availHeight]() {
>+    return this.availHeight;
>+  }
>+  get [_availLeft]() {
>+    return this.availLeft;
>+  }
>+  get [_availTop]() {
>+    return this.availTop;
>+  }
>+  get [_availWidth]() {
>+    return this.availWidth;
>+  }
>+  get [$colorDepth]() {
>+    return this.colorDepth;
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$keepAwake]() {
>+    return this.keepAwake;
>+  }
>+  set [$keepAwake](value) {
>+    this.keepAwake = value;
>+  }
>+  get [$orientation]() {
>+    return this.orientation;
>+  }
>+  get [$pixelDepth]() {
>+    return this.pixelDepth;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+};
>+dart.addTypeTests(html$.Screen);
>+const colorDepth = Symbol("Screen.colorDepth");
>+const height$10 = Symbol("Screen.height");
>+const keepAwake = Symbol("Screen.keepAwake");
>+const orientation$0 = Symbol("Screen.orientation");
>+const pixelDepth = Symbol("Screen.pixelDepth");
>+const width$10 = Symbol("Screen.width");
>+dart.setGetterSignature(html$.Screen, () => ({
>+  __proto__: dart.getGetters(html$.Screen.__proto__),
>+  [$available]: math.Rectangle$(core.num)
>+}));
>+dart.setLibraryUri(html$.Screen, "dart:html");
>+dart.setFieldSignature(html$.Screen, () => ({
>+  __proto__: dart.getFields(html$.Screen.__proto__),
>+  [_availHeight]: dart.finalFieldType(core.int),
>+  [_availLeft]: dart.finalFieldType(core.int),
>+  [_availTop]: dart.finalFieldType(core.int),
>+  [_availWidth]: dart.finalFieldType(core.int),
>+  [$colorDepth]: dart.finalFieldType(core.int),
>+  [$height]: dart.finalFieldType(core.int),
>+  [$keepAwake]: dart.fieldType(core.bool),
>+  [$orientation]: dart.finalFieldType(html$.ScreenOrientation),
>+  [$pixelDepth]: dart.finalFieldType(core.int),
>+  [$width]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("Screen", html$.Screen);
>+html$.ScreenOrientation = class ScreenOrientation extends html$.EventTarget {
>+  get [$angle]() {
>+    return this.angle;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  [$lock](orientation) {
>+    return html$.promiseToFuture(dart.dynamic, this.lock(orientation));
>+  }
>+  [$unlock](...args) {
>+    return this.unlock.apply(this, args);
>+  }
>+  get [$onChange]() {
>+    return html$.ScreenOrientation.changeEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.ScreenOrientation);
>+const angle$ = Symbol("ScreenOrientation.angle");
>+const type$28 = Symbol("ScreenOrientation.type");
>+dart.setMethodSignature(html$.ScreenOrientation, () => ({
>+  __proto__: dart.getMethods(html$.ScreenOrientation.__proto__),
>+  [$lock]: dart.fnType(async.Future, [core.String]),
>+  [$unlock]: dart.fnType(dart.void, [])
>+}));
>+dart.setGetterSignature(html$.ScreenOrientation, () => ({
>+  __proto__: dart.getGetters(html$.ScreenOrientation.__proto__),
>+  [$onChange]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.ScreenOrientation, "dart:html");
>+dart.setFieldSignature(html$.ScreenOrientation, () => ({
>+  __proto__: dart.getFields(html$.ScreenOrientation.__proto__),
>+  [$angle]: dart.finalFieldType(core.int),
>+  [$type]: dart.finalFieldType(core.String)
>+}));
>+dart.defineLazy(html$.ScreenOrientation, {
>+  /*html$.ScreenOrientation.changeEvent*/get changeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("change"));
>+  }
>+});
>+dart.registerExtension("ScreenOrientation", html$.ScreenOrientation);
>+html$.ScriptElement = class ScriptElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("script");
>+  }
>+  get [$async]() {
>+    return this.async;
>+  }
>+  set [$async](value) {
>+    this.async = value;
>+  }
>+  get [$charset]() {
>+    return this.charset;
>+  }
>+  set [$charset](value) {
>+    this.charset = value;
>+  }
>+  get [$crossOrigin]() {
>+    return this.crossOrigin;
>+  }
>+  set [$crossOrigin](value) {
>+    this.crossOrigin = value;
>+  }
>+  get [$defer]() {
>+    return this.defer;
>+  }
>+  set [$defer](value) {
>+    this.defer = value;
>+  }
>+  get [$integrity]() {
>+    return this.integrity;
>+  }
>+  set [$integrity](value) {
>+    this.integrity = value;
>+  }
>+  get [$noModule]() {
>+    return this.noModule;
>+  }
>+  set [$noModule](value) {
>+    this.noModule = value;
>+  }
>+  get [$src]() {
>+    return this.src;
>+  }
>+  set [$src](value) {
>+    this.src = value;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  set [$type](value) {
>+    this.type = value;
>+  }
>+};
>+(html$.ScriptElement.created = function() {
>+  this[async$0] = null;
>+  this[charset] = null;
>+  this[crossOrigin$1] = null;
>+  this[defer] = null;
>+  this[integrity$] = null;
>+  this[noModule] = null;
>+  this[src$4] = null;
>+  this[type$29] = null;
>+  html$.ScriptElement.__proto__.created.call(this);
>+}).prototype = html$.ScriptElement.prototype;
>+dart.addTypeTests(html$.ScriptElement);
>+const async$0 = Symbol("ScriptElement.async");
>+const charset = Symbol("ScriptElement.charset");
>+const crossOrigin$1 = Symbol("ScriptElement.crossOrigin");
>+const defer = Symbol("ScriptElement.defer");
>+const integrity$ = Symbol("ScriptElement.integrity");
>+const noModule = Symbol("ScriptElement.noModule");
>+const src$4 = Symbol("ScriptElement.src");
>+const type$29 = Symbol("ScriptElement.type");
>+dart.setLibraryUri(html$.ScriptElement, "dart:html");
>+dart.setFieldSignature(html$.ScriptElement, () => ({
>+  __proto__: dart.getFields(html$.ScriptElement.__proto__),
>+  [$async]: dart.fieldType(core.bool),
>+  [$charset]: dart.fieldType(core.String),
>+  [$crossOrigin]: dart.fieldType(core.String),
>+  [$defer]: dart.fieldType(core.bool),
>+  [$integrity]: dart.fieldType(core.String),
>+  [$noModule]: dart.fieldType(core.bool),
>+  [$src]: dart.fieldType(core.String),
>+  [$type]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("HTMLScriptElement", html$.ScriptElement);
>+html$.ScrollState = class ScrollState$ extends _interceptors.Interceptor {
>+  static new(scrollStateInit) {
>+    if (scrollStateInit === void 0) scrollStateInit = null;
>+    if (scrollStateInit != null) {
>+      let scrollStateInit_1 = html_common.convertDartToNative_Dictionary(scrollStateInit);
>+      return html$.ScrollState._create_1(scrollStateInit_1);
>+    }
>+    return html$.ScrollState._create_2();
>+  }
>+  static _create_1(scrollStateInit) {
>+    return new ScrollState(scrollStateInit);
>+  }
>+  static _create_2() {
>+    return new ScrollState();
>+  }
>+  get [$deltaGranularity]() {
>+    return this.deltaGranularity;
>+  }
>+  get [$deltaX]() {
>+    return this.deltaX;
>+  }
>+  get [$deltaY]() {
>+    return this.deltaY;
>+  }
>+  get [$fromUserInput]() {
>+    return this.fromUserInput;
>+  }
>+  get [$inInertialPhase]() {
>+    return this.inInertialPhase;
>+  }
>+  get [$isBeginning]() {
>+    return this.isBeginning;
>+  }
>+  get [$isDirectManipulation]() {
>+    return this.isDirectManipulation;
>+  }
>+  get [$isEnding]() {
>+    return this.isEnding;
>+  }
>+  get [$positionX]() {
>+    return this.positionX;
>+  }
>+  get [$positionY]() {
>+    return this.positionY;
>+  }
>+  get [$velocityX]() {
>+    return this.velocityX;
>+  }
>+  get [$velocityY]() {
>+    return this.velocityY;
>+  }
>+  [$consumeDelta](...args) {
>+    return this.consumeDelta.apply(this, args);
>+  }
>+  [$distributeToScrollChainDescendant](...args) {
>+    return this.distributeToScrollChainDescendant.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.ScrollState);
>+const deltaGranularity = Symbol("ScrollState.deltaGranularity");
>+const deltaX = Symbol("ScrollState.deltaX");
>+const deltaY = Symbol("ScrollState.deltaY");
>+const fromUserInput = Symbol("ScrollState.fromUserInput");
>+const inInertialPhase = Symbol("ScrollState.inInertialPhase");
>+const isBeginning = Symbol("ScrollState.isBeginning");
>+const isDirectManipulation = Symbol("ScrollState.isDirectManipulation");
>+const isEnding = Symbol("ScrollState.isEnding");
>+const positionX = Symbol("ScrollState.positionX");
>+const positionY = Symbol("ScrollState.positionY");
>+const velocityX = Symbol("ScrollState.velocityX");
>+const velocityY = Symbol("ScrollState.velocityY");
>+dart.setMethodSignature(html$.ScrollState, () => ({
>+  __proto__: dart.getMethods(html$.ScrollState.__proto__),
>+  [$consumeDelta]: dart.fnType(dart.void, [core.num, core.num]),
>+  [$distributeToScrollChainDescendant]: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(html$.ScrollState, "dart:html");
>+dart.setFieldSignature(html$.ScrollState, () => ({
>+  __proto__: dart.getFields(html$.ScrollState.__proto__),
>+  [$deltaGranularity]: dart.finalFieldType(core.num),
>+  [$deltaX]: dart.finalFieldType(core.num),
>+  [$deltaY]: dart.finalFieldType(core.num),
>+  [$fromUserInput]: dart.finalFieldType(core.bool),
>+  [$inInertialPhase]: dart.finalFieldType(core.bool),
>+  [$isBeginning]: dart.finalFieldType(core.bool),
>+  [$isDirectManipulation]: dart.finalFieldType(core.bool),
>+  [$isEnding]: dart.finalFieldType(core.bool),
>+  [$positionX]: dart.finalFieldType(core.int),
>+  [$positionY]: dart.finalFieldType(core.int),
>+  [$velocityX]: dart.finalFieldType(core.num),
>+  [$velocityY]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("ScrollState", html$.ScrollState);
>+html$.ScrollTimeline = class ScrollTimeline$ extends html$.AnimationTimeline {
>+  static new(options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      return html$.ScrollTimeline._create_1(options_1);
>+    }
>+    return html$.ScrollTimeline._create_2();
>+  }
>+  static _create_1(options) {
>+    return new ScrollTimeline(options);
>+  }
>+  static _create_2() {
>+    return new ScrollTimeline();
>+  }
>+  get [$orientation]() {
>+    return this.orientation;
>+  }
>+  get [$scrollSource]() {
>+    return this.scrollSource;
>+  }
>+  get [$timeRange]() {
>+    return this.timeRange;
>+  }
>+};
>+dart.addTypeTests(html$.ScrollTimeline);
>+const orientation$1 = Symbol("ScrollTimeline.orientation");
>+const scrollSource = Symbol("ScrollTimeline.scrollSource");
>+const timeRange = Symbol("ScrollTimeline.timeRange");
>+dart.setLibraryUri(html$.ScrollTimeline, "dart:html");
>+dart.setFieldSignature(html$.ScrollTimeline, () => ({
>+  __proto__: dart.getFields(html$.ScrollTimeline.__proto__),
>+  [$orientation]: dart.finalFieldType(core.String),
>+  [$scrollSource]: dart.finalFieldType(html$.Element),
>+  [$timeRange]: dart.finalFieldType(core.Object)
>+}));
>+dart.registerExtension("ScrollTimeline", html$.ScrollTimeline);
>+html$.SecurityPolicyViolationEvent = class SecurityPolicyViolationEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.SecurityPolicyViolationEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.SecurityPolicyViolationEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new SecurityPolicyViolationEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new SecurityPolicyViolationEvent(type);
>+  }
>+  get [$blockedUri]() {
>+    return this.blockedURI;
>+  }
>+  get [$columnNumber]() {
>+    return this.columnNumber;
>+  }
>+  get [$disposition]() {
>+    return this.disposition;
>+  }
>+  get [$documentUri]() {
>+    return this.documentURI;
>+  }
>+  get [$effectiveDirective]() {
>+    return this.effectiveDirective;
>+  }
>+  get [$lineNumber]() {
>+    return this.lineNumber;
>+  }
>+  get [$originalPolicy]() {
>+    return this.originalPolicy;
>+  }
>+  get [$referrer]() {
>+    return this.referrer;
>+  }
>+  get [$sample]() {
>+    return this.sample;
>+  }
>+  get [$sourceFile]() {
>+    return this.sourceFile;
>+  }
>+  get [$statusCode]() {
>+    return this.statusCode;
>+  }
>+  get [$violatedDirective]() {
>+    return this.violatedDirective;
>+  }
>+};
>+dart.addTypeTests(html$.SecurityPolicyViolationEvent);
>+const blockedUri = Symbol("SecurityPolicyViolationEvent.blockedUri");
>+const columnNumber = Symbol("SecurityPolicyViolationEvent.columnNumber");
>+const disposition = Symbol("SecurityPolicyViolationEvent.disposition");
>+const documentUri = Symbol("SecurityPolicyViolationEvent.documentUri");
>+const effectiveDirective = Symbol("SecurityPolicyViolationEvent.effectiveDirective");
>+const lineNumber$0 = Symbol("SecurityPolicyViolationEvent.lineNumber");
>+const originalPolicy = Symbol("SecurityPolicyViolationEvent.originalPolicy");
>+const referrer = Symbol("SecurityPolicyViolationEvent.referrer");
>+const sample = Symbol("SecurityPolicyViolationEvent.sample");
>+const sourceFile$0 = Symbol("SecurityPolicyViolationEvent.sourceFile");
>+const statusCode = Symbol("SecurityPolicyViolationEvent.statusCode");
>+const violatedDirective = Symbol("SecurityPolicyViolationEvent.violatedDirective");
>+dart.setLibraryUri(html$.SecurityPolicyViolationEvent, "dart:html");
>+dart.setFieldSignature(html$.SecurityPolicyViolationEvent, () => ({
>+  __proto__: dart.getFields(html$.SecurityPolicyViolationEvent.__proto__),
>+  [$blockedUri]: dart.finalFieldType(core.String),
>+  [$columnNumber]: dart.finalFieldType(core.int),
>+  [$disposition]: dart.finalFieldType(core.String),
>+  [$documentUri]: dart.finalFieldType(core.String),
>+  [$effectiveDirective]: dart.finalFieldType(core.String),
>+  [$lineNumber]: dart.finalFieldType(core.int),
>+  [$originalPolicy]: dart.finalFieldType(core.String),
>+  [$referrer]: dart.finalFieldType(core.String),
>+  [$sample]: dart.finalFieldType(core.String),
>+  [$sourceFile]: dart.finalFieldType(core.String),
>+  [$statusCode]: dart.finalFieldType(core.int),
>+  [$violatedDirective]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("SecurityPolicyViolationEvent", html$.SecurityPolicyViolationEvent);
>+html$.SelectElement = class SelectElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("select");
>+  }
>+  get [$autofocus]() {
>+    return this.autofocus;
>+  }
>+  set [$autofocus](value) {
>+    this.autofocus = value;
>+  }
>+  get [$disabled]() {
>+    return this.disabled;
>+  }
>+  set [$disabled](value) {
>+    this.disabled = value;
>+  }
>+  get [$form]() {
>+    return this.form;
>+  }
>+  get [$labels]() {
>+    return this.labels;
>+  }
>+  get [$length]() {
>+    return this.length;
>+  }
>+  set [$length](value) {
>+    this.length = value;
>+  }
>+  get [$multiple]() {
>+    return this.multiple;
>+  }
>+  set [$multiple](value) {
>+    this.multiple = value;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+  set [$name](value) {
>+    this.name = value;
>+  }
>+  get [$required]() {
>+    return this.required;
>+  }
>+  set [$required](value) {
>+    this.required = value;
>+  }
>+  get [$selectedIndex]() {
>+    return this.selectedIndex;
>+  }
>+  set [$selectedIndex](value) {
>+    this.selectedIndex = value;
>+  }
>+  get [$size]() {
>+    return this.size;
>+  }
>+  set [$size](value) {
>+    this.size = value;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  get [$validationMessage]() {
>+    return this.validationMessage;
>+  }
>+  get [$validity]() {
>+    return this.validity;
>+  }
>+  get [$value]() {
>+    return this.value;
>+  }
>+  set [$value](value) {
>+    this.value = value;
>+  }
>+  get [$willValidate]() {
>+    return this.willValidate;
>+  }
>+  [__setter__](...args) {
>+    return this.__setter__.apply(this, args);
>+  }
>+  [$add](...args) {
>+    return this.add.apply(this, args);
>+  }
>+  [$checkValidity](...args) {
>+    return this.checkValidity.apply(this, args);
>+  }
>+  [$item](...args) {
>+    return this.item.apply(this, args);
>+  }
>+  [$namedItem](...args) {
>+    return this.namedItem.apply(this, args);
>+  }
>+  [$reportValidity](...args) {
>+    return this.reportValidity.apply(this, args);
>+  }
>+  [$setCustomValidity](...args) {
>+    return this.setCustomValidity.apply(this, args);
>+  }
>+  get [$options]() {
>+    let options = this[$querySelectorAll](html$.OptionElement, "option");
>+    return new (UnmodifiableListViewOfOptionElement()).new(IterableOfOptionElement()._check(dart.dsend(options, 'toList', [])));
>+  }
>+  get [$selectedOptions]() {
>+    if (dart.test(this.multiple)) {
>+      let options = this[$options][$where](dart.fn(o => o.selected, OptionElementTobool()))[$toList]();
>+      return new (UnmodifiableListViewOfOptionElement()).new(options);
>+    } else {
>+      return JSArrayOfOptionElement().of([this[$options][$_get](this.selectedIndex)]);
>+    }
>+  }
>+};
>+(html$.SelectElement.created = function() {
>+  this[autofocus$2] = null;
>+  this[disabled$7] = null;
>+  this[form$6] = null;
>+  this[labels$3] = null;
>+  this[length$12] = null;
>+  this[multiple$1] = null;
>+  this[name$33] = null;
>+  this[required$11] = null;
>+  this[selectedIndex] = null;
>+  this[size$5] = null;
>+  this[type$30] = null;
>+  this[validationMessage$3] = null;
>+  this[validity$3] = null;
>+  this[value$16] = null;
>+  this[willValidate$3] = null;
>+  html$.SelectElement.__proto__.created.call(this);
>+}).prototype = html$.SelectElement.prototype;
>+dart.addTypeTests(html$.SelectElement);
>+const autofocus$2 = Symbol("SelectElement.autofocus");
>+const disabled$7 = Symbol("SelectElement.disabled");
>+const form$6 = Symbol("SelectElement.form");
>+const labels$3 = Symbol("SelectElement.labels");
>+const length$12 = Symbol("SelectElement.length");
>+const multiple$1 = Symbol("SelectElement.multiple");
>+const name$33 = Symbol("SelectElement.name");
>+const required$11 = Symbol("SelectElement.required");
>+const selectedIndex = Symbol("SelectElement.selectedIndex");
>+const size$5 = Symbol("SelectElement.size");
>+const type$30 = Symbol("SelectElement.type");
>+const validationMessage$3 = Symbol("SelectElement.validationMessage");
>+const validity$3 = Symbol("SelectElement.validity");
>+const value$16 = Symbol("SelectElement.value");
>+const willValidate$3 = Symbol("SelectElement.willValidate");
>+dart.setMethodSignature(html$.SelectElement, () => ({
>+  __proto__: dart.getMethods(html$.SelectElement.__proto__),
>+  [__setter__]: dart.fnType(dart.void, [core.int, html$.OptionElement]),
>+  [$add]: dart.fnType(dart.void, [core.Object, core.Object]),
>+  [$checkValidity]: dart.fnType(core.bool, []),
>+  [$item]: dart.fnType(html$.Element, [core.int]),
>+  [$namedItem]: dart.fnType(html$.OptionElement, [core.String]),
>+  [$reportValidity]: dart.fnType(core.bool, []),
>+  [$setCustomValidity]: dart.fnType(dart.void, [core.String])
>+}));
>+dart.setGetterSignature(html$.SelectElement, () => ({
>+  __proto__: dart.getGetters(html$.SelectElement.__proto__),
>+  [$options]: core.List$(html$.OptionElement),
>+  [$selectedOptions]: core.List$(html$.OptionElement)
>+}));
>+dart.setLibraryUri(html$.SelectElement, "dart:html");
>+dart.setFieldSignature(html$.SelectElement, () => ({
>+  __proto__: dart.getFields(html$.SelectElement.__proto__),
>+  [$autofocus]: dart.fieldType(core.bool),
>+  [$disabled]: dart.fieldType(core.bool),
>+  [$form]: dart.finalFieldType(html$.FormElement),
>+  [$labels]: dart.finalFieldType(ListOfNode()),
>+  [$length]: dart.fieldType(core.int),
>+  [$multiple]: dart.fieldType(core.bool),
>+  [$name]: dart.fieldType(core.String),
>+  [$required]: dart.fieldType(core.bool),
>+  [$selectedIndex]: dart.fieldType(core.int),
>+  [$size]: dart.fieldType(core.int),
>+  [$type]: dart.finalFieldType(core.String),
>+  [$validationMessage]: dart.finalFieldType(core.String),
>+  [$validity]: dart.finalFieldType(html$.ValidityState),
>+  [$value]: dart.fieldType(core.String),
>+  [$willValidate]: dart.finalFieldType(core.bool)
>+}));
>+dart.registerExtension("HTMLSelectElement", html$.SelectElement);
>+html$.Selection = class Selection extends _interceptors.Interceptor {
>+  get [$anchorNode]() {
>+    return this.anchorNode;
>+  }
>+  get [$anchorOffset]() {
>+    return this.anchorOffset;
>+  }
>+  get [$baseNode]() {
>+    return this.baseNode;
>+  }
>+  get [$baseOffset]() {
>+    return this.baseOffset;
>+  }
>+  get [$extentNode]() {
>+    return this.extentNode;
>+  }
>+  get [$extentOffset]() {
>+    return this.extentOffset;
>+  }
>+  get [$focusNode]() {
>+    return this.focusNode;
>+  }
>+  get [$focusOffset]() {
>+    return this.focusOffset;
>+  }
>+  get [$isCollapsed]() {
>+    return this.isCollapsed;
>+  }
>+  get [$rangeCount]() {
>+    return this.rangeCount;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  [$addRange](...args) {
>+    return this.addRange.apply(this, args);
>+  }
>+  [$collapse](...args) {
>+    return this.collapse.apply(this, args);
>+  }
>+  [$collapseToEnd](...args) {
>+    return this.collapseToEnd.apply(this, args);
>+  }
>+  [$collapseToStart](...args) {
>+    return this.collapseToStart.apply(this, args);
>+  }
>+  [$containsNode](...args) {
>+    return this.containsNode.apply(this, args);
>+  }
>+  [$deleteFromDocument](...args) {
>+    return this.deleteFromDocument.apply(this, args);
>+  }
>+  [$empty](...args) {
>+    return this.empty.apply(this, args);
>+  }
>+  [$extend](...args) {
>+    return this.extend.apply(this, args);
>+  }
>+  [$getRangeAt](...args) {
>+    return this.getRangeAt.apply(this, args);
>+  }
>+  [$modify](...args) {
>+    return this.modify.apply(this, args);
>+  }
>+  [$removeAllRanges](...args) {
>+    return this.removeAllRanges.apply(this, args);
>+  }
>+  [$removeRange](...args) {
>+    return this.removeRange.apply(this, args);
>+  }
>+  [$selectAllChildren](...args) {
>+    return this.selectAllChildren.apply(this, args);
>+  }
>+  [$setBaseAndExtent](...args) {
>+    return this.setBaseAndExtent.apply(this, args);
>+  }
>+  [$setPosition](...args) {
>+    return this.setPosition.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.Selection);
>+const anchorNode = Symbol("Selection.anchorNode");
>+const anchorOffset = Symbol("Selection.anchorOffset");
>+const baseNode = Symbol("Selection.baseNode");
>+const baseOffset = Symbol("Selection.baseOffset");
>+const extentNode = Symbol("Selection.extentNode");
>+const extentOffset = Symbol("Selection.extentOffset");
>+const focusNode = Symbol("Selection.focusNode");
>+const focusOffset = Symbol("Selection.focusOffset");
>+const isCollapsed = Symbol("Selection.isCollapsed");
>+const rangeCount = Symbol("Selection.rangeCount");
>+const type$31 = Symbol("Selection.type");
>+dart.setMethodSignature(html$.Selection, () => ({
>+  __proto__: dart.getMethods(html$.Selection.__proto__),
>+  [$addRange]: dart.fnType(dart.void, [html$.Range]),
>+  [$collapse]: dart.fnType(dart.void, [html$.Node], [core.int]),
>+  [$collapseToEnd]: dart.fnType(dart.void, []),
>+  [$collapseToStart]: dart.fnType(dart.void, []),
>+  [$containsNode]: dart.fnType(core.bool, [html$.Node], [core.bool]),
>+  [$deleteFromDocument]: dart.fnType(dart.void, []),
>+  [$empty]: dart.fnType(dart.void, []),
>+  [$extend]: dart.fnType(dart.void, [html$.Node], [core.int]),
>+  [$getRangeAt]: dart.fnType(html$.Range, [core.int]),
>+  [$modify]: dart.fnType(dart.void, [core.String, core.String, core.String]),
>+  [$removeAllRanges]: dart.fnType(dart.void, []),
>+  [$removeRange]: dart.fnType(dart.void, [html$.Range]),
>+  [$selectAllChildren]: dart.fnType(dart.void, [html$.Node]),
>+  [$setBaseAndExtent]: dart.fnType(dart.void, [html$.Node, core.int, html$.Node, core.int]),
>+  [$setPosition]: dart.fnType(dart.void, [html$.Node], [core.int])
>+}));
>+dart.setLibraryUri(html$.Selection, "dart:html");
>+dart.setFieldSignature(html$.Selection, () => ({
>+  __proto__: dart.getFields(html$.Selection.__proto__),
>+  [$anchorNode]: dart.finalFieldType(html$.Node),
>+  [$anchorOffset]: dart.finalFieldType(core.int),
>+  [$baseNode]: dart.finalFieldType(html$.Node),
>+  [$baseOffset]: dart.finalFieldType(core.int),
>+  [$extentNode]: dart.finalFieldType(html$.Node),
>+  [$extentOffset]: dart.finalFieldType(core.int),
>+  [$focusNode]: dart.finalFieldType(html$.Node),
>+  [$focusOffset]: dart.finalFieldType(core.int),
>+  [$isCollapsed]: dart.finalFieldType(core.bool),
>+  [$rangeCount]: dart.finalFieldType(core.int),
>+  [$type]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("Selection", html$.Selection);
>+html$.SensorErrorEvent = class SensorErrorEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+    return html$.SensorErrorEvent._create_1(type, eventInitDict_1);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new SensorErrorEvent(type, eventInitDict);
>+  }
>+  get [$error]() {
>+    return this.error;
>+  }
>+};
>+dart.addTypeTests(html$.SensorErrorEvent);
>+const error$5 = Symbol("SensorErrorEvent.error");
>+dart.setLibraryUri(html$.SensorErrorEvent, "dart:html");
>+dart.setFieldSignature(html$.SensorErrorEvent, () => ({
>+  __proto__: dart.getFields(html$.SensorErrorEvent.__proto__),
>+  [$error]: dart.finalFieldType(html$.DomException)
>+}));
>+dart.registerExtension("SensorErrorEvent", html$.SensorErrorEvent);
>+html$.ServiceWorker = class ServiceWorker extends html$.EventTarget {
>+  get [$scriptUrl]() {
>+    return this.scriptURL;
>+  }
>+  get [$state]() {
>+    return this.state;
>+  }
>+  [$postMessage](message, transfer) {
>+    if (transfer === void 0) transfer = null;
>+    if (transfer != null) {
>+      let message_1 = html_common.convertDartToNative_SerializedScriptValue(message);
>+      this[_postMessage_1](message_1, transfer);
>+      return;
>+    }
>+    let message_1 = html_common.convertDartToNative_SerializedScriptValue(message);
>+    this[_postMessage_2](message_1);
>+    return;
>+  }
>+  [_postMessage_1](...args) {
>+    return this.postMessage.apply(this, args);
>+  }
>+  [_postMessage_2](...args) {
>+    return this.postMessage.apply(this, args);
>+  }
>+  get [$onError]() {
>+    return html$.ServiceWorker.errorEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.ServiceWorker);
>+const scriptUrl = Symbol("ServiceWorker.scriptUrl");
>+const state$5 = Symbol("ServiceWorker.state");
>+html$.ServiceWorker[dart.implements] = () => [html$.AbstractWorker];
>+dart.setMethodSignature(html$.ServiceWorker, () => ({
>+  __proto__: dart.getMethods(html$.ServiceWorker.__proto__),
>+  [$postMessage]: dart.fnType(dart.void, [dart.dynamic], [core.List$(core.Object)]),
>+  [_postMessage_1]: dart.fnType(dart.void, [dart.dynamic, core.List$(core.Object)]),
>+  [_postMessage_2]: dart.fnType(dart.void, [dart.dynamic])
>+}));
>+dart.setGetterSignature(html$.ServiceWorker, () => ({
>+  __proto__: dart.getGetters(html$.ServiceWorker.__proto__),
>+  [$onError]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.ServiceWorker, "dart:html");
>+dart.setFieldSignature(html$.ServiceWorker, () => ({
>+  __proto__: dart.getFields(html$.ServiceWorker.__proto__),
>+  [$scriptUrl]: dart.finalFieldType(core.String),
>+  [$state]: dart.finalFieldType(core.String)
>+}));
>+dart.defineLazy(html$.ServiceWorker, {
>+  /*html$.ServiceWorker.errorEvent*/get errorEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("error"));
>+  }
>+});
>+dart.registerExtension("ServiceWorker", html$.ServiceWorker);
>+html$.ServiceWorkerContainer = class ServiceWorkerContainer extends html$.EventTarget {
>+  get [$controller]() {
>+    return this.controller;
>+  }
>+  get [$ready]() {
>+    return html$.promiseToFuture(html$.ServiceWorkerRegistration, this.ready);
>+  }
>+  [$getRegistration](documentURL) {
>+    if (documentURL === void 0) documentURL = null;
>+    return html$.promiseToFuture(html$.ServiceWorkerRegistration, this.getRegistration(documentURL));
>+  }
>+  [$getRegistrations]() {
>+    return html$.promiseToFuture(ListOfServiceWorkerRegistration(), this.getRegistrations());
>+  }
>+  [$register](url, options) {
>+    if (options === void 0) options = null;
>+    let options_dict = null;
>+    if (options != null) {
>+      options_dict = html_common.convertDartToNative_Dictionary(options);
>+    }
>+    return html$.promiseToFuture(html$.ServiceWorkerRegistration, this.register(url, options_dict));
>+  }
>+  get [$onMessage]() {
>+    return html$.ServiceWorkerContainer.messageEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.ServiceWorkerContainer);
>+const controller = Symbol("ServiceWorkerContainer.controller");
>+dart.setMethodSignature(html$.ServiceWorkerContainer, () => ({
>+  __proto__: dart.getMethods(html$.ServiceWorkerContainer.__proto__),
>+  [$getRegistration]: dart.fnType(async.Future$(html$.ServiceWorkerRegistration), [], [core.String]),
>+  [$getRegistrations]: dart.fnType(async.Future$(core.List$(html$.ServiceWorkerRegistration)), []),
>+  [$register]: dart.fnType(async.Future$(html$.ServiceWorkerRegistration), [core.String], [core.Map])
>+}));
>+dart.setGetterSignature(html$.ServiceWorkerContainer, () => ({
>+  __proto__: dart.getGetters(html$.ServiceWorkerContainer.__proto__),
>+  [$ready]: async.Future$(html$.ServiceWorkerRegistration),
>+  [$onMessage]: async.Stream$(html$.MessageEvent)
>+}));
>+dart.setLibraryUri(html$.ServiceWorkerContainer, "dart:html");
>+dart.setFieldSignature(html$.ServiceWorkerContainer, () => ({
>+  __proto__: dart.getFields(html$.ServiceWorkerContainer.__proto__),
>+  [$controller]: dart.finalFieldType(html$.ServiceWorker)
>+}));
>+dart.defineLazy(html$.ServiceWorkerContainer, {
>+  /*html$.ServiceWorkerContainer.messageEvent*/get messageEvent() {
>+    return dart.const(new (EventStreamProviderOfMessageEvent()).new("message"));
>+  }
>+});
>+dart.registerExtension("ServiceWorkerContainer", html$.ServiceWorkerContainer);
>+html$.ServiceWorkerGlobalScope = class ServiceWorkerGlobalScope extends html$.WorkerGlobalScope {
>+  get [$clients]() {
>+    return this.clients;
>+  }
>+  get [$registration]() {
>+    return this.registration;
>+  }
>+  [$skipWaiting]() {
>+    return html$.promiseToFuture(dart.dynamic, this.skipWaiting());
>+  }
>+  get [$onActivate]() {
>+    return html$.ServiceWorkerGlobalScope.activateEvent.forTarget(this);
>+  }
>+  get [$onFetch]() {
>+    return html$.ServiceWorkerGlobalScope.fetchEvent.forTarget(this);
>+  }
>+  get [$onForeignfetch]() {
>+    return html$.ServiceWorkerGlobalScope.foreignfetchEvent.forTarget(this);
>+  }
>+  get [$onInstall]() {
>+    return html$.ServiceWorkerGlobalScope.installEvent.forTarget(this);
>+  }
>+  get [$onMessage]() {
>+    return html$.ServiceWorkerGlobalScope.messageEvent.forTarget(this);
>+  }
>+  static get instance() {
>+    return html$.ServiceWorkerGlobalScope.as(html$._workerSelf);
>+  }
>+};
>+dart.addTypeTests(html$.ServiceWorkerGlobalScope);
>+const clients = Symbol("ServiceWorkerGlobalScope.clients");
>+const registration = Symbol("ServiceWorkerGlobalScope.registration");
>+dart.setMethodSignature(html$.ServiceWorkerGlobalScope, () => ({
>+  __proto__: dart.getMethods(html$.ServiceWorkerGlobalScope.__proto__),
>+  [$skipWaiting]: dart.fnType(async.Future, [])
>+}));
>+dart.setGetterSignature(html$.ServiceWorkerGlobalScope, () => ({
>+  __proto__: dart.getGetters(html$.ServiceWorkerGlobalScope.__proto__),
>+  [$onActivate]: async.Stream$(html$.Event),
>+  [$onFetch]: async.Stream$(html$.Event),
>+  [$onForeignfetch]: async.Stream$(html$.ForeignFetchEvent),
>+  [$onInstall]: async.Stream$(html$.Event),
>+  [$onMessage]: async.Stream$(html$.MessageEvent)
>+}));
>+dart.setLibraryUri(html$.ServiceWorkerGlobalScope, "dart:html");
>+dart.setFieldSignature(html$.ServiceWorkerGlobalScope, () => ({
>+  __proto__: dart.getFields(html$.ServiceWorkerGlobalScope.__proto__),
>+  [$clients]: dart.finalFieldType(html$.Clients),
>+  [$registration]: dart.finalFieldType(html$.ServiceWorkerRegistration)
>+}));
>+dart.defineLazy(html$.ServiceWorkerGlobalScope, {
>+  /*html$.ServiceWorkerGlobalScope.activateEvent*/get activateEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("activate"));
>+  },
>+  /*html$.ServiceWorkerGlobalScope.fetchEvent*/get fetchEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("fetch"));
>+  },
>+  /*html$.ServiceWorkerGlobalScope.foreignfetchEvent*/get foreignfetchEvent() {
>+    return dart.const(new (EventStreamProviderOfForeignFetchEvent()).new("foreignfetch"));
>+  },
>+  /*html$.ServiceWorkerGlobalScope.installEvent*/get installEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("install"));
>+  },
>+  /*html$.ServiceWorkerGlobalScope.messageEvent*/get messageEvent() {
>+    return dart.const(new (EventStreamProviderOfMessageEvent()).new("message"));
>+  }
>+});
>+dart.registerExtension("ServiceWorkerGlobalScope", html$.ServiceWorkerGlobalScope);
>+html$.ServiceWorkerRegistration = class ServiceWorkerRegistration extends html$.EventTarget {
>+  get [$active]() {
>+    return this.active;
>+  }
>+  get [$backgroundFetch]() {
>+    return this.backgroundFetch;
>+  }
>+  get [$installing]() {
>+    return this.installing;
>+  }
>+  get [$navigationPreload]() {
>+    return this.navigationPreload;
>+  }
>+  get [$paymentManager]() {
>+    return this.paymentManager;
>+  }
>+  get [$pushManager]() {
>+    return this.pushManager;
>+  }
>+  get [$scope]() {
>+    return this.scope;
>+  }
>+  get [$sync]() {
>+    return this.sync;
>+  }
>+  get [$waiting]() {
>+    return this.waiting;
>+  }
>+  [$getNotifications](filter) {
>+    if (filter === void 0) filter = null;
>+    let filter_dict = null;
>+    if (filter != null) {
>+      filter_dict = html_common.convertDartToNative_Dictionary(filter);
>+    }
>+    return html$.promiseToFuture(ListOfNotification(), this.getNotifications(filter_dict));
>+  }
>+  [$showNotification](title, options) {
>+    if (options === void 0) options = null;
>+    let options_dict = null;
>+    if (options != null) {
>+      options_dict = html_common.convertDartToNative_Dictionary(options);
>+    }
>+    return html$.promiseToFuture(dart.dynamic, this.showNotification(title, options_dict));
>+  }
>+  [$unregister]() {
>+    return html$.promiseToFuture(core.bool, this.unregister());
>+  }
>+  [$update]() {
>+    return html$.promiseToFuture(dart.dynamic, this.update());
>+  }
>+};
>+dart.addTypeTests(html$.ServiceWorkerRegistration);
>+const active$ = Symbol("ServiceWorkerRegistration.active");
>+const backgroundFetch = Symbol("ServiceWorkerRegistration.backgroundFetch");
>+const installing = Symbol("ServiceWorkerRegistration.installing");
>+const navigationPreload = Symbol("ServiceWorkerRegistration.navigationPreload");
>+const paymentManager = Symbol("ServiceWorkerRegistration.paymentManager");
>+const pushManager = Symbol("ServiceWorkerRegistration.pushManager");
>+const scope$ = Symbol("ServiceWorkerRegistration.scope");
>+const sync = Symbol("ServiceWorkerRegistration.sync");
>+const waiting = Symbol("ServiceWorkerRegistration.waiting");
>+dart.setMethodSignature(html$.ServiceWorkerRegistration, () => ({
>+  __proto__: dart.getMethods(html$.ServiceWorkerRegistration.__proto__),
>+  [$getNotifications]: dart.fnType(async.Future$(core.List$(html$.Notification)), [], [core.Map]),
>+  [$showNotification]: dart.fnType(async.Future, [core.String], [core.Map]),
>+  [$unregister]: dart.fnType(async.Future$(core.bool), []),
>+  [$update]: dart.fnType(async.Future, [])
>+}));
>+dart.setLibraryUri(html$.ServiceWorkerRegistration, "dart:html");
>+dart.setFieldSignature(html$.ServiceWorkerRegistration, () => ({
>+  __proto__: dart.getFields(html$.ServiceWorkerRegistration.__proto__),
>+  [$active]: dart.finalFieldType(html$.ServiceWorker),
>+  [$backgroundFetch]: dart.finalFieldType(html$.BackgroundFetchManager),
>+  [$installing]: dart.finalFieldType(html$.ServiceWorker),
>+  [$navigationPreload]: dart.finalFieldType(html$.NavigationPreloadManager),
>+  [$paymentManager]: dart.finalFieldType(html$.PaymentManager),
>+  [$pushManager]: dart.finalFieldType(html$.PushManager),
>+  [$scope]: dart.finalFieldType(core.String),
>+  [$sync]: dart.finalFieldType(html$.SyncManager),
>+  [$waiting]: dart.finalFieldType(html$.ServiceWorker)
>+}));
>+dart.registerExtension("ServiceWorkerRegistration", html$.ServiceWorkerRegistration);
>+html$.ShadowElement = class ShadowElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.ShadowElement._check(html$.document[$createElement]("shadow"));
>+  }
>+  static get supported() {
>+    return html$.Element.isTagSupported("shadow");
>+  }
>+  [$getDistributedNodes](...args) {
>+    return this.getDistributedNodes.apply(this, args);
>+  }
>+};
>+(html$.ShadowElement.created = function() {
>+  html$.ShadowElement.__proto__.created.call(this);
>+}).prototype = html$.ShadowElement.prototype;
>+dart.addTypeTests(html$.ShadowElement);
>+dart.setMethodSignature(html$.ShadowElement, () => ({
>+  __proto__: dart.getMethods(html$.ShadowElement.__proto__),
>+  [$getDistributedNodes]: dart.fnType(core.List$(html$.Node), [])
>+}));
>+dart.setLibraryUri(html$.ShadowElement, "dart:html");
>+dart.registerExtension("HTMLShadowElement", html$.ShadowElement);
>+html$.ShadowRoot = class ShadowRoot extends html$.DocumentFragment {
>+  get [$delegatesFocus]() {
>+    return this.delegatesFocus;
>+  }
>+  get [$host]() {
>+    return this.host;
>+  }
>+  get [$innerHtml]() {
>+    return this.innerHTML;
>+  }
>+  set [$innerHtml](value) {
>+    this.innerHTML = value;
>+  }
>+  get [$mode]() {
>+    return this.mode;
>+  }
>+  get [$olderShadowRoot]() {
>+    return this.olderShadowRoot;
>+  }
>+  get [$activeElement]() {
>+    return this.activeElement;
>+  }
>+  get [$fullscreenElement]() {
>+    return this.fullscreenElement;
>+  }
>+  get [$pointerLockElement]() {
>+    return this.pointerLockElement;
>+  }
>+  get [$styleSheets]() {
>+    return this.styleSheets;
>+  }
>+  [$elementFromPoint](...args) {
>+    return this.elementFromPoint.apply(this, args);
>+  }
>+  [$elementsFromPoint](...args) {
>+    return this.elementsFromPoint.apply(this, args);
>+  }
>+  [$getSelection](...args) {
>+    return this.getSelection.apply(this, args);
>+  }
>+  static get supported() {
>+    return !!(Element.prototype.createShadowRoot || Element.prototype.webkitCreateShadowRoot);
>+  }
>+  static _shadowRootDeprecationReport() {
>+    if (!dart.test(html$.ShadowRoot._shadowRootDeprecationReported)) {
>+      html$.window[$console].warn("ShadowRoot.resetStyleInheritance and ShadowRoot.applyAuthorStyles now deprecated in dart:html.\nPlease remove them from your code.\n");
>+      html$.ShadowRoot._shadowRootDeprecationReported = true;
>+    }
>+  }
>+  get [$resetStyleInheritance]() {
>+    html$.ShadowRoot._shadowRootDeprecationReport();
>+    return false;
>+  }
>+  set [$resetStyleInheritance](value) {
>+    html$.ShadowRoot._shadowRootDeprecationReport();
>+  }
>+  get [$applyAuthorStyles]() {
>+    html$.ShadowRoot._shadowRootDeprecationReport();
>+    return false;
>+  }
>+  set [$applyAuthorStyles](value) {
>+    html$.ShadowRoot._shadowRootDeprecationReport();
>+  }
>+};
>+dart.addTypeTests(html$.ShadowRoot);
>+const delegatesFocus = Symbol("ShadowRoot.delegatesFocus");
>+const host$2 = Symbol("ShadowRoot.host");
>+const innerHtml = Symbol("ShadowRoot.innerHtml");
>+const mode$1 = Symbol("ShadowRoot.mode");
>+const olderShadowRoot = Symbol("ShadowRoot.olderShadowRoot");
>+const activeElement$0 = Symbol("ShadowRoot.activeElement");
>+const fullscreenElement$0 = Symbol("ShadowRoot.fullscreenElement");
>+const pointerLockElement$0 = Symbol("ShadowRoot.pointerLockElement");
>+const styleSheets$ = Symbol("ShadowRoot.styleSheets");
>+html$.ShadowRoot[dart.implements] = () => [html$.DocumentOrShadowRoot];
>+dart.setMethodSignature(html$.ShadowRoot, () => ({
>+  __proto__: dart.getMethods(html$.ShadowRoot.__proto__),
>+  [$elementFromPoint]: dart.fnType(html$.Element, [core.int, core.int]),
>+  [$elementsFromPoint]: dart.fnType(core.List$(html$.Element), [core.int, core.int]),
>+  [$getSelection]: dart.fnType(html$.Selection, [])
>+}));
>+dart.setGetterSignature(html$.ShadowRoot, () => ({
>+  __proto__: dart.getGetters(html$.ShadowRoot.__proto__),
>+  [$resetStyleInheritance]: core.bool,
>+  [$applyAuthorStyles]: core.bool
>+}));
>+dart.setSetterSignature(html$.ShadowRoot, () => ({
>+  __proto__: dart.getSetters(html$.ShadowRoot.__proto__),
>+  [$resetStyleInheritance]: core.bool,
>+  [$applyAuthorStyles]: core.bool
>+}));
>+dart.setLibraryUri(html$.ShadowRoot, "dart:html");
>+dart.setFieldSignature(html$.ShadowRoot, () => ({
>+  __proto__: dart.getFields(html$.ShadowRoot.__proto__),
>+  [$delegatesFocus]: dart.finalFieldType(core.bool),
>+  [$host]: dart.finalFieldType(html$.Element),
>+  [$innerHtml]: dart.fieldType(core.String),
>+  [$mode]: dart.finalFieldType(core.String),
>+  [$olderShadowRoot]: dart.finalFieldType(html$.ShadowRoot),
>+  [$activeElement]: dart.finalFieldType(html$.Element),
>+  [$fullscreenElement]: dart.finalFieldType(html$.Element),
>+  [$pointerLockElement]: dart.finalFieldType(html$.Element),
>+  [$styleSheets]: dart.finalFieldType(ListOfStyleSheet())
>+}));
>+dart.defineLazy(html$.ShadowRoot, {
>+  /*html$.ShadowRoot._shadowRootDeprecationReported*/get _shadowRootDeprecationReported() {
>+    return false;
>+  },
>+  set _shadowRootDeprecationReported(_) {}
>+});
>+dart.registerExtension("ShadowRoot", html$.ShadowRoot);
>+html$.SharedArrayBuffer = class SharedArrayBuffer extends _interceptors.Interceptor {
>+  get [$byteLength]() {
>+    return this.byteLength;
>+  }
>+};
>+dart.addTypeTests(html$.SharedArrayBuffer);
>+const byteLength = Symbol("SharedArrayBuffer.byteLength");
>+dart.setLibraryUri(html$.SharedArrayBuffer, "dart:html");
>+dart.setFieldSignature(html$.SharedArrayBuffer, () => ({
>+  __proto__: dart.getFields(html$.SharedArrayBuffer.__proto__),
>+  [$byteLength]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("SharedArrayBuffer", html$.SharedArrayBuffer);
>+html$.SharedWorker = class SharedWorker$ extends html$.EventTarget {
>+  static new(scriptURL, name) {
>+    if (name === void 0) name = null;
>+    if (name != null) {
>+      return html$.SharedWorker._create_1(scriptURL, name);
>+    }
>+    return html$.SharedWorker._create_2(scriptURL);
>+  }
>+  static _create_1(scriptURL, name) {
>+    return new SharedWorker(scriptURL, name);
>+  }
>+  static _create_2(scriptURL) {
>+    return new SharedWorker(scriptURL);
>+  }
>+  get [$port]() {
>+    return this.port;
>+  }
>+  get [$onError]() {
>+    return html$.SharedWorker.errorEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.SharedWorker);
>+const port$5 = Symbol("SharedWorker.port");
>+html$.SharedWorker[dart.implements] = () => [html$.AbstractWorker];
>+dart.setGetterSignature(html$.SharedWorker, () => ({
>+  __proto__: dart.getGetters(html$.SharedWorker.__proto__),
>+  [$onError]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.SharedWorker, "dart:html");
>+dart.setFieldSignature(html$.SharedWorker, () => ({
>+  __proto__: dart.getFields(html$.SharedWorker.__proto__),
>+  [$port]: dart.finalFieldType(html$.MessagePort)
>+}));
>+dart.defineLazy(html$.SharedWorker, {
>+  /*html$.SharedWorker.errorEvent*/get errorEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("error"));
>+  }
>+});
>+dart.registerExtension("SharedWorker", html$.SharedWorker);
>+html$.SharedWorkerGlobalScope = class SharedWorkerGlobalScope extends html$.WorkerGlobalScope {
>+  get [$name]() {
>+    return this.name;
>+  }
>+  [$close](...args) {
>+    return this.close.apply(this, args);
>+  }
>+  [_webkitRequestFileSystem](...args) {
>+    return this.webkitRequestFileSystem.apply(this, args);
>+  }
>+  [$requestFileSystemSync](...args) {
>+    return this.webkitRequestFileSystemSync.apply(this, args);
>+  }
>+  [$resolveLocalFileSystemSyncUrl](...args) {
>+    return this.webkitResolveLocalFileSystemSyncURL.apply(this, args);
>+  }
>+  [_webkitResolveLocalFileSystemUrl](...args) {
>+    return this.webkitResolveLocalFileSystemURL.apply(this, args);
>+  }
>+  get [$onConnect]() {
>+    return html$.SharedWorkerGlobalScope.connectEvent.forTarget(this);
>+  }
>+  static get instance() {
>+    return html$.SharedWorkerGlobalScope.as(html$._workerSelf);
>+  }
>+};
>+dart.addTypeTests(html$.SharedWorkerGlobalScope);
>+const name$34 = Symbol("SharedWorkerGlobalScope.name");
>+dart.setMethodSignature(html$.SharedWorkerGlobalScope, () => ({
>+  __proto__: dart.getMethods(html$.SharedWorkerGlobalScope.__proto__),
>+  [$close]: dart.fnType(dart.void, []),
>+  [_webkitRequestFileSystem]: dart.fnType(dart.void, [core.int, core.int], [dart.fnType(dart.void, [html$.FileSystem]), dart.fnType(dart.void, [html$.DomException])]),
>+  [$requestFileSystemSync]: dart.fnType(html$._DOMFileSystemSync, [core.int, core.int]),
>+  [$resolveLocalFileSystemSyncUrl]: dart.fnType(html$._EntrySync, [core.String]),
>+  [_webkitResolveLocalFileSystemUrl]: dart.fnType(dart.void, [core.String, dart.fnType(dart.void, [html$.Entry])], [dart.fnType(dart.void, [html$.DomException])])
>+}));
>+dart.setGetterSignature(html$.SharedWorkerGlobalScope, () => ({
>+  __proto__: dart.getGetters(html$.SharedWorkerGlobalScope.__proto__),
>+  [$onConnect]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.SharedWorkerGlobalScope, "dart:html");
>+dart.setFieldSignature(html$.SharedWorkerGlobalScope, () => ({
>+  __proto__: dart.getFields(html$.SharedWorkerGlobalScope.__proto__),
>+  [$name]: dart.finalFieldType(core.String)
>+}));
>+dart.defineLazy(html$.SharedWorkerGlobalScope, {
>+  /*html$.SharedWorkerGlobalScope.connectEvent*/get connectEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("connect"));
>+  },
>+  /*html$.SharedWorkerGlobalScope.PERSISTENT*/get PERSISTENT() {
>+    return 1;
>+  },
>+  /*html$.SharedWorkerGlobalScope.TEMPORARY*/get TEMPORARY() {
>+    return 0;
>+  }
>+});
>+dart.registerExtension("SharedWorkerGlobalScope", html$.SharedWorkerGlobalScope);
>+const _assignedNodes_1 = dart.privateName(html$, "_assignedNodes_1");
>+const _assignedNodes_2 = dart.privateName(html$, "_assignedNodes_2");
>+html$.SlotElement = class SlotElement extends html$.HtmlElement {
>+  get [$name]() {
>+    return this.name;
>+  }
>+  set [$name](value) {
>+    this.name = value;
>+  }
>+  [$assignedNodes](options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      return this[_assignedNodes_1](options_1);
>+    }
>+    return this[_assignedNodes_2]();
>+  }
>+  [_assignedNodes_1](...args) {
>+    return this.assignedNodes.apply(this, args);
>+  }
>+  [_assignedNodes_2](...args) {
>+    return this.assignedNodes.apply(this, args);
>+  }
>+};
>+(html$.SlotElement.created = function() {
>+  this[name$35] = null;
>+  html$.SlotElement.__proto__.created.call(this);
>+}).prototype = html$.SlotElement.prototype;
>+dart.addTypeTests(html$.SlotElement);
>+const name$35 = Symbol("SlotElement.name");
>+dart.setMethodSignature(html$.SlotElement, () => ({
>+  __proto__: dart.getMethods(html$.SlotElement.__proto__),
>+  [$assignedNodes]: dart.fnType(core.List$(html$.Node), [], [core.Map]),
>+  [_assignedNodes_1]: dart.fnType(core.List$(html$.Node), [dart.dynamic]),
>+  [_assignedNodes_2]: dart.fnType(core.List$(html$.Node), [])
>+}));
>+dart.setLibraryUri(html$.SlotElement, "dart:html");
>+dart.setFieldSignature(html$.SlotElement, () => ({
>+  __proto__: dart.getFields(html$.SlotElement.__proto__),
>+  [$name]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("HTMLSlotElement", html$.SlotElement);
>+html$.SourceBuffer = class SourceBuffer extends html$.EventTarget {
>+  get [$appendWindowEnd]() {
>+    return this.appendWindowEnd;
>+  }
>+  set [$appendWindowEnd](value) {
>+    this.appendWindowEnd = value;
>+  }
>+  get [$appendWindowStart]() {
>+    return this.appendWindowStart;
>+  }
>+  set [$appendWindowStart](value) {
>+    this.appendWindowStart = value;
>+  }
>+  get [$audioTracks]() {
>+    return this.audioTracks;
>+  }
>+  get [$buffered]() {
>+    return this.buffered;
>+  }
>+  get [$mode]() {
>+    return this.mode;
>+  }
>+  set [$mode](value) {
>+    this.mode = value;
>+  }
>+  get [$timestampOffset]() {
>+    return this.timestampOffset;
>+  }
>+  set [$timestampOffset](value) {
>+    this.timestampOffset = value;
>+  }
>+  get [$trackDefaults]() {
>+    return this.trackDefaults;
>+  }
>+  set [$trackDefaults](value) {
>+    this.trackDefaults = value;
>+  }
>+  get [$updating]() {
>+    return this.updating;
>+  }
>+  get [$videoTracks]() {
>+    return this.videoTracks;
>+  }
>+  [$abort](...args) {
>+    return this.abort.apply(this, args);
>+  }
>+  [$appendBuffer](...args) {
>+    return this.appendBuffer.apply(this, args);
>+  }
>+  [$appendTypedData](...args) {
>+    return this.appendBuffer.apply(this, args);
>+  }
>+  [$remove](...args) {
>+    return this.remove.apply(this, args);
>+  }
>+  get [$onAbort]() {
>+    return html$.SourceBuffer.abortEvent.forTarget(this);
>+  }
>+  get [$onError]() {
>+    return html$.SourceBuffer.errorEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.SourceBuffer);
>+const appendWindowEnd = Symbol("SourceBuffer.appendWindowEnd");
>+const appendWindowStart = Symbol("SourceBuffer.appendWindowStart");
>+const audioTracks$ = Symbol("SourceBuffer.audioTracks");
>+const buffered$ = Symbol("SourceBuffer.buffered");
>+const mode$2 = Symbol("SourceBuffer.mode");
>+const timestampOffset = Symbol("SourceBuffer.timestampOffset");
>+const trackDefaults = Symbol("SourceBuffer.trackDefaults");
>+const updating = Symbol("SourceBuffer.updating");
>+const videoTracks$ = Symbol("SourceBuffer.videoTracks");
>+dart.setMethodSignature(html$.SourceBuffer, () => ({
>+  __proto__: dart.getMethods(html$.SourceBuffer.__proto__),
>+  [$abort]: dart.fnType(dart.void, []),
>+  [$appendBuffer]: dart.fnType(dart.void, [typed_data.ByteBuffer]),
>+  [$appendTypedData]: dart.fnType(dart.void, [typed_data.TypedData]),
>+  [$remove]: dart.fnType(dart.void, [core.num, core.num])
>+}));
>+dart.setGetterSignature(html$.SourceBuffer, () => ({
>+  __proto__: dart.getGetters(html$.SourceBuffer.__proto__),
>+  [$onAbort]: async.Stream$(html$.Event),
>+  [$onError]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.SourceBuffer, "dart:html");
>+dart.setFieldSignature(html$.SourceBuffer, () => ({
>+  __proto__: dart.getFields(html$.SourceBuffer.__proto__),
>+  [$appendWindowEnd]: dart.fieldType(core.num),
>+  [$appendWindowStart]: dart.fieldType(core.num),
>+  [$audioTracks]: dart.finalFieldType(web_audio.AudioTrackList),
>+  [$buffered]: dart.finalFieldType(html$.TimeRanges),
>+  [$mode]: dart.fieldType(core.String),
>+  [$timestampOffset]: dart.fieldType(core.num),
>+  [$trackDefaults]: dart.fieldType(html$.TrackDefaultList),
>+  [$updating]: dart.finalFieldType(core.bool),
>+  [$videoTracks]: dart.finalFieldType(html$.VideoTrackList)
>+}));
>+dart.defineLazy(html$.SourceBuffer, {
>+  /*html$.SourceBuffer.abortEvent*/get abortEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("abort"));
>+  },
>+  /*html$.SourceBuffer.errorEvent*/get errorEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("error"));
>+  }
>+});
>+dart.registerExtension("SourceBuffer", html$.SourceBuffer);
>+const EventTarget_ListMixin$ = class EventTarget_ListMixin extends html$.EventTarget {};
>+(EventTarget_ListMixin$._created = function() {
>+  EventTarget_ListMixin$.__proto__._created.call(this);
>+}).prototype = EventTarget_ListMixin$.prototype;
>+(EventTarget_ListMixin$.__ = function() {
>+  EventTarget_ListMixin$.__proto__.__.call(this);
>+}).prototype = EventTarget_ListMixin$.prototype;
>+dart.applyMixin(EventTarget_ListMixin$, collection.ListMixin$(html$.SourceBuffer));
>+const EventTarget_ImmutableListMixin$ = class EventTarget_ImmutableListMixin extends EventTarget_ListMixin$ {};
>+(EventTarget_ImmutableListMixin$._created = function() {
>+  EventTarget_ImmutableListMixin$.__proto__._created.call(this);
>+}).prototype = EventTarget_ImmutableListMixin$.prototype;
>+(EventTarget_ImmutableListMixin$.__ = function() {
>+  EventTarget_ImmutableListMixin$.__proto__.__.call(this);
>+}).prototype = EventTarget_ImmutableListMixin$.prototype;
>+dart.applyMixin(EventTarget_ImmutableListMixin$, html$.ImmutableListMixin$(html$.SourceBuffer));
>+html$.SourceBufferList = class SourceBufferList extends EventTarget_ImmutableListMixin$ {
>+  get [$length]() {
>+    return this.length;
>+  }
>+  [$_get](index) {
>+    if (index >>> 0 !== index || index >= this[$length]) dart.throw(core.RangeError.index(index, this));
>+    return this[index];
>+  }
>+  [$_set](index, value) {
>+    html$.SourceBuffer._check(value);
>+    dart.throw(new core.UnsupportedError.new("Cannot assign element of immutable List."));
>+    return value;
>+  }
>+  set [$length](value) {
>+    dart.throw(new core.UnsupportedError.new("Cannot resize immutable List."));
>+  }
>+  get [$first]() {
>+    if (dart.notNull(this[$length]) > 0) {
>+      return this[0];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$first](value) {
>+    super[$first] = value;
>+  }
>+  get [$last]() {
>+    let len = this[$length];
>+    if (dart.notNull(len) > 0) {
>+      return this[dart.notNull(len) - 1];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$last](value) {
>+    super[$last] = value;
>+  }
>+  get [$single]() {
>+    let len = this[$length];
>+    if (len === 1) {
>+      return this[0];
>+    }
>+    if (len === 0) dart.throw(new core.StateError.new("No elements"));
>+    dart.throw(new core.StateError.new("More than one element"));
>+  }
>+  [$elementAt](index) {
>+    return this[$_get](index);
>+  }
>+  [$item](...args) {
>+    return this.item.apply(this, args);
>+  }
>+};
>+html$.SourceBufferList.prototype[dart.isList] = true;
>+dart.addTypeTests(html$.SourceBufferList);
>+html$.SourceBufferList[dart.implements] = () => [JavaScriptIndexingBehaviorOfSourceBuffer(), ListOfSourceBuffer()];
>+dart.setMethodSignature(html$.SourceBufferList, () => ({
>+  __proto__: dart.getMethods(html$.SourceBufferList.__proto__),
>+  [$_get]: dart.fnType(html$.SourceBuffer, [core.int]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$elementAt]: dart.fnType(html$.SourceBuffer, [core.int]),
>+  [$item]: dart.fnType(html$.SourceBuffer, [core.int])
>+}));
>+dart.setGetterSignature(html$.SourceBufferList, () => ({
>+  __proto__: dart.getGetters(html$.SourceBufferList.__proto__),
>+  [$length]: core.int,
>+  [$first]: html$.SourceBuffer,
>+  [$last]: html$.SourceBuffer,
>+  [$single]: html$.SourceBuffer
>+}));
>+dart.setSetterSignature(html$.SourceBufferList, () => ({
>+  __proto__: dart.getSetters(html$.SourceBufferList.__proto__),
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(html$.SourceBufferList, "dart:html");
>+dart.registerExtension("SourceBufferList", html$.SourceBufferList);
>+html$.SourceElement = class SourceElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("source");
>+  }
>+  get [$media]() {
>+    return this.media;
>+  }
>+  set [$media](value) {
>+    this.media = value;
>+  }
>+  get [$sizes]() {
>+    return this.sizes;
>+  }
>+  set [$sizes](value) {
>+    this.sizes = value;
>+  }
>+  get [$src]() {
>+    return this.src;
>+  }
>+  set [$src](value) {
>+    this.src = value;
>+  }
>+  get [$srcset]() {
>+    return this.srcset;
>+  }
>+  set [$srcset](value) {
>+    this.srcset = value;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  set [$type](value) {
>+    this.type = value;
>+  }
>+};
>+(html$.SourceElement.created = function() {
>+  this[media$4] = null;
>+  this[sizes$0] = null;
>+  this[src$5] = null;
>+  this[srcset$] = null;
>+  this[type$32] = null;
>+  html$.SourceElement.__proto__.created.call(this);
>+}).prototype = html$.SourceElement.prototype;
>+dart.addTypeTests(html$.SourceElement);
>+const media$4 = Symbol("SourceElement.media");
>+const sizes$0 = Symbol("SourceElement.sizes");
>+const src$5 = Symbol("SourceElement.src");
>+const srcset$ = Symbol("SourceElement.srcset");
>+const type$32 = Symbol("SourceElement.type");
>+dart.setLibraryUri(html$.SourceElement, "dart:html");
>+dart.setFieldSignature(html$.SourceElement, () => ({
>+  __proto__: dart.getFields(html$.SourceElement.__proto__),
>+  [$media]: dart.fieldType(core.String),
>+  [$sizes]: dart.fieldType(core.String),
>+  [$src]: dart.fieldType(core.String),
>+  [$srcset]: dart.fieldType(core.String),
>+  [$type]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("HTMLSourceElement", html$.SourceElement);
>+html$.SpanElement = class SpanElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("span");
>+  }
>+};
>+(html$.SpanElement.created = function() {
>+  html$.SpanElement.__proto__.created.call(this);
>+}).prototype = html$.SpanElement.prototype;
>+dart.addTypeTests(html$.SpanElement);
>+dart.setLibraryUri(html$.SpanElement, "dart:html");
>+dart.registerExtension("HTMLSpanElement", html$.SpanElement);
>+html$.SpeechGrammar = class SpeechGrammar$ extends _interceptors.Interceptor {
>+  static new() {
>+    return html$.SpeechGrammar._create_1();
>+  }
>+  static _create_1() {
>+    return new SpeechGrammar();
>+  }
>+  get [$src]() {
>+    return this.src;
>+  }
>+  set [$src](value) {
>+    this.src = value;
>+  }
>+  get [$weight]() {
>+    return this.weight;
>+  }
>+  set [$weight](value) {
>+    this.weight = value;
>+  }
>+};
>+dart.addTypeTests(html$.SpeechGrammar);
>+const src$6 = Symbol("SpeechGrammar.src");
>+const weight$ = Symbol("SpeechGrammar.weight");
>+dart.setLibraryUri(html$.SpeechGrammar, "dart:html");
>+dart.setFieldSignature(html$.SpeechGrammar, () => ({
>+  __proto__: dart.getFields(html$.SpeechGrammar.__proto__),
>+  [$src]: dart.fieldType(core.String),
>+  [$weight]: dart.fieldType(core.num)
>+}));
>+dart.registerExtension("SpeechGrammar", html$.SpeechGrammar);
>+const Interceptor_ListMixin$$5 = class Interceptor_ListMixin extends _interceptors.Interceptor {};
>+(Interceptor_ListMixin$$5.new = function() {
>+  Interceptor_ListMixin$$5.__proto__.new.call(this);
>+}).prototype = Interceptor_ListMixin$$5.prototype;
>+dart.applyMixin(Interceptor_ListMixin$$5, collection.ListMixin$(html$.SpeechGrammar));
>+const Interceptor_ImmutableListMixin$$5 = class Interceptor_ImmutableListMixin extends Interceptor_ListMixin$$5 {};
>+(Interceptor_ImmutableListMixin$$5.new = function() {
>+  Interceptor_ImmutableListMixin$$5.__proto__.new.call(this);
>+}).prototype = Interceptor_ImmutableListMixin$$5.prototype;
>+dart.applyMixin(Interceptor_ImmutableListMixin$$5, html$.ImmutableListMixin$(html$.SpeechGrammar));
>+html$.SpeechGrammarList = class SpeechGrammarList$ extends Interceptor_ImmutableListMixin$$5 {
>+  static new() {
>+    return html$.SpeechGrammarList._create_1();
>+  }
>+  static _create_1() {
>+    return new SpeechGrammarList();
>+  }
>+  get [$length]() {
>+    return this.length;
>+  }
>+  [$_get](index) {
>+    if (index >>> 0 !== index || index >= this[$length]) dart.throw(core.RangeError.index(index, this));
>+    return this[index];
>+  }
>+  [$_set](index, value) {
>+    html$.SpeechGrammar._check(value);
>+    dart.throw(new core.UnsupportedError.new("Cannot assign element of immutable List."));
>+    return value;
>+  }
>+  set [$length](value) {
>+    dart.throw(new core.UnsupportedError.new("Cannot resize immutable List."));
>+  }
>+  get [$first]() {
>+    if (dart.notNull(this[$length]) > 0) {
>+      return this[0];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$first](value) {
>+    super[$first] = value;
>+  }
>+  get [$last]() {
>+    let len = this[$length];
>+    if (dart.notNull(len) > 0) {
>+      return this[dart.notNull(len) - 1];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$last](value) {
>+    super[$last] = value;
>+  }
>+  get [$single]() {
>+    let len = this[$length];
>+    if (len === 1) {
>+      return this[0];
>+    }
>+    if (len === 0) dart.throw(new core.StateError.new("No elements"));
>+    dart.throw(new core.StateError.new("More than one element"));
>+  }
>+  [$elementAt](index) {
>+    return this[$_get](index);
>+  }
>+  [$addFromString](...args) {
>+    return this.addFromString.apply(this, args);
>+  }
>+  [$addFromUri](...args) {
>+    return this.addFromUri.apply(this, args);
>+  }
>+  [$item](...args) {
>+    return this.item.apply(this, args);
>+  }
>+};
>+html$.SpeechGrammarList.prototype[dart.isList] = true;
>+dart.addTypeTests(html$.SpeechGrammarList);
>+html$.SpeechGrammarList[dart.implements] = () => [JavaScriptIndexingBehaviorOfSpeechGrammar(), ListOfSpeechGrammar()];
>+dart.setMethodSignature(html$.SpeechGrammarList, () => ({
>+  __proto__: dart.getMethods(html$.SpeechGrammarList.__proto__),
>+  [$_get]: dart.fnType(html$.SpeechGrammar, [core.int]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$elementAt]: dart.fnType(html$.SpeechGrammar, [core.int]),
>+  [$addFromString]: dart.fnType(dart.void, [core.String], [core.num]),
>+  [$addFromUri]: dart.fnType(dart.void, [core.String], [core.num]),
>+  [$item]: dart.fnType(html$.SpeechGrammar, [core.int])
>+}));
>+dart.setGetterSignature(html$.SpeechGrammarList, () => ({
>+  __proto__: dart.getGetters(html$.SpeechGrammarList.__proto__),
>+  [$length]: core.int,
>+  [$first]: html$.SpeechGrammar,
>+  [$last]: html$.SpeechGrammar,
>+  [$single]: html$.SpeechGrammar
>+}));
>+dart.setSetterSignature(html$.SpeechGrammarList, () => ({
>+  __proto__: dart.getSetters(html$.SpeechGrammarList.__proto__),
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(html$.SpeechGrammarList, "dart:html");
>+dart.registerExtension("SpeechGrammarList", html$.SpeechGrammarList);
>+html$.SpeechRecognition = class SpeechRecognition extends html$.EventTarget {
>+  static get supported() {
>+    return !!(window.SpeechRecognition || window.webkitSpeechRecognition);
>+  }
>+  get [$audioTrack]() {
>+    return this.audioTrack;
>+  }
>+  set [$audioTrack](value) {
>+    this.audioTrack = value;
>+  }
>+  get [$continuous]() {
>+    return this.continuous;
>+  }
>+  set [$continuous](value) {
>+    this.continuous = value;
>+  }
>+  get [$grammars]() {
>+    return this.grammars;
>+  }
>+  set [$grammars](value) {
>+    this.grammars = value;
>+  }
>+  get [$interimResults]() {
>+    return this.interimResults;
>+  }
>+  set [$interimResults](value) {
>+    this.interimResults = value;
>+  }
>+  get [$lang]() {
>+    return this.lang;
>+  }
>+  set [$lang](value) {
>+    this.lang = value;
>+  }
>+  get [$maxAlternatives]() {
>+    return this.maxAlternatives;
>+  }
>+  set [$maxAlternatives](value) {
>+    this.maxAlternatives = value;
>+  }
>+  [$abort](...args) {
>+    return this.abort.apply(this, args);
>+  }
>+  [$start](...args) {
>+    return this.start.apply(this, args);
>+  }
>+  [$stop](...args) {
>+    return this.stop.apply(this, args);
>+  }
>+  get [$onAudioEnd]() {
>+    return html$.SpeechRecognition.audioEndEvent.forTarget(this);
>+  }
>+  get [$onAudioStart]() {
>+    return html$.SpeechRecognition.audioStartEvent.forTarget(this);
>+  }
>+  get [$onEnd]() {
>+    return html$.SpeechRecognition.endEvent.forTarget(this);
>+  }
>+  get [$onError]() {
>+    return html$.SpeechRecognition.errorEvent.forTarget(this);
>+  }
>+  get [$onNoMatch]() {
>+    return html$.SpeechRecognition.noMatchEvent.forTarget(this);
>+  }
>+  get [$onResult]() {
>+    return html$.SpeechRecognition.resultEvent.forTarget(this);
>+  }
>+  get [$onSoundEnd]() {
>+    return html$.SpeechRecognition.soundEndEvent.forTarget(this);
>+  }
>+  get [$onSoundStart]() {
>+    return html$.SpeechRecognition.soundStartEvent.forTarget(this);
>+  }
>+  get [$onSpeechEnd]() {
>+    return html$.SpeechRecognition.speechEndEvent.forTarget(this);
>+  }
>+  get [$onSpeechStart]() {
>+    return html$.SpeechRecognition.speechStartEvent.forTarget(this);
>+  }
>+  get [$onStart]() {
>+    return html$.SpeechRecognition.startEvent.forTarget(this);
>+  }
>+  static new() {
>+    return new (window.SpeechRecognition || window.webkitSpeechRecognition)();
>+  }
>+};
>+dart.addTypeTests(html$.SpeechRecognition);
>+const audioTrack = Symbol("SpeechRecognition.audioTrack");
>+const continuous = Symbol("SpeechRecognition.continuous");
>+const grammars = Symbol("SpeechRecognition.grammars");
>+const interimResults = Symbol("SpeechRecognition.interimResults");
>+const lang$0 = Symbol("SpeechRecognition.lang");
>+const maxAlternatives = Symbol("SpeechRecognition.maxAlternatives");
>+dart.setMethodSignature(html$.SpeechRecognition, () => ({
>+  __proto__: dart.getMethods(html$.SpeechRecognition.__proto__),
>+  [$abort]: dart.fnType(dart.void, []),
>+  [$start]: dart.fnType(dart.void, []),
>+  [$stop]: dart.fnType(dart.void, [])
>+}));
>+dart.setGetterSignature(html$.SpeechRecognition, () => ({
>+  __proto__: dart.getGetters(html$.SpeechRecognition.__proto__),
>+  [$onAudioEnd]: async.Stream$(html$.Event),
>+  [$onAudioStart]: async.Stream$(html$.Event),
>+  [$onEnd]: async.Stream$(html$.Event),
>+  [$onError]: async.Stream$(html$.SpeechRecognitionError),
>+  [$onNoMatch]: async.Stream$(html$.SpeechRecognitionEvent),
>+  [$onResult]: async.Stream$(html$.SpeechRecognitionEvent),
>+  [$onSoundEnd]: async.Stream$(html$.Event),
>+  [$onSoundStart]: async.Stream$(html$.Event),
>+  [$onSpeechEnd]: async.Stream$(html$.Event),
>+  [$onSpeechStart]: async.Stream$(html$.Event),
>+  [$onStart]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.SpeechRecognition, "dart:html");
>+dart.setFieldSignature(html$.SpeechRecognition, () => ({
>+  __proto__: dart.getFields(html$.SpeechRecognition.__proto__),
>+  [$audioTrack]: dart.fieldType(html$.MediaStreamTrack),
>+  [$continuous]: dart.fieldType(core.bool),
>+  [$grammars]: dart.fieldType(html$.SpeechGrammarList),
>+  [$interimResults]: dart.fieldType(core.bool),
>+  [$lang]: dart.fieldType(core.String),
>+  [$maxAlternatives]: dart.fieldType(core.int)
>+}));
>+dart.defineLazy(html$.SpeechRecognition, {
>+  /*html$.SpeechRecognition.audioEndEvent*/get audioEndEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("audioend"));
>+  },
>+  /*html$.SpeechRecognition.audioStartEvent*/get audioStartEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("audiostart"));
>+  },
>+  /*html$.SpeechRecognition.endEvent*/get endEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("end"));
>+  },
>+  /*html$.SpeechRecognition.errorEvent*/get errorEvent() {
>+    return dart.const(new (EventStreamProviderOfSpeechRecognitionError()).new("error"));
>+  },
>+  /*html$.SpeechRecognition.noMatchEvent*/get noMatchEvent() {
>+    return dart.const(new (EventStreamProviderOfSpeechRecognitionEvent()).new("nomatch"));
>+  },
>+  /*html$.SpeechRecognition.resultEvent*/get resultEvent() {
>+    return dart.const(new (EventStreamProviderOfSpeechRecognitionEvent()).new("result"));
>+  },
>+  /*html$.SpeechRecognition.soundEndEvent*/get soundEndEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("soundend"));
>+  },
>+  /*html$.SpeechRecognition.soundStartEvent*/get soundStartEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("soundstart"));
>+  },
>+  /*html$.SpeechRecognition.speechEndEvent*/get speechEndEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("speechend"));
>+  },
>+  /*html$.SpeechRecognition.speechStartEvent*/get speechStartEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("speechstart"));
>+  },
>+  /*html$.SpeechRecognition.startEvent*/get startEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("start"));
>+  }
>+});
>+dart.registerExtension("SpeechRecognition", html$.SpeechRecognition);
>+html$.SpeechRecognitionAlternative = class SpeechRecognitionAlternative extends _interceptors.Interceptor {
>+  get [$confidence]() {
>+    return this.confidence;
>+  }
>+  get [$transcript]() {
>+    return this.transcript;
>+  }
>+};
>+dart.addTypeTests(html$.SpeechRecognitionAlternative);
>+const confidence = Symbol("SpeechRecognitionAlternative.confidence");
>+const transcript = Symbol("SpeechRecognitionAlternative.transcript");
>+dart.setLibraryUri(html$.SpeechRecognitionAlternative, "dart:html");
>+dart.setFieldSignature(html$.SpeechRecognitionAlternative, () => ({
>+  __proto__: dart.getFields(html$.SpeechRecognitionAlternative.__proto__),
>+  [$confidence]: dart.finalFieldType(core.num),
>+  [$transcript]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("SpeechRecognitionAlternative", html$.SpeechRecognitionAlternative);
>+html$.SpeechRecognitionError = class SpeechRecognitionError$ extends html$.Event {
>+  static new(type, initDict) {
>+    if (initDict === void 0) initDict = null;
>+    if (initDict != null) {
>+      let initDict_1 = html_common.convertDartToNative_Dictionary(initDict);
>+      return html$.SpeechRecognitionError._create_1(type, initDict_1);
>+    }
>+    return html$.SpeechRecognitionError._create_2(type);
>+  }
>+  static _create_1(type, initDict) {
>+    return new SpeechRecognitionError(type, initDict);
>+  }
>+  static _create_2(type) {
>+    return new SpeechRecognitionError(type);
>+  }
>+  get [$error]() {
>+    return this.error;
>+  }
>+  get [$message]() {
>+    return this.message;
>+  }
>+};
>+dart.addTypeTests(html$.SpeechRecognitionError);
>+const error$6 = Symbol("SpeechRecognitionError.error");
>+const message$27 = Symbol("SpeechRecognitionError.message");
>+dart.setLibraryUri(html$.SpeechRecognitionError, "dart:html");
>+dart.setFieldSignature(html$.SpeechRecognitionError, () => ({
>+  __proto__: dart.getFields(html$.SpeechRecognitionError.__proto__),
>+  [$error]: dart.finalFieldType(core.String),
>+  [$message]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("SpeechRecognitionError", html$.SpeechRecognitionError);
>+html$.SpeechRecognitionEvent = class SpeechRecognitionEvent$ extends html$.Event {
>+  static new(type, initDict) {
>+    if (initDict === void 0) initDict = null;
>+    if (initDict != null) {
>+      let initDict_1 = html_common.convertDartToNative_Dictionary(initDict);
>+      return html$.SpeechRecognitionEvent._create_1(type, initDict_1);
>+    }
>+    return html$.SpeechRecognitionEvent._create_2(type);
>+  }
>+  static _create_1(type, initDict) {
>+    return new SpeechRecognitionEvent(type, initDict);
>+  }
>+  static _create_2(type) {
>+    return new SpeechRecognitionEvent(type);
>+  }
>+  get [$emma]() {
>+    return this.emma;
>+  }
>+  get [$interpretation]() {
>+    return this.interpretation;
>+  }
>+  get [$resultIndex]() {
>+    return this.resultIndex;
>+  }
>+  get [$results]() {
>+    return this.results;
>+  }
>+};
>+dart.addTypeTests(html$.SpeechRecognitionEvent);
>+const emma = Symbol("SpeechRecognitionEvent.emma");
>+const interpretation = Symbol("SpeechRecognitionEvent.interpretation");
>+const resultIndex = Symbol("SpeechRecognitionEvent.resultIndex");
>+const results = Symbol("SpeechRecognitionEvent.results");
>+dart.setLibraryUri(html$.SpeechRecognitionEvent, "dart:html");
>+dart.setFieldSignature(html$.SpeechRecognitionEvent, () => ({
>+  __proto__: dart.getFields(html$.SpeechRecognitionEvent.__proto__),
>+  [$emma]: dart.finalFieldType(html$.Document),
>+  [$interpretation]: dart.finalFieldType(html$.Document),
>+  [$resultIndex]: dart.finalFieldType(core.int),
>+  [$results]: dart.finalFieldType(ListOfSpeechRecognitionResult())
>+}));
>+dart.registerExtension("SpeechRecognitionEvent", html$.SpeechRecognitionEvent);
>+html$.SpeechRecognitionResult = class SpeechRecognitionResult extends _interceptors.Interceptor {
>+  get [$isFinal]() {
>+    return this.isFinal;
>+  }
>+  get [$length]() {
>+    return this.length;
>+  }
>+  [$item](...args) {
>+    return this.item.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.SpeechRecognitionResult);
>+const isFinal = Symbol("SpeechRecognitionResult.isFinal");
>+const length$13 = Symbol("SpeechRecognitionResult.length");
>+dart.setMethodSignature(html$.SpeechRecognitionResult, () => ({
>+  __proto__: dart.getMethods(html$.SpeechRecognitionResult.__proto__),
>+  [$item]: dart.fnType(html$.SpeechRecognitionAlternative, [core.int])
>+}));
>+dart.setLibraryUri(html$.SpeechRecognitionResult, "dart:html");
>+dart.setFieldSignature(html$.SpeechRecognitionResult, () => ({
>+  __proto__: dart.getFields(html$.SpeechRecognitionResult.__proto__),
>+  [$isFinal]: dart.finalFieldType(core.bool),
>+  [$length]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("SpeechRecognitionResult", html$.SpeechRecognitionResult);
>+const _getVoices = dart.privateName(html$, "_getVoices");
>+html$.SpeechSynthesis = class SpeechSynthesis extends html$.EventTarget {
>+  [$getVoices]() {
>+    let voices = this[_getVoices]();
>+    if (dart.notNull(voices[$length]) > 0) _js_helper.applyExtension("SpeechSynthesisVoice", voices[$_get](0));
>+    return voices;
>+  }
>+  get [$paused]() {
>+    return this.paused;
>+  }
>+  get [$pending]() {
>+    return this.pending;
>+  }
>+  get [$speaking]() {
>+    return this.speaking;
>+  }
>+  [$cancel](...args) {
>+    return this.cancel.apply(this, args);
>+  }
>+  [_getVoices](...args) {
>+    return this.getVoices.apply(this, args);
>+  }
>+  [$pause](...args) {
>+    return this.pause.apply(this, args);
>+  }
>+  [$resume](...args) {
>+    return this.resume.apply(this, args);
>+  }
>+  [$speak](...args) {
>+    return this.speak.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.SpeechSynthesis);
>+const paused$ = Symbol("SpeechSynthesis.paused");
>+const pending = Symbol("SpeechSynthesis.pending");
>+const speaking = Symbol("SpeechSynthesis.speaking");
>+dart.setMethodSignature(html$.SpeechSynthesis, () => ({
>+  __proto__: dart.getMethods(html$.SpeechSynthesis.__proto__),
>+  [$getVoices]: dart.fnType(core.List$(html$.SpeechSynthesisVoice), []),
>+  [$cancel]: dart.fnType(dart.void, []),
>+  [_getVoices]: dart.fnType(core.List$(html$.SpeechSynthesisVoice), []),
>+  [$pause]: dart.fnType(dart.void, []),
>+  [$resume]: dart.fnType(dart.void, []),
>+  [$speak]: dart.fnType(dart.void, [html$.SpeechSynthesisUtterance])
>+}));
>+dart.setLibraryUri(html$.SpeechSynthesis, "dart:html");
>+dart.setFieldSignature(html$.SpeechSynthesis, () => ({
>+  __proto__: dart.getFields(html$.SpeechSynthesis.__proto__),
>+  [$paused]: dart.finalFieldType(core.bool),
>+  [$pending]: dart.finalFieldType(core.bool),
>+  [$speaking]: dart.finalFieldType(core.bool)
>+}));
>+dart.registerExtension("SpeechSynthesis", html$.SpeechSynthesis);
>+html$.SpeechSynthesisEvent = class SpeechSynthesisEvent extends html$.Event {
>+  get [$charIndex]() {
>+    return this.charIndex;
>+  }
>+  get [$elapsedTime]() {
>+    return this.elapsedTime;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+  get [$utterance]() {
>+    return this.utterance;
>+  }
>+};
>+dart.addTypeTests(html$.SpeechSynthesisEvent);
>+const charIndex = Symbol("SpeechSynthesisEvent.charIndex");
>+const elapsedTime$ = Symbol("SpeechSynthesisEvent.elapsedTime");
>+const name$36 = Symbol("SpeechSynthesisEvent.name");
>+const utterance = Symbol("SpeechSynthesisEvent.utterance");
>+dart.setLibraryUri(html$.SpeechSynthesisEvent, "dart:html");
>+dart.setFieldSignature(html$.SpeechSynthesisEvent, () => ({
>+  __proto__: dart.getFields(html$.SpeechSynthesisEvent.__proto__),
>+  [$charIndex]: dart.finalFieldType(core.int),
>+  [$elapsedTime]: dart.finalFieldType(core.num),
>+  [$name]: dart.finalFieldType(core.String),
>+  [$utterance]: dart.finalFieldType(html$.SpeechSynthesisUtterance)
>+}));
>+dart.registerExtension("SpeechSynthesisEvent", html$.SpeechSynthesisEvent);
>+html$.SpeechSynthesisUtterance = class SpeechSynthesisUtterance$ extends html$.EventTarget {
>+  static new(text) {
>+    if (text === void 0) text = null;
>+    if (text != null) {
>+      return html$.SpeechSynthesisUtterance._create_1(text);
>+    }
>+    return html$.SpeechSynthesisUtterance._create_2();
>+  }
>+  static _create_1(text) {
>+    return new SpeechSynthesisUtterance(text);
>+  }
>+  static _create_2() {
>+    return new SpeechSynthesisUtterance();
>+  }
>+  get [$lang]() {
>+    return this.lang;
>+  }
>+  set [$lang](value) {
>+    this.lang = value;
>+  }
>+  get [$pitch]() {
>+    return this.pitch;
>+  }
>+  set [$pitch](value) {
>+    this.pitch = value;
>+  }
>+  get [$rate]() {
>+    return this.rate;
>+  }
>+  set [$rate](value) {
>+    this.rate = value;
>+  }
>+  get [$text]() {
>+    return this.text;
>+  }
>+  set [$text](value) {
>+    this.text = value;
>+  }
>+  get [$voice]() {
>+    return this.voice;
>+  }
>+  set [$voice](value) {
>+    this.voice = value;
>+  }
>+  get [$volume]() {
>+    return this.volume;
>+  }
>+  set [$volume](value) {
>+    this.volume = value;
>+  }
>+  get [$onBoundary]() {
>+    return html$.SpeechSynthesisUtterance.boundaryEvent.forTarget(this);
>+  }
>+  get [$onEnd]() {
>+    return html$.SpeechSynthesisUtterance.endEvent.forTarget(this);
>+  }
>+  get [$onError]() {
>+    return html$.SpeechSynthesisUtterance.errorEvent.forTarget(this);
>+  }
>+  get [$onMark]() {
>+    return html$.SpeechSynthesisUtterance.markEvent.forTarget(this);
>+  }
>+  get [$onPause]() {
>+    return html$.SpeechSynthesisUtterance.pauseEvent.forTarget(this);
>+  }
>+  get [$onResume]() {
>+    return html$.SpeechSynthesisUtterance.resumeEvent.forTarget(this);
>+  }
>+  get [$onStart]() {
>+    return html$.SpeechSynthesisUtterance.startEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.SpeechSynthesisUtterance);
>+const lang$1 = Symbol("SpeechSynthesisUtterance.lang");
>+const pitch = Symbol("SpeechSynthesisUtterance.pitch");
>+const rate = Symbol("SpeechSynthesisUtterance.rate");
>+const text$0 = Symbol("SpeechSynthesisUtterance.text");
>+const voice = Symbol("SpeechSynthesisUtterance.voice");
>+const volume$ = Symbol("SpeechSynthesisUtterance.volume");
>+dart.setGetterSignature(html$.SpeechSynthesisUtterance, () => ({
>+  __proto__: dart.getGetters(html$.SpeechSynthesisUtterance.__proto__),
>+  [$onBoundary]: async.Stream$(html$.SpeechSynthesisEvent),
>+  [$onEnd]: async.Stream$(html$.SpeechSynthesisEvent),
>+  [$onError]: async.Stream$(html$.Event),
>+  [$onMark]: async.Stream$(html$.SpeechSynthesisEvent),
>+  [$onPause]: async.Stream$(html$.Event),
>+  [$onResume]: async.Stream$(html$.SpeechSynthesisEvent),
>+  [$onStart]: async.Stream$(html$.SpeechSynthesisEvent)
>+}));
>+dart.setLibraryUri(html$.SpeechSynthesisUtterance, "dart:html");
>+dart.setFieldSignature(html$.SpeechSynthesisUtterance, () => ({
>+  __proto__: dart.getFields(html$.SpeechSynthesisUtterance.__proto__),
>+  [$lang]: dart.fieldType(core.String),
>+  [$pitch]: dart.fieldType(core.num),
>+  [$rate]: dart.fieldType(core.num),
>+  [$text]: dart.fieldType(core.String),
>+  [$voice]: dart.fieldType(html$.SpeechSynthesisVoice),
>+  [$volume]: dart.fieldType(core.num)
>+}));
>+dart.defineLazy(html$.SpeechSynthesisUtterance, {
>+  /*html$.SpeechSynthesisUtterance.boundaryEvent*/get boundaryEvent() {
>+    return dart.const(new (EventStreamProviderOfSpeechSynthesisEvent()).new("boundary"));
>+  },
>+  /*html$.SpeechSynthesisUtterance.endEvent*/get endEvent() {
>+    return dart.const(new (EventStreamProviderOfSpeechSynthesisEvent()).new("end"));
>+  },
>+  /*html$.SpeechSynthesisUtterance.errorEvent*/get errorEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("error"));
>+  },
>+  /*html$.SpeechSynthesisUtterance.markEvent*/get markEvent() {
>+    return dart.const(new (EventStreamProviderOfSpeechSynthesisEvent()).new("mark"));
>+  },
>+  /*html$.SpeechSynthesisUtterance.pauseEvent*/get pauseEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("pause"));
>+  },
>+  /*html$.SpeechSynthesisUtterance.resumeEvent*/get resumeEvent() {
>+    return dart.const(new (EventStreamProviderOfSpeechSynthesisEvent()).new("resume"));
>+  },
>+  /*html$.SpeechSynthesisUtterance.startEvent*/get startEvent() {
>+    return dart.const(new (EventStreamProviderOfSpeechSynthesisEvent()).new("start"));
>+  }
>+});
>+dart.registerExtension("SpeechSynthesisUtterance", html$.SpeechSynthesisUtterance);
>+html$.SpeechSynthesisVoice = class SpeechSynthesisVoice extends _interceptors.Interceptor {
>+  get [$defaultValue]() {
>+    return this.default;
>+  }
>+  get [$lang]() {
>+    return this.lang;
>+  }
>+  get [$localService]() {
>+    return this.localService;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+  get [$voiceUri]() {
>+    return this.voiceURI;
>+  }
>+};
>+dart.addTypeTests(html$.SpeechSynthesisVoice);
>+const defaultValue$0 = Symbol("SpeechSynthesisVoice.defaultValue");
>+const lang$2 = Symbol("SpeechSynthesisVoice.lang");
>+const localService = Symbol("SpeechSynthesisVoice.localService");
>+const name$37 = Symbol("SpeechSynthesisVoice.name");
>+const voiceUri = Symbol("SpeechSynthesisVoice.voiceUri");
>+dart.setLibraryUri(html$.SpeechSynthesisVoice, "dart:html");
>+dart.setFieldSignature(html$.SpeechSynthesisVoice, () => ({
>+  __proto__: dart.getFields(html$.SpeechSynthesisVoice.__proto__),
>+  [$defaultValue]: dart.finalFieldType(core.bool),
>+  [$lang]: dart.finalFieldType(core.String),
>+  [$localService]: dart.finalFieldType(core.bool),
>+  [$name]: dart.finalFieldType(core.String),
>+  [$voiceUri]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("SpeechSynthesisVoice", html$.SpeechSynthesisVoice);
>+html$.StaticRange = class StaticRange extends _interceptors.Interceptor {
>+  get [$collapsed]() {
>+    return this.collapsed;
>+  }
>+  get [$endContainer]() {
>+    return this.endContainer;
>+  }
>+  get [$endOffset]() {
>+    return this.endOffset;
>+  }
>+  get [$startContainer]() {
>+    return this.startContainer;
>+  }
>+  get [$startOffset]() {
>+    return this.startOffset;
>+  }
>+};
>+dart.addTypeTests(html$.StaticRange);
>+const collapsed$ = Symbol("StaticRange.collapsed");
>+const endContainer$ = Symbol("StaticRange.endContainer");
>+const endOffset$ = Symbol("StaticRange.endOffset");
>+const startContainer$ = Symbol("StaticRange.startContainer");
>+const startOffset$ = Symbol("StaticRange.startOffset");
>+dart.setLibraryUri(html$.StaticRange, "dart:html");
>+dart.setFieldSignature(html$.StaticRange, () => ({
>+  __proto__: dart.getFields(html$.StaticRange.__proto__),
>+  [$collapsed]: dart.finalFieldType(core.bool),
>+  [$endContainer]: dart.finalFieldType(html$.Node),
>+  [$endOffset]: dart.finalFieldType(core.int),
>+  [$startContainer]: dart.finalFieldType(html$.Node),
>+  [$startOffset]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("StaticRange", html$.StaticRange);
>+const _setItem = dart.privateName(html$, "_setItem");
>+const _removeItem = dart.privateName(html$, "_removeItem");
>+const _key = dart.privateName(html$, "_key");
>+const _length$2 = dart.privateName(html$, "_length");
>+const Interceptor_MapMixin$$1 = class Interceptor_MapMixin extends _interceptors.Interceptor {};
>+(Interceptor_MapMixin$$1.new = function() {
>+  Interceptor_MapMixin$$1.__proto__.new.call(this);
>+}).prototype = Interceptor_MapMixin$$1.prototype;
>+dart.applyMixin(Interceptor_MapMixin$$1, collection.MapMixin$(core.String, core.String));
>+html$.Storage = class Storage extends Interceptor_MapMixin$$1 {
>+  [$addAll](other) {
>+    MapOfString$String()._check(other);
>+    other[$forEach](dart.fn((k, v) => {
>+      this[$_set](k, v);
>+    }, StringAndStringToNull()));
>+  }
>+  [$containsValue](value) {
>+    return this[$values][$any](dart.fn(e => core.identical(e, value), StringTobool()));
>+  }
>+  [$containsKey](key) {
>+    return this[_getItem](core.String._check(key)) != null;
>+  }
>+  [$_get](key) {
>+    return this[_getItem](core.String._check(key));
>+  }
>+  [$_set](key, value) {
>+    core.String._check(key);
>+    core.String._check(value);
>+    this[_setItem](key, value);
>+    return value;
>+  }
>+  [$putIfAbsent](key, ifAbsent) {
>+    core.String._check(key);
>+    VoidToString()._check(ifAbsent);
>+    if (!dart.test(this[$containsKey](key))) this[$_set](key, ifAbsent());
>+    return this[$_get](key);
>+  }
>+  [$remove](key) {
>+    let value = this[$_get](key);
>+    this[_removeItem](core.String._check(key));
>+    return value;
>+  }
>+  [$clear]() {
>+    return this[_clear$0]();
>+  }
>+  [$forEach](f) {
>+    for (let i = 0; true; i++) {
>+      let key = this[_key](i);
>+      if (key == null) return;
>+      f(key, this[$_get](key));
>+    }
>+  }
>+  get [$keys]() {
>+    let keys = JSArrayOfString().of([]);
>+    this[$forEach](dart.fn((k, v) => keys[$add](k), StringAndStringTovoid()));
>+    return keys;
>+  }
>+  get [$values]() {
>+    let values = JSArrayOfString().of([]);
>+    this[$forEach](dart.fn((k, v) => values[$add](v), StringAndStringTovoid()));
>+    return values;
>+  }
>+  get [$length]() {
>+    return this[_length$2];
>+  }
>+  get [$isEmpty]() {
>+    return this[_key](0) == null;
>+  }
>+  get [$isNotEmpty]() {
>+    return !dart.test(this[$isEmpty]);
>+  }
>+  get [_length$2]() {
>+    return this.length;
>+  }
>+  [_clear$0](...args) {
>+    return this.clear.apply(this, args);
>+  }
>+  [_getItem](...args) {
>+    return this.getItem.apply(this, args);
>+  }
>+  [_key](...args) {
>+    return this.key.apply(this, args);
>+  }
>+  [_removeItem](...args) {
>+    return this.removeItem.apply(this, args);
>+  }
>+  [_setItem](...args) {
>+    return this.setItem.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.Storage);
>+dart.setMethodSignature(html$.Storage, () => ({
>+  __proto__: dart.getMethods(html$.Storage.__proto__),
>+  [$addAll]: dart.fnType(dart.void, [core.Object]),
>+  [$containsValue]: dart.fnType(core.bool, [core.Object]),
>+  [$containsKey]: dart.fnType(core.bool, [core.Object]),
>+  [$_get]: dart.fnType(core.String, [core.Object]),
>+  [$_set]: dart.fnType(dart.void, [core.Object, core.Object]),
>+  [$putIfAbsent]: dart.fnType(core.String, [core.Object, core.Object]),
>+  [$remove]: dart.fnType(core.String, [core.Object]),
>+  [$clear]: dart.fnType(dart.void, []),
>+  [$forEach]: dart.fnType(dart.void, [dart.fnType(dart.void, [core.String, core.String])]),
>+  [_clear$0]: dart.fnType(dart.void, []),
>+  [_getItem]: dart.fnType(core.String, [core.String]),
>+  [_key]: dart.fnType(core.String, [core.int]),
>+  [_removeItem]: dart.fnType(dart.void, [core.String]),
>+  [_setItem]: dart.fnType(dart.void, [core.String, core.String])
>+}));
>+dart.setGetterSignature(html$.Storage, () => ({
>+  __proto__: dart.getGetters(html$.Storage.__proto__),
>+  [$keys]: core.Iterable$(core.String),
>+  [$values]: core.Iterable$(core.String),
>+  [$length]: core.int,
>+  [$isEmpty]: core.bool,
>+  [$isNotEmpty]: core.bool
>+}));
>+dart.setLibraryUri(html$.Storage, "dart:html");
>+dart.setFieldSignature(html$.Storage, () => ({
>+  __proto__: dart.getFields(html$.Storage.__proto__),
>+  [_length$2]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("Storage", html$.Storage);
>+const _initStorageEvent = dart.privateName(html$, "_initStorageEvent");
>+html$.StorageEvent = class StorageEvent$ extends html$.Event {
>+  static new(type, opts) {
>+    let canBubble = opts && 'canBubble' in opts ? opts.canBubble : false;
>+    let cancelable = opts && 'cancelable' in opts ? opts.cancelable : false;
>+    let key = opts && 'key' in opts ? opts.key : null;
>+    let oldValue = opts && 'oldValue' in opts ? opts.oldValue : null;
>+    let newValue = opts && 'newValue' in opts ? opts.newValue : null;
>+    let url = opts && 'url' in opts ? opts.url : null;
>+    let storageArea = opts && 'storageArea' in opts ? opts.storageArea : null;
>+    let e = html$.StorageEvent._check(html$.document[_createEvent]("StorageEvent"));
>+    e[_initStorageEvent](type, canBubble, cancelable, key, oldValue, newValue, url, storageArea);
>+    return e;
>+  }
>+  static __(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.StorageEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.StorageEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new StorageEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new StorageEvent(type);
>+  }
>+  get [$key]() {
>+    return this.key;
>+  }
>+  get [$newValue]() {
>+    return this.newValue;
>+  }
>+  get [$oldValue]() {
>+    return this.oldValue;
>+  }
>+  get [$storageArea]() {
>+    return this.storageArea;
>+  }
>+  get [$url]() {
>+    return this.url;
>+  }
>+  [_initStorageEvent](...args) {
>+    return this.initStorageEvent.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.StorageEvent);
>+const key$1 = Symbol("StorageEvent.key");
>+const newValue$ = Symbol("StorageEvent.newValue");
>+const oldValue$ = Symbol("StorageEvent.oldValue");
>+const storageArea = Symbol("StorageEvent.storageArea");
>+const url$4 = Symbol("StorageEvent.url");
>+dart.setMethodSignature(html$.StorageEvent, () => ({
>+  __proto__: dart.getMethods(html$.StorageEvent.__proto__),
>+  [_initStorageEvent]: dart.fnType(dart.void, [core.String, core.bool, core.bool, core.String, core.String, core.String, core.String, html$.Storage])
>+}));
>+dart.setLibraryUri(html$.StorageEvent, "dart:html");
>+dart.setFieldSignature(html$.StorageEvent, () => ({
>+  __proto__: dart.getFields(html$.StorageEvent.__proto__),
>+  [$key]: dart.finalFieldType(core.String),
>+  [$newValue]: dart.finalFieldType(core.String),
>+  [$oldValue]: dart.finalFieldType(core.String),
>+  [$storageArea]: dart.finalFieldType(html$.Storage),
>+  [$url]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("StorageEvent", html$.StorageEvent);
>+html$.StorageManager = class StorageManager extends _interceptors.Interceptor {
>+  [$estimate]() {
>+    return html$.promiseToFutureAsMap(this.estimate());
>+  }
>+  [$persist]() {
>+    return html$.promiseToFuture(core.bool, this.persist());
>+  }
>+  [$persisted]() {
>+    return html$.promiseToFuture(core.bool, this.persisted());
>+  }
>+};
>+dart.addTypeTests(html$.StorageManager);
>+dart.setMethodSignature(html$.StorageManager, () => ({
>+  __proto__: dart.getMethods(html$.StorageManager.__proto__),
>+  [$estimate]: dart.fnType(async.Future$(core.Map$(core.String, dart.dynamic)), []),
>+  [$persist]: dart.fnType(async.Future$(core.bool), []),
>+  [$persisted]: dart.fnType(async.Future$(core.bool), [])
>+}));
>+dart.setLibraryUri(html$.StorageManager, "dart:html");
>+dart.registerExtension("StorageManager", html$.StorageManager);
>+html$.StyleElement = class StyleElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("style");
>+  }
>+  get [$disabled]() {
>+    return this.disabled;
>+  }
>+  set [$disabled](value) {
>+    this.disabled = value;
>+  }
>+  get [$media]() {
>+    return this.media;
>+  }
>+  set [$media](value) {
>+    this.media = value;
>+  }
>+  get [$sheet]() {
>+    return this.sheet;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  set [$type](value) {
>+    this.type = value;
>+  }
>+};
>+(html$.StyleElement.created = function() {
>+  this[disabled$8] = null;
>+  this[media$5] = null;
>+  this[sheet$0] = null;
>+  this[type$33] = null;
>+  html$.StyleElement.__proto__.created.call(this);
>+}).prototype = html$.StyleElement.prototype;
>+dart.addTypeTests(html$.StyleElement);
>+const disabled$8 = Symbol("StyleElement.disabled");
>+const media$5 = Symbol("StyleElement.media");
>+const sheet$0 = Symbol("StyleElement.sheet");
>+const type$33 = Symbol("StyleElement.type");
>+dart.setLibraryUri(html$.StyleElement, "dart:html");
>+dart.setFieldSignature(html$.StyleElement, () => ({
>+  __proto__: dart.getFields(html$.StyleElement.__proto__),
>+  [$disabled]: dart.fieldType(core.bool),
>+  [$media]: dart.fieldType(core.String),
>+  [$sheet]: dart.finalFieldType(html$.StyleSheet),
>+  [$type]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("HTMLStyleElement", html$.StyleElement);
>+html$.StyleMedia = class StyleMedia extends _interceptors.Interceptor {
>+  get [$type]() {
>+    return this.type;
>+  }
>+  [$matchMedium](...args) {
>+    return this.matchMedium.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.StyleMedia);
>+const type$34 = Symbol("StyleMedia.type");
>+dart.setMethodSignature(html$.StyleMedia, () => ({
>+  __proto__: dart.getMethods(html$.StyleMedia.__proto__),
>+  [$matchMedium]: dart.fnType(core.bool, [core.String])
>+}));
>+dart.setLibraryUri(html$.StyleMedia, "dart:html");
>+dart.setFieldSignature(html$.StyleMedia, () => ({
>+  __proto__: dart.getFields(html$.StyleMedia.__proto__),
>+  [$type]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("StyleMedia", html$.StyleMedia);
>+html$.StylePropertyMapReadonly = class StylePropertyMapReadonly extends _interceptors.Interceptor {
>+  [$get](...args) {
>+    return this.get.apply(this, args);
>+  }
>+  [$getAll](...args) {
>+    return this.getAll.apply(this, args);
>+  }
>+  [$getProperties](...args) {
>+    return this.getProperties.apply(this, args);
>+  }
>+  [$has](...args) {
>+    return this.has.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.StylePropertyMapReadonly);
>+dart.setMethodSignature(html$.StylePropertyMapReadonly, () => ({
>+  __proto__: dart.getMethods(html$.StylePropertyMapReadonly.__proto__),
>+  [$get]: dart.fnType(html$.CssStyleValue, [core.String]),
>+  [$getAll]: dart.fnType(core.List$(html$.CssStyleValue), [core.String]),
>+  [$getProperties]: dart.fnType(core.List$(core.String), []),
>+  [$has]: dart.fnType(core.bool, [core.String])
>+}));
>+dart.setLibraryUri(html$.StylePropertyMapReadonly, "dart:html");
>+dart.registerExtension("StylePropertyMapReadonly", html$.StylePropertyMapReadonly);
>+html$.StylePropertyMap = class StylePropertyMap extends html$.StylePropertyMapReadonly {
>+  [$append](...args) {
>+    return this.append.apply(this, args);
>+  }
>+  [$delete](...args) {
>+    return this.delete.apply(this, args);
>+  }
>+  [$set](...args) {
>+    return this.set.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.StylePropertyMap);
>+dart.setMethodSignature(html$.StylePropertyMap, () => ({
>+  __proto__: dart.getMethods(html$.StylePropertyMap.__proto__),
>+  [$append]: dart.fnType(dart.void, [core.String, core.Object]),
>+  [$delete]: dart.fnType(dart.void, [core.String]),
>+  [$set]: dart.fnType(dart.void, [core.String, core.Object])
>+}));
>+dart.setLibraryUri(html$.StylePropertyMap, "dart:html");
>+dart.registerExtension("StylePropertyMap", html$.StylePropertyMap);
>+html$.SyncEvent = class SyncEvent$ extends html$.ExtendableEvent {
>+  static new(type, init) {
>+    let init_1 = html_common.convertDartToNative_Dictionary(init);
>+    return html$.SyncEvent._create_1(type, init_1);
>+  }
>+  static _create_1(type, init) {
>+    return new SyncEvent(type, init);
>+  }
>+  get [$lastChance]() {
>+    return this.lastChance;
>+  }
>+  get [$tag]() {
>+    return this.tag;
>+  }
>+};
>+dart.addTypeTests(html$.SyncEvent);
>+const lastChance = Symbol("SyncEvent.lastChance");
>+const tag$ = Symbol("SyncEvent.tag");
>+dart.setLibraryUri(html$.SyncEvent, "dart:html");
>+dart.setFieldSignature(html$.SyncEvent, () => ({
>+  __proto__: dart.getFields(html$.SyncEvent.__proto__),
>+  [$lastChance]: dart.finalFieldType(core.bool),
>+  [$tag]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("SyncEvent", html$.SyncEvent);
>+html$.SyncManager = class SyncManager extends _interceptors.Interceptor {
>+  [$getTags]() {
>+    return html$.promiseToFuture(ListOfString(), this.getTags());
>+  }
>+  [$register](tag) {
>+    return html$.promiseToFuture(dart.dynamic, this.register(tag));
>+  }
>+};
>+dart.addTypeTests(html$.SyncManager);
>+dart.setMethodSignature(html$.SyncManager, () => ({
>+  __proto__: dart.getMethods(html$.SyncManager.__proto__),
>+  [$getTags]: dart.fnType(async.Future$(core.List$(core.String)), []),
>+  [$register]: dart.fnType(async.Future, [core.String])
>+}));
>+dart.setLibraryUri(html$.SyncManager, "dart:html");
>+dart.registerExtension("SyncManager", html$.SyncManager);
>+html$.TableCaptionElement = class TableCaptionElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("caption");
>+  }
>+};
>+(html$.TableCaptionElement.created = function() {
>+  html$.TableCaptionElement.__proto__.created.call(this);
>+}).prototype = html$.TableCaptionElement.prototype;
>+dart.addTypeTests(html$.TableCaptionElement);
>+dart.setLibraryUri(html$.TableCaptionElement, "dart:html");
>+dart.registerExtension("HTMLTableCaptionElement", html$.TableCaptionElement);
>+html$.TableCellElement = class TableCellElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("td");
>+  }
>+  get [$cellIndex]() {
>+    return this.cellIndex;
>+  }
>+  get [$colSpan]() {
>+    return this.colSpan;
>+  }
>+  set [$colSpan](value) {
>+    this.colSpan = value;
>+  }
>+  get [$headers]() {
>+    return this.headers;
>+  }
>+  set [$headers](value) {
>+    this.headers = value;
>+  }
>+  get [$rowSpan]() {
>+    return this.rowSpan;
>+  }
>+  set [$rowSpan](value) {
>+    this.rowSpan = value;
>+  }
>+};
>+(html$.TableCellElement.created = function() {
>+  this[cellIndex] = null;
>+  this[colSpan$] = null;
>+  this[headers] = null;
>+  this[rowSpan$] = null;
>+  html$.TableCellElement.__proto__.created.call(this);
>+}).prototype = html$.TableCellElement.prototype;
>+dart.addTypeTests(html$.TableCellElement);
>+const cellIndex = Symbol("TableCellElement.cellIndex");
>+const colSpan$ = Symbol("TableCellElement.colSpan");
>+const headers = Symbol("TableCellElement.headers");
>+const rowSpan$ = Symbol("TableCellElement.rowSpan");
>+dart.setLibraryUri(html$.TableCellElement, "dart:html");
>+dart.setFieldSignature(html$.TableCellElement, () => ({
>+  __proto__: dart.getFields(html$.TableCellElement.__proto__),
>+  [$cellIndex]: dart.finalFieldType(core.int),
>+  [$colSpan]: dart.fieldType(core.int),
>+  [$headers]: dart.fieldType(core.String),
>+  [$rowSpan]: dart.fieldType(core.int)
>+}));
>+dart.registerExtension("HTMLTableCellElement", html$.TableCellElement);
>+dart.registerExtension("HTMLTableDataCellElement", html$.TableCellElement);
>+dart.registerExtension("HTMLTableHeaderCellElement", html$.TableCellElement);
>+html$.TableColElement = class TableColElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("col");
>+  }
>+  get [$span]() {
>+    return this.span;
>+  }
>+  set [$span](value) {
>+    this.span = value;
>+  }
>+};
>+(html$.TableColElement.created = function() {
>+  this[span] = null;
>+  html$.TableColElement.__proto__.created.call(this);
>+}).prototype = html$.TableColElement.prototype;
>+dart.addTypeTests(html$.TableColElement);
>+const span = Symbol("TableColElement.span");
>+dart.setLibraryUri(html$.TableColElement, "dart:html");
>+dart.setFieldSignature(html$.TableColElement, () => ({
>+  __proto__: dart.getFields(html$.TableColElement.__proto__),
>+  [$span]: dart.fieldType(core.int)
>+}));
>+dart.registerExtension("HTMLTableColElement", html$.TableColElement);
>+const _rows = dart.privateName(html$, "_rows");
>+const _tBodies = dart.privateName(html$, "_tBodies");
>+const _createCaption = dart.privateName(html$, "_createCaption");
>+const _createTBody = dart.privateName(html$, "_createTBody");
>+const _createTFoot = dart.privateName(html$, "_createTFoot");
>+const _createTHead = dart.privateName(html$, "_createTHead");
>+const _insertRow = dart.privateName(html$, "_insertRow");
>+const _nativeCreateTBody = dart.privateName(html$, "_nativeCreateTBody");
>+html$.TableElement = class TableElement extends html$.HtmlElement {
>+  get [$tBodies]() {
>+    return new (_WrappedListOfTableSectionElement()).new(this[_tBodies]);
>+  }
>+  get [$rows]() {
>+    return new (_WrappedListOfTableRowElement()).new(this[_rows]);
>+  }
>+  [$addRow]() {
>+    return this[$insertRow](-1);
>+  }
>+  [$createCaption]() {
>+    return this[_createCaption]();
>+  }
>+  [$createTBody]() {
>+    return this[_createTBody]();
>+  }
>+  [$createTFoot]() {
>+    return this[_createTFoot]();
>+  }
>+  [$createTHead]() {
>+    return this[_createTHead]();
>+  }
>+  [$insertRow](index) {
>+    return this[_insertRow](index);
>+  }
>+  [_createTBody]() {
>+    if (!!this.createTBody) {
>+      return this[_nativeCreateTBody]();
>+    }
>+    let tbody = html$.Element.tag("tbody");
>+    this[$children][$add](tbody);
>+    return html$.TableSectionElement._check(tbody);
>+  }
>+  [_nativeCreateTBody](...args) {
>+    return this.createTBody.apply(this, args);
>+  }
>+  [$createFragment](html, opts) {
>+    let validator = opts && 'validator' in opts ? opts.validator : null;
>+    let treeSanitizer = opts && 'treeSanitizer' in opts ? opts.treeSanitizer : null;
>+    if (dart.test(html$.Range.supportsCreateContextualFragment)) {
>+      return super[$createFragment](html, {validator: validator, treeSanitizer: treeSanitizer});
>+    }
>+    let contextualHtml = "<table>" + dart.str(html) + "</table>";
>+    let table = html$.Element.html(contextualHtml, {validator: validator, treeSanitizer: treeSanitizer});
>+    let fragment = html$.DocumentFragment.new();
>+    fragment[$nodes][$addAll](table[$nodes]);
>+    return fragment;
>+  }
>+  static new() {
>+    return html$.document.createElement("table");
>+  }
>+  get [$caption]() {
>+    return this.caption;
>+  }
>+  set [$caption](value) {
>+    this.caption = value;
>+  }
>+  get [_rows]() {
>+    return this.rows;
>+  }
>+  get [_tBodies]() {
>+    return this.tBodies;
>+  }
>+  get [$tFoot]() {
>+    return this.tFoot;
>+  }
>+  set [$tFoot](value) {
>+    this.tFoot = value;
>+  }
>+  get [$tHead]() {
>+    return this.tHead;
>+  }
>+  set [$tHead](value) {
>+    this.tHead = value;
>+  }
>+  [_createCaption](...args) {
>+    return this.createCaption.apply(this, args);
>+  }
>+  [_createTFoot](...args) {
>+    return this.createTFoot.apply(this, args);
>+  }
>+  [_createTHead](...args) {
>+    return this.createTHead.apply(this, args);
>+  }
>+  [$deleteCaption](...args) {
>+    return this.deleteCaption.apply(this, args);
>+  }
>+  [$deleteRow](...args) {
>+    return this.deleteRow.apply(this, args);
>+  }
>+  [$deleteTFoot](...args) {
>+    return this.deleteTFoot.apply(this, args);
>+  }
>+  [$deleteTHead](...args) {
>+    return this.deleteTHead.apply(this, args);
>+  }
>+  [_insertRow](...args) {
>+    return this.insertRow.apply(this, args);
>+  }
>+};
>+(html$.TableElement.created = function() {
>+  this[caption] = null;
>+  this[_rows] = null;
>+  this[_tBodies] = null;
>+  this[tFoot] = null;
>+  this[tHead] = null;
>+  html$.TableElement.__proto__.created.call(this);
>+}).prototype = html$.TableElement.prototype;
>+dart.addTypeTests(html$.TableElement);
>+const caption = Symbol("TableElement.caption");
>+const tFoot = Symbol("TableElement.tFoot");
>+const tHead = Symbol("TableElement.tHead");
>+dart.setMethodSignature(html$.TableElement, () => ({
>+  __proto__: dart.getMethods(html$.TableElement.__proto__),
>+  [$addRow]: dart.fnType(html$.TableRowElement, []),
>+  [$createCaption]: dart.fnType(html$.TableCaptionElement, []),
>+  [$createTBody]: dart.fnType(html$.TableSectionElement, []),
>+  [$createTFoot]: dart.fnType(html$.TableSectionElement, []),
>+  [$createTHead]: dart.fnType(html$.TableSectionElement, []),
>+  [$insertRow]: dart.fnType(html$.TableRowElement, [core.int]),
>+  [_createTBody]: dart.fnType(html$.TableSectionElement, []),
>+  [_nativeCreateTBody]: dart.fnType(html$.TableSectionElement, []),
>+  [_createCaption]: dart.fnType(html$.TableCaptionElement, []),
>+  [_createTFoot]: dart.fnType(html$.TableSectionElement, []),
>+  [_createTHead]: dart.fnType(html$.TableSectionElement, []),
>+  [$deleteCaption]: dart.fnType(dart.void, []),
>+  [$deleteRow]: dart.fnType(dart.void, [core.int]),
>+  [$deleteTFoot]: dart.fnType(dart.void, []),
>+  [$deleteTHead]: dart.fnType(dart.void, []),
>+  [_insertRow]: dart.fnType(html$.TableRowElement, [], [core.int])
>+}));
>+dart.setGetterSignature(html$.TableElement, () => ({
>+  __proto__: dart.getGetters(html$.TableElement.__proto__),
>+  [$tBodies]: core.List$(html$.TableSectionElement),
>+  [$rows]: core.List$(html$.TableRowElement)
>+}));
>+dart.setLibraryUri(html$.TableElement, "dart:html");
>+dart.setFieldSignature(html$.TableElement, () => ({
>+  __proto__: dart.getFields(html$.TableElement.__proto__),
>+  [$caption]: dart.fieldType(html$.TableCaptionElement),
>+  [_rows]: dart.finalFieldType(ListOfNode()),
>+  [_tBodies]: dart.finalFieldType(ListOfNode()),
>+  [$tFoot]: dart.fieldType(html$.TableSectionElement),
>+  [$tHead]: dart.fieldType(html$.TableSectionElement)
>+}));
>+dart.registerExtension("HTMLTableElement", html$.TableElement);
>+const _cells = dart.privateName(html$, "_cells");
>+const _insertCell = dart.privateName(html$, "_insertCell");
>+html$.TableRowElement = class TableRowElement extends html$.HtmlElement {
>+  get [$cells]() {
>+    return new (_WrappedListOfTableCellElement()).new(this[_cells]);
>+  }
>+  [$addCell]() {
>+    return this[$insertCell](-1);
>+  }
>+  [$insertCell](index) {
>+    return html$.TableCellElement._check(this[_insertCell](index));
>+  }
>+  [$createFragment](html, opts) {
>+    let validator = opts && 'validator' in opts ? opts.validator : null;
>+    let treeSanitizer = opts && 'treeSanitizer' in opts ? opts.treeSanitizer : null;
>+    if (dart.test(html$.Range.supportsCreateContextualFragment)) {
>+      return super[$createFragment](html, {validator: validator, treeSanitizer: treeSanitizer});
>+    }
>+    let fragment = html$.DocumentFragment.new();
>+    let section = html$.TableElement.new()[$createFragment](html, {validator: validator, treeSanitizer: treeSanitizer})[$nodes][$single];
>+    let row = section[$nodes][$single];
>+    fragment[$nodes][$addAll](row[$nodes]);
>+    return fragment;
>+  }
>+  static new() {
>+    return html$.document.createElement("tr");
>+  }
>+  get [_cells]() {
>+    return this.cells;
>+  }
>+  get [$rowIndex]() {
>+    return this.rowIndex;
>+  }
>+  get [$sectionRowIndex]() {
>+    return this.sectionRowIndex;
>+  }
>+  [$deleteCell](...args) {
>+    return this.deleteCell.apply(this, args);
>+  }
>+  [_insertCell](...args) {
>+    return this.insertCell.apply(this, args);
>+  }
>+};
>+(html$.TableRowElement.created = function() {
>+  this[_cells] = null;
>+  this[rowIndex$] = null;
>+  this[sectionRowIndex] = null;
>+  html$.TableRowElement.__proto__.created.call(this);
>+}).prototype = html$.TableRowElement.prototype;
>+dart.addTypeTests(html$.TableRowElement);
>+const rowIndex$ = Symbol("TableRowElement.rowIndex");
>+const sectionRowIndex = Symbol("TableRowElement.sectionRowIndex");
>+dart.setMethodSignature(html$.TableRowElement, () => ({
>+  __proto__: dart.getMethods(html$.TableRowElement.__proto__),
>+  [$addCell]: dart.fnType(html$.TableCellElement, []),
>+  [$insertCell]: dart.fnType(html$.TableCellElement, [core.int]),
>+  [$deleteCell]: dart.fnType(dart.void, [core.int]),
>+  [_insertCell]: dart.fnType(html$.HtmlElement, [], [core.int])
>+}));
>+dart.setGetterSignature(html$.TableRowElement, () => ({
>+  __proto__: dart.getGetters(html$.TableRowElement.__proto__),
>+  [$cells]: core.List$(html$.TableCellElement)
>+}));
>+dart.setLibraryUri(html$.TableRowElement, "dart:html");
>+dart.setFieldSignature(html$.TableRowElement, () => ({
>+  __proto__: dart.getFields(html$.TableRowElement.__proto__),
>+  [_cells]: dart.finalFieldType(ListOfNode()),
>+  [$rowIndex]: dart.finalFieldType(core.int),
>+  [$sectionRowIndex]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("HTMLTableRowElement", html$.TableRowElement);
>+html$.TableSectionElement = class TableSectionElement extends html$.HtmlElement {
>+  get [$rows]() {
>+    return new (_WrappedListOfTableRowElement()).new(this[_rows]);
>+  }
>+  [$addRow]() {
>+    return this[$insertRow](-1);
>+  }
>+  [$insertRow](index) {
>+    return html$.TableRowElement._check(this[_insertRow](index));
>+  }
>+  [$createFragment](html, opts) {
>+    let validator = opts && 'validator' in opts ? opts.validator : null;
>+    let treeSanitizer = opts && 'treeSanitizer' in opts ? opts.treeSanitizer : null;
>+    if (dart.test(html$.Range.supportsCreateContextualFragment)) {
>+      return super[$createFragment](html, {validator: validator, treeSanitizer: treeSanitizer});
>+    }
>+    let fragment = html$.DocumentFragment.new();
>+    let section = html$.TableElement.new()[$createFragment](html, {validator: validator, treeSanitizer: treeSanitizer})[$nodes][$single];
>+    fragment[$nodes][$addAll](section[$nodes]);
>+    return fragment;
>+  }
>+  get [_rows]() {
>+    return this.rows;
>+  }
>+  [$deleteRow](...args) {
>+    return this.deleteRow.apply(this, args);
>+  }
>+  [_insertRow](...args) {
>+    return this.insertRow.apply(this, args);
>+  }
>+};
>+(html$.TableSectionElement.created = function() {
>+  this[_rows] = null;
>+  html$.TableSectionElement.__proto__.created.call(this);
>+}).prototype = html$.TableSectionElement.prototype;
>+dart.addTypeTests(html$.TableSectionElement);
>+dart.setMethodSignature(html$.TableSectionElement, () => ({
>+  __proto__: dart.getMethods(html$.TableSectionElement.__proto__),
>+  [$addRow]: dart.fnType(html$.TableRowElement, []),
>+  [$insertRow]: dart.fnType(html$.TableRowElement, [core.int]),
>+  [$deleteRow]: dart.fnType(dart.void, [core.int]),
>+  [_insertRow]: dart.fnType(html$.HtmlElement, [], [core.int])
>+}));
>+dart.setGetterSignature(html$.TableSectionElement, () => ({
>+  __proto__: dart.getGetters(html$.TableSectionElement.__proto__),
>+  [$rows]: core.List$(html$.TableRowElement)
>+}));
>+dart.setLibraryUri(html$.TableSectionElement, "dart:html");
>+dart.setFieldSignature(html$.TableSectionElement, () => ({
>+  __proto__: dart.getFields(html$.TableSectionElement.__proto__),
>+  [_rows]: dart.finalFieldType(ListOfNode())
>+}));
>+dart.registerExtension("HTMLTableSectionElement", html$.TableSectionElement);
>+html$.TaskAttributionTiming = class TaskAttributionTiming extends html$.PerformanceEntry {
>+  get [$containerId]() {
>+    return this.containerId;
>+  }
>+  get [$containerName]() {
>+    return this.containerName;
>+  }
>+  get [$containerSrc]() {
>+    return this.containerSrc;
>+  }
>+  get [$containerType]() {
>+    return this.containerType;
>+  }
>+  get [$scriptUrl]() {
>+    return this.scriptURL;
>+  }
>+};
>+dart.addTypeTests(html$.TaskAttributionTiming);
>+const containerId = Symbol("TaskAttributionTiming.containerId");
>+const containerName = Symbol("TaskAttributionTiming.containerName");
>+const containerSrc = Symbol("TaskAttributionTiming.containerSrc");
>+const containerType = Symbol("TaskAttributionTiming.containerType");
>+const scriptUrl$ = Symbol("TaskAttributionTiming.scriptUrl");
>+dart.setLibraryUri(html$.TaskAttributionTiming, "dart:html");
>+dart.setFieldSignature(html$.TaskAttributionTiming, () => ({
>+  __proto__: dart.getFields(html$.TaskAttributionTiming.__proto__),
>+  [$containerId]: dart.finalFieldType(core.String),
>+  [$containerName]: dart.finalFieldType(core.String),
>+  [$containerSrc]: dart.finalFieldType(core.String),
>+  [$containerType]: dart.finalFieldType(core.String),
>+  [$scriptUrl]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("TaskAttributionTiming", html$.TaskAttributionTiming);
>+html$.TemplateElement = class TemplateElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.TemplateElement._check(html$.document[$createElement]("template"));
>+  }
>+  static get supported() {
>+    return html$.Element.isTagSupported("template");
>+  }
>+  get [$content]() {
>+    return this.content;
>+  }
>+  [$setInnerHtml](html, opts) {
>+    let validator = opts && 'validator' in opts ? opts.validator : null;
>+    let treeSanitizer = opts && 'treeSanitizer' in opts ? opts.treeSanitizer : null;
>+    this[$text] = null;
>+    let fragment = this[$createFragment](html, {validator: validator, treeSanitizer: treeSanitizer});
>+    this.content[$append](fragment);
>+  }
>+};
>+(html$.TemplateElement.created = function() {
>+  this[content$] = null;
>+  html$.TemplateElement.__proto__.created.call(this);
>+}).prototype = html$.TemplateElement.prototype;
>+dart.addTypeTests(html$.TemplateElement);
>+const content$ = Symbol("TemplateElement.content");
>+dart.setLibraryUri(html$.TemplateElement, "dart:html");
>+dart.setFieldSignature(html$.TemplateElement, () => ({
>+  __proto__: dart.getFields(html$.TemplateElement.__proto__),
>+  [$content]: dart.finalFieldType(html$.DocumentFragment)
>+}));
>+dart.registerExtension("HTMLTemplateElement", html$.TemplateElement);
>+html$.TextAreaElement = class TextAreaElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("textarea");
>+  }
>+  get [$autocapitalize]() {
>+    return this.autocapitalize;
>+  }
>+  set [$autocapitalize](value) {
>+    this.autocapitalize = value;
>+  }
>+  get [$autofocus]() {
>+    return this.autofocus;
>+  }
>+  set [$autofocus](value) {
>+    this.autofocus = value;
>+  }
>+  get [$cols]() {
>+    return this.cols;
>+  }
>+  set [$cols](value) {
>+    this.cols = value;
>+  }
>+  get [$defaultValue]() {
>+    return this.defaultValue;
>+  }
>+  set [$defaultValue](value) {
>+    this.defaultValue = value;
>+  }
>+  get [$dirName]() {
>+    return this.dirName;
>+  }
>+  set [$dirName](value) {
>+    this.dirName = value;
>+  }
>+  get [$disabled]() {
>+    return this.disabled;
>+  }
>+  set [$disabled](value) {
>+    this.disabled = value;
>+  }
>+  get [$form]() {
>+    return this.form;
>+  }
>+  get [$labels]() {
>+    return this.labels;
>+  }
>+  get [$maxLength]() {
>+    return this.maxLength;
>+  }
>+  set [$maxLength](value) {
>+    this.maxLength = value;
>+  }
>+  get [$minLength]() {
>+    return this.minLength;
>+  }
>+  set [$minLength](value) {
>+    this.minLength = value;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+  set [$name](value) {
>+    this.name = value;
>+  }
>+  get [$placeholder]() {
>+    return this.placeholder;
>+  }
>+  set [$placeholder](value) {
>+    this.placeholder = value;
>+  }
>+  get [$readOnly]() {
>+    return this.readOnly;
>+  }
>+  set [$readOnly](value) {
>+    this.readOnly = value;
>+  }
>+  get [$required]() {
>+    return this.required;
>+  }
>+  set [$required](value) {
>+    this.required = value;
>+  }
>+  get [$rows]() {
>+    return this.rows;
>+  }
>+  set [$rows](value) {
>+    this.rows = value;
>+  }
>+  get [$selectionDirection]() {
>+    return this.selectionDirection;
>+  }
>+  set [$selectionDirection](value) {
>+    this.selectionDirection = value;
>+  }
>+  get [$selectionEnd]() {
>+    return this.selectionEnd;
>+  }
>+  set [$selectionEnd](value) {
>+    this.selectionEnd = value;
>+  }
>+  get [$selectionStart]() {
>+    return this.selectionStart;
>+  }
>+  set [$selectionStart](value) {
>+    this.selectionStart = value;
>+  }
>+  get [$textLength]() {
>+    return this.textLength;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  get [$validationMessage]() {
>+    return this.validationMessage;
>+  }
>+  get [$validity]() {
>+    return this.validity;
>+  }
>+  get [$value]() {
>+    return this.value;
>+  }
>+  set [$value](value) {
>+    this.value = value;
>+  }
>+  get [$willValidate]() {
>+    return this.willValidate;
>+  }
>+  get [$wrap]() {
>+    return this.wrap;
>+  }
>+  set [$wrap](value) {
>+    this.wrap = value;
>+  }
>+  [$checkValidity](...args) {
>+    return this.checkValidity.apply(this, args);
>+  }
>+  [$reportValidity](...args) {
>+    return this.reportValidity.apply(this, args);
>+  }
>+  [$select](...args) {
>+    return this.select.apply(this, args);
>+  }
>+  [$setCustomValidity](...args) {
>+    return this.setCustomValidity.apply(this, args);
>+  }
>+  [$setRangeText](...args) {
>+    return this.setRangeText.apply(this, args);
>+  }
>+  [$setSelectionRange](...args) {
>+    return this.setSelectionRange.apply(this, args);
>+  }
>+};
>+(html$.TextAreaElement.created = function() {
>+  this[autocapitalize$] = null;
>+  this[autofocus$3] = null;
>+  this[cols] = null;
>+  this[defaultValue$1] = null;
>+  this[dirName$1] = null;
>+  this[disabled$9] = null;
>+  this[form$7] = null;
>+  this[labels$4] = null;
>+  this[maxLength$1] = null;
>+  this[minLength$] = null;
>+  this[name$38] = null;
>+  this[placeholder$3] = null;
>+  this[readOnly$8] = null;
>+  this[required$12] = null;
>+  this[rows] = null;
>+  this[selectionDirection$0] = null;
>+  this[selectionEnd$0] = null;
>+  this[selectionStart$0] = null;
>+  this[textLength] = null;
>+  this[type$35] = null;
>+  this[validationMessage$4] = null;
>+  this[validity$4] = null;
>+  this[value$17] = null;
>+  this[willValidate$4] = null;
>+  this[wrap] = null;
>+  html$.TextAreaElement.__proto__.created.call(this);
>+}).prototype = html$.TextAreaElement.prototype;
>+dart.addTypeTests(html$.TextAreaElement);
>+const autocapitalize$ = Symbol("TextAreaElement.autocapitalize");
>+const autofocus$3 = Symbol("TextAreaElement.autofocus");
>+const cols = Symbol("TextAreaElement.cols");
>+const defaultValue$1 = Symbol("TextAreaElement.defaultValue");
>+const dirName$1 = Symbol("TextAreaElement.dirName");
>+const disabled$9 = Symbol("TextAreaElement.disabled");
>+const form$7 = Symbol("TextAreaElement.form");
>+const labels$4 = Symbol("TextAreaElement.labels");
>+const maxLength$1 = Symbol("TextAreaElement.maxLength");
>+const minLength$ = Symbol("TextAreaElement.minLength");
>+const name$38 = Symbol("TextAreaElement.name");
>+const placeholder$3 = Symbol("TextAreaElement.placeholder");
>+const readOnly$8 = Symbol("TextAreaElement.readOnly");
>+const required$12 = Symbol("TextAreaElement.required");
>+const rows = Symbol("TextAreaElement.rows");
>+const selectionDirection$0 = Symbol("TextAreaElement.selectionDirection");
>+const selectionEnd$0 = Symbol("TextAreaElement.selectionEnd");
>+const selectionStart$0 = Symbol("TextAreaElement.selectionStart");
>+const textLength = Symbol("TextAreaElement.textLength");
>+const type$35 = Symbol("TextAreaElement.type");
>+const validationMessage$4 = Symbol("TextAreaElement.validationMessage");
>+const validity$4 = Symbol("TextAreaElement.validity");
>+const value$17 = Symbol("TextAreaElement.value");
>+const willValidate$4 = Symbol("TextAreaElement.willValidate");
>+const wrap = Symbol("TextAreaElement.wrap");
>+dart.setMethodSignature(html$.TextAreaElement, () => ({
>+  __proto__: dart.getMethods(html$.TextAreaElement.__proto__),
>+  [$checkValidity]: dart.fnType(core.bool, []),
>+  [$reportValidity]: dart.fnType(core.bool, []),
>+  [$select]: dart.fnType(dart.void, []),
>+  [$setCustomValidity]: dart.fnType(dart.void, [core.String]),
>+  [$setRangeText]: dart.fnType(dart.void, [core.String], {start: core.int, end: core.int, selectionMode: core.String}),
>+  [$setSelectionRange]: dart.fnType(dart.void, [core.int, core.int], [core.String])
>+}));
>+dart.setLibraryUri(html$.TextAreaElement, "dart:html");
>+dart.setFieldSignature(html$.TextAreaElement, () => ({
>+  __proto__: dart.getFields(html$.TextAreaElement.__proto__),
>+  [$autocapitalize]: dart.fieldType(core.String),
>+  [$autofocus]: dart.fieldType(core.bool),
>+  [$cols]: dart.fieldType(core.int),
>+  [$defaultValue]: dart.fieldType(core.String),
>+  [$dirName]: dart.fieldType(core.String),
>+  [$disabled]: dart.fieldType(core.bool),
>+  [$form]: dart.finalFieldType(html$.FormElement),
>+  [$labels]: dart.finalFieldType(ListOfNode()),
>+  [$maxLength]: dart.fieldType(core.int),
>+  [$minLength]: dart.fieldType(core.int),
>+  [$name]: dart.fieldType(core.String),
>+  [$placeholder]: dart.fieldType(core.String),
>+  [$readOnly]: dart.fieldType(core.bool),
>+  [$required]: dart.fieldType(core.bool),
>+  [$rows]: dart.fieldType(core.int),
>+  [$selectionDirection]: dart.fieldType(core.String),
>+  [$selectionEnd]: dart.fieldType(core.int),
>+  [$selectionStart]: dart.fieldType(core.int),
>+  [$textLength]: dart.finalFieldType(core.int),
>+  [$type]: dart.finalFieldType(core.String),
>+  [$validationMessage]: dart.finalFieldType(core.String),
>+  [$validity]: dart.finalFieldType(html$.ValidityState),
>+  [$value]: dart.fieldType(core.String),
>+  [$willValidate]: dart.finalFieldType(core.bool),
>+  [$wrap]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("HTMLTextAreaElement", html$.TextAreaElement);
>+html$.TextDetector = class TextDetector$ extends _interceptors.Interceptor {
>+  static new() {
>+    return html$.TextDetector._create_1();
>+  }
>+  static _create_1() {
>+    return new TextDetector();
>+  }
>+  [$detect](image) {
>+    return html$.promiseToFuture(ListOfDetectedText(), this.detect(image));
>+  }
>+};
>+dart.addTypeTests(html$.TextDetector);
>+dart.setMethodSignature(html$.TextDetector, () => ({
>+  __proto__: dart.getMethods(html$.TextDetector.__proto__),
>+  [$detect]: dart.fnType(async.Future$(core.List$(html$.DetectedText)), [dart.dynamic])
>+}));
>+dart.setLibraryUri(html$.TextDetector, "dart:html");
>+dart.registerExtension("TextDetector", html$.TextDetector);
>+const _initTextEvent = dart.privateName(html$, "_initTextEvent");
>+html$.TextEvent = class TextEvent extends html$.UIEvent {
>+  static new(type, opts) {
>+    let canBubble = opts && 'canBubble' in opts ? opts.canBubble : false;
>+    let cancelable = opts && 'cancelable' in opts ? opts.cancelable : false;
>+    let view = opts && 'view' in opts ? opts.view : null;
>+    let data = opts && 'data' in opts ? opts.data : null;
>+    if (view == null) {
>+      view = html$.window;
>+    }
>+    let e = html$.TextEvent._check(html$.document[_createEvent]("TextEvent"));
>+    e[_initTextEvent](type, canBubble, cancelable, view, data);
>+    return e;
>+  }
>+  get [$data]() {
>+    return this.data;
>+  }
>+  [_initTextEvent](...args) {
>+    return this.initTextEvent.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.TextEvent);
>+const data$8 = Symbol("TextEvent.data");
>+dart.setMethodSignature(html$.TextEvent, () => ({
>+  __proto__: dart.getMethods(html$.TextEvent.__proto__),
>+  [_initTextEvent]: dart.fnType(dart.void, [core.String, core.bool, core.bool, html$.Window, core.String])
>+}));
>+dart.setLibraryUri(html$.TextEvent, "dart:html");
>+dart.setFieldSignature(html$.TextEvent, () => ({
>+  __proto__: dart.getFields(html$.TextEvent.__proto__),
>+  [$data]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("TextEvent", html$.TextEvent);
>+html$.TextMetrics = class TextMetrics extends _interceptors.Interceptor {
>+  get [$actualBoundingBoxAscent]() {
>+    return this.actualBoundingBoxAscent;
>+  }
>+  get [$actualBoundingBoxDescent]() {
>+    return this.actualBoundingBoxDescent;
>+  }
>+  get [$actualBoundingBoxLeft]() {
>+    return this.actualBoundingBoxLeft;
>+  }
>+  get [$actualBoundingBoxRight]() {
>+    return this.actualBoundingBoxRight;
>+  }
>+  get [$alphabeticBaseline]() {
>+    return this.alphabeticBaseline;
>+  }
>+  get [$emHeightAscent]() {
>+    return this.emHeightAscent;
>+  }
>+  get [$emHeightDescent]() {
>+    return this.emHeightDescent;
>+  }
>+  get [$fontBoundingBoxAscent]() {
>+    return this.fontBoundingBoxAscent;
>+  }
>+  get [$fontBoundingBoxDescent]() {
>+    return this.fontBoundingBoxDescent;
>+  }
>+  get [$hangingBaseline]() {
>+    return this.hangingBaseline;
>+  }
>+  get [$ideographicBaseline]() {
>+    return this.ideographicBaseline;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+};
>+dart.addTypeTests(html$.TextMetrics);
>+const actualBoundingBoxAscent = Symbol("TextMetrics.actualBoundingBoxAscent");
>+const actualBoundingBoxDescent = Symbol("TextMetrics.actualBoundingBoxDescent");
>+const actualBoundingBoxLeft = Symbol("TextMetrics.actualBoundingBoxLeft");
>+const actualBoundingBoxRight = Symbol("TextMetrics.actualBoundingBoxRight");
>+const alphabeticBaseline = Symbol("TextMetrics.alphabeticBaseline");
>+const emHeightAscent = Symbol("TextMetrics.emHeightAscent");
>+const emHeightDescent = Symbol("TextMetrics.emHeightDescent");
>+const fontBoundingBoxAscent = Symbol("TextMetrics.fontBoundingBoxAscent");
>+const fontBoundingBoxDescent = Symbol("TextMetrics.fontBoundingBoxDescent");
>+const hangingBaseline = Symbol("TextMetrics.hangingBaseline");
>+const ideographicBaseline = Symbol("TextMetrics.ideographicBaseline");
>+const width$11 = Symbol("TextMetrics.width");
>+dart.setLibraryUri(html$.TextMetrics, "dart:html");
>+dart.setFieldSignature(html$.TextMetrics, () => ({
>+  __proto__: dart.getFields(html$.TextMetrics.__proto__),
>+  [$actualBoundingBoxAscent]: dart.finalFieldType(core.num),
>+  [$actualBoundingBoxDescent]: dart.finalFieldType(core.num),
>+  [$actualBoundingBoxLeft]: dart.finalFieldType(core.num),
>+  [$actualBoundingBoxRight]: dart.finalFieldType(core.num),
>+  [$alphabeticBaseline]: dart.finalFieldType(core.num),
>+  [$emHeightAscent]: dart.finalFieldType(core.num),
>+  [$emHeightDescent]: dart.finalFieldType(core.num),
>+  [$fontBoundingBoxAscent]: dart.finalFieldType(core.num),
>+  [$fontBoundingBoxDescent]: dart.finalFieldType(core.num),
>+  [$hangingBaseline]: dart.finalFieldType(core.num),
>+  [$ideographicBaseline]: dart.finalFieldType(core.num),
>+  [$width]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("TextMetrics", html$.TextMetrics);
>+html$.TextTrack = class TextTrack extends html$.EventTarget {
>+  get [$activeCues]() {
>+    return this.activeCues;
>+  }
>+  get [$cues]() {
>+    return this.cues;
>+  }
>+  get [$id]() {
>+    return this.id;
>+  }
>+  get [$kind]() {
>+    return this.kind;
>+  }
>+  get [$label]() {
>+    return this.label;
>+  }
>+  get [$language]() {
>+    return this.language;
>+  }
>+  get [$mode]() {
>+    return this.mode;
>+  }
>+  set [$mode](value) {
>+    this.mode = value;
>+  }
>+  [$addCue](...args) {
>+    return this.addCue.apply(this, args);
>+  }
>+  [$removeCue](...args) {
>+    return this.removeCue.apply(this, args);
>+  }
>+  get [$onCueChange]() {
>+    return html$.TextTrack.cueChangeEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.TextTrack);
>+const activeCues = Symbol("TextTrack.activeCues");
>+const cues = Symbol("TextTrack.cues");
>+const id$14 = Symbol("TextTrack.id");
>+const kind$1 = Symbol("TextTrack.kind");
>+const label$4 = Symbol("TextTrack.label");
>+const language$ = Symbol("TextTrack.language");
>+const mode$3 = Symbol("TextTrack.mode");
>+dart.setMethodSignature(html$.TextTrack, () => ({
>+  __proto__: dart.getMethods(html$.TextTrack.__proto__),
>+  [$addCue]: dart.fnType(dart.void, [html$.TextTrackCue]),
>+  [$removeCue]: dart.fnType(dart.void, [html$.TextTrackCue])
>+}));
>+dart.setGetterSignature(html$.TextTrack, () => ({
>+  __proto__: dart.getGetters(html$.TextTrack.__proto__),
>+  [$onCueChange]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.TextTrack, "dart:html");
>+dart.setFieldSignature(html$.TextTrack, () => ({
>+  __proto__: dart.getFields(html$.TextTrack.__proto__),
>+  [$activeCues]: dart.finalFieldType(html$.TextTrackCueList),
>+  [$cues]: dart.finalFieldType(html$.TextTrackCueList),
>+  [$id]: dart.finalFieldType(core.String),
>+  [$kind]: dart.finalFieldType(core.String),
>+  [$label]: dart.finalFieldType(core.String),
>+  [$language]: dart.finalFieldType(core.String),
>+  [$mode]: dart.fieldType(core.String)
>+}));
>+dart.defineLazy(html$.TextTrack, {
>+  /*html$.TextTrack.cueChangeEvent*/get cueChangeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("cuechange"));
>+  }
>+});
>+dart.registerExtension("TextTrack", html$.TextTrack);
>+html$.TextTrackCue = class TextTrackCue extends html$.EventTarget {
>+  get [$endTime]() {
>+    return this.endTime;
>+  }
>+  set [$endTime](value) {
>+    this.endTime = value;
>+  }
>+  get [$id]() {
>+    return this.id;
>+  }
>+  set [$id](value) {
>+    this.id = value;
>+  }
>+  get [$pauseOnExit]() {
>+    return this.pauseOnExit;
>+  }
>+  set [$pauseOnExit](value) {
>+    this.pauseOnExit = value;
>+  }
>+  get [$startTime]() {
>+    return this.startTime;
>+  }
>+  set [$startTime](value) {
>+    this.startTime = value;
>+  }
>+  get [$track]() {
>+    return this.track;
>+  }
>+  get [$onEnter]() {
>+    return html$.TextTrackCue.enterEvent.forTarget(this);
>+  }
>+  get [$onExit]() {
>+    return html$.TextTrackCue.exitEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.TextTrackCue);
>+const endTime = Symbol("TextTrackCue.endTime");
>+const id$15 = Symbol("TextTrackCue.id");
>+const pauseOnExit = Symbol("TextTrackCue.pauseOnExit");
>+const startTime$0 = Symbol("TextTrackCue.startTime");
>+const track$4 = Symbol("TextTrackCue.track");
>+dart.setGetterSignature(html$.TextTrackCue, () => ({
>+  __proto__: dart.getGetters(html$.TextTrackCue.__proto__),
>+  [$onEnter]: async.Stream$(html$.Event),
>+  [$onExit]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.TextTrackCue, "dart:html");
>+dart.setFieldSignature(html$.TextTrackCue, () => ({
>+  __proto__: dart.getFields(html$.TextTrackCue.__proto__),
>+  [$endTime]: dart.fieldType(core.num),
>+  [$id]: dart.fieldType(core.String),
>+  [$pauseOnExit]: dart.fieldType(core.bool),
>+  [$startTime]: dart.fieldType(core.num),
>+  [$track]: dart.finalFieldType(html$.TextTrack)
>+}));
>+dart.defineLazy(html$.TextTrackCue, {
>+  /*html$.TextTrackCue.enterEvent*/get enterEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("enter"));
>+  },
>+  /*html$.TextTrackCue.exitEvent*/get exitEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("exit"));
>+  }
>+});
>+dart.registerExtension("TextTrackCue", html$.TextTrackCue);
>+const Interceptor_ListMixin$$6 = class Interceptor_ListMixin extends _interceptors.Interceptor {};
>+(Interceptor_ListMixin$$6.new = function() {
>+  Interceptor_ListMixin$$6.__proto__.new.call(this);
>+}).prototype = Interceptor_ListMixin$$6.prototype;
>+dart.applyMixin(Interceptor_ListMixin$$6, collection.ListMixin$(html$.TextTrackCue));
>+const Interceptor_ImmutableListMixin$$6 = class Interceptor_ImmutableListMixin extends Interceptor_ListMixin$$6 {};
>+(Interceptor_ImmutableListMixin$$6.new = function() {
>+  Interceptor_ImmutableListMixin$$6.__proto__.new.call(this);
>+}).prototype = Interceptor_ImmutableListMixin$$6.prototype;
>+dart.applyMixin(Interceptor_ImmutableListMixin$$6, html$.ImmutableListMixin$(html$.TextTrackCue));
>+html$.TextTrackCueList = class TextTrackCueList extends Interceptor_ImmutableListMixin$$6 {
>+  get [$length]() {
>+    return this.length;
>+  }
>+  [$_get](index) {
>+    if (index >>> 0 !== index || index >= this[$length]) dart.throw(core.RangeError.index(index, this));
>+    return this[index];
>+  }
>+  [$_set](index, value) {
>+    html$.TextTrackCue._check(value);
>+    dart.throw(new core.UnsupportedError.new("Cannot assign element of immutable List."));
>+    return value;
>+  }
>+  set [$length](value) {
>+    dart.throw(new core.UnsupportedError.new("Cannot resize immutable List."));
>+  }
>+  get [$first]() {
>+    if (dart.notNull(this[$length]) > 0) {
>+      return this[0];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$first](value) {
>+    super[$first] = value;
>+  }
>+  get [$last]() {
>+    let len = this[$length];
>+    if (dart.notNull(len) > 0) {
>+      return this[dart.notNull(len) - 1];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$last](value) {
>+    super[$last] = value;
>+  }
>+  get [$single]() {
>+    let len = this[$length];
>+    if (len === 1) {
>+      return this[0];
>+    }
>+    if (len === 0) dart.throw(new core.StateError.new("No elements"));
>+    dart.throw(new core.StateError.new("More than one element"));
>+  }
>+  [$elementAt](index) {
>+    return this[$_get](index);
>+  }
>+  [__getter__](...args) {
>+    return this.__getter__.apply(this, args);
>+  }
>+  [$getCueById](...args) {
>+    return this.getCueById.apply(this, args);
>+  }
>+};
>+html$.TextTrackCueList.prototype[dart.isList] = true;
>+dart.addTypeTests(html$.TextTrackCueList);
>+html$.TextTrackCueList[dart.implements] = () => [ListOfTextTrackCue(), JavaScriptIndexingBehaviorOfTextTrackCue()];
>+dart.setMethodSignature(html$.TextTrackCueList, () => ({
>+  __proto__: dart.getMethods(html$.TextTrackCueList.__proto__),
>+  [$_get]: dart.fnType(html$.TextTrackCue, [core.int]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$elementAt]: dart.fnType(html$.TextTrackCue, [core.int]),
>+  [__getter__]: dart.fnType(html$.TextTrackCue, [core.int]),
>+  [$getCueById]: dart.fnType(html$.TextTrackCue, [core.String])
>+}));
>+dart.setGetterSignature(html$.TextTrackCueList, () => ({
>+  __proto__: dart.getGetters(html$.TextTrackCueList.__proto__),
>+  [$length]: core.int,
>+  [$first]: html$.TextTrackCue,
>+  [$last]: html$.TextTrackCue,
>+  [$single]: html$.TextTrackCue
>+}));
>+dart.setSetterSignature(html$.TextTrackCueList, () => ({
>+  __proto__: dart.getSetters(html$.TextTrackCueList.__proto__),
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(html$.TextTrackCueList, "dart:html");
>+dart.registerExtension("TextTrackCueList", html$.TextTrackCueList);
>+const EventTarget_ListMixin$$ = class EventTarget_ListMixin extends html$.EventTarget {};
>+(EventTarget_ListMixin$$._created = function() {
>+  EventTarget_ListMixin$$.__proto__._created.call(this);
>+}).prototype = EventTarget_ListMixin$$.prototype;
>+(EventTarget_ListMixin$$.__ = function() {
>+  EventTarget_ListMixin$$.__proto__.__.call(this);
>+}).prototype = EventTarget_ListMixin$$.prototype;
>+dart.applyMixin(EventTarget_ListMixin$$, collection.ListMixin$(html$.TextTrack));
>+const EventTarget_ImmutableListMixin$$ = class EventTarget_ImmutableListMixin extends EventTarget_ListMixin$$ {};
>+(EventTarget_ImmutableListMixin$$._created = function() {
>+  EventTarget_ImmutableListMixin$$.__proto__._created.call(this);
>+}).prototype = EventTarget_ImmutableListMixin$$.prototype;
>+(EventTarget_ImmutableListMixin$$.__ = function() {
>+  EventTarget_ImmutableListMixin$$.__proto__.__.call(this);
>+}).prototype = EventTarget_ImmutableListMixin$$.prototype;
>+dart.applyMixin(EventTarget_ImmutableListMixin$$, html$.ImmutableListMixin$(html$.TextTrack));
>+html$.TextTrackList = class TextTrackList extends EventTarget_ImmutableListMixin$$ {
>+  get [$length]() {
>+    return this.length;
>+  }
>+  [$_get](index) {
>+    if (index >>> 0 !== index || index >= this[$length]) dart.throw(core.RangeError.index(index, this));
>+    return this[index];
>+  }
>+  [$_set](index, value) {
>+    html$.TextTrack._check(value);
>+    dart.throw(new core.UnsupportedError.new("Cannot assign element of immutable List."));
>+    return value;
>+  }
>+  set [$length](value) {
>+    dart.throw(new core.UnsupportedError.new("Cannot resize immutable List."));
>+  }
>+  get [$first]() {
>+    if (dart.notNull(this[$length]) > 0) {
>+      return this[0];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$first](value) {
>+    super[$first] = value;
>+  }
>+  get [$last]() {
>+    let len = this[$length];
>+    if (dart.notNull(len) > 0) {
>+      return this[dart.notNull(len) - 1];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$last](value) {
>+    super[$last] = value;
>+  }
>+  get [$single]() {
>+    let len = this[$length];
>+    if (len === 1) {
>+      return this[0];
>+    }
>+    if (len === 0) dart.throw(new core.StateError.new("No elements"));
>+    dart.throw(new core.StateError.new("More than one element"));
>+  }
>+  [$elementAt](index) {
>+    return this[$_get](index);
>+  }
>+  [__getter__](...args) {
>+    return this.__getter__.apply(this, args);
>+  }
>+  [$getTrackById](...args) {
>+    return this.getTrackById.apply(this, args);
>+  }
>+  get [$onAddTrack]() {
>+    return html$.TextTrackList.addTrackEvent.forTarget(this);
>+  }
>+  get [$onChange]() {
>+    return html$.TextTrackList.changeEvent.forTarget(this);
>+  }
>+};
>+html$.TextTrackList.prototype[dart.isList] = true;
>+dart.addTypeTests(html$.TextTrackList);
>+html$.TextTrackList[dart.implements] = () => [ListOfTextTrack(), JavaScriptIndexingBehaviorOfTextTrack()];
>+dart.setMethodSignature(html$.TextTrackList, () => ({
>+  __proto__: dart.getMethods(html$.TextTrackList.__proto__),
>+  [$_get]: dart.fnType(html$.TextTrack, [core.int]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$elementAt]: dart.fnType(html$.TextTrack, [core.int]),
>+  [__getter__]: dart.fnType(html$.TextTrack, [core.int]),
>+  [$getTrackById]: dart.fnType(html$.TextTrack, [core.String])
>+}));
>+dart.setGetterSignature(html$.TextTrackList, () => ({
>+  __proto__: dart.getGetters(html$.TextTrackList.__proto__),
>+  [$length]: core.int,
>+  [$first]: html$.TextTrack,
>+  [$last]: html$.TextTrack,
>+  [$single]: html$.TextTrack,
>+  [$onAddTrack]: async.Stream$(html$.TrackEvent),
>+  [$onChange]: async.Stream$(html$.Event)
>+}));
>+dart.setSetterSignature(html$.TextTrackList, () => ({
>+  __proto__: dart.getSetters(html$.TextTrackList.__proto__),
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(html$.TextTrackList, "dart:html");
>+dart.defineLazy(html$.TextTrackList, {
>+  /*html$.TextTrackList.addTrackEvent*/get addTrackEvent() {
>+    return dart.const(new (EventStreamProviderOfTrackEvent()).new("addtrack"));
>+  },
>+  /*html$.TextTrackList.changeEvent*/get changeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("change"));
>+  }
>+});
>+dart.registerExtension("TextTrackList", html$.TextTrackList);
>+html$.TimeElement = class TimeElement extends html$.HtmlElement {
>+  get [$dateTime]() {
>+    return this.dateTime;
>+  }
>+  set [$dateTime](value) {
>+    this.dateTime = value;
>+  }
>+};
>+(html$.TimeElement.created = function() {
>+  this[dateTime$] = null;
>+  html$.TimeElement.__proto__.created.call(this);
>+}).prototype = html$.TimeElement.prototype;
>+dart.addTypeTests(html$.TimeElement);
>+const dateTime$ = Symbol("TimeElement.dateTime");
>+dart.setLibraryUri(html$.TimeElement, "dart:html");
>+dart.setFieldSignature(html$.TimeElement, () => ({
>+  __proto__: dart.getFields(html$.TimeElement.__proto__),
>+  [$dateTime]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("HTMLTimeElement", html$.TimeElement);
>+html$.TimeRanges = class TimeRanges extends _interceptors.Interceptor {
>+  get [$length]() {
>+    return this.length;
>+  }
>+  [$end](...args) {
>+    return this.end.apply(this, args);
>+  }
>+  [$start](...args) {
>+    return this.start.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.TimeRanges);
>+const length$14 = Symbol("TimeRanges.length");
>+dart.setMethodSignature(html$.TimeRanges, () => ({
>+  __proto__: dart.getMethods(html$.TimeRanges.__proto__),
>+  [$end]: dart.fnType(core.double, [core.int]),
>+  [$start]: dart.fnType(core.double, [core.int])
>+}));
>+dart.setLibraryUri(html$.TimeRanges, "dart:html");
>+dart.setFieldSignature(html$.TimeRanges, () => ({
>+  __proto__: dart.getFields(html$.TimeRanges.__proto__),
>+  [$length]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("TimeRanges", html$.TimeRanges);
>+html$.TitleElement = class TitleElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("title");
>+  }
>+};
>+(html$.TitleElement.created = function() {
>+  html$.TitleElement.__proto__.created.call(this);
>+}).prototype = html$.TitleElement.prototype;
>+dart.addTypeTests(html$.TitleElement);
>+dart.setLibraryUri(html$.TitleElement, "dart:html");
>+dart.registerExtension("HTMLTitleElement", html$.TitleElement);
>+const _radiusX = dart.privateName(html$, "_radiusX");
>+const _radiusY = dart.privateName(html$, "_radiusY");
>+const __clientX = dart.privateName(html$, "__clientX");
>+const __clientY = dart.privateName(html$, "__clientY");
>+const __screenX = dart.privateName(html$, "__screenX");
>+const __screenY = dart.privateName(html$, "__screenY");
>+const __pageX = dart.privateName(html$, "__pageX");
>+const __pageY = dart.privateName(html$, "__pageY");
>+const __radiusX = dart.privateName(html$, "__radiusX");
>+const __radiusY = dart.privateName(html$, "__radiusY");
>+html$.Touch = class Touch$ extends _interceptors.Interceptor {
>+  static new(initDict) {
>+    let initDict_1 = html_common.convertDartToNative_Dictionary(initDict);
>+    return html$.Touch._create_1(initDict_1);
>+  }
>+  static _create_1(initDict) {
>+    return new Touch(initDict);
>+  }
>+  get [_clientX]() {
>+    return this.clientX;
>+  }
>+  get [_clientY]() {
>+    return this.clientY;
>+  }
>+  get [$force]() {
>+    return this.force;
>+  }
>+  get [$identifier]() {
>+    return this.identifier;
>+  }
>+  get [_pageX]() {
>+    return this.pageX;
>+  }
>+  get [_pageY]() {
>+    return this.pageY;
>+  }
>+  get [_radiusX]() {
>+    return this.radiusX;
>+  }
>+  get [_radiusY]() {
>+    return this.radiusY;
>+  }
>+  get [$region]() {
>+    return this.region;
>+  }
>+  get [$rotationAngle]() {
>+    return this.rotationAngle;
>+  }
>+  get [_screenX]() {
>+    return this.screenX;
>+  }
>+  get [_screenY]() {
>+    return this.screenY;
>+  }
>+  get [$target]() {
>+    return html$._convertNativeToDart_EventTarget(this[_get_target]);
>+  }
>+  get [_get_target]() {
>+    return this.target;
>+  }
>+  get [__clientX]() {
>+    return this.clientX[$round]();
>+  }
>+  get [__clientY]() {
>+    return this.clientY[$round]();
>+  }
>+  get [__screenX]() {
>+    return this.screenX[$round]();
>+  }
>+  get [__screenY]() {
>+    return this.screenY[$round]();
>+  }
>+  get [__pageX]() {
>+    return this.pageX[$round]();
>+  }
>+  get [__pageY]() {
>+    return this.pageY[$round]();
>+  }
>+  get [__radiusX]() {
>+    return this.radiusX[$round]();
>+  }
>+  get [__radiusY]() {
>+    return this.radiusY[$round]();
>+  }
>+  get [$client]() {
>+    return new (PointOfnum()).new(this[__clientX], this[__clientY]);
>+  }
>+  get [$page]() {
>+    return new (PointOfnum()).new(this[__pageX], this[__pageY]);
>+  }
>+  get [$screen]() {
>+    return new (PointOfnum()).new(this[__screenX], this[__screenY]);
>+  }
>+  get [$radiusX]() {
>+    return this[__radiusX];
>+  }
>+  get [$radiusY]() {
>+    return this[__radiusY];
>+  }
>+};
>+dart.addTypeTests(html$.Touch);
>+const force = Symbol("Touch.force");
>+const identifier = Symbol("Touch.identifier");
>+const region$0 = Symbol("Touch.region");
>+const rotationAngle = Symbol("Touch.rotationAngle");
>+dart.setGetterSignature(html$.Touch, () => ({
>+  __proto__: dart.getGetters(html$.Touch.__proto__),
>+  [$target]: html$.EventTarget,
>+  [__clientX]: core.int,
>+  [__clientY]: core.int,
>+  [__screenX]: core.int,
>+  [__screenY]: core.int,
>+  [__pageX]: core.int,
>+  [__pageY]: core.int,
>+  [__radiusX]: core.int,
>+  [__radiusY]: core.int,
>+  [$client]: math.Point$(core.num),
>+  [$page]: math.Point$(core.num),
>+  [$screen]: math.Point$(core.num),
>+  [$radiusX]: core.int,
>+  [$radiusY]: core.int
>+}));
>+dart.setLibraryUri(html$.Touch, "dart:html");
>+dart.setFieldSignature(html$.Touch, () => ({
>+  __proto__: dart.getFields(html$.Touch.__proto__),
>+  [_clientX]: dart.finalFieldType(core.num),
>+  [_clientY]: dart.finalFieldType(core.num),
>+  [$force]: dart.finalFieldType(core.num),
>+  [$identifier]: dart.finalFieldType(core.int),
>+  [_pageX]: dart.finalFieldType(core.num),
>+  [_pageY]: dart.finalFieldType(core.num),
>+  [_radiusX]: dart.finalFieldType(core.num),
>+  [_radiusY]: dart.finalFieldType(core.num),
>+  [$region]: dart.finalFieldType(core.String),
>+  [$rotationAngle]: dart.finalFieldType(core.num),
>+  [_screenX]: dart.finalFieldType(core.num),
>+  [_screenY]: dart.finalFieldType(core.num),
>+  [_get_target]: dart.finalFieldType(dart.dynamic)
>+}));
>+dart.registerExtension("Touch", html$.Touch);
>+html$.TouchEvent = class TouchEvent$ extends html$.UIEvent {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.TouchEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.TouchEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new TouchEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new TouchEvent(type);
>+  }
>+  get [$altKey]() {
>+    return this.altKey;
>+  }
>+  get [$changedTouches]() {
>+    return this.changedTouches;
>+  }
>+  get [$ctrlKey]() {
>+    return this.ctrlKey;
>+  }
>+  get [$metaKey]() {
>+    return this.metaKey;
>+  }
>+  get [$shiftKey]() {
>+    return this.shiftKey;
>+  }
>+  get [$targetTouches]() {
>+    return this.targetTouches;
>+  }
>+  get [$touches]() {
>+    return this.touches;
>+  }
>+  static get supported() {
>+    return html_common.Device.isEventTypeSupported("TouchEvent");
>+  }
>+};
>+dart.addTypeTests(html$.TouchEvent);
>+const altKey$0 = Symbol("TouchEvent.altKey");
>+const changedTouches = Symbol("TouchEvent.changedTouches");
>+const ctrlKey$0 = Symbol("TouchEvent.ctrlKey");
>+const metaKey$0 = Symbol("TouchEvent.metaKey");
>+const shiftKey$0 = Symbol("TouchEvent.shiftKey");
>+const targetTouches = Symbol("TouchEvent.targetTouches");
>+const touches = Symbol("TouchEvent.touches");
>+dart.setLibraryUri(html$.TouchEvent, "dart:html");
>+dart.setFieldSignature(html$.TouchEvent, () => ({
>+  __proto__: dart.getFields(html$.TouchEvent.__proto__),
>+  [$altKey]: dart.finalFieldType(core.bool),
>+  [$changedTouches]: dart.finalFieldType(html$.TouchList),
>+  [$ctrlKey]: dart.finalFieldType(core.bool),
>+  [$metaKey]: dart.finalFieldType(core.bool),
>+  [$shiftKey]: dart.finalFieldType(core.bool),
>+  [$targetTouches]: dart.finalFieldType(html$.TouchList),
>+  [$touches]: dart.finalFieldType(html$.TouchList)
>+}));
>+dart.registerExtension("TouchEvent", html$.TouchEvent);
>+const Interceptor_ListMixin$$7 = class Interceptor_ListMixin extends _interceptors.Interceptor {};
>+(Interceptor_ListMixin$$7.new = function() {
>+  Interceptor_ListMixin$$7.__proto__.new.call(this);
>+}).prototype = Interceptor_ListMixin$$7.prototype;
>+dart.applyMixin(Interceptor_ListMixin$$7, collection.ListMixin$(html$.Touch));
>+const Interceptor_ImmutableListMixin$$7 = class Interceptor_ImmutableListMixin extends Interceptor_ListMixin$$7 {};
>+(Interceptor_ImmutableListMixin$$7.new = function() {
>+  Interceptor_ImmutableListMixin$$7.__proto__.new.call(this);
>+}).prototype = Interceptor_ImmutableListMixin$$7.prototype;
>+dart.applyMixin(Interceptor_ImmutableListMixin$$7, html$.ImmutableListMixin$(html$.Touch));
>+html$.TouchList = class TouchList extends Interceptor_ImmutableListMixin$$7 {
>+  static new() {
>+    return null;
>+  }
>+  static get supported() {
>+    return !!document.createTouchList;
>+  }
>+  get [$length]() {
>+    return this.length;
>+  }
>+  [$_get](index) {
>+    if (index >>> 0 !== index || index >= this[$length]) dart.throw(core.RangeError.index(index, this));
>+    return this[index];
>+  }
>+  [$_set](index, value) {
>+    html$.Touch._check(value);
>+    dart.throw(new core.UnsupportedError.new("Cannot assign element of immutable List."));
>+    return value;
>+  }
>+  set [$length](value) {
>+    dart.throw(new core.UnsupportedError.new("Cannot resize immutable List."));
>+  }
>+  get [$first]() {
>+    if (dart.notNull(this[$length]) > 0) {
>+      return this[0];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$first](value) {
>+    super[$first] = value;
>+  }
>+  get [$last]() {
>+    let len = this[$length];
>+    if (dart.notNull(len) > 0) {
>+      return this[dart.notNull(len) - 1];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$last](value) {
>+    super[$last] = value;
>+  }
>+  get [$single]() {
>+    let len = this[$length];
>+    if (len === 1) {
>+      return this[0];
>+    }
>+    if (len === 0) dart.throw(new core.StateError.new("No elements"));
>+    dart.throw(new core.StateError.new("More than one element"));
>+  }
>+  [$elementAt](index) {
>+    return this[$_get](index);
>+  }
>+  [$item](...args) {
>+    return this.item.apply(this, args);
>+  }
>+};
>+html$.TouchList.prototype[dart.isList] = true;
>+dart.addTypeTests(html$.TouchList);
>+html$.TouchList[dart.implements] = () => [JavaScriptIndexingBehaviorOfTouch(), ListOfTouch()];
>+dart.setMethodSignature(html$.TouchList, () => ({
>+  __proto__: dart.getMethods(html$.TouchList.__proto__),
>+  [$_get]: dart.fnType(html$.Touch, [core.int]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$elementAt]: dart.fnType(html$.Touch, [core.int]),
>+  [$item]: dart.fnType(html$.Touch, [core.int])
>+}));
>+dart.setGetterSignature(html$.TouchList, () => ({
>+  __proto__: dart.getGetters(html$.TouchList.__proto__),
>+  [$length]: core.int,
>+  [$first]: html$.Touch,
>+  [$last]: html$.Touch,
>+  [$single]: html$.Touch
>+}));
>+dart.setSetterSignature(html$.TouchList, () => ({
>+  __proto__: dart.getSetters(html$.TouchList.__proto__),
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(html$.TouchList, "dart:html");
>+dart.registerExtension("TouchList", html$.TouchList);
>+html$.TrackDefault = class TrackDefault$ extends _interceptors.Interceptor {
>+  static new(type, language, label, kinds, byteStreamTrackID) {
>+    if (byteStreamTrackID === void 0) byteStreamTrackID = null;
>+    if (byteStreamTrackID != null) {
>+      let kinds_1 = html_common.convertDartToNative_StringArray(kinds);
>+      return html$.TrackDefault._create_1(type, language, label, kinds_1, byteStreamTrackID);
>+    }
>+    let kinds_1 = html_common.convertDartToNative_StringArray(kinds);
>+    return html$.TrackDefault._create_2(type, language, label, kinds_1);
>+  }
>+  static _create_1(type, language, label, kinds, byteStreamTrackID) {
>+    return new TrackDefault(type, language, label, kinds, byteStreamTrackID);
>+  }
>+  static _create_2(type, language, label, kinds) {
>+    return new TrackDefault(type, language, label, kinds);
>+  }
>+  get [$byteStreamTrackID]() {
>+    return this.byteStreamTrackID;
>+  }
>+  get [$kinds]() {
>+    return this.kinds;
>+  }
>+  get [$label]() {
>+    return this.label;
>+  }
>+  get [$language]() {
>+    return this.language;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+};
>+dart.addTypeTests(html$.TrackDefault);
>+const byteStreamTrackID = Symbol("TrackDefault.byteStreamTrackID");
>+const kinds = Symbol("TrackDefault.kinds");
>+const label$5 = Symbol("TrackDefault.label");
>+const language$0 = Symbol("TrackDefault.language");
>+const type$36 = Symbol("TrackDefault.type");
>+dart.setLibraryUri(html$.TrackDefault, "dart:html");
>+dart.setFieldSignature(html$.TrackDefault, () => ({
>+  __proto__: dart.getFields(html$.TrackDefault.__proto__),
>+  [$byteStreamTrackID]: dart.finalFieldType(core.String),
>+  [$kinds]: dart.finalFieldType(core.Object),
>+  [$label]: dart.finalFieldType(core.String),
>+  [$language]: dart.finalFieldType(core.String),
>+  [$type]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("TrackDefault", html$.TrackDefault);
>+html$.TrackDefaultList = class TrackDefaultList$ extends _interceptors.Interceptor {
>+  static new(trackDefaults) {
>+    if (trackDefaults === void 0) trackDefaults = null;
>+    if (trackDefaults != null) {
>+      return html$.TrackDefaultList._create_1(trackDefaults);
>+    }
>+    return html$.TrackDefaultList._create_2();
>+  }
>+  static _create_1(trackDefaults) {
>+    return new TrackDefaultList(trackDefaults);
>+  }
>+  static _create_2() {
>+    return new TrackDefaultList();
>+  }
>+  get [$length]() {
>+    return this.length;
>+  }
>+  [$item](...args) {
>+    return this.item.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.TrackDefaultList);
>+const length$15 = Symbol("TrackDefaultList.length");
>+dart.setMethodSignature(html$.TrackDefaultList, () => ({
>+  __proto__: dart.getMethods(html$.TrackDefaultList.__proto__),
>+  [$item]: dart.fnType(html$.TrackDefault, [core.int])
>+}));
>+dart.setLibraryUri(html$.TrackDefaultList, "dart:html");
>+dart.setFieldSignature(html$.TrackDefaultList, () => ({
>+  __proto__: dart.getFields(html$.TrackDefaultList.__proto__),
>+  [$length]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("TrackDefaultList", html$.TrackDefaultList);
>+html$.TrackElement = class TrackElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.TrackElement._check(html$.document[$createElement]("track"));
>+  }
>+  static get supported() {
>+    return html$.Element.isTagSupported("track");
>+  }
>+  get [$defaultValue]() {
>+    return this.default;
>+  }
>+  set [$defaultValue](value) {
>+    this.default = value;
>+  }
>+  get [$kind]() {
>+    return this.kind;
>+  }
>+  set [$kind](value) {
>+    this.kind = value;
>+  }
>+  get [$label]() {
>+    return this.label;
>+  }
>+  set [$label](value) {
>+    this.label = value;
>+  }
>+  get [$readyState]() {
>+    return this.readyState;
>+  }
>+  get [$src]() {
>+    return this.src;
>+  }
>+  set [$src](value) {
>+    this.src = value;
>+  }
>+  get [$srclang]() {
>+    return this.srclang;
>+  }
>+  set [$srclang](value) {
>+    this.srclang = value;
>+  }
>+  get [$track]() {
>+    return this.track;
>+  }
>+};
>+(html$.TrackElement.created = function() {
>+  this[defaultValue$2] = null;
>+  this[kind$2] = null;
>+  this[label$6] = null;
>+  this[readyState$8] = null;
>+  this[src$7] = null;
>+  this[srclang] = null;
>+  this[track$5] = null;
>+  html$.TrackElement.__proto__.created.call(this);
>+}).prototype = html$.TrackElement.prototype;
>+dart.addTypeTests(html$.TrackElement);
>+const defaultValue$2 = Symbol("TrackElement.defaultValue");
>+const kind$2 = Symbol("TrackElement.kind");
>+const label$6 = Symbol("TrackElement.label");
>+const readyState$8 = Symbol("TrackElement.readyState");
>+const src$7 = Symbol("TrackElement.src");
>+const srclang = Symbol("TrackElement.srclang");
>+const track$5 = Symbol("TrackElement.track");
>+dart.setLibraryUri(html$.TrackElement, "dart:html");
>+dart.setFieldSignature(html$.TrackElement, () => ({
>+  __proto__: dart.getFields(html$.TrackElement.__proto__),
>+  [$defaultValue]: dart.fieldType(core.bool),
>+  [$kind]: dart.fieldType(core.String),
>+  [$label]: dart.fieldType(core.String),
>+  [$readyState]: dart.finalFieldType(core.int),
>+  [$src]: dart.fieldType(core.String),
>+  [$srclang]: dart.fieldType(core.String),
>+  [$track]: dart.finalFieldType(html$.TextTrack)
>+}));
>+dart.defineLazy(html$.TrackElement, {
>+  /*html$.TrackElement.ERROR*/get ERROR() {
>+    return 3;
>+  },
>+  /*html$.TrackElement.LOADED*/get LOADED() {
>+    return 2;
>+  },
>+  /*html$.TrackElement.LOADING*/get LOADING() {
>+    return 1;
>+  },
>+  /*html$.TrackElement.NONE*/get NONE() {
>+    return 0;
>+  }
>+});
>+dart.registerExtension("HTMLTrackElement", html$.TrackElement);
>+html$.TrackEvent = class TrackEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.TrackEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.TrackEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new TrackEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new TrackEvent(type);
>+  }
>+  get [$track]() {
>+    return this.track;
>+  }
>+};
>+dart.addTypeTests(html$.TrackEvent);
>+const track$6 = Symbol("TrackEvent.track");
>+dart.setLibraryUri(html$.TrackEvent, "dart:html");
>+dart.setFieldSignature(html$.TrackEvent, () => ({
>+  __proto__: dart.getFields(html$.TrackEvent.__proto__),
>+  [$track]: dart.finalFieldType(core.Object)
>+}));
>+dart.registerExtension("TrackEvent", html$.TrackEvent);
>+html$.TransitionEvent = class TransitionEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.TransitionEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.TransitionEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new TransitionEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new TransitionEvent(type);
>+  }
>+  get [$elapsedTime]() {
>+    return this.elapsedTime;
>+  }
>+  get [$propertyName]() {
>+    return this.propertyName;
>+  }
>+  get [$pseudoElement]() {
>+    return this.pseudoElement;
>+  }
>+};
>+dart.addTypeTests(html$.TransitionEvent);
>+const elapsedTime$0 = Symbol("TransitionEvent.elapsedTime");
>+const propertyName = Symbol("TransitionEvent.propertyName");
>+const pseudoElement = Symbol("TransitionEvent.pseudoElement");
>+dart.setLibraryUri(html$.TransitionEvent, "dart:html");
>+dart.setFieldSignature(html$.TransitionEvent, () => ({
>+  __proto__: dart.getFields(html$.TransitionEvent.__proto__),
>+  [$elapsedTime]: dart.finalFieldType(core.num),
>+  [$propertyName]: dart.finalFieldType(core.String),
>+  [$pseudoElement]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("TransitionEvent", html$.TransitionEvent);
>+dart.registerExtension("WebKitTransitionEvent", html$.TransitionEvent);
>+html$.TreeWalker = class TreeWalker extends _interceptors.Interceptor {
>+  static new(root, whatToShow) {
>+    return html$.document[_createTreeWalker](root, whatToShow, null);
>+  }
>+  get [$currentNode]() {
>+    return this.currentNode;
>+  }
>+  set [$currentNode](value) {
>+    this.currentNode = value;
>+  }
>+  get [$filter]() {
>+    return this.filter;
>+  }
>+  get [$root]() {
>+    return this.root;
>+  }
>+  get [$whatToShow]() {
>+    return this.whatToShow;
>+  }
>+  [$firstChild](...args) {
>+    return this.firstChild.apply(this, args);
>+  }
>+  [$lastChild](...args) {
>+    return this.lastChild.apply(this, args);
>+  }
>+  [$nextNode](...args) {
>+    return this.nextNode.apply(this, args);
>+  }
>+  [$nextSibling](...args) {
>+    return this.nextSibling.apply(this, args);
>+  }
>+  [$parentNode](...args) {
>+    return this.parentNode.apply(this, args);
>+  }
>+  [$previousNode](...args) {
>+    return this.previousNode.apply(this, args);
>+  }
>+  [$previousSibling](...args) {
>+    return this.previousSibling.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.TreeWalker);
>+const currentNode = Symbol("TreeWalker.currentNode");
>+const filter$1 = Symbol("TreeWalker.filter");
>+const root$1 = Symbol("TreeWalker.root");
>+const whatToShow$ = Symbol("TreeWalker.whatToShow");
>+dart.setMethodSignature(html$.TreeWalker, () => ({
>+  __proto__: dart.getMethods(html$.TreeWalker.__proto__),
>+  [$firstChild]: dart.fnType(html$.Node, []),
>+  [$lastChild]: dart.fnType(html$.Node, []),
>+  [$nextNode]: dart.fnType(html$.Node, []),
>+  [$nextSibling]: dart.fnType(html$.Node, []),
>+  [$parentNode]: dart.fnType(html$.Node, []),
>+  [$previousNode]: dart.fnType(html$.Node, []),
>+  [$previousSibling]: dart.fnType(html$.Node, [])
>+}));
>+dart.setLibraryUri(html$.TreeWalker, "dart:html");
>+dart.setFieldSignature(html$.TreeWalker, () => ({
>+  __proto__: dart.getFields(html$.TreeWalker.__proto__),
>+  [$currentNode]: dart.fieldType(html$.Node),
>+  [$filter]: dart.finalFieldType(html$.NodeFilter),
>+  [$root]: dart.finalFieldType(html$.Node),
>+  [$whatToShow]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("TreeWalker", html$.TreeWalker);
>+html$.TrustedHtml = class TrustedHtml extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$.TrustedHtml);
>+dart.setLibraryUri(html$.TrustedHtml, "dart:html");
>+dart.registerExtension("TrustedHTML", html$.TrustedHtml);
>+html$.TrustedScriptUrl = class TrustedScriptUrl extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$.TrustedScriptUrl);
>+dart.setLibraryUri(html$.TrustedScriptUrl, "dart:html");
>+dart.registerExtension("TrustedScriptURL", html$.TrustedScriptUrl);
>+html$.TrustedUrl = class TrustedUrl extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$.TrustedUrl);
>+dart.setLibraryUri(html$.TrustedUrl, "dart:html");
>+dart.registerExtension("TrustedURL", html$.TrustedUrl);
>+html$.UListElement = class UListElement extends html$.HtmlElement {
>+  static new() {
>+    return html$.document.createElement("ul");
>+  }
>+};
>+(html$.UListElement.created = function() {
>+  html$.UListElement.__proto__.created.call(this);
>+}).prototype = html$.UListElement.prototype;
>+dart.addTypeTests(html$.UListElement);
>+dart.setLibraryUri(html$.UListElement, "dart:html");
>+dart.registerExtension("HTMLUListElement", html$.UListElement);
>+html$.UnderlyingSourceBase = class UnderlyingSourceBase extends _interceptors.Interceptor {
>+  [$cancel](reason) {
>+    return html$.promiseToFuture(dart.dynamic, this.cancel(reason));
>+  }
>+  [$notifyLockAcquired](...args) {
>+    return this.notifyLockAcquired.apply(this, args);
>+  }
>+  [$notifyLockReleased](...args) {
>+    return this.notifyLockReleased.apply(this, args);
>+  }
>+  [$pull]() {
>+    return html$.promiseToFuture(dart.dynamic, this.pull());
>+  }
>+  [$start](stream) {
>+    return html$.promiseToFuture(dart.dynamic, this.start(stream));
>+  }
>+};
>+dart.addTypeTests(html$.UnderlyingSourceBase);
>+dart.setMethodSignature(html$.UnderlyingSourceBase, () => ({
>+  __proto__: dart.getMethods(html$.UnderlyingSourceBase.__proto__),
>+  [$cancel]: dart.fnType(async.Future, [core.Object]),
>+  [$notifyLockAcquired]: dart.fnType(dart.void, []),
>+  [$notifyLockReleased]: dart.fnType(dart.void, []),
>+  [$pull]: dart.fnType(async.Future, []),
>+  [$start]: dart.fnType(async.Future, [core.Object])
>+}));
>+dart.setLibraryUri(html$.UnderlyingSourceBase, "dart:html");
>+dart.registerExtension("UnderlyingSourceBase", html$.UnderlyingSourceBase);
>+html$.UnknownElement = class UnknownElement extends html$.HtmlElement {};
>+(html$.UnknownElement.created = function() {
>+  html$.UnknownElement.__proto__.created.call(this);
>+}).prototype = html$.UnknownElement.prototype;
>+dart.addTypeTests(html$.UnknownElement);
>+dart.setLibraryUri(html$.UnknownElement, "dart:html");
>+dart.registerExtension("HTMLUnknownElement", html$.UnknownElement);
>+html$.Url = class Url extends _interceptors.Interceptor {
>+  static createObjectUrl(blob_OR_source_OR_stream) {
>+    return (self.URL || self.webkitURL).createObjectURL(blob_OR_source_OR_stream);
>+  }
>+  static createObjectUrlFromSource(source) {
>+    return (self.URL || self.webkitURL).createObjectURL(source);
>+  }
>+  static createObjectUrlFromStream(stream) {
>+    return (self.URL || self.webkitURL).createObjectURL(stream);
>+  }
>+  static createObjectUrlFromBlob(blob) {
>+    return (self.URL || self.webkitURL).createObjectURL(blob);
>+  }
>+  static revokeObjectUrl(url) {
>+    return (self.URL || self.webkitURL).revokeObjectURL(url);
>+  }
>+  [$toString]() {
>+    return String(this);
>+  }
>+  get [$hash]() {
>+    return this.hash;
>+  }
>+  set [$hash](value) {
>+    this.hash = value;
>+  }
>+  get [$host]() {
>+    return this.host;
>+  }
>+  set [$host](value) {
>+    this.host = value;
>+  }
>+  get [$hostname]() {
>+    return this.hostname;
>+  }
>+  set [$hostname](value) {
>+    this.hostname = value;
>+  }
>+  get [$href]() {
>+    return this.href;
>+  }
>+  set [$href](value) {
>+    this.href = value;
>+  }
>+  get [$origin]() {
>+    return this.origin;
>+  }
>+  get [$password]() {
>+    return this.password;
>+  }
>+  set [$password](value) {
>+    this.password = value;
>+  }
>+  get [$pathname]() {
>+    return this.pathname;
>+  }
>+  set [$pathname](value) {
>+    this.pathname = value;
>+  }
>+  get [$port]() {
>+    return this.port;
>+  }
>+  set [$port](value) {
>+    this.port = value;
>+  }
>+  get [$protocol]() {
>+    return this.protocol;
>+  }
>+  set [$protocol](value) {
>+    this.protocol = value;
>+  }
>+  get [$search]() {
>+    return this.search;
>+  }
>+  set [$search](value) {
>+    this.search = value;
>+  }
>+  get [$searchParams]() {
>+    return this.searchParams;
>+  }
>+  get [$username]() {
>+    return this.username;
>+  }
>+  set [$username](value) {
>+    this.username = value;
>+  }
>+};
>+dart.addTypeTests(html$.Url);
>+const hash$2 = Symbol("Url.hash");
>+const host$3 = Symbol("Url.host");
>+const hostname$2 = Symbol("Url.hostname");
>+const href$6 = Symbol("Url.href");
>+const origin$6 = Symbol("Url.origin");
>+const password$2 = Symbol("Url.password");
>+const pathname$2 = Symbol("Url.pathname");
>+const port$6 = Symbol("Url.port");
>+const protocol$4 = Symbol("Url.protocol");
>+const search$2 = Symbol("Url.search");
>+const searchParams = Symbol("Url.searchParams");
>+const username$1 = Symbol("Url.username");
>+dart.setLibraryUri(html$.Url, "dart:html");
>+dart.setFieldSignature(html$.Url, () => ({
>+  __proto__: dart.getFields(html$.Url.__proto__),
>+  [$hash]: dart.fieldType(core.String),
>+  [$host]: dart.fieldType(core.String),
>+  [$hostname]: dart.fieldType(core.String),
>+  [$href]: dart.fieldType(core.String),
>+  [$origin]: dart.finalFieldType(core.String),
>+  [$password]: dart.fieldType(core.String),
>+  [$pathname]: dart.fieldType(core.String),
>+  [$port]: dart.fieldType(core.String),
>+  [$protocol]: dart.fieldType(core.String),
>+  [$search]: dart.fieldType(core.String),
>+  [$searchParams]: dart.finalFieldType(html$.UrlSearchParams),
>+  [$username]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("URL", html$.Url);
>+html$.UrlSearchParams = class UrlSearchParams extends _interceptors.Interceptor {
>+  static new(init) {
>+    if (init === void 0) init = null;
>+    if (init != null) {
>+      return html$.UrlSearchParams._create_1(init);
>+    }
>+    return html$.UrlSearchParams._create_2();
>+  }
>+  static _create_1(init) {
>+    return new URLSearchParams(init);
>+  }
>+  static _create_2() {
>+    return new URLSearchParams();
>+  }
>+  [$append](...args) {
>+    return this.append.apply(this, args);
>+  }
>+  [$delete](...args) {
>+    return this.delete.apply(this, args);
>+  }
>+  [$get](...args) {
>+    return this.get.apply(this, args);
>+  }
>+  [$getAll](...args) {
>+    return this.getAll.apply(this, args);
>+  }
>+  [$has](...args) {
>+    return this.has.apply(this, args);
>+  }
>+  [$set](...args) {
>+    return this.set.apply(this, args);
>+  }
>+  [$sort](...args) {
>+    return this.sort.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.UrlSearchParams);
>+dart.setMethodSignature(html$.UrlSearchParams, () => ({
>+  __proto__: dart.getMethods(html$.UrlSearchParams.__proto__),
>+  [$append]: dart.fnType(dart.void, [core.String, core.String]),
>+  [$delete]: dart.fnType(dart.void, [core.String]),
>+  [$get]: dart.fnType(core.String, [core.String]),
>+  [$getAll]: dart.fnType(core.List$(core.String), [core.String]),
>+  [$has]: dart.fnType(core.bool, [core.String]),
>+  [$set]: dart.fnType(dart.void, [core.String, core.String]),
>+  [$sort]: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(html$.UrlSearchParams, "dart:html");
>+dart.registerExtension("URLSearchParams", html$.UrlSearchParams);
>+html$.UrlUtilsReadOnly = class UrlUtilsReadOnly extends _interceptors.Interceptor {
>+  get hash() {
>+    return this[hash$3];
>+  }
>+  set hash(value) {
>+    super.hash = value;
>+  }
>+  get host() {
>+    return this[host$4];
>+  }
>+  set host(value) {
>+    super.host = value;
>+  }
>+  get hostname() {
>+    return this[hostname$3];
>+  }
>+  set hostname(value) {
>+    super.hostname = value;
>+  }
>+  get href() {
>+    return this[href$7];
>+  }
>+  set href(value) {
>+    super.href = value;
>+  }
>+  get origin() {
>+    return this[origin$7];
>+  }
>+  set origin(value) {
>+    super.origin = value;
>+  }
>+  get pathname() {
>+    return this[pathname$3];
>+  }
>+  set pathname(value) {
>+    super.pathname = value;
>+  }
>+  get port() {
>+    return this[port$7];
>+  }
>+  set port(value) {
>+    super.port = value;
>+  }
>+  get protocol() {
>+    return this[protocol$5];
>+  }
>+  set protocol(value) {
>+    super.protocol = value;
>+  }
>+  get search() {
>+    return this[search$3];
>+  }
>+  set search(value) {
>+    super.search = value;
>+  }
>+};
>+dart.addTypeTests(html$.UrlUtilsReadOnly);
>+const hash$3 = Symbol("UrlUtilsReadOnly.hash");
>+const host$4 = Symbol("UrlUtilsReadOnly.host");
>+const hostname$3 = Symbol("UrlUtilsReadOnly.hostname");
>+const href$7 = Symbol("UrlUtilsReadOnly.href");
>+const origin$7 = Symbol("UrlUtilsReadOnly.origin");
>+const pathname$3 = Symbol("UrlUtilsReadOnly.pathname");
>+const port$7 = Symbol("UrlUtilsReadOnly.port");
>+const protocol$5 = Symbol("UrlUtilsReadOnly.protocol");
>+const search$3 = Symbol("UrlUtilsReadOnly.search");
>+dart.setLibraryUri(html$.UrlUtilsReadOnly, "dart:html");
>+dart.setFieldSignature(html$.UrlUtilsReadOnly, () => ({
>+  __proto__: dart.getFields(html$.UrlUtilsReadOnly.__proto__),
>+  hash: dart.finalFieldType(core.String),
>+  host: dart.finalFieldType(core.String),
>+  hostname: dart.finalFieldType(core.String),
>+  href: dart.finalFieldType(core.String),
>+  origin: dart.finalFieldType(core.String),
>+  pathname: dart.finalFieldType(core.String),
>+  port: dart.finalFieldType(core.String),
>+  protocol: dart.finalFieldType(core.String),
>+  search: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionAccessors(html$.UrlUtilsReadOnly, [
>+  'hash',
>+  'host',
>+  'hostname',
>+  'href',
>+  'origin',
>+  'pathname',
>+  'port',
>+  'protocol',
>+  'search'
>+]);
>+html$.VR = class VR extends html$.EventTarget {
>+  [$getDevices]() {
>+    return html$.promiseToFuture(dart.dynamic, this.getDevices());
>+  }
>+};
>+dart.addTypeTests(html$.VR);
>+dart.setMethodSignature(html$.VR, () => ({
>+  __proto__: dart.getMethods(html$.VR.__proto__),
>+  [$getDevices]: dart.fnType(async.Future, [])
>+}));
>+dart.setLibraryUri(html$.VR, "dart:html");
>+dart.registerExtension("VR", html$.VR);
>+html$.VRCoordinateSystem = class VRCoordinateSystem extends _interceptors.Interceptor {
>+  [$getTransformTo](...args) {
>+    return this.getTransformTo.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.VRCoordinateSystem);
>+dart.setMethodSignature(html$.VRCoordinateSystem, () => ({
>+  __proto__: dart.getMethods(html$.VRCoordinateSystem.__proto__),
>+  [$getTransformTo]: dart.fnType(typed_data.Float32List, [html$.VRCoordinateSystem])
>+}));
>+dart.setLibraryUri(html$.VRCoordinateSystem, "dart:html");
>+dart.registerExtension("VRCoordinateSystem", html$.VRCoordinateSystem);
>+html$.VRDevice = class VRDevice extends html$.EventTarget {
>+  get [$deviceName]() {
>+    return this.deviceName;
>+  }
>+  get [$isExternal]() {
>+    return this.isExternal;
>+  }
>+  [$requestSession](options) {
>+    if (options === void 0) options = null;
>+    let options_dict = null;
>+    if (options != null) {
>+      options_dict = html_common.convertDartToNative_Dictionary(options);
>+    }
>+    return html$.promiseToFuture(dart.dynamic, this.requestSession(options_dict));
>+  }
>+  [$supportsSession](options) {
>+    if (options === void 0) options = null;
>+    let options_dict = null;
>+    if (options != null) {
>+      options_dict = html_common.convertDartToNative_Dictionary(options);
>+    }
>+    return html$.promiseToFuture(dart.dynamic, this.supportsSession(options_dict));
>+  }
>+};
>+dart.addTypeTests(html$.VRDevice);
>+const deviceName = Symbol("VRDevice.deviceName");
>+const isExternal = Symbol("VRDevice.isExternal");
>+dart.setMethodSignature(html$.VRDevice, () => ({
>+  __proto__: dart.getMethods(html$.VRDevice.__proto__),
>+  [$requestSession]: dart.fnType(async.Future, [], [core.Map]),
>+  [$supportsSession]: dart.fnType(async.Future, [], [core.Map])
>+}));
>+dart.setLibraryUri(html$.VRDevice, "dart:html");
>+dart.setFieldSignature(html$.VRDevice, () => ({
>+  __proto__: dart.getFields(html$.VRDevice.__proto__),
>+  [$deviceName]: dart.finalFieldType(core.String),
>+  [$isExternal]: dart.finalFieldType(core.bool)
>+}));
>+dart.registerExtension("VRDevice", html$.VRDevice);
>+html$.VRDeviceEvent = class VRDeviceEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+    return html$.VRDeviceEvent._create_1(type, eventInitDict_1);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new VRDeviceEvent(type, eventInitDict);
>+  }
>+  get [$device]() {
>+    return this.device;
>+  }
>+};
>+dart.addTypeTests(html$.VRDeviceEvent);
>+const device = Symbol("VRDeviceEvent.device");
>+dart.setLibraryUri(html$.VRDeviceEvent, "dart:html");
>+dart.setFieldSignature(html$.VRDeviceEvent, () => ({
>+  __proto__: dart.getFields(html$.VRDeviceEvent.__proto__),
>+  [$device]: dart.finalFieldType(html$.VRDevice)
>+}));
>+dart.registerExtension("VRDeviceEvent", html$.VRDeviceEvent);
>+html$.VRDisplay = class VRDisplay extends html$.EventTarget {
>+  get [$capabilities]() {
>+    return this.capabilities;
>+  }
>+  get [$depthFar]() {
>+    return this.depthFar;
>+  }
>+  set [$depthFar](value) {
>+    this.depthFar = value;
>+  }
>+  get [$depthNear]() {
>+    return this.depthNear;
>+  }
>+  set [$depthNear](value) {
>+    this.depthNear = value;
>+  }
>+  get [$displayId]() {
>+    return this.displayId;
>+  }
>+  get [$displayName]() {
>+    return this.displayName;
>+  }
>+  get [$isPresenting]() {
>+    return this.isPresenting;
>+  }
>+  get [$stageParameters]() {
>+    return this.stageParameters;
>+  }
>+  [$cancelAnimationFrame](...args) {
>+    return this.cancelAnimationFrame.apply(this, args);
>+  }
>+  [$exitPresent]() {
>+    return html$.promiseToFuture(dart.dynamic, this.exitPresent());
>+  }
>+  [$getEyeParameters](...args) {
>+    return this.getEyeParameters.apply(this, args);
>+  }
>+  [$getFrameData](...args) {
>+    return this.getFrameData.apply(this, args);
>+  }
>+  [$getLayers](...args) {
>+    return this.getLayers.apply(this, args);
>+  }
>+  [$requestAnimationFrame](...args) {
>+    return this.requestAnimationFrame.apply(this, args);
>+  }
>+  [$requestPresent](layers) {
>+    return html$.promiseToFuture(dart.dynamic, this.requestPresent(layers));
>+  }
>+  [$submitFrame](...args) {
>+    return this.submitFrame.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.VRDisplay);
>+const capabilities = Symbol("VRDisplay.capabilities");
>+const depthFar = Symbol("VRDisplay.depthFar");
>+const depthNear = Symbol("VRDisplay.depthNear");
>+const displayId$ = Symbol("VRDisplay.displayId");
>+const displayName = Symbol("VRDisplay.displayName");
>+const isPresenting = Symbol("VRDisplay.isPresenting");
>+const stageParameters = Symbol("VRDisplay.stageParameters");
>+dart.setMethodSignature(html$.VRDisplay, () => ({
>+  __proto__: dart.getMethods(html$.VRDisplay.__proto__),
>+  [$cancelAnimationFrame]: dart.fnType(dart.void, [core.int]),
>+  [$exitPresent]: dart.fnType(async.Future, []),
>+  [$getEyeParameters]: dart.fnType(html$.VREyeParameters, [core.String]),
>+  [$getFrameData]: dart.fnType(core.bool, [html$.VRFrameData]),
>+  [$getLayers]: dart.fnType(core.List$(core.Map), []),
>+  [$requestAnimationFrame]: dart.fnType(core.int, [dart.fnType(dart.void, [core.num])]),
>+  [$requestPresent]: dart.fnType(async.Future, [core.List$(core.Map)]),
>+  [$submitFrame]: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(html$.VRDisplay, "dart:html");
>+dart.setFieldSignature(html$.VRDisplay, () => ({
>+  __proto__: dart.getFields(html$.VRDisplay.__proto__),
>+  [$capabilities]: dart.finalFieldType(html$.VRDisplayCapabilities),
>+  [$depthFar]: dart.fieldType(core.num),
>+  [$depthNear]: dart.fieldType(core.num),
>+  [$displayId]: dart.finalFieldType(core.int),
>+  [$displayName]: dart.finalFieldType(core.String),
>+  [$isPresenting]: dart.finalFieldType(core.bool),
>+  [$stageParameters]: dart.finalFieldType(html$.VRStageParameters)
>+}));
>+dart.registerExtension("VRDisplay", html$.VRDisplay);
>+html$.VRDisplayCapabilities = class VRDisplayCapabilities extends _interceptors.Interceptor {
>+  get [$canPresent]() {
>+    return this.canPresent;
>+  }
>+  get [$hasExternalDisplay]() {
>+    return this.hasExternalDisplay;
>+  }
>+  get [$hasPosition]() {
>+    return this.hasPosition;
>+  }
>+  get [$maxLayers]() {
>+    return this.maxLayers;
>+  }
>+};
>+dart.addTypeTests(html$.VRDisplayCapabilities);
>+const canPresent = Symbol("VRDisplayCapabilities.canPresent");
>+const hasExternalDisplay = Symbol("VRDisplayCapabilities.hasExternalDisplay");
>+const hasPosition$ = Symbol("VRDisplayCapabilities.hasPosition");
>+const maxLayers = Symbol("VRDisplayCapabilities.maxLayers");
>+dart.setLibraryUri(html$.VRDisplayCapabilities, "dart:html");
>+dart.setFieldSignature(html$.VRDisplayCapabilities, () => ({
>+  __proto__: dart.getFields(html$.VRDisplayCapabilities.__proto__),
>+  [$canPresent]: dart.finalFieldType(core.bool),
>+  [$hasExternalDisplay]: dart.finalFieldType(core.bool),
>+  [$hasPosition]: dart.finalFieldType(core.bool),
>+  [$maxLayers]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("VRDisplayCapabilities", html$.VRDisplayCapabilities);
>+html$.VRDisplayEvent = class VRDisplayEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.VRDisplayEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.VRDisplayEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new VRDisplayEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new VRDisplayEvent(type);
>+  }
>+  get [$display]() {
>+    return this.display;
>+  }
>+  get [$reason]() {
>+    return this.reason;
>+  }
>+};
>+dart.addTypeTests(html$.VRDisplayEvent);
>+const display$ = Symbol("VRDisplayEvent.display");
>+const reason$2 = Symbol("VRDisplayEvent.reason");
>+dart.setLibraryUri(html$.VRDisplayEvent, "dart:html");
>+dart.setFieldSignature(html$.VRDisplayEvent, () => ({
>+  __proto__: dart.getFields(html$.VRDisplayEvent.__proto__),
>+  [$display]: dart.finalFieldType(html$.VRDisplay),
>+  [$reason]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("VRDisplayEvent", html$.VRDisplayEvent);
>+html$.VREyeParameters = class VREyeParameters extends _interceptors.Interceptor {
>+  get [$offset]() {
>+    return this.offset;
>+  }
>+  get [$renderHeight]() {
>+    return this.renderHeight;
>+  }
>+  get [$renderWidth]() {
>+    return this.renderWidth;
>+  }
>+};
>+dart.addTypeTests(html$.VREyeParameters);
>+const offset = Symbol("VREyeParameters.offset");
>+const renderHeight = Symbol("VREyeParameters.renderHeight");
>+const renderWidth = Symbol("VREyeParameters.renderWidth");
>+dart.setLibraryUri(html$.VREyeParameters, "dart:html");
>+dart.setFieldSignature(html$.VREyeParameters, () => ({
>+  __proto__: dart.getFields(html$.VREyeParameters.__proto__),
>+  [$offset]: dart.finalFieldType(typed_data.Float32List),
>+  [$renderHeight]: dart.finalFieldType(core.int),
>+  [$renderWidth]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("VREyeParameters", html$.VREyeParameters);
>+html$.VRFrameData = class VRFrameData$ extends _interceptors.Interceptor {
>+  static new() {
>+    return html$.VRFrameData._create_1();
>+  }
>+  static _create_1() {
>+    return new VRFrameData();
>+  }
>+  get [$leftProjectionMatrix]() {
>+    return this.leftProjectionMatrix;
>+  }
>+  get [$leftViewMatrix]() {
>+    return this.leftViewMatrix;
>+  }
>+  get [$pose]() {
>+    return this.pose;
>+  }
>+  get [$rightProjectionMatrix]() {
>+    return this.rightProjectionMatrix;
>+  }
>+  get [$rightViewMatrix]() {
>+    return this.rightViewMatrix;
>+  }
>+};
>+dart.addTypeTests(html$.VRFrameData);
>+const leftProjectionMatrix = Symbol("VRFrameData.leftProjectionMatrix");
>+const leftViewMatrix = Symbol("VRFrameData.leftViewMatrix");
>+const pose$ = Symbol("VRFrameData.pose");
>+const rightProjectionMatrix = Symbol("VRFrameData.rightProjectionMatrix");
>+const rightViewMatrix = Symbol("VRFrameData.rightViewMatrix");
>+dart.setLibraryUri(html$.VRFrameData, "dart:html");
>+dart.setFieldSignature(html$.VRFrameData, () => ({
>+  __proto__: dart.getFields(html$.VRFrameData.__proto__),
>+  [$leftProjectionMatrix]: dart.finalFieldType(typed_data.Float32List),
>+  [$leftViewMatrix]: dart.finalFieldType(typed_data.Float32List),
>+  [$pose]: dart.finalFieldType(html$.VRPose),
>+  [$rightProjectionMatrix]: dart.finalFieldType(typed_data.Float32List),
>+  [$rightViewMatrix]: dart.finalFieldType(typed_data.Float32List)
>+}));
>+dart.registerExtension("VRFrameData", html$.VRFrameData);
>+html$.VRFrameOfReference = class VRFrameOfReference extends html$.VRCoordinateSystem {
>+  get [$bounds]() {
>+    return this.bounds;
>+  }
>+  get [$emulatedHeight]() {
>+    return this.emulatedHeight;
>+  }
>+};
>+dart.addTypeTests(html$.VRFrameOfReference);
>+const bounds = Symbol("VRFrameOfReference.bounds");
>+const emulatedHeight = Symbol("VRFrameOfReference.emulatedHeight");
>+dart.setLibraryUri(html$.VRFrameOfReference, "dart:html");
>+dart.setFieldSignature(html$.VRFrameOfReference, () => ({
>+  __proto__: dart.getFields(html$.VRFrameOfReference.__proto__),
>+  [$bounds]: dart.finalFieldType(html$.VRStageBounds),
>+  [$emulatedHeight]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("VRFrameOfReference", html$.VRFrameOfReference);
>+html$.VRPose = class VRPose extends _interceptors.Interceptor {
>+  get [$angularAcceleration]() {
>+    return this.angularAcceleration;
>+  }
>+  get [$angularVelocity]() {
>+    return this.angularVelocity;
>+  }
>+  get [$linearAcceleration]() {
>+    return this.linearAcceleration;
>+  }
>+  get [$linearVelocity]() {
>+    return this.linearVelocity;
>+  }
>+  get [$orientation]() {
>+    return this.orientation;
>+  }
>+  get [$position]() {
>+    return this.position;
>+  }
>+};
>+dart.addTypeTests(html$.VRPose);
>+const angularAcceleration$ = Symbol("VRPose.angularAcceleration");
>+const angularVelocity$ = Symbol("VRPose.angularVelocity");
>+const linearAcceleration$ = Symbol("VRPose.linearAcceleration");
>+const linearVelocity$ = Symbol("VRPose.linearVelocity");
>+const orientation$2 = Symbol("VRPose.orientation");
>+const position$1 = Symbol("VRPose.position");
>+dart.setLibraryUri(html$.VRPose, "dart:html");
>+dart.setFieldSignature(html$.VRPose, () => ({
>+  __proto__: dart.getFields(html$.VRPose.__proto__),
>+  [$angularAcceleration]: dart.finalFieldType(typed_data.Float32List),
>+  [$angularVelocity]: dart.finalFieldType(typed_data.Float32List),
>+  [$linearAcceleration]: dart.finalFieldType(typed_data.Float32List),
>+  [$linearVelocity]: dart.finalFieldType(typed_data.Float32List),
>+  [$orientation]: dart.finalFieldType(typed_data.Float32List),
>+  [$position]: dart.finalFieldType(typed_data.Float32List)
>+}));
>+dart.registerExtension("VRPose", html$.VRPose);
>+html$.VRSession = class VRSession extends html$.EventTarget {
>+  get [$depthFar]() {
>+    return this.depthFar;
>+  }
>+  set [$depthFar](value) {
>+    this.depthFar = value;
>+  }
>+  get [$depthNear]() {
>+    return this.depthNear;
>+  }
>+  set [$depthNear](value) {
>+    this.depthNear = value;
>+  }
>+  get [$device]() {
>+    return this.device;
>+  }
>+  get [$exclusive]() {
>+    return this.exclusive;
>+  }
>+  [$end]() {
>+    return html$.promiseToFuture(dart.dynamic, this.end());
>+  }
>+  [$requestFrameOfReference](type, options) {
>+    if (options === void 0) options = null;
>+    let options_dict = null;
>+    if (options != null) {
>+      options_dict = html_common.convertDartToNative_Dictionary(options);
>+    }
>+    return html$.promiseToFuture(dart.dynamic, this.requestFrameOfReference(type, options_dict));
>+  }
>+  get [$onBlur]() {
>+    return html$.VRSession.blurEvent.forTarget(this);
>+  }
>+  get [$onFocus]() {
>+    return html$.VRSession.focusEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.VRSession);
>+const depthFar$ = Symbol("VRSession.depthFar");
>+const depthNear$ = Symbol("VRSession.depthNear");
>+const device$ = Symbol("VRSession.device");
>+const exclusive = Symbol("VRSession.exclusive");
>+dart.setMethodSignature(html$.VRSession, () => ({
>+  __proto__: dart.getMethods(html$.VRSession.__proto__),
>+  [$end]: dart.fnType(async.Future, []),
>+  [$requestFrameOfReference]: dart.fnType(async.Future, [core.String], [core.Map])
>+}));
>+dart.setGetterSignature(html$.VRSession, () => ({
>+  __proto__: dart.getGetters(html$.VRSession.__proto__),
>+  [$onBlur]: async.Stream$(html$.Event),
>+  [$onFocus]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.VRSession, "dart:html");
>+dart.setFieldSignature(html$.VRSession, () => ({
>+  __proto__: dart.getFields(html$.VRSession.__proto__),
>+  [$depthFar]: dart.fieldType(core.num),
>+  [$depthNear]: dart.fieldType(core.num),
>+  [$device]: dart.finalFieldType(html$.VRDevice),
>+  [$exclusive]: dart.finalFieldType(core.bool)
>+}));
>+dart.defineLazy(html$.VRSession, {
>+  /*html$.VRSession.blurEvent*/get blurEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("blur"));
>+  },
>+  /*html$.VRSession.focusEvent*/get focusEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("focus"));
>+  }
>+});
>+dart.registerExtension("VRSession", html$.VRSession);
>+html$.VRSessionEvent = class VRSessionEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+    return html$.VRSessionEvent._create_1(type, eventInitDict_1);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new VRSessionEvent(type, eventInitDict);
>+  }
>+  get [$session]() {
>+    return this.session;
>+  }
>+};
>+dart.addTypeTests(html$.VRSessionEvent);
>+const session = Symbol("VRSessionEvent.session");
>+dart.setLibraryUri(html$.VRSessionEvent, "dart:html");
>+dart.setFieldSignature(html$.VRSessionEvent, () => ({
>+  __proto__: dart.getFields(html$.VRSessionEvent.__proto__),
>+  [$session]: dart.finalFieldType(html$.VRSession)
>+}));
>+dart.registerExtension("VRSessionEvent", html$.VRSessionEvent);
>+html$.VRStageBounds = class VRStageBounds extends _interceptors.Interceptor {
>+  get [$geometry]() {
>+    return this.geometry;
>+  }
>+};
>+dart.addTypeTests(html$.VRStageBounds);
>+const geometry = Symbol("VRStageBounds.geometry");
>+dart.setLibraryUri(html$.VRStageBounds, "dart:html");
>+dart.setFieldSignature(html$.VRStageBounds, () => ({
>+  __proto__: dart.getFields(html$.VRStageBounds.__proto__),
>+  [$geometry]: dart.finalFieldType(ListOfVRStageBoundsPoint())
>+}));
>+dart.registerExtension("VRStageBounds", html$.VRStageBounds);
>+html$.VRStageBoundsPoint = class VRStageBoundsPoint extends _interceptors.Interceptor {
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$z]() {
>+    return this.z;
>+  }
>+};
>+dart.addTypeTests(html$.VRStageBoundsPoint);
>+const x$6 = Symbol("VRStageBoundsPoint.x");
>+const z$5 = Symbol("VRStageBoundsPoint.z");
>+dart.setLibraryUri(html$.VRStageBoundsPoint, "dart:html");
>+dart.setFieldSignature(html$.VRStageBoundsPoint, () => ({
>+  __proto__: dart.getFields(html$.VRStageBoundsPoint.__proto__),
>+  [$x]: dart.finalFieldType(core.num),
>+  [$z]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("VRStageBoundsPoint", html$.VRStageBoundsPoint);
>+html$.VRStageParameters = class VRStageParameters extends _interceptors.Interceptor {
>+  get [$sittingToStandingTransform]() {
>+    return this.sittingToStandingTransform;
>+  }
>+  get [$sizeX]() {
>+    return this.sizeX;
>+  }
>+  get [$sizeZ]() {
>+    return this.sizeZ;
>+  }
>+};
>+dart.addTypeTests(html$.VRStageParameters);
>+const sittingToStandingTransform = Symbol("VRStageParameters.sittingToStandingTransform");
>+const sizeX = Symbol("VRStageParameters.sizeX");
>+const sizeZ = Symbol("VRStageParameters.sizeZ");
>+dart.setLibraryUri(html$.VRStageParameters, "dart:html");
>+dart.setFieldSignature(html$.VRStageParameters, () => ({
>+  __proto__: dart.getFields(html$.VRStageParameters.__proto__),
>+  [$sittingToStandingTransform]: dart.finalFieldType(typed_data.Float32List),
>+  [$sizeX]: dart.finalFieldType(core.num),
>+  [$sizeZ]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("VRStageParameters", html$.VRStageParameters);
>+html$.ValidityState = class ValidityState extends _interceptors.Interceptor {
>+  get [$badInput]() {
>+    return this.badInput;
>+  }
>+  get [$customError]() {
>+    return this.customError;
>+  }
>+  get [$patternMismatch]() {
>+    return this.patternMismatch;
>+  }
>+  get [$rangeOverflow]() {
>+    return this.rangeOverflow;
>+  }
>+  get [$rangeUnderflow]() {
>+    return this.rangeUnderflow;
>+  }
>+  get [$stepMismatch]() {
>+    return this.stepMismatch;
>+  }
>+  get [$tooLong]() {
>+    return this.tooLong;
>+  }
>+  get [$tooShort]() {
>+    return this.tooShort;
>+  }
>+  get [$typeMismatch]() {
>+    return this.typeMismatch;
>+  }
>+  get [$valid]() {
>+    return this.valid;
>+  }
>+  get [$valueMissing]() {
>+    return this.valueMissing;
>+  }
>+};
>+dart.addTypeTests(html$.ValidityState);
>+const badInput = Symbol("ValidityState.badInput");
>+const customError = Symbol("ValidityState.customError");
>+const patternMismatch = Symbol("ValidityState.patternMismatch");
>+const rangeOverflow = Symbol("ValidityState.rangeOverflow");
>+const rangeUnderflow = Symbol("ValidityState.rangeUnderflow");
>+const stepMismatch = Symbol("ValidityState.stepMismatch");
>+const tooLong = Symbol("ValidityState.tooLong");
>+const tooShort = Symbol("ValidityState.tooShort");
>+const typeMismatch = Symbol("ValidityState.typeMismatch");
>+const valid = Symbol("ValidityState.valid");
>+const valueMissing = Symbol("ValidityState.valueMissing");
>+dart.setLibraryUri(html$.ValidityState, "dart:html");
>+dart.setFieldSignature(html$.ValidityState, () => ({
>+  __proto__: dart.getFields(html$.ValidityState.__proto__),
>+  [$badInput]: dart.finalFieldType(core.bool),
>+  [$customError]: dart.finalFieldType(core.bool),
>+  [$patternMismatch]: dart.finalFieldType(core.bool),
>+  [$rangeOverflow]: dart.finalFieldType(core.bool),
>+  [$rangeUnderflow]: dart.finalFieldType(core.bool),
>+  [$stepMismatch]: dart.finalFieldType(core.bool),
>+  [$tooLong]: dart.finalFieldType(core.bool),
>+  [$tooShort]: dart.finalFieldType(core.bool),
>+  [$typeMismatch]: dart.finalFieldType(core.bool),
>+  [$valid]: dart.finalFieldType(core.bool),
>+  [$valueMissing]: dart.finalFieldType(core.bool)
>+}));
>+dart.registerExtension("ValidityState", html$.ValidityState);
>+html$.VideoElement = class VideoElement extends html$.MediaElement {
>+  static new() {
>+    return html$.document.createElement("video");
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  set [$height](value) {
>+    this.height = value;
>+  }
>+  get [$poster]() {
>+    return this.poster;
>+  }
>+  set [$poster](value) {
>+    this.poster = value;
>+  }
>+  get [$videoHeight]() {
>+    return this.videoHeight;
>+  }
>+  get [$videoWidth]() {
>+    return this.videoWidth;
>+  }
>+  get [$decodedFrameCount]() {
>+    return this.webkitDecodedFrameCount;
>+  }
>+  get [$droppedFrameCount]() {
>+    return this.webkitDroppedFrameCount;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  set [$width](value) {
>+    this.width = value;
>+  }
>+  [$getVideoPlaybackQuality](...args) {
>+    return this.getVideoPlaybackQuality.apply(this, args);
>+  }
>+  [$enterFullscreen](...args) {
>+    return this.webkitEnterFullscreen.apply(this, args);
>+  }
>+  [$exitFullscreen](...args) {
>+    return this.webkitExitFullscreen.apply(this, args);
>+  }
>+};
>+(html$.VideoElement.created = function() {
>+  this[height$11] = null;
>+  this[poster] = null;
>+  this[videoHeight] = null;
>+  this[videoWidth] = null;
>+  this[decodedFrameCount] = null;
>+  this[droppedFrameCount] = null;
>+  this[width$12] = null;
>+  html$.VideoElement.__proto__.created.call(this);
>+}).prototype = html$.VideoElement.prototype;
>+dart.addTypeTests(html$.VideoElement);
>+const height$11 = Symbol("VideoElement.height");
>+const poster = Symbol("VideoElement.poster");
>+const videoHeight = Symbol("VideoElement.videoHeight");
>+const videoWidth = Symbol("VideoElement.videoWidth");
>+const decodedFrameCount = Symbol("VideoElement.decodedFrameCount");
>+const droppedFrameCount = Symbol("VideoElement.droppedFrameCount");
>+const width$12 = Symbol("VideoElement.width");
>+html$.VideoElement[dart.implements] = () => [html$.CanvasImageSource];
>+dart.setMethodSignature(html$.VideoElement, () => ({
>+  __proto__: dart.getMethods(html$.VideoElement.__proto__),
>+  [$getVideoPlaybackQuality]: dart.fnType(html$.VideoPlaybackQuality, []),
>+  [$enterFullscreen]: dart.fnType(dart.void, []),
>+  [$exitFullscreen]: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(html$.VideoElement, "dart:html");
>+dart.setFieldSignature(html$.VideoElement, () => ({
>+  __proto__: dart.getFields(html$.VideoElement.__proto__),
>+  [$height]: dart.fieldType(core.int),
>+  [$poster]: dart.fieldType(core.String),
>+  [$videoHeight]: dart.finalFieldType(core.int),
>+  [$videoWidth]: dart.finalFieldType(core.int),
>+  [$decodedFrameCount]: dart.finalFieldType(core.int),
>+  [$droppedFrameCount]: dart.finalFieldType(core.int),
>+  [$width]: dart.fieldType(core.int)
>+}));
>+dart.registerExtension("HTMLVideoElement", html$.VideoElement);
>+html$.VideoPlaybackQuality = class VideoPlaybackQuality extends _interceptors.Interceptor {
>+  get [$corruptedVideoFrames]() {
>+    return this.corruptedVideoFrames;
>+  }
>+  get [$creationTime]() {
>+    return this.creationTime;
>+  }
>+  get [$droppedVideoFrames]() {
>+    return this.droppedVideoFrames;
>+  }
>+  get [$totalVideoFrames]() {
>+    return this.totalVideoFrames;
>+  }
>+};
>+dart.addTypeTests(html$.VideoPlaybackQuality);
>+const corruptedVideoFrames = Symbol("VideoPlaybackQuality.corruptedVideoFrames");
>+const creationTime = Symbol("VideoPlaybackQuality.creationTime");
>+const droppedVideoFrames = Symbol("VideoPlaybackQuality.droppedVideoFrames");
>+const totalVideoFrames = Symbol("VideoPlaybackQuality.totalVideoFrames");
>+dart.setLibraryUri(html$.VideoPlaybackQuality, "dart:html");
>+dart.setFieldSignature(html$.VideoPlaybackQuality, () => ({
>+  __proto__: dart.getFields(html$.VideoPlaybackQuality.__proto__),
>+  [$corruptedVideoFrames]: dart.finalFieldType(core.int),
>+  [$creationTime]: dart.finalFieldType(core.num),
>+  [$droppedVideoFrames]: dart.finalFieldType(core.int),
>+  [$totalVideoFrames]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("VideoPlaybackQuality", html$.VideoPlaybackQuality);
>+html$.VideoTrack = class VideoTrack extends _interceptors.Interceptor {
>+  get [$id]() {
>+    return this.id;
>+  }
>+  get [$kind]() {
>+    return this.kind;
>+  }
>+  get [$label]() {
>+    return this.label;
>+  }
>+  get [$language]() {
>+    return this.language;
>+  }
>+  get [$selected]() {
>+    return this.selected;
>+  }
>+  set [$selected](value) {
>+    this.selected = value;
>+  }
>+  get [$sourceBuffer]() {
>+    return this.sourceBuffer;
>+  }
>+};
>+dart.addTypeTests(html$.VideoTrack);
>+const id$16 = Symbol("VideoTrack.id");
>+const kind$3 = Symbol("VideoTrack.kind");
>+const label$7 = Symbol("VideoTrack.label");
>+const language$1 = Symbol("VideoTrack.language");
>+const selected$0 = Symbol("VideoTrack.selected");
>+const sourceBuffer = Symbol("VideoTrack.sourceBuffer");
>+dart.setLibraryUri(html$.VideoTrack, "dart:html");
>+dart.setFieldSignature(html$.VideoTrack, () => ({
>+  __proto__: dart.getFields(html$.VideoTrack.__proto__),
>+  [$id]: dart.finalFieldType(core.String),
>+  [$kind]: dart.finalFieldType(core.String),
>+  [$label]: dart.finalFieldType(core.String),
>+  [$language]: dart.finalFieldType(core.String),
>+  [$selected]: dart.fieldType(core.bool),
>+  [$sourceBuffer]: dart.finalFieldType(html$.SourceBuffer)
>+}));
>+dart.registerExtension("VideoTrack", html$.VideoTrack);
>+html$.VideoTrackList = class VideoTrackList extends html$.EventTarget {
>+  get [$length]() {
>+    return this.length;
>+  }
>+  get [$selectedIndex]() {
>+    return this.selectedIndex;
>+  }
>+  [__getter__](...args) {
>+    return this.__getter__.apply(this, args);
>+  }
>+  [$getTrackById](...args) {
>+    return this.getTrackById.apply(this, args);
>+  }
>+  get [$onChange]() {
>+    return html$.VideoTrackList.changeEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.VideoTrackList);
>+const length$16 = Symbol("VideoTrackList.length");
>+const selectedIndex$ = Symbol("VideoTrackList.selectedIndex");
>+dart.setMethodSignature(html$.VideoTrackList, () => ({
>+  __proto__: dart.getMethods(html$.VideoTrackList.__proto__),
>+  [__getter__]: dart.fnType(html$.VideoTrack, [core.int]),
>+  [$getTrackById]: dart.fnType(html$.VideoTrack, [core.String])
>+}));
>+dart.setGetterSignature(html$.VideoTrackList, () => ({
>+  __proto__: dart.getGetters(html$.VideoTrackList.__proto__),
>+  [$onChange]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.VideoTrackList, "dart:html");
>+dart.setFieldSignature(html$.VideoTrackList, () => ({
>+  __proto__: dart.getFields(html$.VideoTrackList.__proto__),
>+  [$length]: dart.finalFieldType(core.int),
>+  [$selectedIndex]: dart.finalFieldType(core.int)
>+}));
>+dart.defineLazy(html$.VideoTrackList, {
>+  /*html$.VideoTrackList.changeEvent*/get changeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("change"));
>+  }
>+});
>+dart.registerExtension("VideoTrackList", html$.VideoTrackList);
>+html$.VisualViewport = class VisualViewport extends html$.EventTarget {
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$offsetLeft]() {
>+    return this.offsetLeft;
>+  }
>+  get [$offsetTop]() {
>+    return this.offsetTop;
>+  }
>+  get [$pageLeft]() {
>+    return this.pageLeft;
>+  }
>+  get [$pageTop]() {
>+    return this.pageTop;
>+  }
>+  get [$scale]() {
>+    return this.scale;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  get [$onResize]() {
>+    return html$.VisualViewport.resizeEvent.forTarget(this);
>+  }
>+  get [$onScroll]() {
>+    return html$.VisualViewport.scrollEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.VisualViewport);
>+const height$12 = Symbol("VisualViewport.height");
>+const offsetLeft = Symbol("VisualViewport.offsetLeft");
>+const offsetTop = Symbol("VisualViewport.offsetTop");
>+const pageLeft = Symbol("VisualViewport.pageLeft");
>+const pageTop = Symbol("VisualViewport.pageTop");
>+const scale = Symbol("VisualViewport.scale");
>+const width$13 = Symbol("VisualViewport.width");
>+dart.setGetterSignature(html$.VisualViewport, () => ({
>+  __proto__: dart.getGetters(html$.VisualViewport.__proto__),
>+  [$onResize]: async.Stream$(html$.Event),
>+  [$onScroll]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.VisualViewport, "dart:html");
>+dart.setFieldSignature(html$.VisualViewport, () => ({
>+  __proto__: dart.getFields(html$.VisualViewport.__proto__),
>+  [$height]: dart.finalFieldType(core.num),
>+  [$offsetLeft]: dart.finalFieldType(core.num),
>+  [$offsetTop]: dart.finalFieldType(core.num),
>+  [$pageLeft]: dart.finalFieldType(core.num),
>+  [$pageTop]: dart.finalFieldType(core.num),
>+  [$scale]: dart.finalFieldType(core.num),
>+  [$width]: dart.finalFieldType(core.num)
>+}));
>+dart.defineLazy(html$.VisualViewport, {
>+  /*html$.VisualViewport.resizeEvent*/get resizeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("resize"));
>+  },
>+  /*html$.VisualViewport.scrollEvent*/get scrollEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("scroll"));
>+  }
>+});
>+dart.registerExtension("VisualViewport", html$.VisualViewport);
>+html$.VttCue = class VttCue extends html$.TextTrackCue {
>+  static new(startTime, endTime, text) {
>+    return html$.VttCue._create_1(startTime, endTime, text);
>+  }
>+  static _create_1(startTime, endTime, text) {
>+    return new VTTCue(startTime, endTime, text);
>+  }
>+  get [$align]() {
>+    return this.align;
>+  }
>+  set [$align](value) {
>+    this.align = value;
>+  }
>+  get [$line]() {
>+    return this.line;
>+  }
>+  set [$line](value) {
>+    this.line = value;
>+  }
>+  get [$position]() {
>+    return this.position;
>+  }
>+  set [$position](value) {
>+    this.position = value;
>+  }
>+  get [$region]() {
>+    return this.region;
>+  }
>+  set [$region](value) {
>+    this.region = value;
>+  }
>+  get [$size]() {
>+    return this.size;
>+  }
>+  set [$size](value) {
>+    this.size = value;
>+  }
>+  get [$snapToLines]() {
>+    return this.snapToLines;
>+  }
>+  set [$snapToLines](value) {
>+    this.snapToLines = value;
>+  }
>+  get [$text]() {
>+    return this.text;
>+  }
>+  set [$text](value) {
>+    this.text = value;
>+  }
>+  get [$vertical]() {
>+    return this.vertical;
>+  }
>+  set [$vertical](value) {
>+    this.vertical = value;
>+  }
>+  [$getCueAsHtml](...args) {
>+    return this.getCueAsHTML.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.VttCue);
>+const align = Symbol("VttCue.align");
>+const line = Symbol("VttCue.line");
>+const position$2 = Symbol("VttCue.position");
>+const region$1 = Symbol("VttCue.region");
>+const size$6 = Symbol("VttCue.size");
>+const snapToLines = Symbol("VttCue.snapToLines");
>+const text$1 = Symbol("VttCue.text");
>+const vertical = Symbol("VttCue.vertical");
>+dart.setMethodSignature(html$.VttCue, () => ({
>+  __proto__: dart.getMethods(html$.VttCue.__proto__),
>+  [$getCueAsHtml]: dart.fnType(html$.DocumentFragment, [])
>+}));
>+dart.setLibraryUri(html$.VttCue, "dart:html");
>+dart.setFieldSignature(html$.VttCue, () => ({
>+  __proto__: dart.getFields(html$.VttCue.__proto__),
>+  [$align]: dart.fieldType(core.String),
>+  [$line]: dart.fieldType(core.Object),
>+  [$position]: dart.fieldType(core.Object),
>+  [$region]: dart.fieldType(html$.VttRegion),
>+  [$size]: dart.fieldType(core.num),
>+  [$snapToLines]: dart.fieldType(core.bool),
>+  [$text]: dart.fieldType(core.String),
>+  [$vertical]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("VTTCue", html$.VttCue);
>+html$.VttRegion = class VttRegion extends _interceptors.Interceptor {
>+  static new() {
>+    return html$.VttRegion._create_1();
>+  }
>+  static _create_1() {
>+    return new VTTRegion();
>+  }
>+  get [$id]() {
>+    return this.id;
>+  }
>+  set [$id](value) {
>+    this.id = value;
>+  }
>+  get [$lines]() {
>+    return this.lines;
>+  }
>+  set [$lines](value) {
>+    this.lines = value;
>+  }
>+  get [$regionAnchorX]() {
>+    return this.regionAnchorX;
>+  }
>+  set [$regionAnchorX](value) {
>+    this.regionAnchorX = value;
>+  }
>+  get [$regionAnchorY]() {
>+    return this.regionAnchorY;
>+  }
>+  set [$regionAnchorY](value) {
>+    this.regionAnchorY = value;
>+  }
>+  get [$scroll]() {
>+    return this.scroll;
>+  }
>+  set [$scroll](value) {
>+    this.scroll = value;
>+  }
>+  get [$viewportAnchorX]() {
>+    return this.viewportAnchorX;
>+  }
>+  set [$viewportAnchorX](value) {
>+    this.viewportAnchorX = value;
>+  }
>+  get [$viewportAnchorY]() {
>+    return this.viewportAnchorY;
>+  }
>+  set [$viewportAnchorY](value) {
>+    this.viewportAnchorY = value;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  set [$width](value) {
>+    this.width = value;
>+  }
>+};
>+dart.addTypeTests(html$.VttRegion);
>+const id$17 = Symbol("VttRegion.id");
>+const lines = Symbol("VttRegion.lines");
>+const regionAnchorX = Symbol("VttRegion.regionAnchorX");
>+const regionAnchorY = Symbol("VttRegion.regionAnchorY");
>+const scroll = Symbol("VttRegion.scroll");
>+const viewportAnchorX = Symbol("VttRegion.viewportAnchorX");
>+const viewportAnchorY = Symbol("VttRegion.viewportAnchorY");
>+const width$14 = Symbol("VttRegion.width");
>+dart.setLibraryUri(html$.VttRegion, "dart:html");
>+dart.setFieldSignature(html$.VttRegion, () => ({
>+  __proto__: dart.getFields(html$.VttRegion.__proto__),
>+  [$id]: dart.fieldType(core.String),
>+  [$lines]: dart.fieldType(core.int),
>+  [$regionAnchorX]: dart.fieldType(core.num),
>+  [$regionAnchorY]: dart.fieldType(core.num),
>+  [$scroll]: dart.fieldType(core.String),
>+  [$viewportAnchorX]: dart.fieldType(core.num),
>+  [$viewportAnchorY]: dart.fieldType(core.num),
>+  [$width]: dart.fieldType(core.num)
>+}));
>+dart.registerExtension("VTTRegion", html$.VttRegion);
>+html$.WebSocket = class WebSocket$ extends html$.EventTarget {
>+  static new(url, protocols) {
>+    if (protocols === void 0) protocols = null;
>+    if (protocols != null) {
>+      return html$.WebSocket._create_1(url, protocols);
>+    }
>+    return html$.WebSocket._create_2(url);
>+  }
>+  static _create_1(url, protocols) {
>+    return new WebSocket(url, protocols);
>+  }
>+  static _create_2(url) {
>+    return new WebSocket(url);
>+  }
>+  static get supported() {
>+    return typeof window.WebSocket != "undefined";
>+  }
>+  get [$binaryType]() {
>+    return this.binaryType;
>+  }
>+  set [$binaryType](value) {
>+    this.binaryType = value;
>+  }
>+  get [$bufferedAmount]() {
>+    return this.bufferedAmount;
>+  }
>+  get [$extensions]() {
>+    return this.extensions;
>+  }
>+  get [$protocol]() {
>+    return this.protocol;
>+  }
>+  get [$readyState]() {
>+    return this.readyState;
>+  }
>+  get [$url]() {
>+    return this.url;
>+  }
>+  [$close](...args) {
>+    return this.close.apply(this, args);
>+  }
>+  [$send](...args) {
>+    return this.send.apply(this, args);
>+  }
>+  [$sendBlob](...args) {
>+    return this.send.apply(this, args);
>+  }
>+  [$sendByteBuffer](...args) {
>+    return this.send.apply(this, args);
>+  }
>+  [$sendString](...args) {
>+    return this.send.apply(this, args);
>+  }
>+  [$sendTypedData](...args) {
>+    return this.send.apply(this, args);
>+  }
>+  get [$onClose]() {
>+    return html$.WebSocket.closeEvent.forTarget(this);
>+  }
>+  get [$onError]() {
>+    return html$.WebSocket.errorEvent.forTarget(this);
>+  }
>+  get [$onMessage]() {
>+    return html$.WebSocket.messageEvent.forTarget(this);
>+  }
>+  get [$onOpen]() {
>+    return html$.WebSocket.openEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.WebSocket);
>+const binaryType$0 = Symbol("WebSocket.binaryType");
>+const bufferedAmount$ = Symbol("WebSocket.bufferedAmount");
>+const extensions = Symbol("WebSocket.extensions");
>+const protocol$6 = Symbol("WebSocket.protocol");
>+const readyState$9 = Symbol("WebSocket.readyState");
>+const url$5 = Symbol("WebSocket.url");
>+dart.setMethodSignature(html$.WebSocket, () => ({
>+  __proto__: dart.getMethods(html$.WebSocket.__proto__),
>+  [$close]: dart.fnType(dart.void, [], [core.int, core.String]),
>+  [$send]: dart.fnType(dart.void, [dart.dynamic]),
>+  [$sendBlob]: dart.fnType(dart.void, [html$.Blob]),
>+  [$sendByteBuffer]: dart.fnType(dart.void, [typed_data.ByteBuffer]),
>+  [$sendString]: dart.fnType(dart.void, [core.String]),
>+  [$sendTypedData]: dart.fnType(dart.void, [typed_data.TypedData])
>+}));
>+dart.setGetterSignature(html$.WebSocket, () => ({
>+  __proto__: dart.getGetters(html$.WebSocket.__proto__),
>+  [$onClose]: async.Stream$(html$.CloseEvent),
>+  [$onError]: async.Stream$(html$.Event),
>+  [$onMessage]: async.Stream$(html$.MessageEvent),
>+  [$onOpen]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.WebSocket, "dart:html");
>+dart.setFieldSignature(html$.WebSocket, () => ({
>+  __proto__: dart.getFields(html$.WebSocket.__proto__),
>+  [$binaryType]: dart.fieldType(core.String),
>+  [$bufferedAmount]: dart.finalFieldType(core.int),
>+  [$extensions]: dart.finalFieldType(core.String),
>+  [$protocol]: dart.finalFieldType(core.String),
>+  [$readyState]: dart.finalFieldType(core.int),
>+  [$url]: dart.finalFieldType(core.String)
>+}));
>+dart.defineLazy(html$.WebSocket, {
>+  /*html$.WebSocket.closeEvent*/get closeEvent() {
>+    return dart.const(new (EventStreamProviderOfCloseEvent()).new("close"));
>+  },
>+  /*html$.WebSocket.errorEvent*/get errorEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("error"));
>+  },
>+  /*html$.WebSocket.messageEvent*/get messageEvent() {
>+    return dart.const(new (EventStreamProviderOfMessageEvent()).new("message"));
>+  },
>+  /*html$.WebSocket.openEvent*/get openEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("open"));
>+  },
>+  /*html$.WebSocket.CLOSED*/get CLOSED() {
>+    return 3;
>+  },
>+  /*html$.WebSocket.CLOSING*/get CLOSING() {
>+    return 2;
>+  },
>+  /*html$.WebSocket.CONNECTING*/get CONNECTING() {
>+    return 0;
>+  },
>+  /*html$.WebSocket.OPEN*/get OPEN() {
>+    return 1;
>+  }
>+});
>+dart.registerExtension("WebSocket", html$.WebSocket);
>+const _deltaX = dart.privateName(html$, "_deltaX");
>+const _deltaY = dart.privateName(html$, "_deltaY");
>+const _wheelDelta = dart.privateName(html$, "_wheelDelta");
>+const _wheelDeltaX = dart.privateName(html$, "_wheelDeltaX");
>+const _hasInitMouseScrollEvent = dart.privateName(html$, "_hasInitMouseScrollEvent");
>+const _initMouseScrollEvent = dart.privateName(html$, "_initMouseScrollEvent");
>+const _hasInitWheelEvent = dart.privateName(html$, "_hasInitWheelEvent");
>+const _initWheelEvent = dart.privateName(html$, "_initWheelEvent");
>+html$.WheelEvent = class WheelEvent$ extends html$.MouseEvent {
>+  static new(type, opts) {
>+    let view = opts && 'view' in opts ? opts.view : null;
>+    let deltaX = opts && 'deltaX' in opts ? opts.deltaX : 0;
>+    let deltaY = opts && 'deltaY' in opts ? opts.deltaY : 0;
>+    let deltaZ = opts && 'deltaZ' in opts ? opts.deltaZ : 0;
>+    let deltaMode = opts && 'deltaMode' in opts ? opts.deltaMode : 0;
>+    let detail = opts && 'detail' in opts ? opts.detail : 0;
>+    let screenX = opts && 'screenX' in opts ? opts.screenX : 0;
>+    let screenY = opts && 'screenY' in opts ? opts.screenY : 0;
>+    let clientX = opts && 'clientX' in opts ? opts.clientX : 0;
>+    let clientY = opts && 'clientY' in opts ? opts.clientY : 0;
>+    let button = opts && 'button' in opts ? opts.button : 0;
>+    let canBubble = opts && 'canBubble' in opts ? opts.canBubble : true;
>+    let cancelable = opts && 'cancelable' in opts ? opts.cancelable : true;
>+    let ctrlKey = opts && 'ctrlKey' in opts ? opts.ctrlKey : false;
>+    let altKey = opts && 'altKey' in opts ? opts.altKey : false;
>+    let shiftKey = opts && 'shiftKey' in opts ? opts.shiftKey : false;
>+    let metaKey = opts && 'metaKey' in opts ? opts.metaKey : false;
>+    let relatedTarget = opts && 'relatedTarget' in opts ? opts.relatedTarget : null;
>+    let options = new (IdentityMapOfString$Object()).from(["view", view, "deltaMode", deltaMode, "deltaX", deltaX, "deltaY", deltaY, "deltaZ", deltaZ, "detail", detail, "screenX", screenX, "screenY", screenY, "clientX", clientX, "clientY", clientY, "button", button, "bubbles", canBubble, "cancelable", cancelable, "ctrlKey", ctrlKey, "altKey", altKey, "shiftKey", shiftKey, "metaKey", metaKey, "relatedTarget", relatedTarget]);
>+    if (view == null) {
>+      view = html$.window;
>+    }
>+    return new WheelEvent(type, html_common.convertDartToNative_Dictionary(options));
>+  }
>+  static __(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$.WheelEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$.WheelEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new WheelEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new WheelEvent(type);
>+  }
>+  get [_deltaX]() {
>+    return this.deltaX;
>+  }
>+  get [_deltaY]() {
>+    return this.deltaY;
>+  }
>+  get [$deltaZ]() {
>+    return this.deltaZ;
>+  }
>+  get [$deltaY]() {
>+    if (this.deltaY !== undefined) {
>+      return this[_deltaY];
>+    }
>+    dart.throw(new core.UnsupportedError.new("deltaY is not supported"));
>+  }
>+  get [$deltaX]() {
>+    if (this.deltaX !== undefined) {
>+      return this[_deltaX];
>+    }
>+    dart.throw(new core.UnsupportedError.new("deltaX is not supported"));
>+  }
>+  get [$deltaMode]() {
>+    if (!!this.deltaMode) {
>+      return this.deltaMode;
>+    }
>+    return 0;
>+  }
>+  get [_wheelDelta]() {
>+    return this.wheelDelta;
>+  }
>+  get [_wheelDeltaX]() {
>+    return this.wheelDeltaX;
>+  }
>+  get [_detail]() {
>+    return this.detail;
>+  }
>+  get [_hasInitMouseScrollEvent]() {
>+    return !!this.initMouseScrollEvent;
>+  }
>+  [_initMouseScrollEvent](...args) {
>+    return this.initMouseScrollEvent.apply(this, args);
>+  }
>+  get [_hasInitWheelEvent]() {
>+    return !!this.initWheelEvent;
>+  }
>+  [_initWheelEvent](...args) {
>+    return this.initWheelEvent.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.WheelEvent);
>+const deltaZ = Symbol("WheelEvent.deltaZ");
>+dart.setMethodSignature(html$.WheelEvent, () => ({
>+  __proto__: dart.getMethods(html$.WheelEvent.__proto__),
>+  [_initMouseScrollEvent]: dart.fnType(dart.void, [core.String, core.bool, core.bool, html$.Window, core.int, core.int, core.int, core.int, core.int, core.bool, core.bool, core.bool, core.bool, core.int, html$.EventTarget, core.int]),
>+  [_initWheelEvent]: dart.fnType(dart.void, [core.String, core.bool, core.bool, html$.Window, core.int, core.int, core.int, core.int, core.int, core.int, html$.EventTarget, core.String, core.int, core.int, core.int, core.int])
>+}));
>+dart.setGetterSignature(html$.WheelEvent, () => ({
>+  __proto__: dart.getGetters(html$.WheelEvent.__proto__),
>+  [$deltaY]: core.num,
>+  [$deltaX]: core.num,
>+  [$deltaMode]: core.int,
>+  [_wheelDelta]: core.num,
>+  [_wheelDeltaX]: core.num,
>+  [_detail]: core.num,
>+  [_hasInitMouseScrollEvent]: core.bool,
>+  [_hasInitWheelEvent]: core.bool
>+}));
>+dart.setLibraryUri(html$.WheelEvent, "dart:html");
>+dart.setFieldSignature(html$.WheelEvent, () => ({
>+  __proto__: dart.getFields(html$.WheelEvent.__proto__),
>+  [_deltaX]: dart.finalFieldType(core.num),
>+  [_deltaY]: dart.finalFieldType(core.num),
>+  [$deltaZ]: dart.finalFieldType(core.num)
>+}));
>+dart.defineLazy(html$.WheelEvent, {
>+  /*html$.WheelEvent.DOM_DELTA_LINE*/get DOM_DELTA_LINE() {
>+    return 1;
>+  },
>+  /*html$.WheelEvent.DOM_DELTA_PAGE*/get DOM_DELTA_PAGE() {
>+    return 2;
>+  },
>+  /*html$.WheelEvent.DOM_DELTA_PIXEL*/get DOM_DELTA_PIXEL() {
>+    return 0;
>+  }
>+});
>+dart.registerExtension("WheelEvent", html$.WheelEvent);
>+const _open2 = dart.privateName(html$, "_open2");
>+const _open3 = dart.privateName(html$, "_open3");
>+const _location = dart.privateName(html$, "_location");
>+const _ensureRequestAnimationFrame = dart.privateName(html$, "_ensureRequestAnimationFrame");
>+const _requestAnimationFrame = dart.privateName(html$, "_requestAnimationFrame");
>+const _cancelAnimationFrame = dart.privateName(html$, "_cancelAnimationFrame");
>+const _requestFileSystem = dart.privateName(html$, "_requestFileSystem");
>+const _get_opener = dart.privateName(html$, "_get_opener");
>+const _pageXOffset = dart.privateName(html$, "_pageXOffset");
>+const _pageYOffset = dart.privateName(html$, "_pageYOffset");
>+const _get_parent = dart.privateName(html$, "_get_parent");
>+const _get_self = dart.privateName(html$, "_get_self");
>+const _get_top = dart.privateName(html$, "_get_top");
>+const __getter___1 = dart.privateName(html$, "__getter___1");
>+const __getter___2 = dart.privateName(html$, "__getter___2");
>+const _openDatabase = dart.privateName(html$, "_openDatabase");
>+const _requestIdleCallback_1 = dart.privateName(html$, "_requestIdleCallback_1");
>+const _requestIdleCallback_2 = dart.privateName(html$, "_requestIdleCallback_2");
>+const _scroll_4 = dart.privateName(html$, "_scroll_4");
>+const _scroll_5 = dart.privateName(html$, "_scroll_5");
>+const _scrollBy_4 = dart.privateName(html$, "_scrollBy_4");
>+const _scrollBy_5 = dart.privateName(html$, "_scrollBy_5");
>+const _scrollTo_4 = dart.privateName(html$, "_scrollTo_4");
>+const _scrollTo_5 = dart.privateName(html$, "_scrollTo_5");
>+const __requestFileSystem = dart.privateName(html$, "__requestFileSystem");
>+const _resolveLocalFileSystemUrl = dart.privateName(html$, "_resolveLocalFileSystemUrl");
>+html$.Window = class Window extends html$.EventTarget {
>+  get [$animationFrame]() {
>+    let completer = CompleterOfnum().sync();
>+    this[$requestAnimationFrame](dart.fn(time => {
>+      completer.complete(time);
>+    }, numToNull()));
>+    return completer.future;
>+  }
>+  get [$document]() {
>+    return this.document;
>+  }
>+  [_open2](url, name) {
>+    return this.open(url, name);
>+  }
>+  [_open3](url, name, options) {
>+    return this.open(url, name, options);
>+  }
>+  [$open](url, name, options) {
>+    if (options === void 0) options = null;
>+    if (options == null) {
>+      return html$._DOMWindowCrossFrame._createSafe(this[_open2](url, name));
>+    } else {
>+      return html$._DOMWindowCrossFrame._createSafe(this[_open3](url, name, options));
>+    }
>+  }
>+  get [$location]() {
>+    return html$.Location._check(this[_location]);
>+  }
>+  set [$location](value) {
>+    this[_location] = value;
>+  }
>+  get [_location]() {
>+    return this.location;
>+  }
>+  set [_location](value) {
>+    this.location = value;
>+  }
>+  [$requestAnimationFrame](callback) {
>+    this[_ensureRequestAnimationFrame]();
>+    return this[_requestAnimationFrame](html$._wrapZone(core.num, callback));
>+  }
>+  [$cancelAnimationFrame](id) {
>+    this[_ensureRequestAnimationFrame]();
>+    this[_cancelAnimationFrame](id);
>+  }
>+  [_requestAnimationFrame](...args) {
>+    return this.requestAnimationFrame.apply(this, args);
>+  }
>+  [_cancelAnimationFrame](...args) {
>+    return this.cancelAnimationFrame.apply(this, args);
>+  }
>+  [_ensureRequestAnimationFrame]() {
>+    if (!!(this.requestAnimationFrame && this.cancelAnimationFrame)) return;
>+    (function($this) {
>+      var vendors = ['ms', 'moz', 'webkit', 'o'];
>+      for (var i = 0; i < vendors.length && !$this.requestAnimationFrame; ++i) {
>+        $this.requestAnimationFrame = $this[vendors[i] + 'RequestAnimationFrame'];
>+        $this.cancelAnimationFrame = $this[vendors[i] + 'CancelAnimationFrame'] || $this[vendors[i] + 'CancelRequestAnimationFrame'];
>+      }
>+      if ($this.requestAnimationFrame && $this.cancelAnimationFrame) return;
>+      $this.requestAnimationFrame = function(callback) {
>+        return window.setTimeout(function() {
>+          callback(Date.now());
>+        }, 16);
>+      };
>+      $this.cancelAnimationFrame = function(id) {
>+        clearTimeout(id);
>+      };
>+    })(this);
>+  }
>+  get [$indexedDB]() {
>+    return this.indexedDB || this.webkitIndexedDB || this.mozIndexedDB;
>+  }
>+  get [$console]() {
>+    return html$.Console._safeConsole;
>+  }
>+  [$requestFileSystem](size, opts) {
>+    let persistent = opts && 'persistent' in opts ? opts.persistent : false;
>+    return this[_requestFileSystem](dart.test(persistent) ? 1 : 0, size);
>+  }
>+  static get supportsPointConversions() {
>+    return html$.DomPoint.supported;
>+  }
>+  get [$animationWorklet]() {
>+    return this.animationWorklet;
>+  }
>+  get [$applicationCache]() {
>+    return this.applicationCache;
>+  }
>+  get [$audioWorklet]() {
>+    return this.audioWorklet;
>+  }
>+  get [$caches]() {
>+    return this.caches;
>+  }
>+  get [$closed]() {
>+    return this.closed;
>+  }
>+  get [$cookieStore]() {
>+    return this.cookieStore;
>+  }
>+  get [$crypto]() {
>+    return this.crypto;
>+  }
>+  get [$customElements]() {
>+    return this.customElements;
>+  }
>+  get [$defaultStatus]() {
>+    return this.defaultStatus;
>+  }
>+  set [$defaultStatus](value) {
>+    this.defaultStatus = value;
>+  }
>+  get [$defaultstatus]() {
>+    return this.defaultstatus;
>+  }
>+  set [$defaultstatus](value) {
>+    this.defaultstatus = value;
>+  }
>+  get [$devicePixelRatio]() {
>+    return this.devicePixelRatio;
>+  }
>+  get [$external]() {
>+    return this.external;
>+  }
>+  get [$history]() {
>+    return this.history;
>+  }
>+  get [$innerHeight]() {
>+    return this.innerHeight;
>+  }
>+  get [$innerWidth]() {
>+    return this.innerWidth;
>+  }
>+  get [$isSecureContext]() {
>+    return this.isSecureContext;
>+  }
>+  get [$localStorage]() {
>+    return this.localStorage;
>+  }
>+  get [$locationbar]() {
>+    return this.locationbar;
>+  }
>+  get [$menubar]() {
>+    return this.menubar;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+  set [$name](value) {
>+    this.name = value;
>+  }
>+  get [$navigator]() {
>+    return this.navigator;
>+  }
>+  get [$offscreenBuffering]() {
>+    return this.offscreenBuffering;
>+  }
>+  get [$opener]() {
>+    return html$._convertNativeToDart_Window(this[_get_opener]);
>+  }
>+  get [_get_opener]() {
>+    return this.opener;
>+  }
>+  set [$opener](value) {
>+    this.opener = value;
>+  }
>+  get [$orientation]() {
>+    return this.orientation;
>+  }
>+  get [$origin]() {
>+    return this.origin;
>+  }
>+  get [$outerHeight]() {
>+    return this.outerHeight;
>+  }
>+  get [$outerWidth]() {
>+    return this.outerWidth;
>+  }
>+  get [_pageXOffset]() {
>+    return this.pageXOffset;
>+  }
>+  get [_pageYOffset]() {
>+    return this.pageYOffset;
>+  }
>+  get [$parent]() {
>+    return html$._convertNativeToDart_Window(this[_get_parent]);
>+  }
>+  get [_get_parent]() {
>+    return this.parent;
>+  }
>+  get [$performance]() {
>+    return this.performance;
>+  }
>+  get [$screen]() {
>+    return this.screen;
>+  }
>+  get [$screenLeft]() {
>+    return this.screenLeft;
>+  }
>+  get [$screenTop]() {
>+    return this.screenTop;
>+  }
>+  get [$screenX]() {
>+    return this.screenX;
>+  }
>+  get [$screenY]() {
>+    return this.screenY;
>+  }
>+  get [$scrollbars]() {
>+    return this.scrollbars;
>+  }
>+  get [$self]() {
>+    return html$._convertNativeToDart_Window(this[_get_self]);
>+  }
>+  get [_get_self]() {
>+    return this.self;
>+  }
>+  get [$sessionStorage]() {
>+    return this.sessionStorage;
>+  }
>+  get [$speechSynthesis]() {
>+    return this.speechSynthesis;
>+  }
>+  get [$status]() {
>+    return this.status;
>+  }
>+  set [$status](value) {
>+    this.status = value;
>+  }
>+  get [$statusbar]() {
>+    return this.statusbar;
>+  }
>+  get [$styleMedia]() {
>+    return this.styleMedia;
>+  }
>+  get [$toolbar]() {
>+    return this.toolbar;
>+  }
>+  get [$top]() {
>+    return html$._convertNativeToDart_Window(this[_get_top]);
>+  }
>+  get [_get_top]() {
>+    return this.top;
>+  }
>+  get [$visualViewport]() {
>+    return this.visualViewport;
>+  }
>+  get [$window]() {
>+    return html$._convertNativeToDart_Window(this[_get_window]);
>+  }
>+  get [_get_window]() {
>+    return this.window;
>+  }
>+  [__getter__](index_OR_name) {
>+    if (core.int.is(index_OR_name)) {
>+      return html$._convertNativeToDart_Window(this[__getter___1](index_OR_name));
>+    }
>+    if (typeof index_OR_name == 'string') {
>+      return html$._convertNativeToDart_Window(this[__getter___2](index_OR_name));
>+    }
>+    dart.throw(new core.ArgumentError.new("Incorrect number or type of arguments"));
>+  }
>+  [__getter___1](...args) {
>+    return this.__getter__.apply(this, args);
>+  }
>+  [__getter___2](...args) {
>+    return this.__getter__.apply(this, args);
>+  }
>+  [$alert](...args) {
>+    return this.alert.apply(this, args);
>+  }
>+  [$cancelIdleCallback](...args) {
>+    return this.cancelIdleCallback.apply(this, args);
>+  }
>+  [$close](...args) {
>+    return this.close.apply(this, args);
>+  }
>+  [$confirm](...args) {
>+    return this.confirm.apply(this, args);
>+  }
>+  [$fetch](input, init) {
>+    if (init === void 0) init = null;
>+    let init_dict = null;
>+    if (init != null) {
>+      init_dict = html_common.convertDartToNative_Dictionary(init);
>+    }
>+    return html$.promiseToFuture(dart.dynamic, this.fetch(input, init_dict));
>+  }
>+  [$find](...args) {
>+    return this.find.apply(this, args);
>+  }
>+  [_getComputedStyle](...args) {
>+    return this.getComputedStyle.apply(this, args);
>+  }
>+  [$getComputedStyleMap](...args) {
>+    return this.getComputedStyleMap.apply(this, args);
>+  }
>+  [$getMatchedCssRules](...args) {
>+    return this.getMatchedCSSRules.apply(this, args);
>+  }
>+  [$getSelection](...args) {
>+    return this.getSelection.apply(this, args);
>+  }
>+  [$matchMedia](...args) {
>+    return this.matchMedia.apply(this, args);
>+  }
>+  [$moveBy](...args) {
>+    return this.moveBy.apply(this, args);
>+  }
>+  [_moveTo](...args) {
>+    return this.moveTo.apply(this, args);
>+  }
>+  [_openDatabase](...args) {
>+    return this.openDatabase.apply(this, args);
>+  }
>+  [$postMessage](message, targetOrigin, transfer) {
>+    if (transfer === void 0) transfer = null;
>+    if (transfer != null) {
>+      let message_1 = html_common.convertDartToNative_SerializedScriptValue(message);
>+      this[_postMessage_1](message_1, targetOrigin, transfer);
>+      return;
>+    }
>+    let message_1 = html_common.convertDartToNative_SerializedScriptValue(message);
>+    this[_postMessage_2](message_1, targetOrigin);
>+    return;
>+  }
>+  [_postMessage_1](...args) {
>+    return this.postMessage.apply(this, args);
>+  }
>+  [_postMessage_2](...args) {
>+    return this.postMessage.apply(this, args);
>+  }
>+  [$print](...args) {
>+    return this.print.apply(this, args);
>+  }
>+  [$requestIdleCallback](callback, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let callback_1 = _js_helper.convertDartClosureToJS(IdleDeadlineTovoid(), callback, 1);
>+      let options_2 = html_common.convertDartToNative_Dictionary(options);
>+      return this[_requestIdleCallback_1](callback_1, options_2);
>+    }
>+    let callback_1 = _js_helper.convertDartClosureToJS(IdleDeadlineTovoid(), callback, 1);
>+    return this[_requestIdleCallback_2](callback_1);
>+  }
>+  [_requestIdleCallback_1](...args) {
>+    return this.requestIdleCallback.apply(this, args);
>+  }
>+  [_requestIdleCallback_2](...args) {
>+    return this.requestIdleCallback.apply(this, args);
>+  }
>+  [$resizeBy](...args) {
>+    return this.resizeBy.apply(this, args);
>+  }
>+  [$resizeTo](...args) {
>+    return this.resizeTo.apply(this, args);
>+  }
>+  [$scroll](options_OR_x, y, scrollOptions) {
>+    if (options_OR_x === void 0) options_OR_x = null;
>+    if (y === void 0) y = null;
>+    if (scrollOptions === void 0) scrollOptions = null;
>+    if (options_OR_x == null && y == null && scrollOptions == null) {
>+      this[_scroll_1]();
>+      return;
>+    }
>+    if (core.Map.is(options_OR_x) && y == null && scrollOptions == null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options_OR_x);
>+      this[_scroll_2](options_1);
>+      return;
>+    }
>+    if (typeof y == 'number' && typeof options_OR_x == 'number' && scrollOptions == null) {
>+      this[_scroll_3](options_OR_x, y);
>+      return;
>+    }
>+    if (core.int.is(y) && core.int.is(options_OR_x) && scrollOptions == null) {
>+      this[_scroll_4](options_OR_x, y);
>+      return;
>+    }
>+    if (scrollOptions != null && core.int.is(y) && core.int.is(options_OR_x)) {
>+      let scrollOptions_1 = html_common.convertDartToNative_Dictionary(scrollOptions);
>+      this[_scroll_5](options_OR_x, y, scrollOptions_1);
>+      return;
>+    }
>+    dart.throw(new core.ArgumentError.new("Incorrect number or type of arguments"));
>+  }
>+  [_scroll_1](...args) {
>+    return this.scroll.apply(this, args);
>+  }
>+  [_scroll_2](...args) {
>+    return this.scroll.apply(this, args);
>+  }
>+  [_scroll_3](...args) {
>+    return this.scroll.apply(this, args);
>+  }
>+  [_scroll_4](...args) {
>+    return this.scroll.apply(this, args);
>+  }
>+  [_scroll_5](...args) {
>+    return this.scroll.apply(this, args);
>+  }
>+  [$scrollBy](options_OR_x, y, scrollOptions) {
>+    if (options_OR_x === void 0) options_OR_x = null;
>+    if (y === void 0) y = null;
>+    if (scrollOptions === void 0) scrollOptions = null;
>+    if (options_OR_x == null && y == null && scrollOptions == null) {
>+      this[_scrollBy_1]();
>+      return;
>+    }
>+    if (core.Map.is(options_OR_x) && y == null && scrollOptions == null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options_OR_x);
>+      this[_scrollBy_2](options_1);
>+      return;
>+    }
>+    if (typeof y == 'number' && typeof options_OR_x == 'number' && scrollOptions == null) {
>+      this[_scrollBy_3](options_OR_x, y);
>+      return;
>+    }
>+    if (core.int.is(y) && core.int.is(options_OR_x) && scrollOptions == null) {
>+      this[_scrollBy_4](options_OR_x, y);
>+      return;
>+    }
>+    if (scrollOptions != null && core.int.is(y) && core.int.is(options_OR_x)) {
>+      let scrollOptions_1 = html_common.convertDartToNative_Dictionary(scrollOptions);
>+      this[_scrollBy_5](options_OR_x, y, scrollOptions_1);
>+      return;
>+    }
>+    dart.throw(new core.ArgumentError.new("Incorrect number or type of arguments"));
>+  }
>+  [_scrollBy_1](...args) {
>+    return this.scrollBy.apply(this, args);
>+  }
>+  [_scrollBy_2](...args) {
>+    return this.scrollBy.apply(this, args);
>+  }
>+  [_scrollBy_3](...args) {
>+    return this.scrollBy.apply(this, args);
>+  }
>+  [_scrollBy_4](...args) {
>+    return this.scrollBy.apply(this, args);
>+  }
>+  [_scrollBy_5](...args) {
>+    return this.scrollBy.apply(this, args);
>+  }
>+  [$scrollTo](options_OR_x, y, scrollOptions) {
>+    if (options_OR_x === void 0) options_OR_x = null;
>+    if (y === void 0) y = null;
>+    if (scrollOptions === void 0) scrollOptions = null;
>+    if (options_OR_x == null && y == null && scrollOptions == null) {
>+      this[_scrollTo_1]();
>+      return;
>+    }
>+    if (core.Map.is(options_OR_x) && y == null && scrollOptions == null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options_OR_x);
>+      this[_scrollTo_2](options_1);
>+      return;
>+    }
>+    if (typeof y == 'number' && typeof options_OR_x == 'number' && scrollOptions == null) {
>+      this[_scrollTo_3](options_OR_x, y);
>+      return;
>+    }
>+    if (core.int.is(y) && core.int.is(options_OR_x) && scrollOptions == null) {
>+      this[_scrollTo_4](options_OR_x, y);
>+      return;
>+    }
>+    if (scrollOptions != null && core.int.is(y) && core.int.is(options_OR_x)) {
>+      let scrollOptions_1 = html_common.convertDartToNative_Dictionary(scrollOptions);
>+      this[_scrollTo_5](options_OR_x, y, scrollOptions_1);
>+      return;
>+    }
>+    dart.throw(new core.ArgumentError.new("Incorrect number or type of arguments"));
>+  }
>+  [_scrollTo_1](...args) {
>+    return this.scrollTo.apply(this, args);
>+  }
>+  [_scrollTo_2](...args) {
>+    return this.scrollTo.apply(this, args);
>+  }
>+  [_scrollTo_3](...args) {
>+    return this.scrollTo.apply(this, args);
>+  }
>+  [_scrollTo_4](...args) {
>+    return this.scrollTo.apply(this, args);
>+  }
>+  [_scrollTo_5](...args) {
>+    return this.scrollTo.apply(this, args);
>+  }
>+  [$stop](...args) {
>+    return this.stop.apply(this, args);
>+  }
>+  [__requestFileSystem](...args) {
>+    return this.webkitRequestFileSystem.apply(this, args);
>+  }
>+  [_requestFileSystem](type, size) {
>+    let completer = CompleterOfFileSystem().new();
>+    this[__requestFileSystem](type, size, dart.fn(value => {
>+      _js_helper.applyExtension("DOMFileSystem", value);
>+      _js_helper.applyExtension("DirectoryEntry", value.root);
>+      completer.complete(value);
>+    }, FileSystemToNull()), dart.fn(error => {
>+      completer.completeError(error);
>+    }, DomExceptionToNull()));
>+    return completer.future;
>+  }
>+  [_resolveLocalFileSystemUrl](...args) {
>+    return this.webkitResolveLocalFileSystemURL.apply(this, args);
>+  }
>+  [$resolveLocalFileSystemUrl](url) {
>+    let completer = CompleterOfEntry().new();
>+    this[_resolveLocalFileSystemUrl](url, dart.fn(value => {
>+      completer.complete(value);
>+    }, EntryToNull()), dart.fn(error => {
>+      completer.completeError(error);
>+    }, DomExceptionToNull()));
>+    return completer.future;
>+  }
>+  [$atob](...args) {
>+    return this.atob.apply(this, args);
>+  }
>+  [$btoa](...args) {
>+    return this.btoa.apply(this, args);
>+  }
>+  [_setInterval_String](...args) {
>+    return this.setInterval.apply(this, args);
>+  }
>+  [_setTimeout_String](...args) {
>+    return this.setTimeout.apply(this, args);
>+  }
>+  [_clearInterval](...args) {
>+    return this.clearInterval.apply(this, args);
>+  }
>+  [_clearTimeout](...args) {
>+    return this.clearTimeout.apply(this, args);
>+  }
>+  [_setInterval](...args) {
>+    return this.setInterval.apply(this, args);
>+  }
>+  [_setTimeout](...args) {
>+    return this.setTimeout.apply(this, args);
>+  }
>+  get [$onContentLoaded]() {
>+    return html$.Window.contentLoadedEvent.forTarget(this);
>+  }
>+  get [$onAbort]() {
>+    return html$.Element.abortEvent.forTarget(this);
>+  }
>+  get [$onBlur]() {
>+    return html$.Element.blurEvent.forTarget(this);
>+  }
>+  get [$onCanPlay]() {
>+    return html$.Element.canPlayEvent.forTarget(this);
>+  }
>+  get [$onCanPlayThrough]() {
>+    return html$.Element.canPlayThroughEvent.forTarget(this);
>+  }
>+  get [$onChange]() {
>+    return html$.Element.changeEvent.forTarget(this);
>+  }
>+  get [$onClick]() {
>+    return html$.Element.clickEvent.forTarget(this);
>+  }
>+  get [$onContextMenu]() {
>+    return html$.Element.contextMenuEvent.forTarget(this);
>+  }
>+  get [$onDoubleClick]() {
>+    return html$.Element.doubleClickEvent.forTarget(this);
>+  }
>+  get [$onDeviceMotion]() {
>+    return html$.Window.deviceMotionEvent.forTarget(this);
>+  }
>+  get [$onDeviceOrientation]() {
>+    return html$.Window.deviceOrientationEvent.forTarget(this);
>+  }
>+  get [$onDrag]() {
>+    return html$.Element.dragEvent.forTarget(this);
>+  }
>+  get [$onDragEnd]() {
>+    return html$.Element.dragEndEvent.forTarget(this);
>+  }
>+  get [$onDragEnter]() {
>+    return html$.Element.dragEnterEvent.forTarget(this);
>+  }
>+  get [$onDragLeave]() {
>+    return html$.Element.dragLeaveEvent.forTarget(this);
>+  }
>+  get [$onDragOver]() {
>+    return html$.Element.dragOverEvent.forTarget(this);
>+  }
>+  get [$onDragStart]() {
>+    return html$.Element.dragStartEvent.forTarget(this);
>+  }
>+  get [$onDrop]() {
>+    return html$.Element.dropEvent.forTarget(this);
>+  }
>+  get [$onDurationChange]() {
>+    return html$.Element.durationChangeEvent.forTarget(this);
>+  }
>+  get [$onEmptied]() {
>+    return html$.Element.emptiedEvent.forTarget(this);
>+  }
>+  get [$onEnded]() {
>+    return html$.Element.endedEvent.forTarget(this);
>+  }
>+  get [$onError]() {
>+    return html$.Element.errorEvent.forTarget(this);
>+  }
>+  get [$onFocus]() {
>+    return html$.Element.focusEvent.forTarget(this);
>+  }
>+  get [$onHashChange]() {
>+    return html$.Window.hashChangeEvent.forTarget(this);
>+  }
>+  get [$onInput]() {
>+    return html$.Element.inputEvent.forTarget(this);
>+  }
>+  get [$onInvalid]() {
>+    return html$.Element.invalidEvent.forTarget(this);
>+  }
>+  get [$onKeyDown]() {
>+    return html$.Element.keyDownEvent.forTarget(this);
>+  }
>+  get [$onKeyPress]() {
>+    return html$.Element.keyPressEvent.forTarget(this);
>+  }
>+  get [$onKeyUp]() {
>+    return html$.Element.keyUpEvent.forTarget(this);
>+  }
>+  get [$onLoad]() {
>+    return html$.Element.loadEvent.forTarget(this);
>+  }
>+  get [$onLoadedData]() {
>+    return html$.Element.loadedDataEvent.forTarget(this);
>+  }
>+  get [$onLoadedMetadata]() {
>+    return html$.Element.loadedMetadataEvent.forTarget(this);
>+  }
>+  get [$onLoadStart]() {
>+    return html$.Window.loadStartEvent.forTarget(this);
>+  }
>+  get [$onMessage]() {
>+    return html$.Window.messageEvent.forTarget(this);
>+  }
>+  get [$onMouseDown]() {
>+    return html$.Element.mouseDownEvent.forTarget(this);
>+  }
>+  get [$onMouseEnter]() {
>+    return html$.Element.mouseEnterEvent.forTarget(this);
>+  }
>+  get [$onMouseLeave]() {
>+    return html$.Element.mouseLeaveEvent.forTarget(this);
>+  }
>+  get [$onMouseMove]() {
>+    return html$.Element.mouseMoveEvent.forTarget(this);
>+  }
>+  get [$onMouseOut]() {
>+    return html$.Element.mouseOutEvent.forTarget(this);
>+  }
>+  get [$onMouseOver]() {
>+    return html$.Element.mouseOverEvent.forTarget(this);
>+  }
>+  get [$onMouseUp]() {
>+    return html$.Element.mouseUpEvent.forTarget(this);
>+  }
>+  get [$onMouseWheel]() {
>+    return html$.Element.mouseWheelEvent.forTarget(this);
>+  }
>+  get [$onOffline]() {
>+    return html$.Window.offlineEvent.forTarget(this);
>+  }
>+  get [$onOnline]() {
>+    return html$.Window.onlineEvent.forTarget(this);
>+  }
>+  get [$onPageHide]() {
>+    return html$.Window.pageHideEvent.forTarget(this);
>+  }
>+  get [$onPageShow]() {
>+    return html$.Window.pageShowEvent.forTarget(this);
>+  }
>+  get [$onPause]() {
>+    return html$.Element.pauseEvent.forTarget(this);
>+  }
>+  get [$onPlay]() {
>+    return html$.Element.playEvent.forTarget(this);
>+  }
>+  get [$onPlaying]() {
>+    return html$.Element.playingEvent.forTarget(this);
>+  }
>+  get [$onPopState]() {
>+    return html$.Window.popStateEvent.forTarget(this);
>+  }
>+  get [$onProgress]() {
>+    return html$.Window.progressEvent.forTarget(this);
>+  }
>+  get [$onRateChange]() {
>+    return html$.Element.rateChangeEvent.forTarget(this);
>+  }
>+  get [$onReset]() {
>+    return html$.Element.resetEvent.forTarget(this);
>+  }
>+  get [$onResize]() {
>+    return html$.Element.resizeEvent.forTarget(this);
>+  }
>+  get [$onScroll]() {
>+    return html$.Element.scrollEvent.forTarget(this);
>+  }
>+  get [$onSearch]() {
>+    return html$.Element.searchEvent.forTarget(this);
>+  }
>+  get [$onSeeked]() {
>+    return html$.Element.seekedEvent.forTarget(this);
>+  }
>+  get [$onSeeking]() {
>+    return html$.Element.seekingEvent.forTarget(this);
>+  }
>+  get [$onSelect]() {
>+    return html$.Element.selectEvent.forTarget(this);
>+  }
>+  get [$onStalled]() {
>+    return html$.Element.stalledEvent.forTarget(this);
>+  }
>+  get [$onStorage]() {
>+    return html$.Window.storageEvent.forTarget(this);
>+  }
>+  get [$onSubmit]() {
>+    return html$.Element.submitEvent.forTarget(this);
>+  }
>+  get [$onSuspend]() {
>+    return html$.Element.suspendEvent.forTarget(this);
>+  }
>+  get [$onTimeUpdate]() {
>+    return html$.Element.timeUpdateEvent.forTarget(this);
>+  }
>+  get [$onTouchCancel]() {
>+    return html$.Element.touchCancelEvent.forTarget(this);
>+  }
>+  get [$onTouchEnd]() {
>+    return html$.Element.touchEndEvent.forTarget(this);
>+  }
>+  get [$onTouchMove]() {
>+    return html$.Element.touchMoveEvent.forTarget(this);
>+  }
>+  get [$onTouchStart]() {
>+    return html$.Element.touchStartEvent.forTarget(this);
>+  }
>+  get [$onTransitionEnd]() {
>+    return html$.Element.transitionEndEvent.forTarget(this);
>+  }
>+  get [$onUnload]() {
>+    return html$.Window.unloadEvent.forTarget(this);
>+  }
>+  get [$onVolumeChange]() {
>+    return html$.Element.volumeChangeEvent.forTarget(this);
>+  }
>+  get [$onWaiting]() {
>+    return html$.Element.waitingEvent.forTarget(this);
>+  }
>+  get [$onAnimationEnd]() {
>+    return html$.Window.animationEndEvent.forTarget(this);
>+  }
>+  get [$onAnimationIteration]() {
>+    return html$.Window.animationIterationEvent.forTarget(this);
>+  }
>+  get [$onAnimationStart]() {
>+    return html$.Window.animationStartEvent.forTarget(this);
>+  }
>+  get [$onBeforeUnload]() {
>+    return html$.Window.beforeUnloadEvent.forTarget(this);
>+  }
>+  get [$onWheel]() {
>+    return html$.Element.wheelEvent.forTarget(this);
>+  }
>+  [$moveTo](p) {
>+    this[_moveTo](dart.asInt(p.x), dart.asInt(p.y));
>+  }
>+  [$openDatabase](name, version, displayName, estimatedSize, creationCallback) {
>+    if (creationCallback === void 0) creationCallback = null;
>+    let db = null;
>+    if (creationCallback == null)
>+      db = this[_openDatabase](name, version, displayName, estimatedSize);
>+    else
>+      db = this[_openDatabase](name, version, displayName, estimatedSize, creationCallback);
>+    _js_helper.applyExtension("Database", db);
>+    return web_sql.SqlDatabase._check(db);
>+  }
>+  get [$pageXOffset]() {
>+    return this.pageXOffset[$round]();
>+  }
>+  get [$pageYOffset]() {
>+    return this.pageYOffset[$round]();
>+  }
>+  get [$scrollX]() {
>+    return "scrollX" in this ? this.scrollX[$round]() : this[$document].documentElement[$scrollLeft];
>+  }
>+  get [$scrollY]() {
>+    return "scrollY" in this ? this.scrollY[$round]() : this[$document].documentElement[$scrollTop];
>+  }
>+};
>+dart.addTypeTests(html$.Window);
>+const animationWorklet = Symbol("Window.animationWorklet");
>+const applicationCache = Symbol("Window.applicationCache");
>+const audioWorklet = Symbol("Window.audioWorklet");
>+const caches$ = Symbol("Window.caches");
>+const closed = Symbol("Window.closed");
>+const cookieStore = Symbol("Window.cookieStore");
>+const crypto$0 = Symbol("Window.crypto");
>+const customElements = Symbol("Window.customElements");
>+const defaultStatus = Symbol("Window.defaultStatus");
>+const defaultstatus = Symbol("Window.defaultstatus");
>+const devicePixelRatio$ = Symbol("Window.devicePixelRatio");
>+const external = Symbol("Window.external");
>+const history = Symbol("Window.history");
>+const innerHeight = Symbol("Window.innerHeight");
>+const innerWidth = Symbol("Window.innerWidth");
>+const isSecureContext$ = Symbol("Window.isSecureContext");
>+const localStorage = Symbol("Window.localStorage");
>+const locationbar = Symbol("Window.locationbar");
>+const menubar = Symbol("Window.menubar");
>+const name$39 = Symbol("Window.name");
>+const navigator$ = Symbol("Window.navigator");
>+const offscreenBuffering = Symbol("Window.offscreenBuffering");
>+const orientation$3 = Symbol("Window.orientation");
>+const origin$8 = Symbol("Window.origin");
>+const outerHeight = Symbol("Window.outerHeight");
>+const outerWidth = Symbol("Window.outerWidth");
>+const performance$ = Symbol("Window.performance");
>+const screen = Symbol("Window.screen");
>+const screenLeft = Symbol("Window.screenLeft");
>+const screenTop = Symbol("Window.screenTop");
>+const screenX = Symbol("Window.screenX");
>+const screenY = Symbol("Window.screenY");
>+const scrollbars = Symbol("Window.scrollbars");
>+const sessionStorage = Symbol("Window.sessionStorage");
>+const speechSynthesis = Symbol("Window.speechSynthesis");
>+const status$3 = Symbol("Window.status");
>+const statusbar = Symbol("Window.statusbar");
>+const styleMedia = Symbol("Window.styleMedia");
>+const toolbar = Symbol("Window.toolbar");
>+const visualViewport = Symbol("Window.visualViewport");
>+html$.Window[dart.implements] = () => [html$.WindowEventHandlers, html$.WindowBase, html$.GlobalEventHandlers, html$._WindowTimers, html$.WindowBase64];
>+dart.setMethodSignature(html$.Window, () => ({
>+  __proto__: dart.getMethods(html$.Window.__proto__),
>+  [_open2]: dart.fnType(html$.WindowBase, [dart.dynamic, dart.dynamic]),
>+  [_open3]: dart.fnType(html$.WindowBase, [dart.dynamic, dart.dynamic, dart.dynamic]),
>+  [$open]: dart.fnType(html$.WindowBase, [core.String, core.String], [core.String]),
>+  [$requestAnimationFrame]: dart.fnType(core.int, [dart.fnType(dart.void, [core.num])]),
>+  [$cancelAnimationFrame]: dart.fnType(dart.void, [core.int]),
>+  [_requestAnimationFrame]: dart.fnType(core.int, [dart.fnType(dart.void, [core.num])]),
>+  [_cancelAnimationFrame]: dart.fnType(dart.void, [core.int]),
>+  [_ensureRequestAnimationFrame]: dart.fnType(dart.dynamic, []),
>+  [$requestFileSystem]: dart.fnType(async.Future$(html$.FileSystem), [core.int], {persistent: core.bool}),
>+  [__getter__]: dart.fnType(html$.WindowBase, [dart.dynamic]),
>+  [__getter___1]: dart.fnType(dart.dynamic, [core.int]),
>+  [__getter___2]: dart.fnType(dart.dynamic, [core.String]),
>+  [$alert]: dart.fnType(dart.void, [], [core.String]),
>+  [$cancelIdleCallback]: dart.fnType(dart.void, [core.int]),
>+  [$close]: dart.fnType(dart.void, []),
>+  [$confirm]: dart.fnType(core.bool, [], [core.String]),
>+  [$fetch]: dart.fnType(async.Future, [dart.dynamic], [core.Map]),
>+  [$find]: dart.fnType(core.bool, [core.String, core.bool, core.bool, core.bool, core.bool, core.bool, core.bool]),
>+  [_getComputedStyle]: dart.fnType(html$.CssStyleDeclaration, [html$.Element], [core.String]),
>+  [$getComputedStyleMap]: dart.fnType(html$.StylePropertyMapReadonly, [html$.Element, core.String]),
>+  [$getMatchedCssRules]: dart.fnType(core.List$(html$.CssRule), [html$.Element, core.String]),
>+  [$getSelection]: dart.fnType(html$.Selection, []),
>+  [$matchMedia]: dart.fnType(html$.MediaQueryList, [core.String]),
>+  [$moveBy]: dart.fnType(dart.void, [core.int, core.int]),
>+  [_moveTo]: dart.fnType(dart.void, [core.int, core.int]),
>+  [_openDatabase]: dart.fnType(web_sql.SqlDatabase, [core.String, core.String, core.String, core.int], [dart.fnType(dart.void, [web_sql.SqlDatabase])]),
>+  [$postMessage]: dart.fnType(dart.void, [dart.dynamic, core.String], [core.List$(core.Object)]),
>+  [_postMessage_1]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, core.List$(core.Object)]),
>+  [_postMessage_2]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic]),
>+  [$print]: dart.fnType(dart.void, []),
>+  [$requestIdleCallback]: dart.fnType(core.int, [dart.fnType(dart.void, [html$.IdleDeadline])], [core.Map]),
>+  [_requestIdleCallback_1]: dart.fnType(core.int, [dart.dynamic, dart.dynamic]),
>+  [_requestIdleCallback_2]: dart.fnType(core.int, [dart.dynamic]),
>+  [$resizeBy]: dart.fnType(dart.void, [core.int, core.int]),
>+  [$resizeTo]: dart.fnType(dart.void, [core.int, core.int]),
>+  [$scroll]: dart.fnType(dart.void, [], [dart.dynamic, dart.dynamic, core.Map]),
>+  [_scroll_1]: dart.fnType(dart.void, []),
>+  [_scroll_2]: dart.fnType(dart.void, [dart.dynamic]),
>+  [_scroll_3]: dart.fnType(dart.void, [core.num, core.num]),
>+  [_scroll_4]: dart.fnType(dart.void, [core.int, core.int]),
>+  [_scroll_5]: dart.fnType(dart.void, [core.int, core.int, dart.dynamic]),
>+  [$scrollBy]: dart.fnType(dart.void, [], [dart.dynamic, dart.dynamic, core.Map]),
>+  [_scrollBy_1]: dart.fnType(dart.void, []),
>+  [_scrollBy_2]: dart.fnType(dart.void, [dart.dynamic]),
>+  [_scrollBy_3]: dart.fnType(dart.void, [core.num, core.num]),
>+  [_scrollBy_4]: dart.fnType(dart.void, [core.int, core.int]),
>+  [_scrollBy_5]: dart.fnType(dart.void, [core.int, core.int, dart.dynamic]),
>+  [$scrollTo]: dart.fnType(dart.void, [], [dart.dynamic, dart.dynamic, core.Map]),
>+  [_scrollTo_1]: dart.fnType(dart.void, []),
>+  [_scrollTo_2]: dart.fnType(dart.void, [dart.dynamic]),
>+  [_scrollTo_3]: dart.fnType(dart.void, [core.num, core.num]),
>+  [_scrollTo_4]: dart.fnType(dart.void, [core.int, core.int]),
>+  [_scrollTo_5]: dart.fnType(dart.void, [core.int, core.int, dart.dynamic]),
>+  [$stop]: dart.fnType(dart.void, []),
>+  [__requestFileSystem]: dart.fnType(dart.void, [core.int, core.int, dart.fnType(dart.void, [html$.FileSystem])], [dart.fnType(dart.void, [html$.DomException])]),
>+  [_requestFileSystem]: dart.fnType(async.Future$(html$.FileSystem), [core.int, core.int]),
>+  [_resolveLocalFileSystemUrl]: dart.fnType(dart.void, [core.String, dart.fnType(dart.void, [html$.Entry])], [dart.fnType(dart.void, [html$.DomException])]),
>+  [$resolveLocalFileSystemUrl]: dart.fnType(async.Future$(html$.Entry), [core.String]),
>+  [$atob]: dart.fnType(core.String, [core.String]),
>+  [$btoa]: dart.fnType(core.String, [core.String]),
>+  [_setInterval_String]: dart.fnType(core.int, [core.String], [core.int, core.Object]),
>+  [_setTimeout_String]: dart.fnType(core.int, [core.String], [core.int, core.Object]),
>+  [_clearInterval]: dart.fnType(dart.void, [], [core.int]),
>+  [_clearTimeout]: dart.fnType(dart.void, [], [core.int]),
>+  [_setInterval]: dart.fnType(core.int, [core.Object], [core.int]),
>+  [_setTimeout]: dart.fnType(core.int, [core.Object], [core.int]),
>+  [$moveTo]: dart.fnType(dart.void, [math.Point$(core.num)]),
>+  [$openDatabase]: dart.fnType(web_sql.SqlDatabase, [core.String, core.String, core.String, core.int], [dart.fnType(dart.void, [web_sql.SqlDatabase])])
>+}));
>+dart.setGetterSignature(html$.Window, () => ({
>+  __proto__: dart.getGetters(html$.Window.__proto__),
>+  [$animationFrame]: async.Future$(core.num),
>+  [$document]: html$.Document,
>+  [$location]: html$.Location,
>+  [_location]: dart.dynamic,
>+  [$indexedDB]: indexed_db.IdbFactory,
>+  [$console]: html$.Console,
>+  [$opener]: html$.WindowBase,
>+  [$parent]: html$.WindowBase,
>+  [$self]: html$.WindowBase,
>+  [$top]: html$.WindowBase,
>+  [$window]: html$.WindowBase,
>+  [$onContentLoaded]: async.Stream$(html$.Event),
>+  [$onAbort]: async.Stream$(html$.Event),
>+  [$onBlur]: async.Stream$(html$.Event),
>+  [$onCanPlay]: async.Stream$(html$.Event),
>+  [$onCanPlayThrough]: async.Stream$(html$.Event),
>+  [$onChange]: async.Stream$(html$.Event),
>+  [$onClick]: async.Stream$(html$.MouseEvent),
>+  [$onContextMenu]: async.Stream$(html$.MouseEvent),
>+  [$onDoubleClick]: async.Stream$(html$.Event),
>+  [$onDeviceMotion]: async.Stream$(html$.DeviceMotionEvent),
>+  [$onDeviceOrientation]: async.Stream$(html$.DeviceOrientationEvent),
>+  [$onDrag]: async.Stream$(html$.MouseEvent),
>+  [$onDragEnd]: async.Stream$(html$.MouseEvent),
>+  [$onDragEnter]: async.Stream$(html$.MouseEvent),
>+  [$onDragLeave]: async.Stream$(html$.MouseEvent),
>+  [$onDragOver]: async.Stream$(html$.MouseEvent),
>+  [$onDragStart]: async.Stream$(html$.MouseEvent),
>+  [$onDrop]: async.Stream$(html$.MouseEvent),
>+  [$onDurationChange]: async.Stream$(html$.Event),
>+  [$onEmptied]: async.Stream$(html$.Event),
>+  [$onEnded]: async.Stream$(html$.Event),
>+  [$onError]: async.Stream$(html$.Event),
>+  [$onFocus]: async.Stream$(html$.Event),
>+  [$onHashChange]: async.Stream$(html$.Event),
>+  [$onInput]: async.Stream$(html$.Event),
>+  [$onInvalid]: async.Stream$(html$.Event),
>+  [$onKeyDown]: async.Stream$(html$.KeyboardEvent),
>+  [$onKeyPress]: async.Stream$(html$.KeyboardEvent),
>+  [$onKeyUp]: async.Stream$(html$.KeyboardEvent),
>+  [$onLoad]: async.Stream$(html$.Event),
>+  [$onLoadedData]: async.Stream$(html$.Event),
>+  [$onLoadedMetadata]: async.Stream$(html$.Event),
>+  [$onLoadStart]: async.Stream$(html$.Event),
>+  [$onMessage]: async.Stream$(html$.MessageEvent),
>+  [$onMouseDown]: async.Stream$(html$.MouseEvent),
>+  [$onMouseEnter]: async.Stream$(html$.MouseEvent),
>+  [$onMouseLeave]: async.Stream$(html$.MouseEvent),
>+  [$onMouseMove]: async.Stream$(html$.MouseEvent),
>+  [$onMouseOut]: async.Stream$(html$.MouseEvent),
>+  [$onMouseOver]: async.Stream$(html$.MouseEvent),
>+  [$onMouseUp]: async.Stream$(html$.MouseEvent),
>+  [$onMouseWheel]: async.Stream$(html$.WheelEvent),
>+  [$onOffline]: async.Stream$(html$.Event),
>+  [$onOnline]: async.Stream$(html$.Event),
>+  [$onPageHide]: async.Stream$(html$.Event),
>+  [$onPageShow]: async.Stream$(html$.Event),
>+  [$onPause]: async.Stream$(html$.Event),
>+  [$onPlay]: async.Stream$(html$.Event),
>+  [$onPlaying]: async.Stream$(html$.Event),
>+  [$onPopState]: async.Stream$(html$.PopStateEvent),
>+  [$onProgress]: async.Stream$(html$.Event),
>+  [$onRateChange]: async.Stream$(html$.Event),
>+  [$onReset]: async.Stream$(html$.Event),
>+  [$onResize]: async.Stream$(html$.Event),
>+  [$onScroll]: async.Stream$(html$.Event),
>+  [$onSearch]: async.Stream$(html$.Event),
>+  [$onSeeked]: async.Stream$(html$.Event),
>+  [$onSeeking]: async.Stream$(html$.Event),
>+  [$onSelect]: async.Stream$(html$.Event),
>+  [$onStalled]: async.Stream$(html$.Event),
>+  [$onStorage]: async.Stream$(html$.StorageEvent),
>+  [$onSubmit]: async.Stream$(html$.Event),
>+  [$onSuspend]: async.Stream$(html$.Event),
>+  [$onTimeUpdate]: async.Stream$(html$.Event),
>+  [$onTouchCancel]: async.Stream$(html$.TouchEvent),
>+  [$onTouchEnd]: async.Stream$(html$.TouchEvent),
>+  [$onTouchMove]: async.Stream$(html$.TouchEvent),
>+  [$onTouchStart]: async.Stream$(html$.TouchEvent),
>+  [$onTransitionEnd]: async.Stream$(html$.TransitionEvent),
>+  [$onUnload]: async.Stream$(html$.Event),
>+  [$onVolumeChange]: async.Stream$(html$.Event),
>+  [$onWaiting]: async.Stream$(html$.Event),
>+  [$onAnimationEnd]: async.Stream$(html$.AnimationEvent),
>+  [$onAnimationIteration]: async.Stream$(html$.AnimationEvent),
>+  [$onAnimationStart]: async.Stream$(html$.AnimationEvent),
>+  [$onBeforeUnload]: async.Stream$(html$.Event),
>+  [$onWheel]: async.Stream$(html$.WheelEvent),
>+  [$pageXOffset]: core.int,
>+  [$pageYOffset]: core.int,
>+  [$scrollX]: core.int,
>+  [$scrollY]: core.int
>+}));
>+dart.setSetterSignature(html$.Window, () => ({
>+  __proto__: dart.getSetters(html$.Window.__proto__),
>+  [$location]: html$.LocationBase,
>+  [_location]: dart.dynamic,
>+  [$opener]: html$.Window
>+}));
>+dart.setLibraryUri(html$.Window, "dart:html");
>+dart.setFieldSignature(html$.Window, () => ({
>+  __proto__: dart.getFields(html$.Window.__proto__),
>+  [$animationWorklet]: dart.finalFieldType(html$._Worklet),
>+  [$applicationCache]: dart.finalFieldType(html$.ApplicationCache),
>+  [$audioWorklet]: dart.finalFieldType(html$._Worklet),
>+  [$caches]: dart.finalFieldType(html$.CacheStorage),
>+  [$closed]: dart.finalFieldType(core.bool),
>+  [$cookieStore]: dart.finalFieldType(html$.CookieStore),
>+  [$crypto]: dart.finalFieldType(html$.Crypto),
>+  [$customElements]: dart.finalFieldType(html$.CustomElementRegistry),
>+  [$defaultStatus]: dart.fieldType(core.String),
>+  [$defaultstatus]: dart.fieldType(core.String),
>+  [$devicePixelRatio]: dart.finalFieldType(core.num),
>+  [$external]: dart.finalFieldType(html$.External),
>+  [$history]: dart.finalFieldType(html$.History),
>+  [$innerHeight]: dart.finalFieldType(core.int),
>+  [$innerWidth]: dart.finalFieldType(core.int),
>+  [$isSecureContext]: dart.finalFieldType(core.bool),
>+  [$localStorage]: dart.finalFieldType(html$.Storage),
>+  [$locationbar]: dart.finalFieldType(html$.BarProp),
>+  [$menubar]: dart.finalFieldType(html$.BarProp),
>+  [$name]: dart.fieldType(core.String),
>+  [$navigator]: dart.finalFieldType(html$.Navigator),
>+  [$offscreenBuffering]: dart.finalFieldType(core.bool),
>+  [_get_opener]: dart.finalFieldType(dart.dynamic),
>+  [$orientation]: dart.finalFieldType(core.int),
>+  [$origin]: dart.finalFieldType(core.String),
>+  [$outerHeight]: dart.finalFieldType(core.int),
>+  [$outerWidth]: dart.finalFieldType(core.int),
>+  [_pageXOffset]: dart.finalFieldType(core.num),
>+  [_pageYOffset]: dart.finalFieldType(core.num),
>+  [_get_parent]: dart.finalFieldType(dart.dynamic),
>+  [$performance]: dart.finalFieldType(html$.Performance),
>+  [$screen]: dart.finalFieldType(html$.Screen),
>+  [$screenLeft]: dart.finalFieldType(core.int),
>+  [$screenTop]: dart.finalFieldType(core.int),
>+  [$screenX]: dart.finalFieldType(core.int),
>+  [$screenY]: dart.finalFieldType(core.int),
>+  [$scrollbars]: dart.finalFieldType(html$.BarProp),
>+  [_get_self]: dart.finalFieldType(dart.dynamic),
>+  [$sessionStorage]: dart.finalFieldType(html$.Storage),
>+  [$speechSynthesis]: dart.finalFieldType(html$.SpeechSynthesis),
>+  [$status]: dart.fieldType(core.String),
>+  [$statusbar]: dart.finalFieldType(html$.BarProp),
>+  [$styleMedia]: dart.finalFieldType(html$.StyleMedia),
>+  [$toolbar]: dart.finalFieldType(html$.BarProp),
>+  [_get_top]: dart.finalFieldType(dart.dynamic),
>+  [$visualViewport]: dart.finalFieldType(html$.VisualViewport),
>+  [_get_window]: dart.finalFieldType(dart.dynamic)
>+}));
>+dart.defineLazy(html$.Window, {
>+  /*html$.Window.contentLoadedEvent*/get contentLoadedEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("DOMContentLoaded"));
>+  },
>+  /*html$.Window.deviceMotionEvent*/get deviceMotionEvent() {
>+    return dart.const(new (EventStreamProviderOfDeviceMotionEvent()).new("devicemotion"));
>+  },
>+  /*html$.Window.deviceOrientationEvent*/get deviceOrientationEvent() {
>+    return dart.const(new (EventStreamProviderOfDeviceOrientationEvent()).new("deviceorientation"));
>+  },
>+  /*html$.Window.hashChangeEvent*/get hashChangeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("hashchange"));
>+  },
>+  /*html$.Window.loadStartEvent*/get loadStartEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("loadstart"));
>+  },
>+  /*html$.Window.messageEvent*/get messageEvent() {
>+    return dart.const(new (EventStreamProviderOfMessageEvent()).new("message"));
>+  },
>+  /*html$.Window.offlineEvent*/get offlineEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("offline"));
>+  },
>+  /*html$.Window.onlineEvent*/get onlineEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("online"));
>+  },
>+  /*html$.Window.pageHideEvent*/get pageHideEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("pagehide"));
>+  },
>+  /*html$.Window.pageShowEvent*/get pageShowEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("pageshow"));
>+  },
>+  /*html$.Window.popStateEvent*/get popStateEvent() {
>+    return dart.const(new (EventStreamProviderOfPopStateEvent()).new("popstate"));
>+  },
>+  /*html$.Window.progressEvent*/get progressEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("progress"));
>+  },
>+  /*html$.Window.storageEvent*/get storageEvent() {
>+    return dart.const(new (EventStreamProviderOfStorageEvent()).new("storage"));
>+  },
>+  /*html$.Window.unloadEvent*/get unloadEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("unload"));
>+  },
>+  /*html$.Window.animationEndEvent*/get animationEndEvent() {
>+    return dart.const(new (EventStreamProviderOfAnimationEvent()).new("webkitAnimationEnd"));
>+  },
>+  /*html$.Window.animationIterationEvent*/get animationIterationEvent() {
>+    return dart.const(new (EventStreamProviderOfAnimationEvent()).new("webkitAnimationIteration"));
>+  },
>+  /*html$.Window.animationStartEvent*/get animationStartEvent() {
>+    return dart.const(new (EventStreamProviderOfAnimationEvent()).new("webkitAnimationStart"));
>+  },
>+  /*html$.Window.PERSISTENT*/get PERSISTENT() {
>+    return 1;
>+  },
>+  /*html$.Window.TEMPORARY*/get TEMPORARY() {
>+    return 0;
>+  },
>+  /*html$.Window.beforeUnloadEvent*/get beforeUnloadEvent() {
>+    return dart.const(new html$._BeforeUnloadEventStreamProvider.new("beforeunload"));
>+  }
>+});
>+dart.registerExtension("Window", html$.Window);
>+dart.registerExtension("DOMWindow", html$.Window);
>+const _returnValue = dart.privateName(html$, "_returnValue");
>+html$._WrappedEvent = class _WrappedEvent extends core.Object {
>+  get wrapped() {
>+    return this[wrapped$];
>+  }
>+  set wrapped(value) {
>+    super.wrapped = value;
>+  }
>+  get bubbles() {
>+    return this.wrapped.bubbles;
>+  }
>+  get cancelable() {
>+    return this.wrapped.cancelable;
>+  }
>+  get composed() {
>+    return this.wrapped.composed;
>+  }
>+  get currentTarget() {
>+    return this.wrapped[$currentTarget];
>+  }
>+  get defaultPrevented() {
>+    return this.wrapped.defaultPrevented;
>+  }
>+  get eventPhase() {
>+    return this.wrapped.eventPhase;
>+  }
>+  get isTrusted() {
>+    return this.wrapped.isTrusted;
>+  }
>+  get target() {
>+    return this.wrapped[$target];
>+  }
>+  get timeStamp() {
>+    return this.wrapped.timeStamp;
>+  }
>+  get type() {
>+    return this.wrapped.type;
>+  }
>+  [_initEvent](type, bubbles, cancelable) {
>+    if (bubbles === void 0) bubbles = null;
>+    if (cancelable === void 0) cancelable = null;
>+    dart.throw(new core.UnsupportedError.new("Cannot initialize this Event."));
>+  }
>+  preventDefault() {
>+    this.wrapped.preventDefault();
>+  }
>+  stopImmediatePropagation() {
>+    this.wrapped.stopImmediatePropagation();
>+  }
>+  stopPropagation() {
>+    this.wrapped.stopPropagation();
>+  }
>+  composedPath() {
>+    return this.wrapped.composedPath();
>+  }
>+  get matchingTarget() {
>+    if (this[_selector] == null) {
>+      dart.throw(new core.UnsupportedError.new("Cannot call matchingTarget if this Event did" + " not arise as a result of event delegation."));
>+    }
>+    let currentTarget = html$.Element._check(this.currentTarget);
>+    let target = html$.Element._check(this.target);
>+    let matchedTarget = null;
>+    do {
>+      if (dart.test(target[$matches](this[_selector]))) return target;
>+      target = target[$parent];
>+    } while (target != null && !dart.equals(target, currentTarget[$parent]));
>+    dart.throw(new core.StateError.new("No selector matched for populating matchedTarget."));
>+  }
>+  get path() {
>+    return ListOfNode()._check(this.wrapped[$path]);
>+  }
>+  get [_get_currentTarget]() {
>+    return this.wrapped[_get_currentTarget];
>+  }
>+  get [_get_target]() {
>+    return this.wrapped[_get_target];
>+  }
>+};
>+(html$._WrappedEvent.new = function(wrapped) {
>+  this[_selector] = null;
>+  this[wrapped$] = wrapped;
>+}).prototype = html$._WrappedEvent.prototype;
>+dart.addTypeTests(html$._WrappedEvent);
>+const wrapped$ = Symbol("_WrappedEvent.wrapped");
>+html$._WrappedEvent[dart.implements] = () => [html$.Event];
>+dart.setMethodSignature(html$._WrappedEvent, () => ({
>+  __proto__: dart.getMethods(html$._WrappedEvent.__proto__),
>+  [_initEvent]: dart.fnType(dart.void, [core.String], [core.bool, core.bool]),
>+  preventDefault: dart.fnType(dart.void, []),
>+  [$preventDefault]: dart.fnType(dart.void, []),
>+  stopImmediatePropagation: dart.fnType(dart.void, []),
>+  [$stopImmediatePropagation]: dart.fnType(dart.void, []),
>+  stopPropagation: dart.fnType(dart.void, []),
>+  [$stopPropagation]: dart.fnType(dart.void, []),
>+  composedPath: dart.fnType(core.List$(html$.EventTarget), []),
>+  [$composedPath]: dart.fnType(core.List$(html$.EventTarget), [])
>+}));
>+dart.setGetterSignature(html$._WrappedEvent, () => ({
>+  __proto__: dart.getGetters(html$._WrappedEvent.__proto__),
>+  bubbles: core.bool,
>+  [$bubbles]: core.bool,
>+  cancelable: core.bool,
>+  [$cancelable]: core.bool,
>+  composed: core.bool,
>+  [$composed]: core.bool,
>+  currentTarget: html$.EventTarget,
>+  [$currentTarget]: html$.EventTarget,
>+  defaultPrevented: core.bool,
>+  [$defaultPrevented]: core.bool,
>+  eventPhase: core.int,
>+  [$eventPhase]: core.int,
>+  isTrusted: core.bool,
>+  [$isTrusted]: core.bool,
>+  target: html$.EventTarget,
>+  [$target]: html$.EventTarget,
>+  timeStamp: core.double,
>+  [$timeStamp]: core.double,
>+  type: core.String,
>+  [$type]: core.String,
>+  matchingTarget: html$.Element,
>+  [$matchingTarget]: html$.Element,
>+  path: core.List$(html$.Node),
>+  [$path]: core.List$(html$.Node),
>+  [_get_currentTarget]: dart.dynamic,
>+  [_get_target]: dart.dynamic
>+}));
>+dart.setLibraryUri(html$._WrappedEvent, "dart:html");
>+dart.setFieldSignature(html$._WrappedEvent, () => ({
>+  __proto__: dart.getFields(html$._WrappedEvent.__proto__),
>+  wrapped: dart.finalFieldType(html$.Event),
>+  [_selector]: dart.fieldType(core.String)
>+}));
>+dart.defineExtensionMethods(html$._WrappedEvent, ['preventDefault', 'stopImmediatePropagation', 'stopPropagation', 'composedPath']);
>+dart.defineExtensionAccessors(html$._WrappedEvent, [
>+  'bubbles',
>+  'cancelable',
>+  'composed',
>+  'currentTarget',
>+  'defaultPrevented',
>+  'eventPhase',
>+  'isTrusted',
>+  'target',
>+  'timeStamp',
>+  'type',
>+  'matchingTarget',
>+  'path'
>+]);
>+html$._BeforeUnloadEvent = class _BeforeUnloadEvent extends html$._WrappedEvent {
>+  get returnValue() {
>+    return this[_returnValue];
>+  }
>+  set returnValue(value) {
>+    this[_returnValue] = value;
>+    if ("returnValue" in this.wrapped) {
>+      this.wrapped.returnValue = value;
>+    }
>+  }
>+};
>+(html$._BeforeUnloadEvent.new = function(base) {
>+  this[_returnValue] = null;
>+  html$._BeforeUnloadEvent.__proto__.new.call(this, base);
>+}).prototype = html$._BeforeUnloadEvent.prototype;
>+dart.addTypeTests(html$._BeforeUnloadEvent);
>+html$._BeforeUnloadEvent[dart.implements] = () => [html$.BeforeUnloadEvent];
>+dart.setGetterSignature(html$._BeforeUnloadEvent, () => ({
>+  __proto__: dart.getGetters(html$._BeforeUnloadEvent.__proto__),
>+  returnValue: core.String,
>+  [$returnValue]: core.String
>+}));
>+dart.setSetterSignature(html$._BeforeUnloadEvent, () => ({
>+  __proto__: dart.getSetters(html$._BeforeUnloadEvent.__proto__),
>+  returnValue: core.String,
>+  [$returnValue]: core.String
>+}));
>+dart.setLibraryUri(html$._BeforeUnloadEvent, "dart:html");
>+dart.setFieldSignature(html$._BeforeUnloadEvent, () => ({
>+  __proto__: dart.getFields(html$._BeforeUnloadEvent.__proto__),
>+  [_returnValue]: dart.fieldType(core.String)
>+}));
>+dart.defineExtensionAccessors(html$._BeforeUnloadEvent, ['returnValue']);
>+const _eventType = dart.privateName(html$, "_eventType");
>+html$._BeforeUnloadEventStreamProvider = class _BeforeUnloadEventStreamProvider extends core.Object {
>+  forTarget(e, opts) {
>+    let useCapture = opts && 'useCapture' in opts ? opts.useCapture : false;
>+    let stream = new (_EventStreamOfBeforeUnloadEvent()).new(e, this[_eventType], useCapture);
>+    let controller = StreamControllerOfBeforeUnloadEvent().new({sync: true});
>+    stream.listen(dart.fn(event => {
>+      let wrapped = new html$._BeforeUnloadEvent.new(event);
>+      controller.add(wrapped);
>+    }, BeforeUnloadEventToNull()));
>+    return controller.stream;
>+  }
>+  getEventType(target) {
>+    return this[_eventType];
>+  }
>+  forElement(e, opts) {
>+    let useCapture = opts && 'useCapture' in opts ? opts.useCapture : false;
>+    return new (_ElementEventStreamImplOfBeforeUnloadEvent()).new(e, this[_eventType], useCapture);
>+  }
>+  [_forElementList](e, opts) {
>+    let useCapture = opts && 'useCapture' in opts ? opts.useCapture : false;
>+    return new (_ElementListEventStreamImplOfBeforeUnloadEvent()).new(e, this[_eventType], useCapture);
>+  }
>+};
>+(html$._BeforeUnloadEventStreamProvider.new = function(eventType) {
>+  this[_eventType] = eventType;
>+}).prototype = html$._BeforeUnloadEventStreamProvider.prototype;
>+dart.addTypeTests(html$._BeforeUnloadEventStreamProvider);
>+html$._BeforeUnloadEventStreamProvider[dart.implements] = () => [EventStreamProviderOfBeforeUnloadEvent()];
>+dart.setMethodSignature(html$._BeforeUnloadEventStreamProvider, () => ({
>+  __proto__: dart.getMethods(html$._BeforeUnloadEventStreamProvider.__proto__),
>+  forTarget: dart.fnType(async.Stream$(html$.BeforeUnloadEvent), [html$.EventTarget], {useCapture: core.bool}),
>+  getEventType: dart.fnType(core.String, [html$.EventTarget]),
>+  forElement: dart.fnType(html$.ElementStream$(html$.BeforeUnloadEvent), [html$.Element], {useCapture: core.bool}),
>+  [_forElementList]: dart.fnType(html$.ElementStream$(html$.BeforeUnloadEvent), [html$.ElementList$(html$.Element)], {useCapture: core.bool})
>+}));
>+dart.setLibraryUri(html$._BeforeUnloadEventStreamProvider, "dart:html");
>+dart.setFieldSignature(html$._BeforeUnloadEventStreamProvider, () => ({
>+  __proto__: dart.getFields(html$._BeforeUnloadEventStreamProvider.__proto__),
>+  [_eventType]: dart.finalFieldType(core.String)
>+}));
>+html$.WindowBase64 = class WindowBase64 extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$.WindowBase64);
>+dart.setLibraryUri(html$.WindowBase64, "dart:html");
>+html$.WindowClient = class WindowClient extends html$.Client {
>+  get [$focused]() {
>+    return this.focused;
>+  }
>+  get [$visibilityState]() {
>+    return this.visibilityState;
>+  }
>+  [$focus]() {
>+    return html$.promiseToFuture(html$.WindowClient, this.focus());
>+  }
>+  [$navigate](url) {
>+    return html$.promiseToFuture(html$.WindowClient, this.navigate(url));
>+  }
>+};
>+dart.addTypeTests(html$.WindowClient);
>+const focused = Symbol("WindowClient.focused");
>+const visibilityState = Symbol("WindowClient.visibilityState");
>+dart.setMethodSignature(html$.WindowClient, () => ({
>+  __proto__: dart.getMethods(html$.WindowClient.__proto__),
>+  [$focus]: dart.fnType(async.Future$(html$.WindowClient), []),
>+  [$navigate]: dart.fnType(async.Future$(html$.WindowClient), [core.String])
>+}));
>+dart.setLibraryUri(html$.WindowClient, "dart:html");
>+dart.setFieldSignature(html$.WindowClient, () => ({
>+  __proto__: dart.getFields(html$.WindowClient.__proto__),
>+  [$focused]: dart.finalFieldType(core.bool),
>+  [$visibilityState]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("WindowClient", html$.WindowClient);
>+html$.WindowEventHandlers = class WindowEventHandlers extends html$.EventTarget {
>+  get onHashChange() {
>+    return html$.WindowEventHandlers.hashChangeEvent.forTarget(this);
>+  }
>+  get onMessage() {
>+    return html$.WindowEventHandlers.messageEvent.forTarget(this);
>+  }
>+  get onOffline() {
>+    return html$.WindowEventHandlers.offlineEvent.forTarget(this);
>+  }
>+  get onOnline() {
>+    return html$.WindowEventHandlers.onlineEvent.forTarget(this);
>+  }
>+  get onPopState() {
>+    return html$.WindowEventHandlers.popStateEvent.forTarget(this);
>+  }
>+  get onStorage() {
>+    return html$.WindowEventHandlers.storageEvent.forTarget(this);
>+  }
>+  get onUnload() {
>+    return html$.WindowEventHandlers.unloadEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.WindowEventHandlers);
>+dart.setGetterSignature(html$.WindowEventHandlers, () => ({
>+  __proto__: dart.getGetters(html$.WindowEventHandlers.__proto__),
>+  onHashChange: async.Stream$(html$.Event),
>+  [$onHashChange]: async.Stream$(html$.Event),
>+  onMessage: async.Stream$(html$.MessageEvent),
>+  [$onMessage]: async.Stream$(html$.MessageEvent),
>+  onOffline: async.Stream$(html$.Event),
>+  [$onOffline]: async.Stream$(html$.Event),
>+  onOnline: async.Stream$(html$.Event),
>+  [$onOnline]: async.Stream$(html$.Event),
>+  onPopState: async.Stream$(html$.PopStateEvent),
>+  [$onPopState]: async.Stream$(html$.PopStateEvent),
>+  onStorage: async.Stream$(html$.StorageEvent),
>+  [$onStorage]: async.Stream$(html$.StorageEvent),
>+  onUnload: async.Stream$(html$.Event),
>+  [$onUnload]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(html$.WindowEventHandlers, "dart:html");
>+dart.defineExtensionAccessors(html$.WindowEventHandlers, [
>+  'onHashChange',
>+  'onMessage',
>+  'onOffline',
>+  'onOnline',
>+  'onPopState',
>+  'onStorage',
>+  'onUnload'
>+]);
>+dart.defineLazy(html$.WindowEventHandlers, {
>+  /*html$.WindowEventHandlers.hashChangeEvent*/get hashChangeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("hashchange"));
>+  },
>+  /*html$.WindowEventHandlers.messageEvent*/get messageEvent() {
>+    return dart.const(new (EventStreamProviderOfMessageEvent()).new("message"));
>+  },
>+  /*html$.WindowEventHandlers.offlineEvent*/get offlineEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("offline"));
>+  },
>+  /*html$.WindowEventHandlers.onlineEvent*/get onlineEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("online"));
>+  },
>+  /*html$.WindowEventHandlers.popStateEvent*/get popStateEvent() {
>+    return dart.const(new (EventStreamProviderOfPopStateEvent()).new("popstate"));
>+  },
>+  /*html$.WindowEventHandlers.storageEvent*/get storageEvent() {
>+    return dart.const(new (EventStreamProviderOfStorageEvent()).new("storage"));
>+  },
>+  /*html$.WindowEventHandlers.unloadEvent*/get unloadEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("unload"));
>+  }
>+});
>+html$.Worker = class Worker$ extends html$.EventTarget {
>+  static new(scriptUrl) {
>+    return html$.Worker._create_1(scriptUrl);
>+  }
>+  static _create_1(scriptUrl) {
>+    return new Worker(scriptUrl);
>+  }
>+  static get supported() {
>+    return typeof window.Worker != "undefined";
>+  }
>+  [$postMessage](message, transfer) {
>+    if (transfer === void 0) transfer = null;
>+    if (transfer != null) {
>+      let message_1 = html_common.convertDartToNative_SerializedScriptValue(message);
>+      this[_postMessage_1](message_1, transfer);
>+      return;
>+    }
>+    let message_1 = html_common.convertDartToNative_SerializedScriptValue(message);
>+    this[_postMessage_2](message_1);
>+    return;
>+  }
>+  [_postMessage_1](...args) {
>+    return this.postMessage.apply(this, args);
>+  }
>+  [_postMessage_2](...args) {
>+    return this.postMessage.apply(this, args);
>+  }
>+  [$terminate](...args) {
>+    return this.terminate.apply(this, args);
>+  }
>+  get [$onError]() {
>+    return html$.Worker.errorEvent.forTarget(this);
>+  }
>+  get [$onMessage]() {
>+    return html$.Worker.messageEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(html$.Worker);
>+html$.Worker[dart.implements] = () => [html$.AbstractWorker];
>+dart.setMethodSignature(html$.Worker, () => ({
>+  __proto__: dart.getMethods(html$.Worker.__proto__),
>+  [$postMessage]: dart.fnType(dart.void, [dart.dynamic], [core.List$(core.Object)]),
>+  [_postMessage_1]: dart.fnType(dart.void, [dart.dynamic, core.List$(core.Object)]),
>+  [_postMessage_2]: dart.fnType(dart.void, [dart.dynamic]),
>+  [$terminate]: dart.fnType(dart.void, [])
>+}));
>+dart.setGetterSignature(html$.Worker, () => ({
>+  __proto__: dart.getGetters(html$.Worker.__proto__),
>+  [$onError]: async.Stream$(html$.Event),
>+  [$onMessage]: async.Stream$(html$.MessageEvent)
>+}));
>+dart.setLibraryUri(html$.Worker, "dart:html");
>+dart.defineLazy(html$.Worker, {
>+  /*html$.Worker.errorEvent*/get errorEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("error"));
>+  },
>+  /*html$.Worker.messageEvent*/get messageEvent() {
>+    return dart.const(new (EventStreamProviderOfMessageEvent()).new("message"));
>+  }
>+});
>+dart.registerExtension("Worker", html$.Worker);
>+html$.WorkerPerformance = class WorkerPerformance extends html$.EventTarget {
>+  get [$memory]() {
>+    return this.memory;
>+  }
>+  get [$timeOrigin]() {
>+    return this.timeOrigin;
>+  }
>+  [$clearMarks](...args) {
>+    return this.clearMarks.apply(this, args);
>+  }
>+  [$clearMeasures](...args) {
>+    return this.clearMeasures.apply(this, args);
>+  }
>+  [$clearResourceTimings](...args) {
>+    return this.clearResourceTimings.apply(this, args);
>+  }
>+  [$getEntries](...args) {
>+    return this.getEntries.apply(this, args);
>+  }
>+  [$getEntriesByName](...args) {
>+    return this.getEntriesByName.apply(this, args);
>+  }
>+  [$getEntriesByType](...args) {
>+    return this.getEntriesByType.apply(this, args);
>+  }
>+  [$mark](...args) {
>+    return this.mark.apply(this, args);
>+  }
>+  [$measure](...args) {
>+    return this.measure.apply(this, args);
>+  }
>+  [$now](...args) {
>+    return this.now.apply(this, args);
>+  }
>+  [$setResourceTimingBufferSize](...args) {
>+    return this.setResourceTimingBufferSize.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.WorkerPerformance);
>+const memory$ = Symbol("WorkerPerformance.memory");
>+const timeOrigin$ = Symbol("WorkerPerformance.timeOrigin");
>+dart.setMethodSignature(html$.WorkerPerformance, () => ({
>+  __proto__: dart.getMethods(html$.WorkerPerformance.__proto__),
>+  [$clearMarks]: dart.fnType(dart.void, [core.String]),
>+  [$clearMeasures]: dart.fnType(dart.void, [core.String]),
>+  [$clearResourceTimings]: dart.fnType(dart.void, []),
>+  [$getEntries]: dart.fnType(core.List$(html$.PerformanceEntry), []),
>+  [$getEntriesByName]: dart.fnType(core.List$(html$.PerformanceEntry), [core.String, core.String]),
>+  [$getEntriesByType]: dart.fnType(core.List$(html$.PerformanceEntry), [core.String]),
>+  [$mark]: dart.fnType(dart.void, [core.String]),
>+  [$measure]: dart.fnType(dart.void, [core.String, core.String, core.String]),
>+  [$now]: dart.fnType(core.double, []),
>+  [$setResourceTimingBufferSize]: dart.fnType(dart.void, [core.int])
>+}));
>+dart.setLibraryUri(html$.WorkerPerformance, "dart:html");
>+dart.setFieldSignature(html$.WorkerPerformance, () => ({
>+  __proto__: dart.getFields(html$.WorkerPerformance.__proto__),
>+  [$memory]: dart.finalFieldType(html$.MemoryInfo),
>+  [$timeOrigin]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("WorkerPerformance", html$.WorkerPerformance);
>+html$.WorkletAnimation = class WorkletAnimation$ extends _interceptors.Interceptor {
>+  static new(animatorName, effects, timelines, options) {
>+    let options_1 = html_common.convertDartToNative_SerializedScriptValue(options);
>+    return html$.WorkletAnimation._create_1(animatorName, effects, timelines, options_1);
>+  }
>+  static _create_1(animatorName, effects, timelines, options) {
>+    return new WorkletAnimation(animatorName, effects, timelines, options);
>+  }
>+  get [$playState]() {
>+    return this.playState;
>+  }
>+  [$cancel](...args) {
>+    return this.cancel.apply(this, args);
>+  }
>+  [$play](...args) {
>+    return this.play.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.WorkletAnimation);
>+const playState$ = Symbol("WorkletAnimation.playState");
>+dart.setMethodSignature(html$.WorkletAnimation, () => ({
>+  __proto__: dart.getMethods(html$.WorkletAnimation.__proto__),
>+  [$cancel]: dart.fnType(dart.void, []),
>+  [$play]: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(html$.WorkletAnimation, "dart:html");
>+dart.setFieldSignature(html$.WorkletAnimation, () => ({
>+  __proto__: dart.getFields(html$.WorkletAnimation.__proto__),
>+  [$playState]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("WorkletAnimation", html$.WorkletAnimation);
>+html$.XPathEvaluator = class XPathEvaluator$ extends _interceptors.Interceptor {
>+  static new() {
>+    return html$.XPathEvaluator._create_1();
>+  }
>+  static _create_1() {
>+    return new XPathEvaluator();
>+  }
>+  [$createExpression](...args) {
>+    return this.createExpression.apply(this, args);
>+  }
>+  [$createNSResolver](...args) {
>+    return this.createNSResolver.apply(this, args);
>+  }
>+  [$evaluate](...args) {
>+    return this.evaluate.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.XPathEvaluator);
>+dart.setMethodSignature(html$.XPathEvaluator, () => ({
>+  __proto__: dart.getMethods(html$.XPathEvaluator.__proto__),
>+  [$createExpression]: dart.fnType(html$.XPathExpression, [core.String, html$.XPathNSResolver]),
>+  [$createNSResolver]: dart.fnType(html$.XPathNSResolver, [html$.Node]),
>+  [$evaluate]: dart.fnType(html$.XPathResult, [core.String, html$.Node, html$.XPathNSResolver], [core.int, core.Object])
>+}));
>+dart.setLibraryUri(html$.XPathEvaluator, "dart:html");
>+dart.registerExtension("XPathEvaluator", html$.XPathEvaluator);
>+html$.XPathExpression = class XPathExpression extends _interceptors.Interceptor {
>+  [$evaluate](...args) {
>+    return this.evaluate.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.XPathExpression);
>+dart.setMethodSignature(html$.XPathExpression, () => ({
>+  __proto__: dart.getMethods(html$.XPathExpression.__proto__),
>+  [$evaluate]: dart.fnType(html$.XPathResult, [html$.Node], [core.int, core.Object])
>+}));
>+dart.setLibraryUri(html$.XPathExpression, "dart:html");
>+dart.registerExtension("XPathExpression", html$.XPathExpression);
>+html$.XPathNSResolver = class XPathNSResolver extends _interceptors.Interceptor {
>+  [$lookupNamespaceUri](...args) {
>+    return this.lookupNamespaceURI.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.XPathNSResolver);
>+dart.setMethodSignature(html$.XPathNSResolver, () => ({
>+  __proto__: dart.getMethods(html$.XPathNSResolver.__proto__),
>+  [$lookupNamespaceUri]: dart.fnType(core.String, [core.String])
>+}));
>+dart.setLibraryUri(html$.XPathNSResolver, "dart:html");
>+dart.registerExtension("XPathNSResolver", html$.XPathNSResolver);
>+html$.XPathResult = class XPathResult extends _interceptors.Interceptor {
>+  get [$booleanValue]() {
>+    return this.booleanValue;
>+  }
>+  get [$invalidIteratorState]() {
>+    return this.invalidIteratorState;
>+  }
>+  get [$numberValue]() {
>+    return this.numberValue;
>+  }
>+  get [$resultType]() {
>+    return this.resultType;
>+  }
>+  get [$singleNodeValue]() {
>+    return this.singleNodeValue;
>+  }
>+  get [$snapshotLength]() {
>+    return this.snapshotLength;
>+  }
>+  get [$stringValue]() {
>+    return this.stringValue;
>+  }
>+  [$iterateNext](...args) {
>+    return this.iterateNext.apply(this, args);
>+  }
>+  [$snapshotItem](...args) {
>+    return this.snapshotItem.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.XPathResult);
>+const booleanValue = Symbol("XPathResult.booleanValue");
>+const invalidIteratorState = Symbol("XPathResult.invalidIteratorState");
>+const numberValue = Symbol("XPathResult.numberValue");
>+const resultType = Symbol("XPathResult.resultType");
>+const singleNodeValue = Symbol("XPathResult.singleNodeValue");
>+const snapshotLength = Symbol("XPathResult.snapshotLength");
>+const stringValue = Symbol("XPathResult.stringValue");
>+dart.setMethodSignature(html$.XPathResult, () => ({
>+  __proto__: dart.getMethods(html$.XPathResult.__proto__),
>+  [$iterateNext]: dart.fnType(html$.Node, []),
>+  [$snapshotItem]: dart.fnType(html$.Node, [core.int])
>+}));
>+dart.setLibraryUri(html$.XPathResult, "dart:html");
>+dart.setFieldSignature(html$.XPathResult, () => ({
>+  __proto__: dart.getFields(html$.XPathResult.__proto__),
>+  [$booleanValue]: dart.finalFieldType(core.bool),
>+  [$invalidIteratorState]: dart.finalFieldType(core.bool),
>+  [$numberValue]: dart.finalFieldType(core.num),
>+  [$resultType]: dart.finalFieldType(core.int),
>+  [$singleNodeValue]: dart.finalFieldType(html$.Node),
>+  [$snapshotLength]: dart.finalFieldType(core.int),
>+  [$stringValue]: dart.finalFieldType(core.String)
>+}));
>+dart.defineLazy(html$.XPathResult, {
>+  /*html$.XPathResult.ANY_TYPE*/get ANY_TYPE() {
>+    return 0;
>+  },
>+  /*html$.XPathResult.ANY_UNORDERED_NODE_TYPE*/get ANY_UNORDERED_NODE_TYPE() {
>+    return 8;
>+  },
>+  /*html$.XPathResult.BOOLEAN_TYPE*/get BOOLEAN_TYPE() {
>+    return 3;
>+  },
>+  /*html$.XPathResult.FIRST_ORDERED_NODE_TYPE*/get FIRST_ORDERED_NODE_TYPE() {
>+    return 9;
>+  },
>+  /*html$.XPathResult.NUMBER_TYPE*/get NUMBER_TYPE() {
>+    return 1;
>+  },
>+  /*html$.XPathResult.ORDERED_NODE_ITERATOR_TYPE*/get ORDERED_NODE_ITERATOR_TYPE() {
>+    return 5;
>+  },
>+  /*html$.XPathResult.ORDERED_NODE_SNAPSHOT_TYPE*/get ORDERED_NODE_SNAPSHOT_TYPE() {
>+    return 7;
>+  },
>+  /*html$.XPathResult.STRING_TYPE*/get STRING_TYPE() {
>+    return 2;
>+  },
>+  /*html$.XPathResult.UNORDERED_NODE_ITERATOR_TYPE*/get UNORDERED_NODE_ITERATOR_TYPE() {
>+    return 4;
>+  },
>+  /*html$.XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE*/get UNORDERED_NODE_SNAPSHOT_TYPE() {
>+    return 6;
>+  }
>+});
>+dart.registerExtension("XPathResult", html$.XPathResult);
>+html$.XmlDocument = class XmlDocument extends html$.Document {};
>+dart.addTypeTests(html$.XmlDocument);
>+dart.setLibraryUri(html$.XmlDocument, "dart:html");
>+dart.registerExtension("XMLDocument", html$.XmlDocument);
>+html$.XmlSerializer = class XmlSerializer extends _interceptors.Interceptor {
>+  static new() {
>+    return html$.XmlSerializer._create_1();
>+  }
>+  static _create_1() {
>+    return new XMLSerializer();
>+  }
>+  [$serializeToString](...args) {
>+    return this.serializeToString.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.XmlSerializer);
>+dart.setMethodSignature(html$.XmlSerializer, () => ({
>+  __proto__: dart.getMethods(html$.XmlSerializer.__proto__),
>+  [$serializeToString]: dart.fnType(core.String, [html$.Node])
>+}));
>+dart.setLibraryUri(html$.XmlSerializer, "dart:html");
>+dart.registerExtension("XMLSerializer", html$.XmlSerializer);
>+html$.XsltProcessor = class XsltProcessor extends _interceptors.Interceptor {
>+  static new() {
>+    return html$.XsltProcessor._create_1();
>+  }
>+  static _create_1() {
>+    return new XSLTProcessor();
>+  }
>+  static get supported() {
>+    return !!window.XSLTProcessor;
>+  }
>+  [$clearParameters](...args) {
>+    return this.clearParameters.apply(this, args);
>+  }
>+  [$getParameter](...args) {
>+    return this.getParameter.apply(this, args);
>+  }
>+  [$importStylesheet](...args) {
>+    return this.importStylesheet.apply(this, args);
>+  }
>+  [$removeParameter](...args) {
>+    return this.removeParameter.apply(this, args);
>+  }
>+  [$reset](...args) {
>+    return this.reset.apply(this, args);
>+  }
>+  [$setParameter](...args) {
>+    return this.setParameter.apply(this, args);
>+  }
>+  [$transformToDocument](...args) {
>+    return this.transformToDocument.apply(this, args);
>+  }
>+  [$transformToFragment](...args) {
>+    return this.transformToFragment.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$.XsltProcessor);
>+dart.setMethodSignature(html$.XsltProcessor, () => ({
>+  __proto__: dart.getMethods(html$.XsltProcessor.__proto__),
>+  [$clearParameters]: dart.fnType(dart.void, []),
>+  [$getParameter]: dart.fnType(core.String, [core.String, core.String]),
>+  [$importStylesheet]: dart.fnType(dart.void, [html$.Node]),
>+  [$removeParameter]: dart.fnType(dart.void, [core.String, core.String]),
>+  [$reset]: dart.fnType(dart.void, []),
>+  [$setParameter]: dart.fnType(dart.void, [core.String, core.String, core.String]),
>+  [$transformToDocument]: dart.fnType(html$.Document, [html$.Node]),
>+  [$transformToFragment]: dart.fnType(html$.DocumentFragment, [html$.Node, html$.Document])
>+}));
>+dart.setLibraryUri(html$.XsltProcessor, "dart:html");
>+dart.registerExtension("XSLTProcessor", html$.XsltProcessor);
>+html$._Attr = class _Attr extends html$.Node {
>+  get [_localName]() {
>+    return this.localName;
>+  }
>+  get [$name]() {
>+    return this.name;
>+  }
>+  get [_namespaceUri]() {
>+    return this.namespaceURI;
>+  }
>+  get [$value]() {
>+    return this.value;
>+  }
>+  set [$value](value) {
>+    this.value = value;
>+  }
>+};
>+dart.addTypeTests(html$._Attr);
>+dart.setLibraryUri(html$._Attr, "dart:html");
>+dart.setFieldSignature(html$._Attr, () => ({
>+  __proto__: dart.getFields(html$._Attr.__proto__),
>+  [_localName]: dart.finalFieldType(core.String),
>+  [$name]: dart.finalFieldType(core.String),
>+  [_namespaceUri]: dart.finalFieldType(core.String),
>+  [$value]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("Attr", html$._Attr);
>+html$._Bluetooth = class _Bluetooth extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$._Bluetooth);
>+dart.setLibraryUri(html$._Bluetooth, "dart:html");
>+dart.registerExtension("Bluetooth", html$._Bluetooth);
>+html$._BluetoothCharacteristicProperties = class _BluetoothCharacteristicProperties extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$._BluetoothCharacteristicProperties);
>+dart.setLibraryUri(html$._BluetoothCharacteristicProperties, "dart:html");
>+dart.registerExtension("BluetoothCharacteristicProperties", html$._BluetoothCharacteristicProperties);
>+html$._BluetoothDevice = class _BluetoothDevice extends html$.EventTarget {};
>+dart.addTypeTests(html$._BluetoothDevice);
>+dart.setLibraryUri(html$._BluetoothDevice, "dart:html");
>+dart.registerExtension("BluetoothDevice", html$._BluetoothDevice);
>+html$._BluetoothRemoteGATTCharacteristic = class _BluetoothRemoteGATTCharacteristic extends html$.EventTarget {};
>+dart.addTypeTests(html$._BluetoothRemoteGATTCharacteristic);
>+dart.setLibraryUri(html$._BluetoothRemoteGATTCharacteristic, "dart:html");
>+dart.registerExtension("BluetoothRemoteGATTCharacteristic", html$._BluetoothRemoteGATTCharacteristic);
>+html$._BluetoothRemoteGATTServer = class _BluetoothRemoteGATTServer extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$._BluetoothRemoteGATTServer);
>+dart.setLibraryUri(html$._BluetoothRemoteGATTServer, "dart:html");
>+dart.registerExtension("BluetoothRemoteGATTServer", html$._BluetoothRemoteGATTServer);
>+html$._BluetoothRemoteGATTService = class _BluetoothRemoteGATTService extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$._BluetoothRemoteGATTService);
>+dart.setLibraryUri(html$._BluetoothRemoteGATTService, "dart:html");
>+dart.registerExtension("BluetoothRemoteGATTService", html$._BluetoothRemoteGATTService);
>+html$._BluetoothUUID = class _BluetoothUUID extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$._BluetoothUUID);
>+dart.setLibraryUri(html$._BluetoothUUID, "dart:html");
>+dart.registerExtension("BluetoothUUID", html$._BluetoothUUID);
>+html$._BudgetService = class _BudgetService extends _interceptors.Interceptor {
>+  [$getBudget]() {
>+    return html$.promiseToFuture(html$.BudgetState, this.getBudget());
>+  }
>+  [$getCost](operation) {
>+    return html$.promiseToFuture(core.double, this.getCost(operation));
>+  }
>+  [$reserve](operation) {
>+    return html$.promiseToFuture(core.bool, this.reserve(operation));
>+  }
>+};
>+dart.addTypeTests(html$._BudgetService);
>+dart.setMethodSignature(html$._BudgetService, () => ({
>+  __proto__: dart.getMethods(html$._BudgetService.__proto__),
>+  [$getBudget]: dart.fnType(async.Future$(html$.BudgetState), []),
>+  [$getCost]: dart.fnType(async.Future$(core.double), [core.String]),
>+  [$reserve]: dart.fnType(async.Future$(core.bool), [core.String])
>+}));
>+dart.setLibraryUri(html$._BudgetService, "dart:html");
>+dart.registerExtension("BudgetService", html$._BudgetService);
>+html$._Cache = class _Cache extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$._Cache);
>+dart.setLibraryUri(html$._Cache, "dart:html");
>+dart.registerExtension("Cache", html$._Cache);
>+html$._CanvasPath = class _CanvasPath extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$._CanvasPath);
>+dart.setLibraryUri(html$._CanvasPath, "dart:html");
>+html$._Clipboard = class _Clipboard extends html$.EventTarget {
>+  [$read]() {
>+    return html$.promiseToFuture(html$.DataTransfer, this.read());
>+  }
>+  [$readText]() {
>+    return html$.promiseToFuture(core.String, this.readText());
>+  }
>+  [$write](data) {
>+    return html$.promiseToFuture(dart.dynamic, this.write(data));
>+  }
>+  [$writeText](data) {
>+    return html$.promiseToFuture(dart.dynamic, this.writeText(data));
>+  }
>+};
>+dart.addTypeTests(html$._Clipboard);
>+dart.setMethodSignature(html$._Clipboard, () => ({
>+  __proto__: dart.getMethods(html$._Clipboard.__proto__),
>+  [$read]: dart.fnType(async.Future$(html$.DataTransfer), []),
>+  [$readText]: dart.fnType(async.Future$(core.String), []),
>+  [$write]: dart.fnType(async.Future, [html$.DataTransfer]),
>+  [$writeText]: dart.fnType(async.Future, [core.String])
>+}));
>+dart.setLibraryUri(html$._Clipboard, "dart:html");
>+dart.registerExtension("Clipboard", html$._Clipboard);
>+const Interceptor_ListMixin$$8 = class Interceptor_ListMixin extends _interceptors.Interceptor {};
>+(Interceptor_ListMixin$$8.new = function() {
>+  Interceptor_ListMixin$$8.__proto__.new.call(this);
>+}).prototype = Interceptor_ListMixin$$8.prototype;
>+dart.applyMixin(Interceptor_ListMixin$$8, collection.ListMixin$(html$.CssRule));
>+const Interceptor_ImmutableListMixin$$8 = class Interceptor_ImmutableListMixin extends Interceptor_ListMixin$$8 {};
>+(Interceptor_ImmutableListMixin$$8.new = function() {
>+  Interceptor_ImmutableListMixin$$8.__proto__.new.call(this);
>+}).prototype = Interceptor_ImmutableListMixin$$8.prototype;
>+dart.applyMixin(Interceptor_ImmutableListMixin$$8, html$.ImmutableListMixin$(html$.CssRule));
>+html$._CssRuleList = class _CssRuleList extends Interceptor_ImmutableListMixin$$8 {
>+  get [$length]() {
>+    return this.length;
>+  }
>+  [$_get](index) {
>+    if (index >>> 0 !== index || index >= this[$length]) dart.throw(core.RangeError.index(index, this));
>+    return this[index];
>+  }
>+  [$_set](index, value) {
>+    html$.CssRule._check(value);
>+    dart.throw(new core.UnsupportedError.new("Cannot assign element of immutable List."));
>+    return value;
>+  }
>+  set [$length](value) {
>+    dart.throw(new core.UnsupportedError.new("Cannot resize immutable List."));
>+  }
>+  get [$first]() {
>+    if (dart.notNull(this[$length]) > 0) {
>+      return this[0];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$first](value) {
>+    super[$first] = value;
>+  }
>+  get [$last]() {
>+    let len = this[$length];
>+    if (dart.notNull(len) > 0) {
>+      return this[dart.notNull(len) - 1];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$last](value) {
>+    super[$last] = value;
>+  }
>+  get [$single]() {
>+    let len = this[$length];
>+    if (len === 1) {
>+      return this[0];
>+    }
>+    if (len === 0) dart.throw(new core.StateError.new("No elements"));
>+    dart.throw(new core.StateError.new("More than one element"));
>+  }
>+  [$elementAt](index) {
>+    return this[$_get](index);
>+  }
>+  [$item](...args) {
>+    return this.item.apply(this, args);
>+  }
>+};
>+html$._CssRuleList.prototype[dart.isList] = true;
>+dart.addTypeTests(html$._CssRuleList);
>+html$._CssRuleList[dart.implements] = () => [JavaScriptIndexingBehaviorOfCssRule(), ListOfCssRule()];
>+dart.setMethodSignature(html$._CssRuleList, () => ({
>+  __proto__: dart.getMethods(html$._CssRuleList.__proto__),
>+  [$_get]: dart.fnType(html$.CssRule, [core.int]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$elementAt]: dart.fnType(html$.CssRule, [core.int]),
>+  [$item]: dart.fnType(html$.CssRule, [core.int])
>+}));
>+dart.setGetterSignature(html$._CssRuleList, () => ({
>+  __proto__: dart.getGetters(html$._CssRuleList.__proto__),
>+  [$length]: core.int,
>+  [$first]: html$.CssRule,
>+  [$last]: html$.CssRule,
>+  [$single]: html$.CssRule
>+}));
>+dart.setSetterSignature(html$._CssRuleList, () => ({
>+  __proto__: dart.getSetters(html$._CssRuleList.__proto__),
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(html$._CssRuleList, "dart:html");
>+dart.registerExtension("CSSRuleList", html$._CssRuleList);
>+html$._DOMFileSystemSync = class _DOMFileSystemSync extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$._DOMFileSystemSync);
>+dart.setLibraryUri(html$._DOMFileSystemSync, "dart:html");
>+dart.registerExtension("DOMFileSystemSync", html$._DOMFileSystemSync);
>+html$._EntrySync = class _EntrySync extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$._EntrySync);
>+dart.setLibraryUri(html$._EntrySync, "dart:html");
>+dart.registerExtension("EntrySync", html$._EntrySync);
>+html$._DirectoryEntrySync = class _DirectoryEntrySync extends html$._EntrySync {};
>+dart.addTypeTests(html$._DirectoryEntrySync);
>+dart.setLibraryUri(html$._DirectoryEntrySync, "dart:html");
>+dart.registerExtension("DirectoryEntrySync", html$._DirectoryEntrySync);
>+html$._DirectoryReaderSync = class _DirectoryReaderSync extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$._DirectoryReaderSync);
>+dart.setLibraryUri(html$._DirectoryReaderSync, "dart:html");
>+dart.registerExtension("DirectoryReaderSync", html$._DirectoryReaderSync);
>+html$._DocumentType = class _DocumentType extends html$.Node {};
>+dart.addTypeTests(html$._DocumentType);
>+html$._DocumentType[dart.implements] = () => [html$.ChildNode];
>+dart.setLibraryUri(html$._DocumentType, "dart:html");
>+dart.registerExtension("DocumentType", html$._DocumentType);
>+html$._DomRect = class _DomRect extends html$.DomRectReadOnly {
>+  [$toString]() {
>+    return "Rectangle (" + dart.str(this[$left]) + ", " + dart.str(this[$top]) + ") " + dart.str(this[$width]) + " x " + dart.str(this[$height]);
>+  }
>+  [$_equals](other) {
>+    if (!RectangleOfnum().is(other)) return false;
>+    return core.identical(this[$left], dart.dload(other, 'left')) && core.identical(this[$top], dart.dload(other, 'top')) && core.identical(this[$width], dart.dload(other, 'width')) && core.identical(this[$height], dart.dload(other, 'height'));
>+  }
>+  get [$hashCode]() {
>+    return html$._JenkinsSmiHash.hash4(dart.hashCode(this[$left]), dart.hashCode(this[$top]), dart.hashCode(this[$width]), dart.hashCode(this[$height]));
>+  }
>+  [$intersection](other) {
>+    let x0 = math.max(core.num, this[$left], other[$left]);
>+    let x1 = math.min(core.num, dart.notNull(this[$left]) + dart.notNull(this[$width]), dart.notNull(other[$left]) + dart.notNull(other[$width]));
>+    if (x0 <= x1) {
>+      let y0 = math.max(core.num, this[$top], other[$top]);
>+      let y1 = math.min(core.num, dart.notNull(this[$top]) + dart.notNull(this[$height]), dart.notNull(other[$top]) + dart.notNull(other[$height]));
>+      if (y0 <= y1) {
>+        return new (RectangleOfnum()).new(x0, y0, x1 - x0, y1 - y0);
>+      }
>+    }
>+    return null;
>+  }
>+  [$intersects](other) {
>+    return dart.notNull(this[$left]) <= dart.notNull(other[$left]) + dart.notNull(other[$width]) && dart.notNull(other[$left]) <= dart.notNull(this[$left]) + dart.notNull(this[$width]) && dart.notNull(this[$top]) <= dart.notNull(other[$top]) + dart.notNull(other[$height]) && dart.notNull(other[$top]) <= dart.notNull(this[$top]) + dart.notNull(this[$height]);
>+  }
>+  [$boundingBox](other) {
>+    let right = math.max(core.num, dart.notNull(this[$left]) + dart.notNull(this[$width]), dart.notNull(other[$left]) + dart.notNull(other[$width]));
>+    let bottom = math.max(core.num, dart.notNull(this[$top]) + dart.notNull(this[$height]), dart.notNull(other[$top]) + dart.notNull(other[$height]));
>+    let left = math.min(core.num, this[$left], other[$left]);
>+    let top = math.min(core.num, this[$top], other[$top]);
>+    return new (RectangleOfnum()).new(left, top, right - left, bottom - top);
>+  }
>+  [$containsRectangle](another) {
>+    return dart.notNull(this[$left]) <= dart.notNull(another[$left]) && dart.notNull(this[$left]) + dart.notNull(this[$width]) >= dart.notNull(another[$left]) + dart.notNull(another[$width]) && dart.notNull(this[$top]) <= dart.notNull(another[$top]) && dart.notNull(this[$top]) + dart.notNull(this[$height]) >= dart.notNull(another[$top]) + dart.notNull(another[$height]);
>+  }
>+  [$containsPoint](another) {
>+    return dart.notNull(another.x) >= dart.notNull(this[$left]) && dart.notNull(another.x) <= dart.notNull(this[$left]) + dart.notNull(this[$width]) && dart.notNull(another.y) >= dart.notNull(this[$top]) && dart.notNull(another.y) <= dart.notNull(this[$top]) + dart.notNull(this[$height]);
>+  }
>+  get [$topLeft]() {
>+    return new (PointOfnum()).new(this[$left], this[$top]);
>+  }
>+  get [$topRight]() {
>+    return new (PointOfnum()).new(dart.notNull(this[$left]) + dart.notNull(this[$width]), this[$top]);
>+  }
>+  get [$bottomRight]() {
>+    return new (PointOfnum()).new(dart.notNull(this[$left]) + dart.notNull(this[$width]), dart.notNull(this[$top]) + dart.notNull(this[$height]));
>+  }
>+  get [$bottomLeft]() {
>+    return new (PointOfnum()).new(this[$left], dart.notNull(this[$top]) + dart.notNull(this[$height]));
>+  }
>+  static new(x, y, width, height) {
>+    if (x === void 0) x = null;
>+    if (y === void 0) y = null;
>+    if (width === void 0) width = null;
>+    if (height === void 0) height = null;
>+    if (height != null) {
>+      return html$._DomRect._create_1(x, y, width, height);
>+    }
>+    if (width != null) {
>+      return html$._DomRect._create_2(x, y, width);
>+    }
>+    if (y != null) {
>+      return html$._DomRect._create_3(x, y);
>+    }
>+    if (x != null) {
>+      return html$._DomRect._create_4(x);
>+    }
>+    return html$._DomRect._create_5();
>+  }
>+  static _create_1(x, y, width, height) {
>+    return new DOMRect(x, y, width, height);
>+  }
>+  static _create_2(x, y, width) {
>+    return new DOMRect(x, y, width);
>+  }
>+  static _create_3(x, y) {
>+    return new DOMRect(x, y);
>+  }
>+  static _create_4(x) {
>+    return new DOMRect(x);
>+  }
>+  static _create_5() {
>+    return new DOMRect();
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  set [$height](value) {
>+    this.height = value;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  set [$width](value) {
>+    this.width = value;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  set [$x](value) {
>+    this.x = value;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+  set [$y](value) {
>+    this.y = value;
>+  }
>+};
>+dart.addTypeTests(html$._DomRect);
>+html$._DomRect[dart.implements] = () => [RectangleOfnum()];
>+dart.setSetterSignature(html$._DomRect, () => ({
>+  __proto__: dart.getSetters(html$._DomRect.__proto__),
>+  [$height]: core.num,
>+  [$width]: core.num,
>+  [$x]: core.num,
>+  [$y]: core.num
>+}));
>+dart.setLibraryUri(html$._DomRect, "dart:html");
>+dart.registerExtension("ClientRect", html$._DomRect);
>+dart.registerExtension("DOMRect", html$._DomRect);
>+html$._JenkinsSmiHash = class _JenkinsSmiHash extends core.Object {
>+  static combine(hash, value) {
>+    hash = 536870911 & dart.notNull(hash) + dart.notNull(value);
>+    hash = 536870911 & dart.notNull(hash) + ((524287 & dart.notNull(hash)) << 10);
>+    return (dart.notNull(hash) ^ hash[$rightShift](6)) >>> 0;
>+  }
>+  static finish(hash) {
>+    hash = 536870911 & dart.notNull(hash) + ((67108863 & dart.notNull(hash)) << 3);
>+    hash = (dart.notNull(hash) ^ hash[$rightShift](11)) >>> 0;
>+    return 536870911 & dart.notNull(hash) + ((16383 & dart.notNull(hash)) << 15);
>+  }
>+  static hash2(a, b) {
>+    return html$._JenkinsSmiHash.finish(html$._JenkinsSmiHash.combine(html$._JenkinsSmiHash.combine(0, core.int._check(a)), core.int._check(b)));
>+  }
>+  static hash4(a, b, c, d) {
>+    return html$._JenkinsSmiHash.finish(html$._JenkinsSmiHash.combine(html$._JenkinsSmiHash.combine(html$._JenkinsSmiHash.combine(html$._JenkinsSmiHash.combine(0, core.int._check(a)), core.int._check(b)), core.int._check(c)), core.int._check(d)));
>+  }
>+};
>+(html$._JenkinsSmiHash.new = function() {
>+}).prototype = html$._JenkinsSmiHash.prototype;
>+dart.addTypeTests(html$._JenkinsSmiHash);
>+dart.setLibraryUri(html$._JenkinsSmiHash, "dart:html");
>+html$._FileEntrySync = class _FileEntrySync extends html$._EntrySync {};
>+dart.addTypeTests(html$._FileEntrySync);
>+dart.setLibraryUri(html$._FileEntrySync, "dart:html");
>+dart.registerExtension("FileEntrySync", html$._FileEntrySync);
>+html$._FileReaderSync = class _FileReaderSync extends _interceptors.Interceptor {
>+  static new() {
>+    return html$._FileReaderSync._create_1();
>+  }
>+  static _create_1() {
>+    return new FileReaderSync();
>+  }
>+};
>+dart.addTypeTests(html$._FileReaderSync);
>+dart.setLibraryUri(html$._FileReaderSync, "dart:html");
>+dart.registerExtension("FileReaderSync", html$._FileReaderSync);
>+html$._FileWriterSync = class _FileWriterSync extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$._FileWriterSync);
>+dart.setLibraryUri(html$._FileWriterSync, "dart:html");
>+dart.registerExtension("FileWriterSync", html$._FileWriterSync);
>+const Interceptor_ListMixin$$9 = class Interceptor_ListMixin extends _interceptors.Interceptor {};
>+(Interceptor_ListMixin$$9.new = function() {
>+  Interceptor_ListMixin$$9.__proto__.new.call(this);
>+}).prototype = Interceptor_ListMixin$$9.prototype;
>+dart.applyMixin(Interceptor_ListMixin$$9, collection.ListMixin$(html$.Gamepad));
>+const Interceptor_ImmutableListMixin$$9 = class Interceptor_ImmutableListMixin extends Interceptor_ListMixin$$9 {};
>+(Interceptor_ImmutableListMixin$$9.new = function() {
>+  Interceptor_ImmutableListMixin$$9.__proto__.new.call(this);
>+}).prototype = Interceptor_ImmutableListMixin$$9.prototype;
>+dart.applyMixin(Interceptor_ImmutableListMixin$$9, html$.ImmutableListMixin$(html$.Gamepad));
>+html$._GamepadList = class _GamepadList extends Interceptor_ImmutableListMixin$$9 {
>+  get [$length]() {
>+    return this.length;
>+  }
>+  [$_get](index) {
>+    if (index >>> 0 !== index || index >= this[$length]) dart.throw(core.RangeError.index(index, this));
>+    return this[index];
>+  }
>+  [$_set](index, value) {
>+    html$.Gamepad._check(value);
>+    dart.throw(new core.UnsupportedError.new("Cannot assign element of immutable List."));
>+    return value;
>+  }
>+  set [$length](value) {
>+    dart.throw(new core.UnsupportedError.new("Cannot resize immutable List."));
>+  }
>+  get [$first]() {
>+    if (dart.notNull(this[$length]) > 0) {
>+      return this[0];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$first](value) {
>+    super[$first] = value;
>+  }
>+  get [$last]() {
>+    let len = this[$length];
>+    if (dart.notNull(len) > 0) {
>+      return this[dart.notNull(len) - 1];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$last](value) {
>+    super[$last] = value;
>+  }
>+  get [$single]() {
>+    let len = this[$length];
>+    if (len === 1) {
>+      return this[0];
>+    }
>+    if (len === 0) dart.throw(new core.StateError.new("No elements"));
>+    dart.throw(new core.StateError.new("More than one element"));
>+  }
>+  [$elementAt](index) {
>+    return this[$_get](index);
>+  }
>+  [$item](...args) {
>+    return this.item.apply(this, args);
>+  }
>+};
>+html$._GamepadList.prototype[dart.isList] = true;
>+dart.addTypeTests(html$._GamepadList);
>+html$._GamepadList[dart.implements] = () => [ListOfGamepad(), JavaScriptIndexingBehaviorOfGamepad()];
>+dart.setMethodSignature(html$._GamepadList, () => ({
>+  __proto__: dart.getMethods(html$._GamepadList.__proto__),
>+  [$_get]: dart.fnType(html$.Gamepad, [core.int]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$elementAt]: dart.fnType(html$.Gamepad, [core.int]),
>+  [$item]: dart.fnType(html$.Gamepad, [core.int])
>+}));
>+dart.setGetterSignature(html$._GamepadList, () => ({
>+  __proto__: dart.getGetters(html$._GamepadList.__proto__),
>+  [$length]: core.int,
>+  [$first]: html$.Gamepad,
>+  [$last]: html$.Gamepad,
>+  [$single]: html$.Gamepad
>+}));
>+dart.setSetterSignature(html$._GamepadList, () => ({
>+  __proto__: dart.getSetters(html$._GamepadList.__proto__),
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(html$._GamepadList, "dart:html");
>+dart.registerExtension("GamepadList", html$._GamepadList);
>+html$._HTMLAllCollection = class _HTMLAllCollection extends _interceptors.Interceptor {
>+  [_item](...args) {
>+    return this.item.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$._HTMLAllCollection);
>+dart.setMethodSignature(html$._HTMLAllCollection, () => ({
>+  __proto__: dart.getMethods(html$._HTMLAllCollection.__proto__),
>+  [_item]: dart.fnType(html$.Element, [core.int])
>+}));
>+dart.setLibraryUri(html$._HTMLAllCollection, "dart:html");
>+dart.registerExtension("HTMLAllCollection", html$._HTMLAllCollection);
>+html$._HTMLDirectoryElement = class _HTMLDirectoryElement extends html$.HtmlElement {};
>+(html$._HTMLDirectoryElement.created = function() {
>+  html$._HTMLDirectoryElement.__proto__.created.call(this);
>+}).prototype = html$._HTMLDirectoryElement.prototype;
>+dart.addTypeTests(html$._HTMLDirectoryElement);
>+dart.setLibraryUri(html$._HTMLDirectoryElement, "dart:html");
>+dart.registerExtension("HTMLDirectoryElement", html$._HTMLDirectoryElement);
>+html$._HTMLFontElement = class _HTMLFontElement extends html$.HtmlElement {};
>+(html$._HTMLFontElement.created = function() {
>+  html$._HTMLFontElement.__proto__.created.call(this);
>+}).prototype = html$._HTMLFontElement.prototype;
>+dart.addTypeTests(html$._HTMLFontElement);
>+dart.setLibraryUri(html$._HTMLFontElement, "dart:html");
>+dart.registerExtension("HTMLFontElement", html$._HTMLFontElement);
>+html$._HTMLFrameElement = class _HTMLFrameElement extends html$.HtmlElement {};
>+(html$._HTMLFrameElement.created = function() {
>+  html$._HTMLFrameElement.__proto__.created.call(this);
>+}).prototype = html$._HTMLFrameElement.prototype;
>+dart.addTypeTests(html$._HTMLFrameElement);
>+dart.setLibraryUri(html$._HTMLFrameElement, "dart:html");
>+dart.registerExtension("HTMLFrameElement", html$._HTMLFrameElement);
>+html$._HTMLFrameSetElement = class _HTMLFrameSetElement extends html$.HtmlElement {};
>+(html$._HTMLFrameSetElement.created = function() {
>+  html$._HTMLFrameSetElement.__proto__.created.call(this);
>+}).prototype = html$._HTMLFrameSetElement.prototype;
>+dart.addTypeTests(html$._HTMLFrameSetElement);
>+html$._HTMLFrameSetElement[dart.implements] = () => [html$.WindowEventHandlers];
>+dart.setLibraryUri(html$._HTMLFrameSetElement, "dart:html");
>+dart.registerExtension("HTMLFrameSetElement", html$._HTMLFrameSetElement);
>+html$._HTMLMarqueeElement = class _HTMLMarqueeElement extends html$.HtmlElement {};
>+(html$._HTMLMarqueeElement.created = function() {
>+  html$._HTMLMarqueeElement.__proto__.created.call(this);
>+}).prototype = html$._HTMLMarqueeElement.prototype;
>+dart.addTypeTests(html$._HTMLMarqueeElement);
>+dart.setLibraryUri(html$._HTMLMarqueeElement, "dart:html");
>+dart.registerExtension("HTMLMarqueeElement", html$._HTMLMarqueeElement);
>+html$._Mojo = class _Mojo extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$._Mojo);
>+dart.setLibraryUri(html$._Mojo, "dart:html");
>+dart.registerExtension("Mojo", html$._Mojo);
>+html$._MojoHandle = class _MojoHandle extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$._MojoHandle);
>+dart.setLibraryUri(html$._MojoHandle, "dart:html");
>+dart.registerExtension("MojoHandle", html$._MojoHandle);
>+html$._MojoInterfaceInterceptor = class _MojoInterfaceInterceptor extends html$.EventTarget {
>+  static new(interfaceName, scope) {
>+    if (scope === void 0) scope = null;
>+    if (scope != null) {
>+      return html$._MojoInterfaceInterceptor._create_1(interfaceName, scope);
>+    }
>+    return html$._MojoInterfaceInterceptor._create_2(interfaceName);
>+  }
>+  static _create_1(interfaceName, scope) {
>+    return new MojoInterfaceInterceptor(interfaceName, scope);
>+  }
>+  static _create_2(interfaceName) {
>+    return new MojoInterfaceInterceptor(interfaceName);
>+  }
>+};
>+dart.addTypeTests(html$._MojoInterfaceInterceptor);
>+dart.setLibraryUri(html$._MojoInterfaceInterceptor, "dart:html");
>+dart.registerExtension("MojoInterfaceInterceptor", html$._MojoInterfaceInterceptor);
>+html$._MojoInterfaceRequestEvent = class _MojoInterfaceRequestEvent extends html$.Event {
>+  static new(type, eventInitDict) {
>+    if (eventInitDict === void 0) eventInitDict = null;
>+    if (eventInitDict != null) {
>+      let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+      return html$._MojoInterfaceRequestEvent._create_1(type, eventInitDict_1);
>+    }
>+    return html$._MojoInterfaceRequestEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new MojoInterfaceRequestEvent(type, eventInitDict);
>+  }
>+  static _create_2(type) {
>+    return new MojoInterfaceRequestEvent(type);
>+  }
>+};
>+dart.addTypeTests(html$._MojoInterfaceRequestEvent);
>+dart.setLibraryUri(html$._MojoInterfaceRequestEvent, "dart:html");
>+dart.registerExtension("MojoInterfaceRequestEvent", html$._MojoInterfaceRequestEvent);
>+html$._MojoWatcher = class _MojoWatcher extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$._MojoWatcher);
>+dart.setLibraryUri(html$._MojoWatcher, "dart:html");
>+dart.registerExtension("MojoWatcher", html$._MojoWatcher);
>+html$._NFC = class _NFC extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$._NFC);
>+dart.setLibraryUri(html$._NFC, "dart:html");
>+dart.registerExtension("NFC", html$._NFC);
>+const Interceptor_ListMixin$$10 = class Interceptor_ListMixin extends _interceptors.Interceptor {};
>+(Interceptor_ListMixin$$10.new = function() {
>+  Interceptor_ListMixin$$10.__proto__.new.call(this);
>+}).prototype = Interceptor_ListMixin$$10.prototype;
>+dart.applyMixin(Interceptor_ListMixin$$10, collection.ListMixin$(html$.Node));
>+const Interceptor_ImmutableListMixin$$10 = class Interceptor_ImmutableListMixin extends Interceptor_ListMixin$$10 {};
>+(Interceptor_ImmutableListMixin$$10.new = function() {
>+  Interceptor_ImmutableListMixin$$10.__proto__.new.call(this);
>+}).prototype = Interceptor_ImmutableListMixin$$10.prototype;
>+dart.applyMixin(Interceptor_ImmutableListMixin$$10, html$.ImmutableListMixin$(html$.Node));
>+html$._NamedNodeMap = class _NamedNodeMap extends Interceptor_ImmutableListMixin$$10 {
>+  get [$length]() {
>+    return this.length;
>+  }
>+  [$_get](index) {
>+    if (index >>> 0 !== index || index >= this[$length]) dart.throw(core.RangeError.index(index, this));
>+    return this[index];
>+  }
>+  [$_set](index, value) {
>+    html$.Node._check(value);
>+    dart.throw(new core.UnsupportedError.new("Cannot assign element of immutable List."));
>+    return value;
>+  }
>+  set [$length](value) {
>+    dart.throw(new core.UnsupportedError.new("Cannot resize immutable List."));
>+  }
>+  get [$first]() {
>+    if (dart.notNull(this[$length]) > 0) {
>+      return this[0];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$first](value) {
>+    super[$first] = value;
>+  }
>+  get [$last]() {
>+    let len = this[$length];
>+    if (dart.notNull(len) > 0) {
>+      return this[dart.notNull(len) - 1];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$last](value) {
>+    super[$last] = value;
>+  }
>+  get [$single]() {
>+    let len = this[$length];
>+    if (len === 1) {
>+      return this[0];
>+    }
>+    if (len === 0) dart.throw(new core.StateError.new("No elements"));
>+    dart.throw(new core.StateError.new("More than one element"));
>+  }
>+  [$elementAt](index) {
>+    return this[$_get](index);
>+  }
>+  [$getNamedItem](...args) {
>+    return this.getNamedItem.apply(this, args);
>+  }
>+  [$getNamedItemNS](...args) {
>+    return this.getNamedItemNS.apply(this, args);
>+  }
>+  [$item](...args) {
>+    return this.item.apply(this, args);
>+  }
>+  [$removeNamedItem](...args) {
>+    return this.removeNamedItem.apply(this, args);
>+  }
>+  [$removeNamedItemNS](...args) {
>+    return this.removeNamedItemNS.apply(this, args);
>+  }
>+  [$setNamedItem](...args) {
>+    return this.setNamedItem.apply(this, args);
>+  }
>+  [$setNamedItemNS](...args) {
>+    return this.setNamedItemNS.apply(this, args);
>+  }
>+};
>+html$._NamedNodeMap.prototype[dart.isList] = true;
>+dart.addTypeTests(html$._NamedNodeMap);
>+html$._NamedNodeMap[dart.implements] = () => [JavaScriptIndexingBehaviorOfNode(), ListOfNode()];
>+dart.setMethodSignature(html$._NamedNodeMap, () => ({
>+  __proto__: dart.getMethods(html$._NamedNodeMap.__proto__),
>+  [$_get]: dart.fnType(html$.Node, [core.int]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$elementAt]: dart.fnType(html$.Node, [core.int]),
>+  [$getNamedItem]: dart.fnType(html$._Attr, [core.String]),
>+  [$getNamedItemNS]: dart.fnType(html$._Attr, [core.String, core.String]),
>+  [$item]: dart.fnType(html$._Attr, [core.int]),
>+  [$removeNamedItem]: dart.fnType(html$._Attr, [core.String]),
>+  [$removeNamedItemNS]: dart.fnType(html$._Attr, [core.String, core.String]),
>+  [$setNamedItem]: dart.fnType(html$._Attr, [html$._Attr]),
>+  [$setNamedItemNS]: dart.fnType(html$._Attr, [html$._Attr])
>+}));
>+dart.setGetterSignature(html$._NamedNodeMap, () => ({
>+  __proto__: dart.getGetters(html$._NamedNodeMap.__proto__),
>+  [$length]: core.int,
>+  [$first]: html$.Node,
>+  [$last]: html$.Node,
>+  [$single]: html$.Node
>+}));
>+dart.setSetterSignature(html$._NamedNodeMap, () => ({
>+  __proto__: dart.getSetters(html$._NamedNodeMap.__proto__),
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(html$._NamedNodeMap, "dart:html");
>+dart.registerExtension("NamedNodeMap", html$._NamedNodeMap);
>+dart.registerExtension("MozNamedAttrMap", html$._NamedNodeMap);
>+html$._PagePopupController = class _PagePopupController extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$._PagePopupController);
>+dart.setLibraryUri(html$._PagePopupController, "dart:html");
>+dart.registerExtension("PagePopupController", html$._PagePopupController);
>+html$._Report = class _Report extends _interceptors.Interceptor {
>+  get [$body]() {
>+    return this.body;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  get [$url]() {
>+    return this.url;
>+  }
>+};
>+dart.addTypeTests(html$._Report);
>+dart.setLibraryUri(html$._Report, "dart:html");
>+dart.setFieldSignature(html$._Report, () => ({
>+  __proto__: dart.getFields(html$._Report.__proto__),
>+  [$body]: dart.finalFieldType(html$.ReportBody),
>+  [$type]: dart.finalFieldType(core.String),
>+  [$url]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("Report", html$._Report);
>+html$._Request = class _Request extends html$.Body {
>+  static new(input, requestInitDict) {
>+    if (requestInitDict === void 0) requestInitDict = null;
>+    if (requestInitDict != null) {
>+      let requestInitDict_1 = html_common.convertDartToNative_Dictionary(requestInitDict);
>+      return html$._Request._create_1(input, requestInitDict_1);
>+    }
>+    return html$._Request._create_2(input);
>+  }
>+  static _create_1(input, requestInitDict) {
>+    return new Request(input, requestInitDict);
>+  }
>+  static _create_2(input) {
>+    return new Request(input);
>+  }
>+  get [$cache]() {
>+    return this.cache;
>+  }
>+  get [$credentials]() {
>+    return this.credentials;
>+  }
>+  get [$headers]() {
>+    return this.headers;
>+  }
>+  get [$integrity]() {
>+    return this.integrity;
>+  }
>+  get [$mode]() {
>+    return this.mode;
>+  }
>+  get [$redirect]() {
>+    return this.redirect;
>+  }
>+  get [$referrer]() {
>+    return this.referrer;
>+  }
>+  get [$referrerPolicy]() {
>+    return this.referrerPolicy;
>+  }
>+  get [$url]() {
>+    return this.url;
>+  }
>+  [$clone](...args) {
>+    return this.clone.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(html$._Request);
>+dart.setMethodSignature(html$._Request, () => ({
>+  __proto__: dart.getMethods(html$._Request.__proto__),
>+  [$clone]: dart.fnType(html$._Request, [])
>+}));
>+dart.setLibraryUri(html$._Request, "dart:html");
>+dart.setFieldSignature(html$._Request, () => ({
>+  __proto__: dart.getFields(html$._Request.__proto__),
>+  [$cache]: dart.finalFieldType(core.String),
>+  [$credentials]: dart.finalFieldType(core.String),
>+  [$headers]: dart.finalFieldType(html$.Headers),
>+  [$integrity]: dart.finalFieldType(core.String),
>+  [$mode]: dart.finalFieldType(core.String),
>+  [$redirect]: dart.finalFieldType(core.String),
>+  [$referrer]: dart.finalFieldType(core.String),
>+  [$referrerPolicy]: dart.finalFieldType(core.String),
>+  [$url]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("Request", html$._Request);
>+html$._ResourceProgressEvent = class _ResourceProgressEvent extends html$.ProgressEvent {};
>+dart.addTypeTests(html$._ResourceProgressEvent);
>+dart.setLibraryUri(html$._ResourceProgressEvent, "dart:html");
>+dart.registerExtension("ResourceProgressEvent", html$._ResourceProgressEvent);
>+html$._Response = class _Response extends html$.Body {
>+  static new(body, init) {
>+    if (body === void 0) body = null;
>+    if (init === void 0) init = null;
>+    if (init != null) {
>+      let init_1 = html_common.convertDartToNative_Dictionary(init);
>+      return html$._Response._create_1(body, init_1);
>+    }
>+    if (body != null) {
>+      return html$._Response._create_2(body);
>+    }
>+    return html$._Response._create_3();
>+  }
>+  static _create_1(body, init) {
>+    return new Response(body, init);
>+  }
>+  static _create_2(body) {
>+    return new Response(body);
>+  }
>+  static _create_3() {
>+    return new Response();
>+  }
>+};
>+dart.addTypeTests(html$._Response);
>+dart.setLibraryUri(html$._Response, "dart:html");
>+dart.registerExtension("Response", html$._Response);
>+const Interceptor_ListMixin$$11 = class Interceptor_ListMixin extends _interceptors.Interceptor {};
>+(Interceptor_ListMixin$$11.new = function() {
>+  Interceptor_ListMixin$$11.__proto__.new.call(this);
>+}).prototype = Interceptor_ListMixin$$11.prototype;
>+dart.applyMixin(Interceptor_ListMixin$$11, collection.ListMixin$(html$.SpeechRecognitionResult));
>+const Interceptor_ImmutableListMixin$$11 = class Interceptor_ImmutableListMixin extends Interceptor_ListMixin$$11 {};
>+(Interceptor_ImmutableListMixin$$11.new = function() {
>+  Interceptor_ImmutableListMixin$$11.__proto__.new.call(this);
>+}).prototype = Interceptor_ImmutableListMixin$$11.prototype;
>+dart.applyMixin(Interceptor_ImmutableListMixin$$11, html$.ImmutableListMixin$(html$.SpeechRecognitionResult));
>+html$._SpeechRecognitionResultList = class _SpeechRecognitionResultList extends Interceptor_ImmutableListMixin$$11 {
>+  get [$length]() {
>+    return this.length;
>+  }
>+  [$_get](index) {
>+    if (index >>> 0 !== index || index >= this[$length]) dart.throw(core.RangeError.index(index, this));
>+    return this[index];
>+  }
>+  [$_set](index, value) {
>+    html$.SpeechRecognitionResult._check(value);
>+    dart.throw(new core.UnsupportedError.new("Cannot assign element of immutable List."));
>+    return value;
>+  }
>+  set [$length](value) {
>+    dart.throw(new core.UnsupportedError.new("Cannot resize immutable List."));
>+  }
>+  get [$first]() {
>+    if (dart.notNull(this[$length]) > 0) {
>+      return this[0];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$first](value) {
>+    super[$first] = value;
>+  }
>+  get [$last]() {
>+    let len = this[$length];
>+    if (dart.notNull(len) > 0) {
>+      return this[dart.notNull(len) - 1];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$last](value) {
>+    super[$last] = value;
>+  }
>+  get [$single]() {
>+    let len = this[$length];
>+    if (len === 1) {
>+      return this[0];
>+    }
>+    if (len === 0) dart.throw(new core.StateError.new("No elements"));
>+    dart.throw(new core.StateError.new("More than one element"));
>+  }
>+  [$elementAt](index) {
>+    return this[$_get](index);
>+  }
>+  [$item](...args) {
>+    return this.item.apply(this, args);
>+  }
>+};
>+html$._SpeechRecognitionResultList.prototype[dart.isList] = true;
>+dart.addTypeTests(html$._SpeechRecognitionResultList);
>+html$._SpeechRecognitionResultList[dart.implements] = () => [JavaScriptIndexingBehaviorOfSpeechRecognitionResult(), ListOfSpeechRecognitionResult()];
>+dart.setMethodSignature(html$._SpeechRecognitionResultList, () => ({
>+  __proto__: dart.getMethods(html$._SpeechRecognitionResultList.__proto__),
>+  [$_get]: dart.fnType(html$.SpeechRecognitionResult, [core.int]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$elementAt]: dart.fnType(html$.SpeechRecognitionResult, [core.int]),
>+  [$item]: dart.fnType(html$.SpeechRecognitionResult, [core.int])
>+}));
>+dart.setGetterSignature(html$._SpeechRecognitionResultList, () => ({
>+  __proto__: dart.getGetters(html$._SpeechRecognitionResultList.__proto__),
>+  [$length]: core.int,
>+  [$first]: html$.SpeechRecognitionResult,
>+  [$last]: html$.SpeechRecognitionResult,
>+  [$single]: html$.SpeechRecognitionResult
>+}));
>+dart.setSetterSignature(html$._SpeechRecognitionResultList, () => ({
>+  __proto__: dart.getSetters(html$._SpeechRecognitionResultList.__proto__),
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(html$._SpeechRecognitionResultList, "dart:html");
>+dart.registerExtension("SpeechRecognitionResultList", html$._SpeechRecognitionResultList);
>+const Interceptor_ListMixin$$12 = class Interceptor_ListMixin extends _interceptors.Interceptor {};
>+(Interceptor_ListMixin$$12.new = function() {
>+  Interceptor_ListMixin$$12.__proto__.new.call(this);
>+}).prototype = Interceptor_ListMixin$$12.prototype;
>+dart.applyMixin(Interceptor_ListMixin$$12, collection.ListMixin$(html$.StyleSheet));
>+const Interceptor_ImmutableListMixin$$12 = class Interceptor_ImmutableListMixin extends Interceptor_ListMixin$$12 {};
>+(Interceptor_ImmutableListMixin$$12.new = function() {
>+  Interceptor_ImmutableListMixin$$12.__proto__.new.call(this);
>+}).prototype = Interceptor_ImmutableListMixin$$12.prototype;
>+dart.applyMixin(Interceptor_ImmutableListMixin$$12, html$.ImmutableListMixin$(html$.StyleSheet));
>+html$._StyleSheetList = class _StyleSheetList extends Interceptor_ImmutableListMixin$$12 {
>+  get [$length]() {
>+    return this.length;
>+  }
>+  [$_get](index) {
>+    if (index >>> 0 !== index || index >= this[$length]) dart.throw(core.RangeError.index(index, this));
>+    return this[index];
>+  }
>+  [$_set](index, value) {
>+    html$.StyleSheet._check(value);
>+    dart.throw(new core.UnsupportedError.new("Cannot assign element of immutable List."));
>+    return value;
>+  }
>+  set [$length](value) {
>+    dart.throw(new core.UnsupportedError.new("Cannot resize immutable List."));
>+  }
>+  get [$first]() {
>+    if (dart.notNull(this[$length]) > 0) {
>+      return this[0];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$first](value) {
>+    super[$first] = value;
>+  }
>+  get [$last]() {
>+    let len = this[$length];
>+    if (dart.notNull(len) > 0) {
>+      return this[dart.notNull(len) - 1];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$last](value) {
>+    super[$last] = value;
>+  }
>+  get [$single]() {
>+    let len = this[$length];
>+    if (len === 1) {
>+      return this[0];
>+    }
>+    if (len === 0) dart.throw(new core.StateError.new("No elements"));
>+    dart.throw(new core.StateError.new("More than one element"));
>+  }
>+  [$elementAt](index) {
>+    return this[$_get](index);
>+  }
>+  [__getter__](...args) {
>+    return this.__getter__.apply(this, args);
>+  }
>+  [$item](...args) {
>+    return this.item.apply(this, args);
>+  }
>+};
>+html$._StyleSheetList.prototype[dart.isList] = true;
>+dart.addTypeTests(html$._StyleSheetList);
>+html$._StyleSheetList[dart.implements] = () => [ListOfStyleSheet(), JavaScriptIndexingBehaviorOfStyleSheet()];
>+dart.setMethodSignature(html$._StyleSheetList, () => ({
>+  __proto__: dart.getMethods(html$._StyleSheetList.__proto__),
>+  [$_get]: dart.fnType(html$.StyleSheet, [core.int]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$elementAt]: dart.fnType(html$.StyleSheet, [core.int]),
>+  [__getter__]: dart.fnType(html$.CssStyleSheet, [core.String]),
>+  [$item]: dart.fnType(html$.StyleSheet, [core.int])
>+}));
>+dart.setGetterSignature(html$._StyleSheetList, () => ({
>+  __proto__: dart.getGetters(html$._StyleSheetList.__proto__),
>+  [$length]: core.int,
>+  [$first]: html$.StyleSheet,
>+  [$last]: html$.StyleSheet,
>+  [$single]: html$.StyleSheet
>+}));
>+dart.setSetterSignature(html$._StyleSheetList, () => ({
>+  __proto__: dart.getSetters(html$._StyleSheetList.__proto__),
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(html$._StyleSheetList, "dart:html");
>+dart.registerExtension("StyleSheetList", html$._StyleSheetList);
>+html$._SubtleCrypto = class _SubtleCrypto extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$._SubtleCrypto);
>+dart.setLibraryUri(html$._SubtleCrypto, "dart:html");
>+dart.registerExtension("SubtleCrypto", html$._SubtleCrypto);
>+html$._USB = class _USB extends html$.EventTarget {};
>+dart.addTypeTests(html$._USB);
>+dart.setLibraryUri(html$._USB, "dart:html");
>+dart.registerExtension("USB", html$._USB);
>+html$._USBAlternateInterface = class _USBAlternateInterface extends _interceptors.Interceptor {
>+  static new(deviceInterface, alternateSetting) {
>+    return html$._USBAlternateInterface._create_1(deviceInterface, alternateSetting);
>+  }
>+  static _create_1(deviceInterface, alternateSetting) {
>+    return new USBAlternateInterface(deviceInterface, alternateSetting);
>+  }
>+};
>+dart.addTypeTests(html$._USBAlternateInterface);
>+dart.setLibraryUri(html$._USBAlternateInterface, "dart:html");
>+dart.registerExtension("USBAlternateInterface", html$._USBAlternateInterface);
>+html$._USBConfiguration = class _USBConfiguration extends _interceptors.Interceptor {
>+  static new(device, configurationValue) {
>+    return html$._USBConfiguration._create_1(device, configurationValue);
>+  }
>+  static _create_1(device, configurationValue) {
>+    return new USBConfiguration(device, configurationValue);
>+  }
>+};
>+dart.addTypeTests(html$._USBConfiguration);
>+dart.setLibraryUri(html$._USBConfiguration, "dart:html");
>+dart.registerExtension("USBConfiguration", html$._USBConfiguration);
>+html$._USBConnectionEvent = class _USBConnectionEvent extends html$.Event {
>+  static new(type, eventInitDict) {
>+    let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+    return html$._USBConnectionEvent._create_1(type, eventInitDict_1);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new USBConnectionEvent(type, eventInitDict);
>+  }
>+};
>+dart.addTypeTests(html$._USBConnectionEvent);
>+dart.setLibraryUri(html$._USBConnectionEvent, "dart:html");
>+dart.registerExtension("USBConnectionEvent", html$._USBConnectionEvent);
>+html$._USBDevice = class _USBDevice extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$._USBDevice);
>+dart.setLibraryUri(html$._USBDevice, "dart:html");
>+dart.registerExtension("USBDevice", html$._USBDevice);
>+html$._USBEndpoint = class _USBEndpoint extends _interceptors.Interceptor {
>+  static new(alternate, endpointNumber, direction) {
>+    return html$._USBEndpoint._create_1(alternate, endpointNumber, direction);
>+  }
>+  static _create_1(alternate, endpointNumber, direction) {
>+    return new USBEndpoint(alternate, endpointNumber, direction);
>+  }
>+};
>+dart.addTypeTests(html$._USBEndpoint);
>+dart.setLibraryUri(html$._USBEndpoint, "dart:html");
>+dart.registerExtension("USBEndpoint", html$._USBEndpoint);
>+html$._USBInTransferResult = class _USBInTransferResult extends _interceptors.Interceptor {
>+  static new(status, data) {
>+    if (data === void 0) data = null;
>+    if (data != null) {
>+      return html$._USBInTransferResult._create_1(status, data);
>+    }
>+    return html$._USBInTransferResult._create_2(status);
>+  }
>+  static _create_1(status, data) {
>+    return new USBInTransferResult(status, data);
>+  }
>+  static _create_2(status) {
>+    return new USBInTransferResult(status);
>+  }
>+};
>+dart.addTypeTests(html$._USBInTransferResult);
>+dart.setLibraryUri(html$._USBInTransferResult, "dart:html");
>+dart.registerExtension("USBInTransferResult", html$._USBInTransferResult);
>+html$._USBInterface = class _USBInterface extends _interceptors.Interceptor {
>+  static new(configuration, interfaceNumber) {
>+    return html$._USBInterface._create_1(configuration, interfaceNumber);
>+  }
>+  static _create_1(configuration, interfaceNumber) {
>+    return new USBInterface(configuration, interfaceNumber);
>+  }
>+};
>+dart.addTypeTests(html$._USBInterface);
>+dart.setLibraryUri(html$._USBInterface, "dart:html");
>+dart.registerExtension("USBInterface", html$._USBInterface);
>+html$._USBIsochronousInTransferPacket = class _USBIsochronousInTransferPacket extends _interceptors.Interceptor {
>+  static new(status, data) {
>+    if (data === void 0) data = null;
>+    if (data != null) {
>+      return html$._USBIsochronousInTransferPacket._create_1(status, data);
>+    }
>+    return html$._USBIsochronousInTransferPacket._create_2(status);
>+  }
>+  static _create_1(status, data) {
>+    return new USBIsochronousInTransferPacket(status, data);
>+  }
>+  static _create_2(status) {
>+    return new USBIsochronousInTransferPacket(status);
>+  }
>+};
>+dart.addTypeTests(html$._USBIsochronousInTransferPacket);
>+dart.setLibraryUri(html$._USBIsochronousInTransferPacket, "dart:html");
>+dart.registerExtension("USBIsochronousInTransferPacket", html$._USBIsochronousInTransferPacket);
>+html$._USBIsochronousInTransferResult = class _USBIsochronousInTransferResult extends _interceptors.Interceptor {
>+  static new(packets, data) {
>+    if (data === void 0) data = null;
>+    if (data != null) {
>+      return html$._USBIsochronousInTransferResult._create_1(packets, data);
>+    }
>+    return html$._USBIsochronousInTransferResult._create_2(packets);
>+  }
>+  static _create_1(packets, data) {
>+    return new USBIsochronousInTransferResult(packets, data);
>+  }
>+  static _create_2(packets) {
>+    return new USBIsochronousInTransferResult(packets);
>+  }
>+};
>+dart.addTypeTests(html$._USBIsochronousInTransferResult);
>+dart.setLibraryUri(html$._USBIsochronousInTransferResult, "dart:html");
>+dart.registerExtension("USBIsochronousInTransferResult", html$._USBIsochronousInTransferResult);
>+html$._USBIsochronousOutTransferPacket = class _USBIsochronousOutTransferPacket extends _interceptors.Interceptor {
>+  static new(status, bytesWritten) {
>+    if (bytesWritten === void 0) bytesWritten = null;
>+    if (bytesWritten != null) {
>+      return html$._USBIsochronousOutTransferPacket._create_1(status, bytesWritten);
>+    }
>+    return html$._USBIsochronousOutTransferPacket._create_2(status);
>+  }
>+  static _create_1(status, bytesWritten) {
>+    return new USBIsochronousOutTransferPacket(status, bytesWritten);
>+  }
>+  static _create_2(status) {
>+    return new USBIsochronousOutTransferPacket(status);
>+  }
>+};
>+dart.addTypeTests(html$._USBIsochronousOutTransferPacket);
>+dart.setLibraryUri(html$._USBIsochronousOutTransferPacket, "dart:html");
>+dart.registerExtension("USBIsochronousOutTransferPacket", html$._USBIsochronousOutTransferPacket);
>+html$._USBIsochronousOutTransferResult = class _USBIsochronousOutTransferResult extends _interceptors.Interceptor {
>+  static new(packets) {
>+    return html$._USBIsochronousOutTransferResult._create_1(packets);
>+  }
>+  static _create_1(packets) {
>+    return new USBIsochronousOutTransferResult(packets);
>+  }
>+};
>+dart.addTypeTests(html$._USBIsochronousOutTransferResult);
>+dart.setLibraryUri(html$._USBIsochronousOutTransferResult, "dart:html");
>+dart.registerExtension("USBIsochronousOutTransferResult", html$._USBIsochronousOutTransferResult);
>+html$._USBOutTransferResult = class _USBOutTransferResult extends _interceptors.Interceptor {
>+  static new(status, bytesWritten) {
>+    if (bytesWritten === void 0) bytesWritten = null;
>+    if (bytesWritten != null) {
>+      return html$._USBOutTransferResult._create_1(status, bytesWritten);
>+    }
>+    return html$._USBOutTransferResult._create_2(status);
>+  }
>+  static _create_1(status, bytesWritten) {
>+    return new USBOutTransferResult(status, bytesWritten);
>+  }
>+  static _create_2(status) {
>+    return new USBOutTransferResult(status);
>+  }
>+};
>+dart.addTypeTests(html$._USBOutTransferResult);
>+dart.setLibraryUri(html$._USBOutTransferResult, "dart:html");
>+dart.registerExtension("USBOutTransferResult", html$._USBOutTransferResult);
>+html$._WindowTimers = class _WindowTimers extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$._WindowTimers);
>+dart.setLibraryUri(html$._WindowTimers, "dart:html");
>+html$._WorkerLocation = class _WorkerLocation extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$._WorkerLocation);
>+html$._WorkerLocation[dart.implements] = () => [html$.UrlUtilsReadOnly];
>+dart.setLibraryUri(html$._WorkerLocation, "dart:html");
>+dart.registerExtension("WorkerLocation", html$._WorkerLocation);
>+html$._WorkerNavigator = class _WorkerNavigator extends html$.NavigatorConcurrentHardware {};
>+dart.addTypeTests(html$._WorkerNavigator);
>+html$._WorkerNavigator[dart.implements] = () => [html$.NavigatorOnLine, html$.NavigatorID];
>+dart.setLibraryUri(html$._WorkerNavigator, "dart:html");
>+dart.registerExtension("WorkerNavigator", html$._WorkerNavigator);
>+html$._Worklet = class _Worklet extends _interceptors.Interceptor {};
>+dart.addTypeTests(html$._Worklet);
>+dart.setLibraryUri(html$._Worklet, "dart:html");
>+dart.registerExtension("Worklet", html$._Worklet);
>+const _matches = dart.privateName(html$, "_matches");
>+html$._AttributeMap = class _AttributeMap extends collection.MapBase$(core.String, core.String) {
>+  addAll(other) {
>+    MapOfString$String()._check(other);
>+    other[$forEach](dart.fn((k, v) => {
>+      this._set(k, v);
>+    }, StringAndStringToNull()));
>+  }
>+  cast(K, V) {
>+    return core.Map.castFrom(core.String, core.String, K, V, this);
>+  }
>+  containsValue(value) {
>+    for (let v of this.values) {
>+      if (dart.equals(value, v)) {
>+        return true;
>+      }
>+    }
>+    return false;
>+  }
>+  putIfAbsent(key, ifAbsent) {
>+    core.String._check(key);
>+    VoidToString()._check(ifAbsent);
>+    if (!dart.test(this[$containsKey](key))) {
>+      this._set(key, ifAbsent());
>+    }
>+    return this._get(key);
>+  }
>+  clear() {
>+    for (let key of this.keys) {
>+      this[$remove](key);
>+    }
>+  }
>+  forEach(f) {
>+    for (let key of this.keys) {
>+      let value = this._get(key);
>+      f(key, value);
>+    }
>+  }
>+  get keys() {
>+    let attributes = this[_element$][_attributes$];
>+    let keys = JSArrayOfString().of([]);
>+    for (let i = 0, len = attributes[$length]; i < dart.notNull(len); i++) {
>+      let attr = html$._Attr._check(attributes[$_get](i));
>+      if (dart.test(this[_matches](attr))) {
>+        keys[$add](attr.name);
>+      }
>+    }
>+    return keys;
>+  }
>+  get values() {
>+    let attributes = this[_element$][_attributes$];
>+    let values = JSArrayOfString().of([]);
>+    for (let i = 0, len = attributes[$length]; i < dart.notNull(len); i++) {
>+      let attr = html$._Attr._check(attributes[$_get](i));
>+      if (dart.test(this[_matches](attr))) {
>+        values[$add](attr.value);
>+      }
>+    }
>+    return values;
>+  }
>+  get isEmpty() {
>+    return this[$length] === 0;
>+  }
>+  get isNotEmpty() {
>+    return !dart.test(this.isEmpty);
>+  }
>+};
>+(html$._AttributeMap.new = function(element) {
>+  this[_element$] = element;
>+}).prototype = html$._AttributeMap.prototype;
>+dart.addTypeTests(html$._AttributeMap);
>+dart.setMethodSignature(html$._AttributeMap, () => ({
>+  __proto__: dart.getMethods(html$._AttributeMap.__proto__),
>+  addAll: dart.fnType(dart.void, [core.Object]),
>+  [$addAll]: dart.fnType(dart.void, [core.Object]),
>+  cast: dart.gFnType((K, V) => [core.Map$(K, V), []]),
>+  [$cast]: dart.gFnType((K, V) => [core.Map$(K, V), []]),
>+  containsValue: dart.fnType(core.bool, [core.Object]),
>+  [$containsValue]: dart.fnType(core.bool, [core.Object]),
>+  putIfAbsent: dart.fnType(core.String, [core.Object, core.Object]),
>+  [$putIfAbsent]: dart.fnType(core.String, [core.Object, core.Object]),
>+  clear: dart.fnType(dart.void, []),
>+  [$clear]: dart.fnType(dart.void, []),
>+  forEach: dart.fnType(dart.void, [dart.fnType(dart.void, [core.String, core.String])]),
>+  [$forEach]: dart.fnType(dart.void, [dart.fnType(dart.void, [core.String, core.String])])
>+}));
>+dart.setGetterSignature(html$._AttributeMap, () => ({
>+  __proto__: dart.getGetters(html$._AttributeMap.__proto__),
>+  keys: core.Iterable$(core.String),
>+  [$keys]: core.Iterable$(core.String),
>+  values: core.Iterable$(core.String),
>+  [$values]: core.Iterable$(core.String),
>+  isEmpty: core.bool,
>+  [$isEmpty]: core.bool,
>+  isNotEmpty: core.bool,
>+  [$isNotEmpty]: core.bool
>+}));
>+dart.setLibraryUri(html$._AttributeMap, "dart:html");
>+dart.setFieldSignature(html$._AttributeMap, () => ({
>+  __proto__: dart.getFields(html$._AttributeMap.__proto__),
>+  [_element$]: dart.finalFieldType(html$.Element)
>+}));
>+dart.defineExtensionMethods(html$._AttributeMap, [
>+  'addAll',
>+  'cast',
>+  'containsValue',
>+  'putIfAbsent',
>+  'clear',
>+  'forEach'
>+]);
>+dart.defineExtensionAccessors(html$._AttributeMap, ['keys', 'values', 'isEmpty', 'isNotEmpty']);
>+html$._ElementAttributeMap = class _ElementAttributeMap extends html$._AttributeMap {
>+  containsKey(key) {
>+    return this[_element$][_hasAttribute](core.String._check(key));
>+  }
>+  _get(key) {
>+    return this[_element$][$getAttribute](core.String._check(key));
>+  }
>+  _set(key, value) {
>+    core.String._check(key);
>+    core.String._check(value);
>+    this[_element$][$setAttribute](key, value);
>+    return value;
>+  }
>+  remove(key) {
>+    return typeof key == 'string' ? html$._ElementAttributeMap._remove(this[_element$], key) : null;
>+  }
>+  get length() {
>+    return this.keys[$length];
>+  }
>+  [_matches](node) {
>+    return node[_namespaceUri] == null;
>+  }
>+  static _remove(element, key) {
>+    let value = element.getAttribute(key);
>+    element.removeAttribute(key);
>+    return value;
>+  }
>+};
>+(html$._ElementAttributeMap.new = function(element) {
>+  html$._ElementAttributeMap.__proto__.new.call(this, element);
>+}).prototype = html$._ElementAttributeMap.prototype;
>+dart.addTypeTests(html$._ElementAttributeMap);
>+dart.setMethodSignature(html$._ElementAttributeMap, () => ({
>+  __proto__: dart.getMethods(html$._ElementAttributeMap.__proto__),
>+  containsKey: dart.fnType(core.bool, [core.Object]),
>+  [$containsKey]: dart.fnType(core.bool, [core.Object]),
>+  _get: dart.fnType(core.String, [core.Object]),
>+  [$_get]: dart.fnType(core.String, [core.Object]),
>+  _set: dart.fnType(dart.void, [core.Object, core.Object]),
>+  [$_set]: dart.fnType(dart.void, [core.Object, core.Object]),
>+  remove: dart.fnType(core.String, [core.Object]),
>+  [$remove]: dart.fnType(core.String, [core.Object]),
>+  [_matches]: dart.fnType(core.bool, [html$._Attr])
>+}));
>+dart.setGetterSignature(html$._ElementAttributeMap, () => ({
>+  __proto__: dart.getGetters(html$._ElementAttributeMap.__proto__),
>+  length: core.int,
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(html$._ElementAttributeMap, "dart:html");
>+dart.defineExtensionMethods(html$._ElementAttributeMap, ['containsKey', '_get', '_set', 'remove']);
>+dart.defineExtensionAccessors(html$._ElementAttributeMap, ['length']);
>+const _namespace = dart.privateName(html$, "_namespace");
>+html$._NamespacedAttributeMap = class _NamespacedAttributeMap extends html$._AttributeMap {
>+  containsKey(key) {
>+    return this[_element$][_hasAttributeNS](this[_namespace], core.String._check(key));
>+  }
>+  _get(key) {
>+    return this[_element$][$getAttributeNS](this[_namespace], core.String._check(key));
>+  }
>+  _set(key, value) {
>+    core.String._check(key);
>+    core.String._check(value);
>+    this[_element$][$setAttributeNS](this[_namespace], key, value);
>+    return value;
>+  }
>+  remove(key) {
>+    return typeof key == 'string' ? html$._NamespacedAttributeMap._remove(this[_namespace], this[_element$], key) : null;
>+  }
>+  get length() {
>+    return this.keys[$length];
>+  }
>+  [_matches](node) {
>+    return node[_namespaceUri] == this[_namespace];
>+  }
>+  static _remove(namespace, element, key) {
>+    let value = element.getAttributeNS(namespace, key);
>+    element.removeAttributeNS(namespace, key);
>+    return value;
>+  }
>+};
>+(html$._NamespacedAttributeMap.new = function(element, namespace) {
>+  this[_namespace] = namespace;
>+  html$._NamespacedAttributeMap.__proto__.new.call(this, element);
>+}).prototype = html$._NamespacedAttributeMap.prototype;
>+dart.addTypeTests(html$._NamespacedAttributeMap);
>+dart.setMethodSignature(html$._NamespacedAttributeMap, () => ({
>+  __proto__: dart.getMethods(html$._NamespacedAttributeMap.__proto__),
>+  containsKey: dart.fnType(core.bool, [core.Object]),
>+  [$containsKey]: dart.fnType(core.bool, [core.Object]),
>+  _get: dart.fnType(core.String, [core.Object]),
>+  [$_get]: dart.fnType(core.String, [core.Object]),
>+  _set: dart.fnType(dart.void, [core.Object, core.Object]),
>+  [$_set]: dart.fnType(dart.void, [core.Object, core.Object]),
>+  remove: dart.fnType(core.String, [core.Object]),
>+  [$remove]: dart.fnType(core.String, [core.Object]),
>+  [_matches]: dart.fnType(core.bool, [html$._Attr])
>+}));
>+dart.setGetterSignature(html$._NamespacedAttributeMap, () => ({
>+  __proto__: dart.getGetters(html$._NamespacedAttributeMap.__proto__),
>+  length: core.int,
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(html$._NamespacedAttributeMap, "dart:html");
>+dart.setFieldSignature(html$._NamespacedAttributeMap, () => ({
>+  __proto__: dart.getFields(html$._NamespacedAttributeMap.__proto__),
>+  [_namespace]: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionMethods(html$._NamespacedAttributeMap, ['containsKey', '_get', '_set', 'remove']);
>+dart.defineExtensionAccessors(html$._NamespacedAttributeMap, ['length']);
>+const _attr = dart.privateName(html$, "_attr");
>+const _strip = dart.privateName(html$, "_strip");
>+const _toHyphenedName = dart.privateName(html$, "_toHyphenedName");
>+const _toCamelCase = dart.privateName(html$, "_toCamelCase");
>+html$._DataAttributeMap = class _DataAttributeMap extends collection.MapBase$(core.String, core.String) {
>+  addAll(other) {
>+    MapOfString$String()._check(other);
>+    other[$forEach](dart.fn((k, v) => {
>+      this._set(k, v);
>+    }, StringAndStringToNull()));
>+  }
>+  cast(K, V) {
>+    return core.Map.castFrom(core.String, core.String, K, V, this);
>+  }
>+  containsValue(value) {
>+    return this.values[$any](dart.fn(v => core.identical(v, value), StringTobool()));
>+  }
>+  containsKey(key) {
>+    return this[_attributes$][$containsKey](this[_attr](core.String._check(key)));
>+  }
>+  _get(key) {
>+    return this[_attributes$][$_get](this[_attr](core.String._check(key)));
>+  }
>+  _set(key, value) {
>+    core.String._check(key);
>+    core.String._check(value);
>+    this[_attributes$][$_set](this[_attr](key), value);
>+    return value;
>+  }
>+  putIfAbsent(key, ifAbsent) {
>+    core.String._check(key);
>+    VoidToString()._check(ifAbsent);
>+    return this[_attributes$][$putIfAbsent](this[_attr](key), ifAbsent);
>+  }
>+  remove(key) {
>+    return this[_attributes$][$remove](this[_attr](core.String._check(key)));
>+  }
>+  clear() {
>+    for (let key of this.keys) {
>+      this.remove(key);
>+    }
>+  }
>+  forEach(f) {
>+    this[_attributes$][$forEach](dart.fn((key, value) => {
>+      if (dart.test(this[_matches](key))) {
>+        f(this[_strip](key), value);
>+      }
>+    }, StringAndStringToNull()));
>+  }
>+  get keys() {
>+    let keys = JSArrayOfString().of([]);
>+    this[_attributes$][$forEach](dart.fn((key, value) => {
>+      if (dart.test(this[_matches](key))) {
>+        keys[$add](this[_strip](key));
>+      }
>+    }, StringAndStringToNull()));
>+    return keys;
>+  }
>+  get values() {
>+    let values = JSArrayOfString().of([]);
>+    this[_attributes$][$forEach](dart.fn((key, value) => {
>+      if (dart.test(this[_matches](key))) {
>+        values[$add](value);
>+      }
>+    }, StringAndStringToNull()));
>+    return values;
>+  }
>+  get length() {
>+    return this.keys[$length];
>+  }
>+  get isEmpty() {
>+    return this.length === 0;
>+  }
>+  get isNotEmpty() {
>+    return !dart.test(this.isEmpty);
>+  }
>+  [_attr](key) {
>+    return "data-" + dart.str(this[_toHyphenedName](key));
>+  }
>+  [_matches](key) {
>+    return key[$startsWith]("data-");
>+  }
>+  [_strip](key) {
>+    return this[_toCamelCase](key[$substring](5));
>+  }
>+  [_toCamelCase](hyphenedName, opts) {
>+    let startUppercase = opts && 'startUppercase' in opts ? opts.startUppercase : false;
>+    let segments = hyphenedName[$split]("-");
>+    let start = dart.test(startUppercase) ? 0 : 1;
>+    for (let i = start; i < dart.notNull(segments[$length]); i++) {
>+      let segment = segments[$_get](i);
>+      if (segment.length > 0) {
>+        segments[$_set](i, segment[$_get](0)[$toUpperCase]() + segment[$substring](1));
>+      }
>+    }
>+    return segments[$join]("");
>+  }
>+  [_toHyphenedName](word) {
>+    let sb = new core.StringBuffer.new();
>+    for (let i = 0; i < word.length; i++) {
>+      let lower = word[$_get](i)[$toLowerCase]();
>+      if (word[$_get](i) !== lower && i > 0) sb.write("-");
>+      sb.write(lower);
>+    }
>+    return sb.toString();
>+  }
>+};
>+(html$._DataAttributeMap.new = function(attributes) {
>+  this[_attributes$] = attributes;
>+}).prototype = html$._DataAttributeMap.prototype;
>+dart.addTypeTests(html$._DataAttributeMap);
>+dart.setMethodSignature(html$._DataAttributeMap, () => ({
>+  __proto__: dart.getMethods(html$._DataAttributeMap.__proto__),
>+  addAll: dart.fnType(dart.void, [core.Object]),
>+  [$addAll]: dart.fnType(dart.void, [core.Object]),
>+  cast: dart.gFnType((K, V) => [core.Map$(K, V), []]),
>+  [$cast]: dart.gFnType((K, V) => [core.Map$(K, V), []]),
>+  containsValue: dart.fnType(core.bool, [core.Object]),
>+  [$containsValue]: dart.fnType(core.bool, [core.Object]),
>+  containsKey: dart.fnType(core.bool, [core.Object]),
>+  [$containsKey]: dart.fnType(core.bool, [core.Object]),
>+  _get: dart.fnType(core.String, [core.Object]),
>+  [$_get]: dart.fnType(core.String, [core.Object]),
>+  _set: dart.fnType(dart.void, [core.Object, core.Object]),
>+  [$_set]: dart.fnType(dart.void, [core.Object, core.Object]),
>+  putIfAbsent: dart.fnType(core.String, [core.Object, core.Object]),
>+  [$putIfAbsent]: dart.fnType(core.String, [core.Object, core.Object]),
>+  remove: dart.fnType(core.String, [core.Object]),
>+  [$remove]: dart.fnType(core.String, [core.Object]),
>+  clear: dart.fnType(dart.void, []),
>+  [$clear]: dart.fnType(dart.void, []),
>+  forEach: dart.fnType(dart.void, [dart.fnType(dart.void, [core.String, core.String])]),
>+  [$forEach]: dart.fnType(dart.void, [dart.fnType(dart.void, [core.String, core.String])]),
>+  [_attr]: dart.fnType(core.String, [core.String]),
>+  [_matches]: dart.fnType(core.bool, [core.String]),
>+  [_strip]: dart.fnType(core.String, [core.String]),
>+  [_toCamelCase]: dart.fnType(core.String, [core.String], {startUppercase: core.bool}),
>+  [_toHyphenedName]: dart.fnType(core.String, [core.String])
>+}));
>+dart.setGetterSignature(html$._DataAttributeMap, () => ({
>+  __proto__: dart.getGetters(html$._DataAttributeMap.__proto__),
>+  keys: core.Iterable$(core.String),
>+  [$keys]: core.Iterable$(core.String),
>+  values: core.Iterable$(core.String),
>+  [$values]: core.Iterable$(core.String),
>+  length: core.int,
>+  [$length]: core.int,
>+  isEmpty: core.bool,
>+  [$isEmpty]: core.bool,
>+  isNotEmpty: core.bool,
>+  [$isNotEmpty]: core.bool
>+}));
>+dart.setLibraryUri(html$._DataAttributeMap, "dart:html");
>+dart.setFieldSignature(html$._DataAttributeMap, () => ({
>+  __proto__: dart.getFields(html$._DataAttributeMap.__proto__),
>+  [_attributes$]: dart.finalFieldType(MapOfString$String())
>+}));
>+dart.defineExtensionMethods(html$._DataAttributeMap, [
>+  'addAll',
>+  'cast',
>+  'containsValue',
>+  'containsKey',
>+  '_get',
>+  '_set',
>+  'putIfAbsent',
>+  'remove',
>+  'clear',
>+  'forEach'
>+]);
>+dart.defineExtensionAccessors(html$._DataAttributeMap, [
>+  'keys',
>+  'values',
>+  'length',
>+  'isEmpty',
>+  'isNotEmpty'
>+]);
>+html$.CanvasImageSource = class CanvasImageSource extends core.Object {};
>+(html$.CanvasImageSource.new = function() {
>+}).prototype = html$.CanvasImageSource.prototype;
>+dart.addTypeTests(html$.CanvasImageSource);
>+dart.setLibraryUri(html$.CanvasImageSource, "dart:html");
>+html$.WindowBase = class WindowBase extends core.Object {};
>+(html$.WindowBase.new = function() {
>+}).prototype = html$.WindowBase.prototype;
>+dart.addTypeTests(html$.WindowBase);
>+html$.WindowBase[dart.implements] = () => [html$.EventTarget];
>+dart.setLibraryUri(html$.WindowBase, "dart:html");
>+html$.LocationBase = class LocationBase extends core.Object {};
>+(html$.LocationBase.new = function() {
>+}).prototype = html$.LocationBase.prototype;
>+dart.addTypeTests(html$.LocationBase);
>+dart.setLibraryUri(html$.LocationBase, "dart:html");
>+html$.HistoryBase = class HistoryBase extends core.Object {};
>+(html$.HistoryBase.new = function() {
>+}).prototype = html$.HistoryBase.prototype;
>+dart.addTypeTests(html$.HistoryBase);
>+dart.setLibraryUri(html$.HistoryBase, "dart:html");
>+html$.CssClassSet = class CssClassSet extends core.Object {};
>+(html$.CssClassSet.new = function() {
>+}).prototype = html$.CssClassSet.prototype;
>+dart.addTypeTests(html$.CssClassSet);
>+html$.CssClassSet[dart.implements] = () => [SetOfString()];
>+dart.setLibraryUri(html$.CssClassSet, "dart:html");
>+const _addOrSubtractToBoxModel = dart.privateName(html$, "_addOrSubtractToBoxModel");
>+html$.CssRect = class CssRect extends core.Object {
>+  set height(newHeight) {
>+    dart.throw(new core.UnsupportedError.new("Can only set height for content rect."));
>+  }
>+  set width(newWidth) {
>+    dart.throw(new core.UnsupportedError.new("Can only set width for content rect."));
>+  }
>+  [_addOrSubtractToBoxModel](dimensions, augmentingMeasurement) {
>+    let styles = this[_element$][$getComputedStyle]();
>+    let val = 0;
>+    for (let measurement of dimensions) {
>+      if (augmentingMeasurement == html$._MARGIN) {
>+        val = val + dart.notNull(new html$.Dimension.css(styles[$getPropertyValue](dart.str(augmentingMeasurement) + "-" + dart.str(measurement))).value);
>+      }
>+      if (augmentingMeasurement == html$._CONTENT) {
>+        val = val - dart.notNull(new html$.Dimension.css(styles[$getPropertyValue](dart.str(html$._PADDING) + "-" + dart.str(measurement))).value);
>+      }
>+      if (augmentingMeasurement != html$._MARGIN) {
>+        val = val - dart.notNull(new html$.Dimension.css(styles[$getPropertyValue]("border-" + dart.str(measurement) + "-width")).value);
>+      }
>+    }
>+    return val;
>+  }
>+  get right() {
>+    return dart.notNull(this.left) + dart.notNull(this.width);
>+  }
>+  get bottom() {
>+    return dart.notNull(this.top) + dart.notNull(this.height);
>+  }
>+  toString() {
>+    return "Rectangle (" + dart.str(this.left) + ", " + dart.str(this.top) + ") " + dart.str(this.width) + " x " + dart.str(this.height);
>+  }
>+  _equals(other) {
>+    if (!RectangleOfnum().is(other)) return false;
>+    return core.identical(this.left, dart.dload(other, 'left')) && core.identical(this.top, dart.dload(other, 'top')) && core.identical(this.right, dart.dload(other, 'right')) && core.identical(this.bottom, dart.dload(other, 'bottom'));
>+  }
>+  get hashCode() {
>+    return html$._JenkinsSmiHash.hash4(dart.hashCode(this.left), dart.hashCode(this.top), dart.hashCode(this.right), dart.hashCode(this.bottom));
>+  }
>+  intersection(other) {
>+    let x0 = math.max(core.num, this.left, other[$left]);
>+    let x1 = math.min(core.num, dart.notNull(this.left) + dart.notNull(this.width), dart.notNull(other[$left]) + dart.notNull(other[$width]));
>+    if (x0 <= x1) {
>+      let y0 = math.max(core.num, this.top, other[$top]);
>+      let y1 = math.min(core.num, dart.notNull(this.top) + dart.notNull(this.height), dart.notNull(other[$top]) + dart.notNull(other[$height]));
>+      if (y0 <= y1) {
>+        return new (RectangleOfnum()).new(x0, y0, x1 - x0, y1 - y0);
>+      }
>+    }
>+    return null;
>+  }
>+  intersects(other) {
>+    return dart.notNull(this.left) <= dart.notNull(other[$left]) + dart.notNull(other[$width]) && dart.notNull(other[$left]) <= dart.notNull(this.left) + dart.notNull(this.width) && dart.notNull(this.top) <= dart.notNull(other[$top]) + dart.notNull(other[$height]) && dart.notNull(other[$top]) <= dart.notNull(this.top) + dart.notNull(this.height);
>+  }
>+  boundingBox(other) {
>+    let right = math.max(core.num, dart.notNull(this.left) + dart.notNull(this.width), dart.notNull(other[$left]) + dart.notNull(other[$width]));
>+    let bottom = math.max(core.num, dart.notNull(this.top) + dart.notNull(this.height), dart.notNull(other[$top]) + dart.notNull(other[$height]));
>+    let left = math.min(core.num, this.left, other[$left]);
>+    let top = math.min(core.num, this.top, other[$top]);
>+    return new (RectangleOfnum()).new(left, top, right - left, bottom - top);
>+  }
>+  containsRectangle(another) {
>+    return dart.notNull(this.left) <= dart.notNull(another[$left]) && dart.notNull(this.left) + dart.notNull(this.width) >= dart.notNull(another[$left]) + dart.notNull(another[$width]) && dart.notNull(this.top) <= dart.notNull(another[$top]) && dart.notNull(this.top) + dart.notNull(this.height) >= dart.notNull(another[$top]) + dart.notNull(another[$height]);
>+  }
>+  containsPoint(another) {
>+    return dart.notNull(another.x) >= dart.notNull(this.left) && dart.notNull(another.x) <= dart.notNull(this.left) + dart.notNull(this.width) && dart.notNull(another.y) >= dart.notNull(this.top) && dart.notNull(another.y) <= dart.notNull(this.top) + dart.notNull(this.height);
>+  }
>+  get topLeft() {
>+    return new (PointOfnum()).new(this.left, this.top);
>+  }
>+  get topRight() {
>+    return new (PointOfnum()).new(dart.notNull(this.left) + dart.notNull(this.width), this.top);
>+  }
>+  get bottomRight() {
>+    return new (PointOfnum()).new(dart.notNull(this.left) + dart.notNull(this.width), dart.notNull(this.top) + dart.notNull(this.height));
>+  }
>+  get bottomLeft() {
>+    return new (PointOfnum()).new(this.left, dart.notNull(this.top) + dart.notNull(this.height));
>+  }
>+};
>+(html$.CssRect.new = function(element) {
>+  this[_element$] = element;
>+}).prototype = html$.CssRect.prototype;
>+dart.addTypeTests(html$.CssRect);
>+html$.CssRect[dart.implements] = () => [RectangleOfnum()];
>+dart.setMethodSignature(html$.CssRect, () => ({
>+  __proto__: dart.getMethods(html$.CssRect.__proto__),
>+  [_addOrSubtractToBoxModel]: dart.fnType(core.num, [core.List$(core.String), core.String]),
>+  intersection: dart.fnType(math.Rectangle$(core.num), [math.Rectangle$(core.num)]),
>+  [$intersection]: dart.fnType(math.Rectangle$(core.num), [math.Rectangle$(core.num)]),
>+  intersects: dart.fnType(core.bool, [math.Rectangle$(core.num)]),
>+  [$intersects]: dart.fnType(core.bool, [math.Rectangle$(core.num)]),
>+  boundingBox: dart.fnType(math.Rectangle$(core.num), [math.Rectangle$(core.num)]),
>+  [$boundingBox]: dart.fnType(math.Rectangle$(core.num), [math.Rectangle$(core.num)]),
>+  containsRectangle: dart.fnType(core.bool, [math.Rectangle$(core.num)]),
>+  [$containsRectangle]: dart.fnType(core.bool, [math.Rectangle$(core.num)]),
>+  containsPoint: dart.fnType(core.bool, [math.Point$(core.num)]),
>+  [$containsPoint]: dart.fnType(core.bool, [math.Point$(core.num)])
>+}));
>+dart.setGetterSignature(html$.CssRect, () => ({
>+  __proto__: dart.getGetters(html$.CssRect.__proto__),
>+  right: core.num,
>+  [$right]: core.num,
>+  bottom: core.num,
>+  [$bottom]: core.num,
>+  topLeft: math.Point$(core.num),
>+  [$topLeft]: math.Point$(core.num),
>+  topRight: math.Point$(core.num),
>+  [$topRight]: math.Point$(core.num),
>+  bottomRight: math.Point$(core.num),
>+  [$bottomRight]: math.Point$(core.num),
>+  bottomLeft: math.Point$(core.num),
>+  [$bottomLeft]: math.Point$(core.num)
>+}));
>+dart.setSetterSignature(html$.CssRect, () => ({
>+  __proto__: dart.getSetters(html$.CssRect.__proto__),
>+  height: dart.dynamic,
>+  [$height]: dart.dynamic,
>+  width: dart.dynamic,
>+  [$width]: dart.dynamic
>+}));
>+dart.setLibraryUri(html$.CssRect, "dart:html");
>+dart.setFieldSignature(html$.CssRect, () => ({
>+  __proto__: dart.getFields(html$.CssRect.__proto__),
>+  [_element$]: dart.fieldType(html$.Element)
>+}));
>+dart.defineExtensionMethods(html$.CssRect, [
>+  'toString',
>+  '_equals',
>+  'intersection',
>+  'intersects',
>+  'boundingBox',
>+  'containsRectangle',
>+  'containsPoint'
>+]);
>+dart.defineExtensionAccessors(html$.CssRect, [
>+  'height',
>+  'width',
>+  'right',
>+  'bottom',
>+  'hashCode',
>+  'topLeft',
>+  'topRight',
>+  'bottomRight',
>+  'bottomLeft'
>+]);
>+html$._ContentCssRect = class _ContentCssRect extends html$.CssRect {
>+  get height() {
>+    return dart.notNull(this[_element$][$offsetHeight]) + dart.notNull(this[_addOrSubtractToBoxModel](html$._HEIGHT, html$._CONTENT));
>+  }
>+  get width() {
>+    return dart.notNull(this[_element$][$offsetWidth]) + dart.notNull(this[_addOrSubtractToBoxModel](html$._WIDTH, html$._CONTENT));
>+  }
>+  set height(newHeight) {
>+    if (html$.Dimension.is(newHeight)) {
>+      let newHeightAsDimension = html$.Dimension._check(newHeight);
>+      if (dart.notNull(newHeightAsDimension.value) < 0) newHeight = new html$.Dimension.px(0);
>+      this[_element$].style[$height] = dart.toString(newHeight);
>+    } else if (typeof newHeight == 'number') {
>+      if (dart.dtest(dart.dsend(newHeight, '<', [0]))) newHeight = 0;
>+      this[_element$].style[$height] = dart.str(newHeight) + "px";
>+    } else {
>+      dart.throw(new core.ArgumentError.new("newHeight is not a Dimension or num"));
>+    }
>+  }
>+  set width(newWidth) {
>+    if (html$.Dimension.is(newWidth)) {
>+      let newWidthAsDimension = html$.Dimension._check(newWidth);
>+      if (dart.notNull(newWidthAsDimension.value) < 0) newWidth = new html$.Dimension.px(0);
>+      this[_element$].style[$width] = dart.toString(newWidth);
>+    } else if (typeof newWidth == 'number') {
>+      if (dart.dtest(dart.dsend(newWidth, '<', [0]))) newWidth = 0;
>+      this[_element$].style[$width] = dart.str(newWidth) + "px";
>+    } else {
>+      dart.throw(new core.ArgumentError.new("newWidth is not a Dimension or num"));
>+    }
>+  }
>+  get left() {
>+    return dart.notNull(this[_element$].getBoundingClientRect()[$left]) - dart.notNull(this[_addOrSubtractToBoxModel](JSArrayOfString().of(["left"]), html$._CONTENT));
>+  }
>+  get top() {
>+    return dart.notNull(this[_element$].getBoundingClientRect()[$top]) - dart.notNull(this[_addOrSubtractToBoxModel](JSArrayOfString().of(["top"]), html$._CONTENT));
>+  }
>+};
>+(html$._ContentCssRect.new = function(element) {
>+  html$._ContentCssRect.__proto__.new.call(this, element);
>+}).prototype = html$._ContentCssRect.prototype;
>+dart.addTypeTests(html$._ContentCssRect);
>+dart.setGetterSignature(html$._ContentCssRect, () => ({
>+  __proto__: dart.getGetters(html$._ContentCssRect.__proto__),
>+  height: core.num,
>+  [$height]: core.num,
>+  width: core.num,
>+  [$width]: core.num,
>+  left: core.num,
>+  [$left]: core.num,
>+  top: core.num,
>+  [$top]: core.num
>+}));
>+dart.setLibraryUri(html$._ContentCssRect, "dart:html");
>+dart.defineExtensionAccessors(html$._ContentCssRect, ['height', 'width', 'left', 'top']);
>+const _elementList = dart.privateName(html$, "_elementList");
>+html$._ContentCssListRect = class _ContentCssListRect extends html$._ContentCssRect {
>+  set height(newHeight) {
>+    this[_elementList][$forEach](dart.fn(e => e[$contentEdge].height = newHeight, ElementTodynamic()));
>+  }
>+  get height() {
>+    return super.height;
>+  }
>+  set width(newWidth) {
>+    this[_elementList][$forEach](dart.fn(e => e[$contentEdge].width = newWidth, ElementTodynamic()));
>+  }
>+  get width() {
>+    return super.width;
>+  }
>+};
>+(html$._ContentCssListRect.new = function(elementList) {
>+  this[_elementList] = null;
>+  html$._ContentCssListRect.__proto__.new.call(this, elementList[$first]);
>+  this[_elementList] = elementList;
>+}).prototype = html$._ContentCssListRect.prototype;
>+dart.addTypeTests(html$._ContentCssListRect);
>+dart.setLibraryUri(html$._ContentCssListRect, "dart:html");
>+dart.setFieldSignature(html$._ContentCssListRect, () => ({
>+  __proto__: dart.getFields(html$._ContentCssListRect.__proto__),
>+  [_elementList]: dart.fieldType(ListOfElement())
>+}));
>+dart.defineExtensionAccessors(html$._ContentCssListRect, ['height', 'width']);
>+html$._PaddingCssRect = class _PaddingCssRect extends html$.CssRect {
>+  get height() {
>+    return dart.notNull(this[_element$][$offsetHeight]) + dart.notNull(this[_addOrSubtractToBoxModel](html$._HEIGHT, html$._PADDING));
>+  }
>+  set height(value) {
>+    super.height = value;
>+  }
>+  get width() {
>+    return dart.notNull(this[_element$][$offsetWidth]) + dart.notNull(this[_addOrSubtractToBoxModel](html$._WIDTH, html$._PADDING));
>+  }
>+  set width(value) {
>+    super.width = value;
>+  }
>+  get left() {
>+    return dart.notNull(this[_element$].getBoundingClientRect()[$left]) - dart.notNull(this[_addOrSubtractToBoxModel](JSArrayOfString().of(["left"]), html$._PADDING));
>+  }
>+  get top() {
>+    return dart.notNull(this[_element$].getBoundingClientRect()[$top]) - dart.notNull(this[_addOrSubtractToBoxModel](JSArrayOfString().of(["top"]), html$._PADDING));
>+  }
>+};
>+(html$._PaddingCssRect.new = function(element) {
>+  html$._PaddingCssRect.__proto__.new.call(this, html$.Element._check(element));
>+}).prototype = html$._PaddingCssRect.prototype;
>+dart.addTypeTests(html$._PaddingCssRect);
>+dart.setGetterSignature(html$._PaddingCssRect, () => ({
>+  __proto__: dart.getGetters(html$._PaddingCssRect.__proto__),
>+  height: core.num,
>+  [$height]: core.num,
>+  width: core.num,
>+  [$width]: core.num,
>+  left: core.num,
>+  [$left]: core.num,
>+  top: core.num,
>+  [$top]: core.num
>+}));
>+dart.setLibraryUri(html$._PaddingCssRect, "dart:html");
>+dart.defineExtensionAccessors(html$._PaddingCssRect, ['height', 'width', 'left', 'top']);
>+html$._BorderCssRect = class _BorderCssRect extends html$.CssRect {
>+  get height() {
>+    return this[_element$][$offsetHeight];
>+  }
>+  set height(value) {
>+    super.height = value;
>+  }
>+  get width() {
>+    return this[_element$][$offsetWidth];
>+  }
>+  set width(value) {
>+    super.width = value;
>+  }
>+  get left() {
>+    return this[_element$].getBoundingClientRect()[$left];
>+  }
>+  get top() {
>+    return this[_element$].getBoundingClientRect()[$top];
>+  }
>+};
>+(html$._BorderCssRect.new = function(element) {
>+  html$._BorderCssRect.__proto__.new.call(this, html$.Element._check(element));
>+}).prototype = html$._BorderCssRect.prototype;
>+dart.addTypeTests(html$._BorderCssRect);
>+dart.setGetterSignature(html$._BorderCssRect, () => ({
>+  __proto__: dart.getGetters(html$._BorderCssRect.__proto__),
>+  height: core.num,
>+  [$height]: core.num,
>+  width: core.num,
>+  [$width]: core.num,
>+  left: core.num,
>+  [$left]: core.num,
>+  top: core.num,
>+  [$top]: core.num
>+}));
>+dart.setLibraryUri(html$._BorderCssRect, "dart:html");
>+dart.defineExtensionAccessors(html$._BorderCssRect, ['height', 'width', 'left', 'top']);
>+html$._MarginCssRect = class _MarginCssRect extends html$.CssRect {
>+  get height() {
>+    return dart.notNull(this[_element$][$offsetHeight]) + dart.notNull(this[_addOrSubtractToBoxModel](html$._HEIGHT, html$._MARGIN));
>+  }
>+  set height(value) {
>+    super.height = value;
>+  }
>+  get width() {
>+    return dart.notNull(this[_element$][$offsetWidth]) + dart.notNull(this[_addOrSubtractToBoxModel](html$._WIDTH, html$._MARGIN));
>+  }
>+  set width(value) {
>+    super.width = value;
>+  }
>+  get left() {
>+    return dart.notNull(this[_element$].getBoundingClientRect()[$left]) - dart.notNull(this[_addOrSubtractToBoxModel](JSArrayOfString().of(["left"]), html$._MARGIN));
>+  }
>+  get top() {
>+    return dart.notNull(this[_element$].getBoundingClientRect()[$top]) - dart.notNull(this[_addOrSubtractToBoxModel](JSArrayOfString().of(["top"]), html$._MARGIN));
>+  }
>+};
>+(html$._MarginCssRect.new = function(element) {
>+  html$._MarginCssRect.__proto__.new.call(this, html$.Element._check(element));
>+}).prototype = html$._MarginCssRect.prototype;
>+dart.addTypeTests(html$._MarginCssRect);
>+dart.setGetterSignature(html$._MarginCssRect, () => ({
>+  __proto__: dart.getGetters(html$._MarginCssRect.__proto__),
>+  height: core.num,
>+  [$height]: core.num,
>+  width: core.num,
>+  [$width]: core.num,
>+  left: core.num,
>+  [$left]: core.num,
>+  top: core.num,
>+  [$top]: core.num
>+}));
>+dart.setLibraryUri(html$._MarginCssRect, "dart:html");
>+dart.defineExtensionAccessors(html$._MarginCssRect, ['height', 'width', 'left', 'top']);
>+dart.defineLazy(html$, {
>+  /*html$._HEIGHT*/get _HEIGHT() {
>+    return JSArrayOfString().of(["top", "bottom"]);
>+  },
>+  /*html$._WIDTH*/get _WIDTH() {
>+    return JSArrayOfString().of(["right", "left"]);
>+  },
>+  /*html$._CONTENT*/get _CONTENT() {
>+    return "content";
>+  },
>+  /*html$._PADDING*/get _PADDING() {
>+    return "padding";
>+  },
>+  /*html$._MARGIN*/get _MARGIN() {
>+    return "margin";
>+  }
>+});
>+const _sets = dart.privateName(html$, "_sets");
>+const _validateToken = dart.privateName(html_common, "_validateToken");
>+html_common.CssClassSetImpl = class CssClassSetImpl extends collection.SetBase$(core.String) {
>+  [_validateToken](value) {
>+    if (dart.test(html_common.CssClassSetImpl._validTokenRE.hasMatch(value))) return value;
>+    dart.throw(new core.ArgumentError.value(value, "value", "Not a valid class token"));
>+  }
>+  toString() {
>+    return this.readClasses().join(" ");
>+  }
>+  toggle(value, shouldAdd) {
>+    if (shouldAdd === void 0) shouldAdd = null;
>+    this[_validateToken](value);
>+    let s = this.readClasses();
>+    let result = false;
>+    if (shouldAdd == null) shouldAdd = !dart.test(s.contains(value));
>+    if (dart.test(shouldAdd)) {
>+      s.add(value);
>+      result = true;
>+    } else {
>+      s.remove(value);
>+    }
>+    this.writeClasses(s);
>+    return result;
>+  }
>+  get frozen() {
>+    return false;
>+  }
>+  get iterator() {
>+    return this.readClasses().iterator;
>+  }
>+  forEach(f) {
>+    this.readClasses().forEach(f);
>+  }
>+  join(separator) {
>+    if (separator === void 0) separator = "";
>+    return this.readClasses().join(separator);
>+  }
>+  map(T, f) {
>+    return core.Iterable$(T)._check(this.readClasses().map(T, f));
>+  }
>+  where(f) {
>+    return this.readClasses().where(f);
>+  }
>+  expand(T, f) {
>+    return core.Iterable$(T)._check(this.readClasses().expand(T, f));
>+  }
>+  every(f) {
>+    return this.readClasses().every(f);
>+  }
>+  any(f) {
>+    return this.readClasses().any(f);
>+  }
>+  get isEmpty() {
>+    return this.readClasses().isEmpty;
>+  }
>+  get isNotEmpty() {
>+    return this.readClasses().isNotEmpty;
>+  }
>+  get length() {
>+    return this.readClasses().length;
>+  }
>+  reduce(combine) {
>+    StringAndStringToString()._check(combine);
>+    return this.readClasses().reduce(combine);
>+  }
>+  fold(T, initialValue, combine) {
>+    return T._check(this.readClasses().fold(T, initialValue, combine));
>+  }
>+  contains(value) {
>+    if (!(typeof value == 'string')) return false;
>+    this[_validateToken](core.String._check(value));
>+    return this.readClasses().contains(value);
>+  }
>+  lookup(value) {
>+    return core.String._check(dart.test(this.contains(value)) ? value : null);
>+  }
>+  add(value) {
>+    core.String._check(value);
>+    this[_validateToken](value);
>+    return core.bool._check(this.modify(dart.fn(s => s.add(value), SetOfStringTobool())));
>+  }
>+  remove(value) {
>+    this[_validateToken](core.String._check(value));
>+    if (!(typeof value == 'string')) return false;
>+    let s = this.readClasses();
>+    let result = s.remove(value);
>+    this.writeClasses(s);
>+    return result;
>+  }
>+  addAll(iterable) {
>+    IterableOfString()._check(iterable);
>+    this.modify(dart.fn(s => s.addAll(IterableOfString()._check(iterable[$map](core.String, dart.bind(this, _validateToken)))), SetOfStringTovoid()));
>+  }
>+  removeAll(iterable) {
>+    this.modify(dart.fn(s => s.removeAll(iterable), SetOfStringTovoid()));
>+  }
>+  toggleAll(iterable, shouldAdd) {
>+    if (shouldAdd === void 0) shouldAdd = null;
>+    iterable[$forEach](dart.fn(e => this.toggle(e, shouldAdd), StringTobool()));
>+  }
>+  retainAll(iterable) {
>+    this.modify(dart.fn(s => s.retainAll(iterable), SetOfStringTovoid()));
>+  }
>+  removeWhere(test) {
>+    this.modify(dart.fn(s => s.removeWhere(test), SetOfStringTovoid()));
>+  }
>+  retainWhere(test) {
>+    this.modify(dart.fn(s => s.retainWhere(test), SetOfStringTovoid()));
>+  }
>+  containsAll(collection) {
>+    return this.readClasses().containsAll(collection);
>+  }
>+  intersection(other) {
>+    return this.readClasses().intersection(other);
>+  }
>+  union(other) {
>+    SetOfString()._check(other);
>+    return this.readClasses().union(other);
>+  }
>+  difference(other) {
>+    return this.readClasses().difference(other);
>+  }
>+  get first() {
>+    return this.readClasses().first;
>+  }
>+  get last() {
>+    return this.readClasses().last;
>+  }
>+  get single() {
>+    return this.readClasses().single;
>+  }
>+  toList(opts) {
>+    let growable = opts && 'growable' in opts ? opts.growable : true;
>+    return this.readClasses().toList({growable: growable});
>+  }
>+  toSet() {
>+    return this.readClasses().toSet();
>+  }
>+  take(n) {
>+    return this.readClasses().take(n);
>+  }
>+  takeWhile(test) {
>+    return this.readClasses().takeWhile(test);
>+  }
>+  skip(n) {
>+    return this.readClasses().skip(n);
>+  }
>+  skipWhile(test) {
>+    return this.readClasses().skipWhile(test);
>+  }
>+  firstWhere(test, opts) {
>+    let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+    VoidToString()._check(orElse);
>+    return this.readClasses().firstWhere(test, {orElse: orElse});
>+  }
>+  lastWhere(test, opts) {
>+    let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+    VoidToString()._check(orElse);
>+    return this.readClasses().lastWhere(test, {orElse: orElse});
>+  }
>+  singleWhere(test, opts) {
>+    let orElse = opts && 'orElse' in opts ? opts.orElse : null;
>+    VoidToString()._check(orElse);
>+    return this.readClasses().singleWhere(test, {orElse: orElse});
>+  }
>+  elementAt(index) {
>+    return this.readClasses().elementAt(index);
>+  }
>+  clear() {
>+    this.modify(dart.fn(s => s.clear(), SetOfStringTovoid()));
>+  }
>+  modify(f) {
>+    let s = this.readClasses();
>+    let ret = f(s);
>+    this.writeClasses(s);
>+    return ret;
>+  }
>+};
>+(html_common.CssClassSetImpl.new = function() {
>+}).prototype = html_common.CssClassSetImpl.prototype;
>+dart.addTypeTests(html_common.CssClassSetImpl);
>+html_common.CssClassSetImpl[dart.implements] = () => [html$.CssClassSet];
>+dart.setMethodSignature(html_common.CssClassSetImpl, () => ({
>+  __proto__: dart.getMethods(html_common.CssClassSetImpl.__proto__),
>+  [_validateToken]: dart.fnType(core.String, [core.String]),
>+  toString: dart.fnType(core.String, []),
>+  [$toString]: dart.fnType(core.String, []),
>+  toggle: dart.fnType(core.bool, [core.String], [core.bool]),
>+  forEach: dart.fnType(dart.void, [dart.fnType(dart.void, [core.String])]),
>+  [$forEach]: dart.fnType(dart.void, [dart.fnType(dart.void, [core.String])]),
>+  join: dart.fnType(core.String, [], [core.String]),
>+  [$join]: dart.fnType(core.String, [], [core.String]),
>+  map: dart.gFnType(T => [core.Iterable$(T), [dart.fnType(T, [core.String])]]),
>+  [$map]: dart.gFnType(T => [core.Iterable$(T), [dart.fnType(T, [core.String])]]),
>+  where: dart.fnType(core.Iterable$(core.String), [dart.fnType(core.bool, [core.String])]),
>+  [$where]: dart.fnType(core.Iterable$(core.String), [dart.fnType(core.bool, [core.String])]),
>+  expand: dart.gFnType(T => [core.Iterable$(T), [dart.fnType(core.Iterable$(T), [core.String])]]),
>+  [$expand]: dart.gFnType(T => [core.Iterable$(T), [dart.fnType(core.Iterable$(T), [core.String])]]),
>+  every: dart.fnType(core.bool, [dart.fnType(core.bool, [core.String])]),
>+  [$every]: dart.fnType(core.bool, [dart.fnType(core.bool, [core.String])]),
>+  any: dart.fnType(core.bool, [dart.fnType(core.bool, [core.String])]),
>+  [$any]: dart.fnType(core.bool, [dart.fnType(core.bool, [core.String])]),
>+  reduce: dart.fnType(core.String, [core.Object]),
>+  [$reduce]: dart.fnType(core.String, [core.Object]),
>+  fold: dart.gFnType(T => [T, [T, dart.fnType(T, [T, core.String])]]),
>+  [$fold]: dart.gFnType(T => [T, [T, dart.fnType(T, [T, core.String])]]),
>+  contains: dart.fnType(core.bool, [core.Object]),
>+  [$contains]: dart.fnType(core.bool, [core.Object]),
>+  lookup: dart.fnType(core.String, [core.Object]),
>+  add: dart.fnType(core.bool, [core.Object]),
>+  remove: dart.fnType(core.bool, [core.Object]),
>+  addAll: dart.fnType(dart.void, [core.Object]),
>+  removeAll: dart.fnType(dart.void, [core.Iterable$(core.Object)]),
>+  toggleAll: dart.fnType(dart.void, [core.Iterable$(core.String)], [core.bool]),
>+  retainAll: dart.fnType(dart.void, [core.Iterable$(core.Object)]),
>+  removeWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [core.String])]),
>+  retainWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [core.String])]),
>+  containsAll: dart.fnType(core.bool, [core.Iterable$(core.Object)]),
>+  intersection: dart.fnType(core.Set$(core.String), [core.Set$(core.Object)]),
>+  union: dart.fnType(core.Set$(core.String), [core.Object]),
>+  difference: dart.fnType(core.Set$(core.String), [core.Set$(core.Object)]),
>+  toList: dart.fnType(core.List$(core.String), [], {growable: core.bool}),
>+  [$toList]: dart.fnType(core.List$(core.String), [], {growable: core.bool}),
>+  toSet: dart.fnType(core.Set$(core.String), []),
>+  [$toSet]: dart.fnType(core.Set$(core.String), []),
>+  take: dart.fnType(core.Iterable$(core.String), [core.int]),
>+  [$take]: dart.fnType(core.Iterable$(core.String), [core.int]),
>+  takeWhile: dart.fnType(core.Iterable$(core.String), [dart.fnType(core.bool, [core.String])]),
>+  [$takeWhile]: dart.fnType(core.Iterable$(core.String), [dart.fnType(core.bool, [core.String])]),
>+  skip: dart.fnType(core.Iterable$(core.String), [core.int]),
>+  [$skip]: dart.fnType(core.Iterable$(core.String), [core.int]),
>+  skipWhile: dart.fnType(core.Iterable$(core.String), [dart.fnType(core.bool, [core.String])]),
>+  [$skipWhile]: dart.fnType(core.Iterable$(core.String), [dart.fnType(core.bool, [core.String])]),
>+  firstWhere: dart.fnType(core.String, [dart.fnType(core.bool, [core.String])], {orElse: core.Object}),
>+  [$firstWhere]: dart.fnType(core.String, [dart.fnType(core.bool, [core.String])], {orElse: core.Object}),
>+  lastWhere: dart.fnType(core.String, [dart.fnType(core.bool, [core.String])], {orElse: core.Object}),
>+  [$lastWhere]: dart.fnType(core.String, [dart.fnType(core.bool, [core.String])], {orElse: core.Object}),
>+  singleWhere: dart.fnType(core.String, [dart.fnType(core.bool, [core.String])], {orElse: core.Object}),
>+  [$singleWhere]: dart.fnType(core.String, [dart.fnType(core.bool, [core.String])], {orElse: core.Object}),
>+  elementAt: dart.fnType(core.String, [core.int]),
>+  [$elementAt]: dart.fnType(core.String, [core.int]),
>+  clear: dart.fnType(dart.void, []),
>+  modify: dart.fnType(dart.dynamic, [dart.fnType(dart.dynamic, [core.Set$(core.String)])])
>+}));
>+dart.setGetterSignature(html_common.CssClassSetImpl, () => ({
>+  __proto__: dart.getGetters(html_common.CssClassSetImpl.__proto__),
>+  frozen: core.bool,
>+  iterator: core.Iterator$(core.String),
>+  [$iterator]: core.Iterator$(core.String),
>+  isEmpty: core.bool,
>+  [$isEmpty]: core.bool,
>+  isNotEmpty: core.bool,
>+  [$isNotEmpty]: core.bool,
>+  length: core.int,
>+  [$length]: core.int,
>+  first: core.String,
>+  [$first]: core.String,
>+  last: core.String,
>+  [$last]: core.String,
>+  single: core.String,
>+  [$single]: core.String
>+}));
>+dart.setLibraryUri(html_common.CssClassSetImpl, "dart:html_common");
>+dart.defineExtensionMethods(html_common.CssClassSetImpl, [
>+  'toString',
>+  'forEach',
>+  'join',
>+  'map',
>+  'where',
>+  'expand',
>+  'every',
>+  'any',
>+  'reduce',
>+  'fold',
>+  'contains',
>+  'toList',
>+  'toSet',
>+  'take',
>+  'takeWhile',
>+  'skip',
>+  'skipWhile',
>+  'firstWhere',
>+  'lastWhere',
>+  'singleWhere',
>+  'elementAt'
>+]);
>+dart.defineExtensionAccessors(html_common.CssClassSetImpl, [
>+  'iterator',
>+  'isEmpty',
>+  'isNotEmpty',
>+  'length',
>+  'first',
>+  'last',
>+  'single'
>+]);
>+dart.defineLazy(html_common.CssClassSetImpl, {
>+  /*html_common.CssClassSetImpl._validTokenRE*/get _validTokenRE() {
>+    return core.RegExp.new("^\\S+$");
>+  }
>+});
>+html$._MultiElementCssClassSet = class _MultiElementCssClassSet extends html_common.CssClassSetImpl {
>+  static new(elements) {
>+    return new html$._MultiElementCssClassSet.__(elements, ListOfCssClassSetImpl().from(elements[$map](dart.dynamic, dart.fn(e => e[$classes], ElementToCssClassSet()))));
>+  }
>+  readClasses() {
>+    let s = new (_IdentityHashSetOfString()).new();
>+    this[_sets][$forEach](dart.fn(e => s.addAll(e.readClasses()), CssClassSetImplTovoid()));
>+    return s;
>+  }
>+  writeClasses(s) {
>+    let classes = s.join(" ");
>+    for (let e of this[_elementIterable]) {
>+      e.className = classes;
>+    }
>+  }
>+  modify(f) {
>+    this[_sets][$forEach](dart.fn(e => e.modify(f), CssClassSetImplTodynamic()));
>+  }
>+  toggle(value, shouldAdd) {
>+    if (shouldAdd === void 0) shouldAdd = null;
>+    return core.bool._check(this[_sets][$fold](core.bool, false, dart.fn((changed, e) => dart.test(e.toggle(value, shouldAdd)) || dart.test(changed), boolAndCssClassSetImplTobool())));
>+  }
>+  remove(value) {
>+    return core.bool._check(this[_sets][$fold](core.bool, false, dart.fn((changed, e) => dart.test(e.remove(value)) || dart.test(changed), boolAndCssClassSetImplTobool())));
>+  }
>+};
>+(html$._MultiElementCssClassSet.__ = function(elementIterable, sets) {
>+  this[_elementIterable] = elementIterable;
>+  this[_sets] = sets;
>+}).prototype = html$._MultiElementCssClassSet.prototype;
>+dart.addTypeTests(html$._MultiElementCssClassSet);
>+dart.setMethodSignature(html$._MultiElementCssClassSet, () => ({
>+  __proto__: dart.getMethods(html$._MultiElementCssClassSet.__proto__),
>+  readClasses: dart.fnType(core.Set$(core.String), []),
>+  writeClasses: dart.fnType(dart.void, [core.Set$(core.String)])
>+}));
>+dart.setLibraryUri(html$._MultiElementCssClassSet, "dart:html");
>+dart.setFieldSignature(html$._MultiElementCssClassSet, () => ({
>+  __proto__: dart.getFields(html$._MultiElementCssClassSet.__proto__),
>+  [_elementIterable]: dart.finalFieldType(IterableOfElement()),
>+  [_sets]: dart.finalFieldType(ListOfCssClassSetImpl())
>+}));
>+html$._ElementCssClassSet = class _ElementCssClassSet extends html_common.CssClassSetImpl {
>+  readClasses() {
>+    let s = new (_IdentityHashSetOfString()).new();
>+    let classname = this[_element$].className;
>+    for (let name of classname[$split](" ")) {
>+      let trimmed = name[$trim]();
>+      if (!trimmed[$isEmpty]) {
>+        s.add(trimmed);
>+      }
>+    }
>+    return s;
>+  }
>+  writeClasses(s) {
>+    this[_element$].className = s.join(" ");
>+  }
>+  get length() {
>+    return html$._ElementCssClassSet._classListLength(html$._ElementCssClassSet._classListOf(this[_element$]));
>+  }
>+  get isEmpty() {
>+    return this.length === 0;
>+  }
>+  get isNotEmpty() {
>+    return this.length !== 0;
>+  }
>+  clear() {
>+    this[_element$].className = "";
>+  }
>+  contains(value) {
>+    return html$._ElementCssClassSet._contains(this[_element$], value);
>+  }
>+  add(value) {
>+    core.String._check(value);
>+    return html$._ElementCssClassSet._add(this[_element$], value);
>+  }
>+  remove(value) {
>+    return typeof value == 'string' && dart.test(html$._ElementCssClassSet._remove(this[_element$], value));
>+  }
>+  toggle(value, shouldAdd) {
>+    if (shouldAdd === void 0) shouldAdd = null;
>+    return html$._ElementCssClassSet._toggle(this[_element$], value, shouldAdd);
>+  }
>+  addAll(iterable) {
>+    IterableOfString()._check(iterable);
>+    html$._ElementCssClassSet._addAll(this[_element$], iterable);
>+  }
>+  removeAll(iterable) {
>+    html$._ElementCssClassSet._removeAll(this[_element$], iterable);
>+  }
>+  retainAll(iterable) {
>+    html$._ElementCssClassSet._removeWhere(this[_element$], dart.bind(iterable[$toSet](), 'contains'), false);
>+  }
>+  removeWhere(test) {
>+    html$._ElementCssClassSet._removeWhere(this[_element$], test, true);
>+  }
>+  retainWhere(test) {
>+    html$._ElementCssClassSet._removeWhere(this[_element$], test, false);
>+  }
>+  static _contains(_element, value) {
>+    return typeof value == 'string' && dart.test(html$._ElementCssClassSet._classListContains(html$._ElementCssClassSet._classListOf(_element), value));
>+  }
>+  static _add(_element, value) {
>+    let list = html$._ElementCssClassSet._classListOf(_element);
>+    let added = !dart.test(html$._ElementCssClassSet._classListContainsBeforeAddOrRemove(list, value));
>+    html$._ElementCssClassSet._classListAdd(list, value);
>+    return added;
>+  }
>+  static _remove(_element, value) {
>+    let list = html$._ElementCssClassSet._classListOf(_element);
>+    let removed = html$._ElementCssClassSet._classListContainsBeforeAddOrRemove(list, value);
>+    html$._ElementCssClassSet._classListRemove(list, value);
>+    return removed;
>+  }
>+  static _toggle(_element, value, shouldAdd) {
>+    return shouldAdd == null ? html$._ElementCssClassSet._toggleDefault(_element, value) : html$._ElementCssClassSet._toggleOnOff(_element, value, shouldAdd);
>+  }
>+  static _toggleDefault(_element, value) {
>+    let list = html$._ElementCssClassSet._classListOf(_element);
>+    return html$._ElementCssClassSet._classListToggle1(list, value);
>+  }
>+  static _toggleOnOff(_element, value, shouldAdd) {
>+    let list = html$._ElementCssClassSet._classListOf(_element);
>+    if (dart.test(shouldAdd)) {
>+      html$._ElementCssClassSet._classListAdd(list, value);
>+      return true;
>+    } else {
>+      html$._ElementCssClassSet._classListRemove(list, value);
>+      return false;
>+    }
>+  }
>+  static _addAll(_element, iterable) {
>+    let list = html$._ElementCssClassSet._classListOf(_element);
>+    for (let value of iterable) {
>+      html$._ElementCssClassSet._classListAdd(list, value);
>+    }
>+  }
>+  static _removeAll(_element, iterable) {
>+    let list = html$._ElementCssClassSet._classListOf(_element);
>+    for (let value of iterable) {
>+      core.String._check(value);
>+      html$._ElementCssClassSet._classListRemove(list, value);
>+    }
>+  }
>+  static _removeWhere(_element, test, doRemove) {
>+    let list = html$._ElementCssClassSet._classListOf(_element);
>+    let i = 0;
>+    while (i < dart.notNull(html$._ElementCssClassSet._classListLength(list))) {
>+      let item = list.item(i);
>+      if (doRemove == test(item)) {
>+        html$._ElementCssClassSet._classListRemove(list, item);
>+      } else {
>+        ++i;
>+      }
>+    }
>+  }
>+  static _classListOf(e) {
>+    return e.classList;
>+  }
>+  static _classListLength(list) {
>+    return list.length;
>+  }
>+  static _classListContains(list, value) {
>+    return list.contains(value);
>+  }
>+  static _classListContainsBeforeAddOrRemove(list, value) {
>+    return list.contains(value);
>+  }
>+  static _classListAdd(list, value) {
>+    list.add(value);
>+  }
>+  static _classListRemove(list, value) {
>+    list.remove(value);
>+  }
>+  static _classListToggle1(list, value) {
>+    return list.toggle(value);
>+  }
>+  static _classListToggle2(list, value, shouldAdd) {
>+    return list.toggle(value, shouldAdd);
>+  }
>+};
>+(html$._ElementCssClassSet.new = function(element) {
>+  this[_element$] = element;
>+}).prototype = html$._ElementCssClassSet.prototype;
>+dart.addTypeTests(html$._ElementCssClassSet);
>+dart.setMethodSignature(html$._ElementCssClassSet, () => ({
>+  __proto__: dart.getMethods(html$._ElementCssClassSet.__proto__),
>+  readClasses: dart.fnType(core.Set$(core.String), []),
>+  writeClasses: dart.fnType(dart.void, [core.Set$(core.String)]),
>+  add: dart.fnType(core.bool, [core.Object]),
>+  addAll: dart.fnType(dart.void, [core.Object])
>+}));
>+dart.setLibraryUri(html$._ElementCssClassSet, "dart:html");
>+dart.setFieldSignature(html$._ElementCssClassSet, () => ({
>+  __proto__: dart.getFields(html$._ElementCssClassSet.__proto__),
>+  [_element$]: dart.finalFieldType(html$.Element)
>+}));
>+dart.defineExtensionMethods(html$._ElementCssClassSet, ['contains']);
>+dart.defineExtensionAccessors(html$._ElementCssClassSet, ['length', 'isEmpty', 'isNotEmpty']);
>+const _unit = dart.privateName(html$, "_unit");
>+html$.Dimension = class Dimension extends core.Object {
>+  toString() {
>+    return dart.str(this[_value$3]) + dart.str(this[_unit]);
>+  }
>+  get value() {
>+    return this[_value$3];
>+  }
>+};
>+(html$.Dimension.percent = function(value) {
>+  this[_value$3] = value;
>+  this[_unit] = "%";
>+}).prototype = html$.Dimension.prototype;
>+(html$.Dimension.px = function(value) {
>+  this[_value$3] = value;
>+  this[_unit] = "px";
>+}).prototype = html$.Dimension.prototype;
>+(html$.Dimension.pc = function(value) {
>+  this[_value$3] = value;
>+  this[_unit] = "pc";
>+}).prototype = html$.Dimension.prototype;
>+(html$.Dimension.pt = function(value) {
>+  this[_value$3] = value;
>+  this[_unit] = "pt";
>+}).prototype = html$.Dimension.prototype;
>+(html$.Dimension.inch = function(value) {
>+  this[_value$3] = value;
>+  this[_unit] = "in";
>+}).prototype = html$.Dimension.prototype;
>+(html$.Dimension.cm = function(value) {
>+  this[_value$3] = value;
>+  this[_unit] = "cm";
>+}).prototype = html$.Dimension.prototype;
>+(html$.Dimension.mm = function(value) {
>+  this[_value$3] = value;
>+  this[_unit] = "mm";
>+}).prototype = html$.Dimension.prototype;
>+(html$.Dimension.em = function(value) {
>+  this[_value$3] = value;
>+  this[_unit] = "em";
>+}).prototype = html$.Dimension.prototype;
>+(html$.Dimension.ex = function(value) {
>+  this[_value$3] = value;
>+  this[_unit] = "ex";
>+}).prototype = html$.Dimension.prototype;
>+(html$.Dimension.css = function(cssValue) {
>+  this[_value$3] = null;
>+  this[_unit] = null;
>+  if (cssValue === "") cssValue = "0px";
>+  if (cssValue[$endsWith]("%")) {
>+    this[_unit] = "%";
>+  } else {
>+    this[_unit] = cssValue[$substring](cssValue.length - 2);
>+  }
>+  if (cssValue[$contains](".")) {
>+    this[_value$3] = core.double.parse(cssValue[$substring](0, cssValue.length - this[_unit].length));
>+  } else {
>+    this[_value$3] = core.int.parse(cssValue[$substring](0, cssValue.length - this[_unit].length));
>+  }
>+}).prototype = html$.Dimension.prototype;
>+dart.addTypeTests(html$.Dimension);
>+dart.setGetterSignature(html$.Dimension, () => ({
>+  __proto__: dart.getGetters(html$.Dimension.__proto__),
>+  value: core.num
>+}));
>+dart.setLibraryUri(html$.Dimension, "dart:html");
>+dart.setFieldSignature(html$.Dimension, () => ({
>+  __proto__: dart.getFields(html$.Dimension.__proto__),
>+  [_value$3]: dart.fieldType(core.num),
>+  [_unit]: dart.fieldType(core.String)
>+}));
>+dart.defineExtensionMethods(html$.Dimension, ['toString']);
>+const _is_EventStreamProvider_default = Symbol('_is_EventStreamProvider_default');
>+html$.EventStreamProvider$ = dart.generic(T => {
>+  let _EventStreamOfT = () => (_EventStreamOfT = dart.constFn(html$._EventStream$(T)))();
>+  let _ElementEventStreamImplOfT = () => (_ElementEventStreamImplOfT = dart.constFn(html$._ElementEventStreamImpl$(T)))();
>+  let _ElementListEventStreamImplOfT = () => (_ElementListEventStreamImplOfT = dart.constFn(html$._ElementListEventStreamImpl$(T)))();
>+  class EventStreamProvider extends core.Object {
>+    forTarget(e, opts) {
>+      let useCapture = opts && 'useCapture' in opts ? opts.useCapture : false;
>+      return new (_EventStreamOfT()).new(e, this[_eventType], useCapture);
>+    }
>+    forElement(e, opts) {
>+      let useCapture = opts && 'useCapture' in opts ? opts.useCapture : false;
>+      return new (_ElementEventStreamImplOfT()).new(e, this[_eventType], useCapture);
>+    }
>+    [_forElementList](e, opts) {
>+      let useCapture = opts && 'useCapture' in opts ? opts.useCapture : false;
>+      return new (_ElementListEventStreamImplOfT()).new(e, this[_eventType], useCapture);
>+    }
>+    getEventType(target) {
>+      return this[_eventType];
>+    }
>+  }
>+  (EventStreamProvider.new = function(eventType) {
>+    this[_eventType] = eventType;
>+  }).prototype = EventStreamProvider.prototype;
>+  dart.addTypeTests(EventStreamProvider);
>+  EventStreamProvider.prototype[_is_EventStreamProvider_default] = true;
>+  dart.setMethodSignature(EventStreamProvider, () => ({
>+    __proto__: dart.getMethods(EventStreamProvider.__proto__),
>+    forTarget: dart.fnType(async.Stream$(T), [html$.EventTarget], {useCapture: core.bool}),
>+    forElement: dart.fnType(html$.ElementStream$(T), [html$.Element], {useCapture: core.bool}),
>+    [_forElementList]: dart.fnType(html$.ElementStream$(T), [html$.ElementList$(html$.Element)], {useCapture: core.bool}),
>+    getEventType: dart.fnType(core.String, [html$.EventTarget])
>+  }));
>+  dart.setLibraryUri(EventStreamProvider, "dart:html");
>+  dart.setFieldSignature(EventStreamProvider, () => ({
>+    __proto__: dart.getFields(EventStreamProvider.__proto__),
>+    [_eventType]: dart.finalFieldType(core.String)
>+  }));
>+  return EventStreamProvider;
>+});
>+html$.EventStreamProvider = html$.EventStreamProvider$();
>+dart.addTypeTests(html$.EventStreamProvider, _is_EventStreamProvider_default);
>+const _is_ElementStream_default = Symbol('_is_ElementStream_default');
>+html$.ElementStream$ = dart.generic(T => {
>+  let StreamOfT = () => (StreamOfT = dart.constFn(async.Stream$(T)))();
>+  class ElementStream extends core.Object {}
>+  (ElementStream.new = function() {
>+  }).prototype = ElementStream.prototype;
>+  ElementStream.prototype[dart.isStream] = true;
>+  dart.addTypeTests(ElementStream);
>+  ElementStream.prototype[_is_ElementStream_default] = true;
>+  ElementStream[dart.implements] = () => [StreamOfT()];
>+  dart.setLibraryUri(ElementStream, "dart:html");
>+  return ElementStream;
>+});
>+html$.ElementStream = html$.ElementStream$();
>+dart.addTypeTests(html$.ElementStream, _is_ElementStream_default);
>+const _target$0 = dart.privateName(html$, "_target");
>+const _useCapture = dart.privateName(html$, "_useCapture");
>+const _is__EventStream_default = Symbol('_is__EventStream_default');
>+html$._EventStream$ = dart.generic(T => {
>+  let _EventStreamSubscriptionOfT = () => (_EventStreamSubscriptionOfT = dart.constFn(html$._EventStreamSubscription$(T)))();
>+  class _EventStream extends async.Stream$(T) {
>+    asBroadcastStream(opts) {
>+      let onListen = opts && 'onListen' in opts ? opts.onListen : null;
>+      let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
>+      return this;
>+    }
>+    get isBroadcast() {
>+      return true;
>+    }
>+    listen(onData, opts) {
>+      let onError = opts && 'onError' in opts ? opts.onError : null;
>+      let onDone = opts && 'onDone' in opts ? opts.onDone : null;
>+      let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
>+      return new (_EventStreamSubscriptionOfT()).new(this[_target$0], this[_eventType], onData, this[_useCapture]);
>+    }
>+  }
>+  (_EventStream.new = function(target, eventType, useCapture) {
>+    this[_target$0] = target;
>+    this[_eventType] = eventType;
>+    this[_useCapture] = useCapture;
>+    _EventStream.__proto__.new.call(this);
>+  }).prototype = _EventStream.prototype;
>+  dart.addTypeTests(_EventStream);
>+  _EventStream.prototype[_is__EventStream_default] = true;
>+  dart.setMethodSignature(_EventStream, () => ({
>+    __proto__: dart.getMethods(_EventStream.__proto__),
>+    listen: dart.fnType(async.StreamSubscription$(T), [dart.fnType(dart.void, [T])], {onError: core.Function, onDone: dart.fnType(dart.void, []), cancelOnError: core.bool})
>+  }));
>+  dart.setLibraryUri(_EventStream, "dart:html");
>+  dart.setFieldSignature(_EventStream, () => ({
>+    __proto__: dart.getFields(_EventStream.__proto__),
>+    [_target$0]: dart.finalFieldType(html$.EventTarget),
>+    [_eventType]: dart.finalFieldType(core.String),
>+    [_useCapture]: dart.finalFieldType(core.bool)
>+  }));
>+  return _EventStream;
>+});
>+html$._EventStream = html$._EventStream$();
>+dart.addTypeTests(html$._EventStream, _is__EventStream_default);
>+html$._matchesWithAncestors = function(event, selector) {
>+  let target = event[$target];
>+  return html$.Element.is(target) ? target[$matchesWithAncestors](selector) : false;
>+};
>+const _is__ElementEventStreamImpl_default = Symbol('_is__ElementEventStreamImpl_default');
>+html$._ElementEventStreamImpl$ = dart.generic(T => {
>+  let TToT = () => (TToT = dart.constFn(dart.fnType(T, [T])))();
>+  let TTobool = () => (TTobool = dart.constFn(dart.fnType(core.bool, [T])))();
>+  let StreamOfT = () => (StreamOfT = dart.constFn(async.Stream$(T)))();
>+  let _EventStreamSubscriptionOfT = () => (_EventStreamSubscriptionOfT = dart.constFn(html$._EventStreamSubscription$(T)))();
>+  let ElementStreamOfT = () => (ElementStreamOfT = dart.constFn(html$.ElementStream$(T)))();
>+  class _ElementEventStreamImpl extends html$._EventStream$(T) {
>+    matches(selector) {
>+      return StreamOfT()._check(this.where(dart.fn(event => html$._matchesWithAncestors(event, selector), TTobool())).map(T, dart.fn(e => {
>+        e[_selector] = selector;
>+        return e;
>+      }, TToT())));
>+    }
>+    capture(onData) {
>+      return new (_EventStreamSubscriptionOfT()).new(this[_target$0], this[_eventType], onData, true);
>+    }
>+  }
>+  (_ElementEventStreamImpl.new = function(target, eventType, useCapture) {
>+    _ElementEventStreamImpl.__proto__.new.call(this, html$.EventTarget._check(target), core.String._check(eventType), core.bool._check(useCapture));
>+  }).prototype = _ElementEventStreamImpl.prototype;
>+  dart.addTypeTests(_ElementEventStreamImpl);
>+  _ElementEventStreamImpl.prototype[_is__ElementEventStreamImpl_default] = true;
>+  _ElementEventStreamImpl[dart.implements] = () => [ElementStreamOfT()];
>+  dart.setMethodSignature(_ElementEventStreamImpl, () => ({
>+    __proto__: dart.getMethods(_ElementEventStreamImpl.__proto__),
>+    matches: dart.fnType(async.Stream$(T), [core.String]),
>+    capture: dart.fnType(async.StreamSubscription$(T), [dart.fnType(dart.void, [T])])
>+  }));
>+  dart.setLibraryUri(_ElementEventStreamImpl, "dart:html");
>+  return _ElementEventStreamImpl;
>+});
>+html$._ElementEventStreamImpl = html$._ElementEventStreamImpl$();
>+dart.addTypeTests(html$._ElementEventStreamImpl, _is__ElementEventStreamImpl_default);
>+const _targetList = dart.privateName(html$, "_targetList");
>+const _is__ElementListEventStreamImpl_default = Symbol('_is__ElementListEventStreamImpl_default');
>+html$._ElementListEventStreamImpl$ = dart.generic(T => {
>+  let TToT = () => (TToT = dart.constFn(dart.fnType(T, [T])))();
>+  let TTobool = () => (TTobool = dart.constFn(dart.fnType(core.bool, [T])))();
>+  let StreamOfT = () => (StreamOfT = dart.constFn(async.Stream$(T)))();
>+  let _StreamPoolOfT = () => (_StreamPoolOfT = dart.constFn(html$._StreamPool$(T)))();
>+  let _EventStreamOfT = () => (_EventStreamOfT = dart.constFn(html$._EventStream$(T)))();
>+  let ElementStreamOfT = () => (ElementStreamOfT = dart.constFn(html$.ElementStream$(T)))();
>+  class _ElementListEventStreamImpl extends async.Stream$(T) {
>+    matches(selector) {
>+      return StreamOfT()._check(this.where(dart.fn(event => html$._matchesWithAncestors(event, selector), TTobool())).map(T, dart.fn(e => {
>+        e[_selector] = selector;
>+        return e;
>+      }, TToT())));
>+    }
>+    listen(onData, opts) {
>+      let onError = opts && 'onError' in opts ? opts.onError : null;
>+      let onDone = opts && 'onDone' in opts ? opts.onDone : null;
>+      let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
>+      let pool = new (_StreamPoolOfT()).broadcast();
>+      for (let target of this[_targetList]) {
>+        pool.add(new (_EventStreamOfT()).new(target, this[_eventType], this[_useCapture]));
>+      }
>+      return pool.stream.listen(onData, {onError: onError, onDone: onDone, cancelOnError: cancelOnError});
>+    }
>+    capture(onData) {
>+      let pool = new (_StreamPoolOfT()).broadcast();
>+      for (let target of this[_targetList]) {
>+        pool.add(new (_EventStreamOfT()).new(target, this[_eventType], true));
>+      }
>+      return pool.stream.listen(onData);
>+    }
>+    asBroadcastStream(opts) {
>+      let onListen = opts && 'onListen' in opts ? opts.onListen : null;
>+      let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
>+      return this;
>+    }
>+    get isBroadcast() {
>+      return true;
>+    }
>+  }
>+  (_ElementListEventStreamImpl.new = function(targetList, eventType, useCapture) {
>+    this[_targetList] = targetList;
>+    this[_eventType] = eventType;
>+    this[_useCapture] = useCapture;
>+    _ElementListEventStreamImpl.__proto__.new.call(this);
>+  }).prototype = _ElementListEventStreamImpl.prototype;
>+  dart.addTypeTests(_ElementListEventStreamImpl);
>+  _ElementListEventStreamImpl.prototype[_is__ElementListEventStreamImpl_default] = true;
>+  _ElementListEventStreamImpl[dart.implements] = () => [ElementStreamOfT()];
>+  dart.setMethodSignature(_ElementListEventStreamImpl, () => ({
>+    __proto__: dart.getMethods(_ElementListEventStreamImpl.__proto__),
>+    matches: dart.fnType(async.Stream$(T), [core.String]),
>+    listen: dart.fnType(async.StreamSubscription$(T), [dart.fnType(dart.void, [T])], {onError: core.Function, onDone: dart.fnType(dart.void, []), cancelOnError: core.bool}),
>+    capture: dart.fnType(async.StreamSubscription$(T), [dart.fnType(dart.void, [T])])
>+  }));
>+  dart.setLibraryUri(_ElementListEventStreamImpl, "dart:html");
>+  dart.setFieldSignature(_ElementListEventStreamImpl, () => ({
>+    __proto__: dart.getFields(_ElementListEventStreamImpl.__proto__),
>+    [_targetList]: dart.finalFieldType(IterableOfElement()),
>+    [_useCapture]: dart.finalFieldType(core.bool),
>+    [_eventType]: dart.finalFieldType(core.String)
>+  }));
>+  return _ElementListEventStreamImpl;
>+});
>+html$._ElementListEventStreamImpl = html$._ElementListEventStreamImpl$();
>+dart.addTypeTests(html$._ElementListEventStreamImpl, _is__ElementListEventStreamImpl_default);
>+const _onData$1 = dart.privateName(html$, "_onData");
>+const _pauseCount$ = dart.privateName(html$, "_pauseCount");
>+const _tryResume = dart.privateName(html$, "_tryResume");
>+const _canceled = dart.privateName(html$, "_canceled");
>+const _unlisten = dart.privateName(html$, "_unlisten");
>+const _is__EventStreamSubscription_default = Symbol('_is__EventStreamSubscription_default');
>+html$._EventStreamSubscription$ = dart.generic(T => {
>+  class _EventStreamSubscription extends async.StreamSubscription$(T) {
>+    cancel() {
>+      if (dart.test(this[_canceled])) return null;
>+      this[_unlisten]();
>+      this[_target$0] = null;
>+      this[_onData$1] = null;
>+      return null;
>+    }
>+    get [_canceled]() {
>+      return this[_target$0] == null;
>+    }
>+    onData(handleData) {
>+      if (dart.test(this[_canceled])) {
>+        dart.throw(new core.StateError.new("Subscription has been canceled."));
>+      }
>+      this[_unlisten]();
>+      this[_onData$1] = html$._wrapZone(html$.Event, EventTovoid()._check(handleData));
>+      this[_tryResume]();
>+    }
>+    onError(handleError) {}
>+    onDone(handleDone) {}
>+    pause(resumeSignal) {
>+      if (resumeSignal === void 0) resumeSignal = null;
>+      if (dart.test(this[_canceled])) return;
>+      this[_pauseCount$] = dart.notNull(this[_pauseCount$]) + 1;
>+      this[_unlisten]();
>+      if (resumeSignal != null) {
>+        resumeSignal.whenComplete(dart.bind(this, 'resume'));
>+      }
>+    }
>+    get isPaused() {
>+      return dart.notNull(this[_pauseCount$]) > 0;
>+    }
>+    resume() {
>+      if (dart.test(this[_canceled]) || !dart.test(this.isPaused)) return;
>+      this[_pauseCount$] = dart.notNull(this[_pauseCount$]) - 1;
>+      this[_tryResume]();
>+    }
>+    [_tryResume]() {
>+      if (this[_onData$1] != null && !dart.test(this.isPaused)) {
>+        this[_target$0][$addEventListener](this[_eventType], this[_onData$1], this[_useCapture]);
>+      }
>+    }
>+    [_unlisten]() {
>+      if (this[_onData$1] != null) {
>+        this[_target$0][$removeEventListener](this[_eventType], this[_onData$1], this[_useCapture]);
>+      }
>+    }
>+    asFuture(E, futureValue) {
>+      if (futureValue === void 0) futureValue = null;
>+      let completer = async.Completer$(E).new();
>+      return completer.future;
>+    }
>+  }
>+  (_EventStreamSubscription.new = function(target, eventType, onData, useCapture) {
>+    this[_pauseCount$] = 0;
>+    this[_target$0] = target;
>+    this[_eventType] = eventType;
>+    this[_useCapture] = useCapture;
>+    this[_onData$1] = onData == null ? null : html$._wrapZone(html$.Event, dart.fn(e => dart.dcall(onData, [e]), EventTodynamic()));
>+    this[_tryResume]();
>+  }).prototype = _EventStreamSubscription.prototype;
>+  dart.addTypeTests(_EventStreamSubscription);
>+  _EventStreamSubscription.prototype[_is__EventStreamSubscription_default] = true;
>+  dart.setMethodSignature(_EventStreamSubscription, () => ({
>+    __proto__: dart.getMethods(_EventStreamSubscription.__proto__),
>+    cancel: dart.fnType(async.Future, []),
>+    onData: dart.fnType(dart.void, [dart.fnType(dart.void, [T])]),
>+    onError: dart.fnType(dart.void, [core.Function]),
>+    onDone: dart.fnType(dart.void, [dart.fnType(dart.void, [])]),
>+    pause: dart.fnType(dart.void, [], [async.Future]),
>+    resume: dart.fnType(dart.void, []),
>+    [_tryResume]: dart.fnType(dart.void, []),
>+    [_unlisten]: dart.fnType(dart.void, []),
>+    asFuture: dart.gFnType(E => [async.Future$(E), [], [E]])
>+  }));
>+  dart.setGetterSignature(_EventStreamSubscription, () => ({
>+    __proto__: dart.getGetters(_EventStreamSubscription.__proto__),
>+    [_canceled]: core.bool,
>+    isPaused: core.bool
>+  }));
>+  dart.setLibraryUri(_EventStreamSubscription, "dart:html");
>+  dart.setFieldSignature(_EventStreamSubscription, () => ({
>+    __proto__: dart.getFields(_EventStreamSubscription.__proto__),
>+    [_pauseCount$]: dart.fieldType(core.int),
>+    [_target$0]: dart.fieldType(html$.EventTarget),
>+    [_eventType]: dart.finalFieldType(core.String),
>+    [_onData$1]: dart.fieldType(EventTodynamic()),
>+    [_useCapture]: dart.finalFieldType(core.bool)
>+  }));
>+  return _EventStreamSubscription;
>+});
>+html$._EventStreamSubscription = html$._EventStreamSubscription$();
>+dart.addTypeTests(html$._EventStreamSubscription, _is__EventStreamSubscription_default);
>+const _is_CustomStream_default = Symbol('_is_CustomStream_default');
>+html$.CustomStream$ = dart.generic(T => {
>+  let StreamOfT = () => (StreamOfT = dart.constFn(async.Stream$(T)))();
>+  class CustomStream extends core.Object {}
>+  (CustomStream.new = function() {
>+  }).prototype = CustomStream.prototype;
>+  CustomStream.prototype[dart.isStream] = true;
>+  dart.addTypeTests(CustomStream);
>+  CustomStream.prototype[_is_CustomStream_default] = true;
>+  CustomStream[dart.implements] = () => [StreamOfT()];
>+  dart.setLibraryUri(CustomStream, "dart:html");
>+  return CustomStream;
>+});
>+html$.CustomStream = html$.CustomStream$();
>+dart.addTypeTests(html$.CustomStream, _is_CustomStream_default);
>+const _streamController = dart.privateName(html$, "_streamController");
>+const _type$1 = dart.privateName(html$, "_type");
>+const _is__CustomEventStreamImpl_default = Symbol('_is__CustomEventStreamImpl_default');
>+html$._CustomEventStreamImpl$ = dart.generic(T => {
>+  let StreamControllerOfT = () => (StreamControllerOfT = dart.constFn(async.StreamController$(T)))();
>+  let CustomStreamOfT = () => (CustomStreamOfT = dart.constFn(html$.CustomStream$(T)))();
>+  class _CustomEventStreamImpl extends async.Stream$(T) {
>+    listen(onData, opts) {
>+      let onError = opts && 'onError' in opts ? opts.onError : null;
>+      let onDone = opts && 'onDone' in opts ? opts.onDone : null;
>+      let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
>+      return this[_streamController].stream.listen(onData, {onError: onError, onDone: onDone, cancelOnError: cancelOnError});
>+    }
>+    asBroadcastStream(opts) {
>+      let onListen = opts && 'onListen' in opts ? opts.onListen : null;
>+      let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
>+      return this[_streamController].stream;
>+    }
>+    get isBroadcast() {
>+      return true;
>+    }
>+    add(event) {
>+      T._check(event);
>+      if (event.type == this[_type$1]) this[_streamController].add(event);
>+    }
>+  }
>+  (_CustomEventStreamImpl.new = function(type) {
>+    this[_streamController] = null;
>+    this[_type$1] = null;
>+    _CustomEventStreamImpl.__proto__.new.call(this);
>+    this[_type$1] = type;
>+    this[_streamController] = StreamControllerOfT().broadcast({sync: true});
>+  }).prototype = _CustomEventStreamImpl.prototype;
>+  dart.addTypeTests(_CustomEventStreamImpl);
>+  _CustomEventStreamImpl.prototype[_is__CustomEventStreamImpl_default] = true;
>+  _CustomEventStreamImpl[dart.implements] = () => [CustomStreamOfT()];
>+  dart.setMethodSignature(_CustomEventStreamImpl, () => ({
>+    __proto__: dart.getMethods(_CustomEventStreamImpl.__proto__),
>+    listen: dart.fnType(async.StreamSubscription$(T), [dart.fnType(dart.void, [T])], {onError: core.Function, onDone: dart.fnType(dart.void, []), cancelOnError: core.bool}),
>+    add: dart.fnType(dart.void, [core.Object])
>+  }));
>+  dart.setLibraryUri(_CustomEventStreamImpl, "dart:html");
>+  dart.setFieldSignature(_CustomEventStreamImpl, () => ({
>+    __proto__: dart.getFields(_CustomEventStreamImpl.__proto__),
>+    [_streamController]: dart.fieldType(StreamControllerOfT()),
>+    [_type$1]: dart.fieldType(core.String)
>+  }));
>+  return _CustomEventStreamImpl;
>+});
>+html$._CustomEventStreamImpl = html$._CustomEventStreamImpl$();
>+dart.addTypeTests(html$._CustomEventStreamImpl, _is__CustomEventStreamImpl_default);
>+const _parent$ = dart.privateName(html$, "_parent");
>+const _shadowAltKey = dart.privateName(html$, "_shadowAltKey");
>+const _shadowCharCode = dart.privateName(html$, "_shadowCharCode");
>+const _shadowKeyCode = dart.privateName(html$, "_shadowKeyCode");
>+const _currentTarget = dart.privateName(html$, "_currentTarget");
>+const _realAltKey = dart.privateName(html$, "_realAltKey");
>+const _realCharCode = dart.privateName(html$, "_realCharCode");
>+const _realKeyCode = dart.privateName(html$, "_realKeyCode");
>+const _shadowKeyIdentifier = dart.privateName(html$, "_shadowKeyIdentifier");
>+const _keyIdentifier = dart.privateName(html$, "_keyIdentifier");
>+html$.KeyEvent = class KeyEvent extends html$._WrappedEvent {
>+  get keyCode() {
>+    return this[_shadowKeyCode];
>+  }
>+  get charCode() {
>+    return this.type === "keypress" ? this[_shadowCharCode] : 0;
>+  }
>+  get altKey() {
>+    return this[_shadowAltKey];
>+  }
>+  get which() {
>+    return this.keyCode;
>+  }
>+  get [_realKeyCode]() {
>+    return this[_parent$].keyCode;
>+  }
>+  get [_realCharCode]() {
>+    return this[_parent$].charCode;
>+  }
>+  get [_realAltKey]() {
>+    return this[_parent$].altKey;
>+  }
>+  get sourceCapabilities() {
>+    return this[sourceCapabilities$];
>+  }
>+  set sourceCapabilities(value) {
>+    super.sourceCapabilities = value;
>+  }
>+  static _makeRecord() {
>+    let interceptor = _foreign_helper.JS_INTERCEPTOR_CONSTANT(dart.wrapType(html$.KeyboardEvent));
>+    return _js_helper.makeLeafDispatchRecord(interceptor);
>+  }
>+  static new(type, opts) {
>+    let view = opts && 'view' in opts ? opts.view : null;
>+    let canBubble = opts && 'canBubble' in opts ? opts.canBubble : true;
>+    let cancelable = opts && 'cancelable' in opts ? opts.cancelable : true;
>+    let keyCode = opts && 'keyCode' in opts ? opts.keyCode : 0;
>+    let charCode = opts && 'charCode' in opts ? opts.charCode : 0;
>+    let location = opts && 'location' in opts ? opts.location : 1;
>+    let ctrlKey = opts && 'ctrlKey' in opts ? opts.ctrlKey : false;
>+    let altKey = opts && 'altKey' in opts ? opts.altKey : false;
>+    let shiftKey = opts && 'shiftKey' in opts ? opts.shiftKey : false;
>+    let metaKey = opts && 'metaKey' in opts ? opts.metaKey : false;
>+    let currentTarget = opts && 'currentTarget' in opts ? opts.currentTarget : null;
>+    if (view == null) {
>+      view = html$.window;
>+    }
>+    let eventObj = null;
>+    eventObj = html$.Event.eventType("KeyboardEvent", type, {canBubble: canBubble, cancelable: cancelable});
>+    Object.defineProperty(eventObj, 'keyCode', {
>+      get: function() {
>+        return this.keyCodeVal;
>+      }
>+    });
>+    Object.defineProperty(eventObj, 'which', {
>+      get: function() {
>+        return this.keyCodeVal;
>+      }
>+    });
>+    Object.defineProperty(eventObj, 'charCode', {
>+      get: function() {
>+        return this.charCodeVal;
>+      }
>+    });
>+    let keyIdentifier = html$.KeyEvent._convertToHexString(charCode, keyCode);
>+    dart.dsend(eventObj, _initKeyboardEvent, [type, canBubble, cancelable, view, keyIdentifier, location, ctrlKey, altKey, shiftKey, metaKey]);
>+    eventObj.keyCodeVal = keyCode;
>+    eventObj.charCodeVal = charCode;
>+    _interceptors.setDispatchProperty(eventObj, html$.KeyEvent._keyboardEventDispatchRecord);
>+    let keyEvent = new html$.KeyEvent.wrap(html$.KeyboardEvent._check(eventObj));
>+    if (keyEvent[_currentTarget] == null) {
>+      keyEvent[_currentTarget] = currentTarget == null ? html$.window : currentTarget;
>+    }
>+    return keyEvent;
>+  }
>+  static get canUseDispatchEvent() {
>+    return typeof document.body.dispatchEvent == "function" && document.body.dispatchEvent.length > 0;
>+  }
>+  get currentTarget() {
>+    return this[_currentTarget];
>+  }
>+  static _convertToHexString(charCode, keyCode) {
>+    if (charCode !== -1) {
>+      let hex = charCode[$toRadixString](16);
>+      let sb = new core.StringBuffer.new("U+");
>+      for (let i = 0; i < 4 - hex.length; i++)
>+        sb.write("0");
>+      sb.write(hex);
>+      return sb.toString();
>+    } else {
>+      return html$.KeyCode._convertKeyCodeToKeyName(keyCode);
>+    }
>+  }
>+  get code() {
>+    return this[_parent$].code;
>+  }
>+  get ctrlKey() {
>+    return this[_parent$].ctrlKey;
>+  }
>+  get detail() {
>+    return this[_parent$].detail;
>+  }
>+  get isComposing() {
>+    return this[_parent$].isComposing;
>+  }
>+  get key() {
>+    return this[_parent$].key;
>+  }
>+  get location() {
>+    return this[_parent$].location;
>+  }
>+  get metaKey() {
>+    return this[_parent$].metaKey;
>+  }
>+  get shiftKey() {
>+    return this[_parent$].shiftKey;
>+  }
>+  get view() {
>+    return html$.Window._check(this[_parent$][$view]);
>+  }
>+  [_initUIEvent](type, canBubble, cancelable, view, detail) {
>+    dart.throw(new core.UnsupportedError.new("Cannot initialize a UI Event from a KeyEvent."));
>+  }
>+  get [_shadowKeyIdentifier]() {
>+    return this[_parent$].keyIdentifier;
>+  }
>+  get [_charCode]() {
>+    return this.charCode;
>+  }
>+  get [_keyCode]() {
>+    return this.keyCode;
>+  }
>+  get [_which]() {
>+    return this.which;
>+  }
>+  get [_keyIdentifier]() {
>+    dart.throw(new core.UnsupportedError.new("keyIdentifier is unsupported."));
>+  }
>+  [_initKeyboardEvent](type, canBubble, cancelable, view, keyIdentifier, location, ctrlKey, altKey, shiftKey, metaKey) {
>+    dart.throw(new core.UnsupportedError.new("Cannot initialize a KeyboardEvent from a KeyEvent."));
>+  }
>+  getModifierState(keyArgument) {
>+    return dart.throw(new core.UnimplementedError.new());
>+  }
>+  get repeat() {
>+    return dart.throw(new core.UnimplementedError.new());
>+  }
>+  get isComposed() {
>+    return dart.throw(new core.UnimplementedError.new());
>+  }
>+  get [_get_view]() {
>+    return dart.throw(new core.UnimplementedError.new());
>+  }
>+};
>+(html$.KeyEvent.wrap = function(parent) {
>+  this[_parent$] = null;
>+  this[_shadowAltKey] = null;
>+  this[_shadowCharCode] = null;
>+  this[_shadowKeyCode] = null;
>+  this[_currentTarget] = null;
>+  this[sourceCapabilities$] = null;
>+  html$.KeyEvent.__proto__.new.call(this, parent);
>+  this[_parent$] = parent;
>+  this[_shadowAltKey] = this[_realAltKey];
>+  this[_shadowCharCode] = this[_realCharCode];
>+  this[_shadowKeyCode] = this[_realKeyCode];
>+  this[_currentTarget] = this[_parent$][$currentTarget];
>+}).prototype = html$.KeyEvent.prototype;
>+dart.addTypeTests(html$.KeyEvent);
>+const sourceCapabilities$ = Symbol("KeyEvent.sourceCapabilities");
>+html$.KeyEvent[dart.implements] = () => [html$.KeyboardEvent];
>+dart.setMethodSignature(html$.KeyEvent, () => ({
>+  __proto__: dart.getMethods(html$.KeyEvent.__proto__),
>+  [_initUIEvent]: dart.fnType(dart.void, [core.String, core.bool, core.bool, html$.Window, core.int]),
>+  [_initKeyboardEvent]: dart.fnType(dart.void, [core.String, core.bool, core.bool, html$.Window, core.String, core.int, core.bool, core.bool, core.bool, core.bool]),
>+  getModifierState: dart.fnType(core.bool, [core.String]),
>+  [$getModifierState]: dart.fnType(core.bool, [core.String])
>+}));
>+dart.setGetterSignature(html$.KeyEvent, () => ({
>+  __proto__: dart.getGetters(html$.KeyEvent.__proto__),
>+  keyCode: core.int,
>+  [$keyCode]: core.int,
>+  charCode: core.int,
>+  [$charCode]: core.int,
>+  altKey: core.bool,
>+  [$altKey]: core.bool,
>+  which: core.int,
>+  [$which]: core.int,
>+  [_realKeyCode]: core.int,
>+  [_realCharCode]: core.int,
>+  [_realAltKey]: core.bool,
>+  code: core.String,
>+  [$code]: core.String,
>+  ctrlKey: core.bool,
>+  [$ctrlKey]: core.bool,
>+  detail: core.int,
>+  [$detail]: core.int,
>+  isComposing: core.bool,
>+  [$isComposing]: core.bool,
>+  key: core.String,
>+  [$key]: core.String,
>+  location: core.int,
>+  [$location]: core.int,
>+  metaKey: core.bool,
>+  [$metaKey]: core.bool,
>+  shiftKey: core.bool,
>+  [$shiftKey]: core.bool,
>+  view: html$.Window,
>+  [$view]: html$.Window,
>+  [_shadowKeyIdentifier]: core.String,
>+  [_charCode]: core.int,
>+  [_keyCode]: core.int,
>+  [_which]: core.int,
>+  [_keyIdentifier]: core.String,
>+  repeat: core.bool,
>+  [$repeat]: core.bool,
>+  isComposed: core.bool,
>+  [_get_view]: dart.dynamic
>+}));
>+dart.setLibraryUri(html$.KeyEvent, "dart:html");
>+dart.setFieldSignature(html$.KeyEvent, () => ({
>+  __proto__: dart.getFields(html$.KeyEvent.__proto__),
>+  [_parent$]: dart.fieldType(html$.KeyboardEvent),
>+  [_shadowAltKey]: dart.fieldType(core.bool),
>+  [_shadowCharCode]: dart.fieldType(core.int),
>+  [_shadowKeyCode]: dart.fieldType(core.int),
>+  [_currentTarget]: dart.fieldType(html$.EventTarget),
>+  sourceCapabilities: dart.finalFieldType(html$.InputDeviceCapabilities)
>+}));
>+dart.defineExtensionMethods(html$.KeyEvent, ['getModifierState']);
>+dart.defineExtensionAccessors(html$.KeyEvent, [
>+  'keyCode',
>+  'charCode',
>+  'altKey',
>+  'which',
>+  'currentTarget',
>+  'code',
>+  'ctrlKey',
>+  'detail',
>+  'isComposing',
>+  'key',
>+  'location',
>+  'metaKey',
>+  'shiftKey',
>+  'view',
>+  'repeat',
>+  'sourceCapabilities'
>+]);
>+dart.defineLazy(html$.KeyEvent, {
>+  /*html$.KeyEvent._keyboardEventDispatchRecord*/get _keyboardEventDispatchRecord() {
>+    return html$.KeyEvent._makeRecord();
>+  },
>+  /*html$.KeyEvent.keyDownEvent*/get keyDownEvent() {
>+    return new html$._KeyboardEventHandler.new("keydown");
>+  },
>+  set keyDownEvent(_) {},
>+  /*html$.KeyEvent.keyUpEvent*/get keyUpEvent() {
>+    return new html$._KeyboardEventHandler.new("keyup");
>+  },
>+  set keyUpEvent(_) {},
>+  /*html$.KeyEvent.keyPressEvent*/get keyPressEvent() {
>+    return new html$._KeyboardEventHandler.new("keypress");
>+  },
>+  set keyPressEvent(_) {}
>+});
>+html$._CustomKeyEventStreamImpl = class _CustomKeyEventStreamImpl extends html$._CustomEventStreamImpl$(html$.KeyEvent) {
>+  add(event) {
>+    html$.KeyEvent._check(event);
>+    if (event.type == this[_type$1]) {
>+      event.currentTarget.dispatchEvent(event[_parent$]);
>+      this[_streamController].add(event);
>+    }
>+  }
>+};
>+(html$._CustomKeyEventStreamImpl.new = function(type) {
>+  html$._CustomKeyEventStreamImpl.__proto__.new.call(this, type);
>+}).prototype = html$._CustomKeyEventStreamImpl.prototype;
>+dart.addTypeTests(html$._CustomKeyEventStreamImpl);
>+html$._CustomKeyEventStreamImpl[dart.implements] = () => [CustomStreamOfKeyEvent()];
>+dart.setMethodSignature(html$._CustomKeyEventStreamImpl, () => ({
>+  __proto__: dart.getMethods(html$._CustomKeyEventStreamImpl.__proto__),
>+  add: dart.fnType(dart.void, [core.Object])
>+}));
>+dart.setLibraryUri(html$._CustomKeyEventStreamImpl, "dart:html");
>+const _controller$0 = dart.privateName(html$, "_controller");
>+const _subscriptions = dart.privateName(html$, "_subscriptions");
>+const _is__StreamPool_default = Symbol('_is__StreamPool_default');
>+html$._StreamPool$ = dart.generic(T => {
>+  let StreamOfT = () => (StreamOfT = dart.constFn(async.Stream$(T)))();
>+  let StreamSubscriptionOfT = () => (StreamSubscriptionOfT = dart.constFn(async.StreamSubscription$(T)))();
>+  let LinkedMapOfStreamOfT$StreamSubscriptionOfT = () => (LinkedMapOfStreamOfT$StreamSubscriptionOfT = dart.constFn(_js_helper.LinkedMap$(StreamOfT(), StreamSubscriptionOfT())))();
>+  let StreamControllerOfT = () => (StreamControllerOfT = dart.constFn(async.StreamController$(T)))();
>+  let MapOfStreamOfT$StreamSubscriptionOfT = () => (MapOfStreamOfT$StreamSubscriptionOfT = dart.constFn(core.Map$(StreamOfT(), StreamSubscriptionOfT())))();
>+  class _StreamPool extends core.Object {
>+    get stream() {
>+      return this[_controller$0].stream;
>+    }
>+    add(stream) {
>+      StreamOfT()._check(stream);
>+      if (dart.test(this[_subscriptions][$containsKey](stream))) return;
>+      this[_subscriptions][$_set](stream, stream.listen(dart.bind(this[_controller$0], 'add'), {onError: dart.bind(this[_controller$0], 'addError'), onDone: dart.fn(() => this.remove(stream), VoidTovoid())}));
>+    }
>+    remove(stream) {
>+      StreamOfT()._check(stream);
>+      let subscription = this[_subscriptions][$remove](stream);
>+      if (subscription != null) subscription.cancel();
>+    }
>+    close() {
>+      for (let subscription of this[_subscriptions][$values]) {
>+        subscription.cancel();
>+      }
>+      this[_subscriptions][$clear]();
>+      this[_controller$0].close();
>+    }
>+  }
>+  (_StreamPool.broadcast = function() {
>+    this[_controller$0] = null;
>+    this[_subscriptions] = new (LinkedMapOfStreamOfT$StreamSubscriptionOfT()).new();
>+    this[_controller$0] = StreamControllerOfT().broadcast({sync: true, onCancel: dart.bind(this, 'close')});
>+  }).prototype = _StreamPool.prototype;
>+  dart.addTypeTests(_StreamPool);
>+  _StreamPool.prototype[_is__StreamPool_default] = true;
>+  dart.setMethodSignature(_StreamPool, () => ({
>+    __proto__: dart.getMethods(_StreamPool.__proto__),
>+    add: dart.fnType(dart.void, [core.Object]),
>+    remove: dart.fnType(dart.void, [core.Object]),
>+    close: dart.fnType(dart.void, [])
>+  }));
>+  dart.setGetterSignature(_StreamPool, () => ({
>+    __proto__: dart.getGetters(_StreamPool.__proto__),
>+    stream: async.Stream$(T)
>+  }));
>+  dart.setLibraryUri(_StreamPool, "dart:html");
>+  dart.setFieldSignature(_StreamPool, () => ({
>+    __proto__: dart.getFields(_StreamPool.__proto__),
>+    [_controller$0]: dart.fieldType(StreamControllerOfT()),
>+    [_subscriptions]: dart.fieldType(MapOfStreamOfT$StreamSubscriptionOfT())
>+  }));
>+  return _StreamPool;
>+});
>+html$._StreamPool = html$._StreamPool$();
>+dart.addTypeTests(html$._StreamPool, _is__StreamPool_default);
>+const _eventTypeGetter = dart.privateName(html$, "_eventTypeGetter");
>+const _is__CustomEventStreamProvider_default = Symbol('_is__CustomEventStreamProvider_default');
>+html$._CustomEventStreamProvider$ = dart.generic(T => {
>+  let _EventStreamOfT = () => (_EventStreamOfT = dart.constFn(html$._EventStream$(T)))();
>+  let _ElementEventStreamImplOfT = () => (_ElementEventStreamImplOfT = dart.constFn(html$._ElementEventStreamImpl$(T)))();
>+  let _ElementListEventStreamImplOfT = () => (_ElementListEventStreamImplOfT = dart.constFn(html$._ElementListEventStreamImpl$(T)))();
>+  let EventStreamProviderOfT = () => (EventStreamProviderOfT = dart.constFn(html$.EventStreamProvider$(T)))();
>+  class _CustomEventStreamProvider extends core.Object {
>+    forTarget(e, opts) {
>+      let useCapture = opts && 'useCapture' in opts ? opts.useCapture : false;
>+      return new (_EventStreamOfT()).new(e, core.String._check(dart.dcall(this[_eventTypeGetter], [e])), useCapture);
>+    }
>+    forElement(e, opts) {
>+      let useCapture = opts && 'useCapture' in opts ? opts.useCapture : false;
>+      return new (_ElementEventStreamImplOfT()).new(e, dart.dcall(this[_eventTypeGetter], [e]), useCapture);
>+    }
>+    [_forElementList](e, opts) {
>+      let useCapture = opts && 'useCapture' in opts ? opts.useCapture : false;
>+      return new (_ElementListEventStreamImplOfT()).new(e, core.String._check(dart.dcall(this[_eventTypeGetter], [e])), useCapture);
>+    }
>+    getEventType(target) {
>+      return core.String._check(dart.dcall(this[_eventTypeGetter], [target]));
>+    }
>+    get [_eventType]() {
>+      return dart.throw(new core.UnsupportedError.new("Access type through getEventType method."));
>+    }
>+  }
>+  (_CustomEventStreamProvider.new = function(eventTypeGetter) {
>+    this[_eventTypeGetter] = eventTypeGetter;
>+  }).prototype = _CustomEventStreamProvider.prototype;
>+  dart.addTypeTests(_CustomEventStreamProvider);
>+  _CustomEventStreamProvider.prototype[_is__CustomEventStreamProvider_default] = true;
>+  _CustomEventStreamProvider[dart.implements] = () => [EventStreamProviderOfT()];
>+  dart.setMethodSignature(_CustomEventStreamProvider, () => ({
>+    __proto__: dart.getMethods(_CustomEventStreamProvider.__proto__),
>+    forTarget: dart.fnType(async.Stream$(T), [html$.EventTarget], {useCapture: core.bool}),
>+    forElement: dart.fnType(html$.ElementStream$(T), [html$.Element], {useCapture: core.bool}),
>+    [_forElementList]: dart.fnType(html$.ElementStream$(T), [html$.ElementList$(html$.Element)], {useCapture: core.bool}),
>+    getEventType: dart.fnType(core.String, [html$.EventTarget])
>+  }));
>+  dart.setGetterSignature(_CustomEventStreamProvider, () => ({
>+    __proto__: dart.getGetters(_CustomEventStreamProvider.__proto__),
>+    [_eventType]: core.String
>+  }));
>+  dart.setLibraryUri(_CustomEventStreamProvider, "dart:html");
>+  dart.setFieldSignature(_CustomEventStreamProvider, () => ({
>+    __proto__: dart.getFields(_CustomEventStreamProvider.__proto__),
>+    [_eventTypeGetter]: dart.finalFieldType(dart.dynamic)
>+  }));
>+  return _CustomEventStreamProvider;
>+});
>+html$._CustomEventStreamProvider = html$._CustomEventStreamProvider$();
>+dart.addTypeTests(html$._CustomEventStreamProvider, _is__CustomEventStreamProvider_default);
>+html$._Html5NodeValidator = class _Html5NodeValidator extends core.Object {
>+  allowsElement(element) {
>+    return html$._Html5NodeValidator._allowedElements.contains(html$.Element._safeTagName(element));
>+  }
>+  allowsAttribute(element, attributeName, value) {
>+    let tagName = html$.Element._safeTagName(element);
>+    let validator = html$._Html5NodeValidator._attributeValidators[$_get](dart.str(tagName) + "::" + dart.str(attributeName));
>+    if (validator == null) {
>+      validator = html$._Html5NodeValidator._attributeValidators[$_get]("*::" + dart.str(attributeName));
>+    }
>+    if (validator == null) {
>+      return false;
>+    }
>+    return core.bool._check(dart.dcall(validator, [element, attributeName, value, this]));
>+  }
>+  static _standardAttributeValidator(element, attributeName, value, context) {
>+    return true;
>+  }
>+  static _uriAttributeValidator(element, attributeName, value, context) {
>+    return context.uriPolicy.allowsUri(value);
>+  }
>+};
>+(html$._Html5NodeValidator.new = function(opts) {
>+  let uriPolicy = opts && 'uriPolicy' in opts ? opts.uriPolicy : null;
>+  this.uriPolicy = uriPolicy != null ? uriPolicy : html$.UriPolicy.new();
>+  if (dart.test(html$._Html5NodeValidator._attributeValidators[$isEmpty])) {
>+    for (let attr of html$._Html5NodeValidator._standardAttributes) {
>+      html$._Html5NodeValidator._attributeValidators[$_set](attr, dart.fn(html$._Html5NodeValidator._standardAttributeValidator, ElementAndStringAndString__Tobool()));
>+    }
>+    for (let attr of html$._Html5NodeValidator._uriAttributes) {
>+      html$._Html5NodeValidator._attributeValidators[$_set](attr, dart.fn(html$._Html5NodeValidator._uriAttributeValidator, ElementAndStringAndString__Tobool()));
>+    }
>+  }
>+}).prototype = html$._Html5NodeValidator.prototype;
>+dart.addTypeTests(html$._Html5NodeValidator);
>+html$._Html5NodeValidator[dart.implements] = () => [html$.NodeValidator];
>+dart.setMethodSignature(html$._Html5NodeValidator, () => ({
>+  __proto__: dart.getMethods(html$._Html5NodeValidator.__proto__),
>+  allowsElement: dart.fnType(core.bool, [html$.Element]),
>+  allowsAttribute: dart.fnType(core.bool, [html$.Element, core.String, core.String])
>+}));
>+dart.setLibraryUri(html$._Html5NodeValidator, "dart:html");
>+dart.setFieldSignature(html$._Html5NodeValidator, () => ({
>+  __proto__: dart.getFields(html$._Html5NodeValidator.__proto__),
>+  uriPolicy: dart.finalFieldType(html$.UriPolicy)
>+}));
>+dart.defineLazy(html$._Html5NodeValidator, {
>+  /*html$._Html5NodeValidator._allowedElements*/get _allowedElements() {
>+    return SetOfString().from(["A", "ABBR", "ACRONYM", "ADDRESS", "AREA", "ARTICLE", "ASIDE", "AUDIO", "B", "BDI", "BDO", "BIG", "BLOCKQUOTE", "BR", "BUTTON", "CANVAS", "CAPTION", "CENTER", "CITE", "CODE", "COL", "COLGROUP", "COMMAND", "DATA", "DATALIST", "DD", "DEL", "DETAILS", "DFN", "DIR", "DIV", "DL", "DT", "EM", "FIELDSET", "FIGCAPTION", "FIGURE", "FONT", "FOOTER", "FORM", "H1", "H2", "H3", "H4", "H5", "H6", "HEADER", "HGROUP", "HR", "I", "IFRAME", "IMG", "INPUT", "INS", "KBD", "LABEL", "LEGEND", "LI", "MAP", "MARK", "MENU", "METER", "NAV", "NOBR", "OL", "OPTGROUP", "OPTION", "OUTPUT", "P", "PRE", "PROGRESS", "Q", "S", "SAMP", "SECTION", "SELECT", "SMALL", "SOURCE", "SPAN", "STRIKE", "STRONG", "SUB", "SUMMARY", "SUP", "TABLE", "TBODY", "TD", "TEXTAREA", "TFOOT", "TH", "THEAD", "TIME", "TR", "TRACK", "TT", "U", "UL", "VAR", "VIDEO", "WBR"]);
>+  },
>+  /*html$._Html5NodeValidator._standardAttributes*/get _standardAttributes() {
>+    return dart.constList(["*::class", "*::dir", "*::draggable", "*::hidden", "*::id", "*::inert", "*::itemprop", "*::itemref", "*::itemscope", "*::lang", "*::spellcheck", "*::title", "*::translate", "A::accesskey", "A::coords", "A::hreflang", "A::name", "A::shape", "A::tabindex", "A::target", "A::type", "AREA::accesskey", "AREA::alt", "AREA::coords", "AREA::nohref", "AREA::shape", "AREA::tabindex", "AREA::target", "AUDIO::controls", "AUDIO::loop", "AUDIO::mediagroup", "AUDIO::muted", "AUDIO::preload", "BDO::dir", "BODY::alink", "BODY::bgcolor", "BODY::link", "BODY::text", "BODY::vlink", "BR::clear", "BUTTON::accesskey", "BUTTON::disabled", "BUTTON::name", "BUTTON::tabindex", "BUTTON::type", "BUTTON::value", "CANVAS::height", "CANVAS::width", "CAPTION::align", "COL::align", "COL::char", "COL::charoff", "COL::span", "COL::valign", "COL::width", "COLGROUP::align", "COLGROUP::char", "COLGROUP::charoff", "COLGROUP::span", "COLGROUP::valign", "COLGROUP::width", "COMMAND::checked", "COMMAND::command", "COMMAND::disabled", "COMMAND::label", "COMMAND::radiogroup", "COMMAND::type", "DATA::value", "DEL::datetime", "DETAILS::open", "DIR::compact", "DIV::align", "DL::compact", "FIELDSET::disabled", "FONT::color", "FONT::face", "FONT::size", "FORM::accept", "FORM::autocomplete", "FORM::enctype", "FORM::method", "FORM::name", "FORM::novalidate", "FORM::target", "FRAME::name", "H1::align", "H2::align", "H3::align", "H4::align", "H5::align", "H6::align", "HR::align", "HR::noshade", "HR::size", "HR::width", "HTML::version", "IFRAME::align", "IFRAME::frameborder", "IFRAME::height", "IFRAME::marginheight", "IFRAME::marginwidth", "IFRAME::width", "IMG::align", "IMG::alt", "IMG::border", "IMG::height", "IMG::hspace", "IMG::ismap", "IMG::name", "IMG::usemap", "IMG::vspace", "IMG::width", "INPUT::accept", "INPUT::accesskey", "INPUT::align", "INPUT::alt", "INPUT::autocomplete", "INPUT::autofocus", "INPUT::checked", "INPUT::disabled", "INPUT::inputmode", "INPUT::ismap", "INPUT::list", "INPUT::max", "INPUT::maxlength", "INPUT::min", "INPUT::multiple", "INPUT::name", "INPUT::placeholder", "INPUT::readonly", "INPUT::required", "INPUT::size", "INPUT::step", "INPUT::tabindex", "INPUT::type", "INPUT::usemap", "INPUT::value", "INS::datetime", "KEYGEN::disabled", "KEYGEN::keytype", "KEYGEN::name", "LABEL::accesskey", "LABEL::for", "LEGEND::accesskey", "LEGEND::align", "LI::type", "LI::value", "LINK::sizes", "MAP::name", "MENU::compact", "MENU::label", "MENU::type", "METER::high", "METER::low", "METER::max", "METER::min", "METER::value", "OBJECT::typemustmatch", "OL::compact", "OL::reversed", "OL::start", "OL::type", "OPTGROUP::disabled", "OPTGROUP::label", "OPTION::disabled", "OPTION::label", "OPTION::selected", "OPTION::value", "OUTPUT::for", "OUTPUT::name", "P::align", "PRE::width", "PROGRESS::max", "PROGRESS::min", "PROGRESS::value", "SELECT::autocomplete", "SELECT::disabled", "SELECT::multiple", "SELECT::name", "SELECT::required", "SELECT::size", "SELECT::tabindex", "SOURCE::type", "TABLE::align", "TABLE::bgcolor", "TABLE::border", "TABLE::cellpadding", "TABLE::cellspacing", "TABLE::frame", "TABLE::rules", "TABLE::summary", "TABLE::width", "TBODY::align", "TBODY::char", "TBODY::charoff", "TBODY::valign", "TD::abbr", "TD::align", "TD::axis", "TD::bgcolor", "TD::char", "TD::charoff", "TD::colspan", "TD::headers", "TD::height", "TD::nowrap", "TD::rowspan", "TD::scope", "TD::valign", "TD::width", "TEXTAREA::accesskey", "TEXTAREA::autocomplete", "TEXTAREA::cols", "TEXTAREA::disabled", "TEXTAREA::inputmode", "TEXTAREA::name", "TEXTAREA::placeholder", "TEXTAREA::readonly", "TEXTAREA::required", "TEXTAREA::rows", "TEXTAREA::tabindex", "TEXTAREA::wrap", "TFOOT::align", "TFOOT::char", "TFOOT::charoff", "TFOOT::valign", "TH::abbr", "TH::align", "TH::axis", "TH::bgcolor", "TH::char", "TH::charoff", "TH::colspan", "TH::headers", "TH::height", "TH::nowrap", "TH::rowspan", "TH::scope", "TH::valign", "TH::width", "THEAD::align", "THEAD::char", "THEAD::charoff", "THEAD::valign", "TR::align", "TR::bgcolor", "TR::char", "TR::charoff", "TR::valign", "TRACK::default", "TRACK::kind", "TRACK::label", "TRACK::srclang", "UL::compact", "UL::type", "VIDEO::controls", "VIDEO::height", "VIDEO::loop", "VIDEO::mediagroup", "VIDEO::muted", "VIDEO::preload", "VIDEO::width"], core.String);
>+  },
>+  /*html$._Html5NodeValidator._uriAttributes*/get _uriAttributes() {
>+    return dart.constList(["A::href", "AREA::href", "BLOCKQUOTE::cite", "BODY::background", "COMMAND::icon", "DEL::cite", "FORM::action", "IMG::src", "INPUT::src", "INS::cite", "Q::cite", "VIDEO::poster"], core.String);
>+  },
>+  /*html$._Html5NodeValidator._attributeValidators*/get _attributeValidators() {
>+    return new (IdentityMapOfString$Function()).new();
>+  }
>+});
>+html$.KeyCode = class KeyCode extends core.Object {
>+  static isCharacterKey(keyCode) {
>+    if (dart.notNull(keyCode) >= 48 && dart.notNull(keyCode) <= 57 || dart.notNull(keyCode) >= 96 && dart.notNull(keyCode) <= 106 || dart.notNull(keyCode) >= 65 && dart.notNull(keyCode) <= 90) {
>+      return true;
>+    }
>+    if (dart.test(html_common.Device.isWebKit) && keyCode === 0) {
>+      return true;
>+    }
>+    return keyCode === 32 || keyCode === 63 || keyCode === 107 || keyCode === 109 || keyCode === 110 || keyCode === 111 || keyCode === 186 || keyCode === 59 || keyCode === 189 || keyCode === 187 || keyCode === 61 || keyCode === 188 || keyCode === 190 || keyCode === 191 || keyCode === 192 || keyCode === 222 || keyCode === 219 || keyCode === 220 || keyCode === 221;
>+  }
>+  static _convertKeyCodeToKeyName(keyCode) {
>+    switch (keyCode) {
>+      case html$.KeyCode.ALT:
>+      {
>+        return html$._KeyName.ALT;
>+      }
>+      case html$.KeyCode.BACKSPACE:
>+      {
>+        return html$._KeyName.BACKSPACE;
>+      }
>+      case html$.KeyCode.CAPS_LOCK:
>+      {
>+        return html$._KeyName.CAPS_LOCK;
>+      }
>+      case html$.KeyCode.CTRL:
>+      {
>+        return html$._KeyName.CONTROL;
>+      }
>+      case html$.KeyCode.DELETE:
>+      {
>+        return html$._KeyName.DEL;
>+      }
>+      case html$.KeyCode.DOWN:
>+      {
>+        return html$._KeyName.DOWN;
>+      }
>+      case html$.KeyCode.END:
>+      {
>+        return html$._KeyName.END;
>+      }
>+      case html$.KeyCode.ENTER:
>+      {
>+        return html$._KeyName.ENTER;
>+      }
>+      case html$.KeyCode.ESC:
>+      {
>+        return html$._KeyName.ESC;
>+      }
>+      case html$.KeyCode.F1:
>+      {
>+        return html$._KeyName.F1;
>+      }
>+      case html$.KeyCode.F2:
>+      {
>+        return html$._KeyName.F2;
>+      }
>+      case html$.KeyCode.F3:
>+      {
>+        return html$._KeyName.F3;
>+      }
>+      case html$.KeyCode.F4:
>+      {
>+        return html$._KeyName.F4;
>+      }
>+      case html$.KeyCode.F5:
>+      {
>+        return html$._KeyName.F5;
>+      }
>+      case html$.KeyCode.F6:
>+      {
>+        return html$._KeyName.F6;
>+      }
>+      case html$.KeyCode.F7:
>+      {
>+        return html$._KeyName.F7;
>+      }
>+      case html$.KeyCode.F8:
>+      {
>+        return html$._KeyName.F8;
>+      }
>+      case html$.KeyCode.F9:
>+      {
>+        return html$._KeyName.F9;
>+      }
>+      case html$.KeyCode.F10:
>+      {
>+        return html$._KeyName.F10;
>+      }
>+      case html$.KeyCode.F11:
>+      {
>+        return html$._KeyName.F11;
>+      }
>+      case html$.KeyCode.F12:
>+      {
>+        return html$._KeyName.F12;
>+      }
>+      case html$.KeyCode.HOME:
>+      {
>+        return html$._KeyName.HOME;
>+      }
>+      case html$.KeyCode.INSERT:
>+      {
>+        return html$._KeyName.INSERT;
>+      }
>+      case html$.KeyCode.LEFT:
>+      {
>+        return html$._KeyName.LEFT;
>+      }
>+      case html$.KeyCode.META:
>+      {
>+        return html$._KeyName.META;
>+      }
>+      case html$.KeyCode.NUMLOCK:
>+      {
>+        return html$._KeyName.NUM_LOCK;
>+      }
>+      case html$.KeyCode.PAGE_DOWN:
>+      {
>+        return html$._KeyName.PAGE_DOWN;
>+      }
>+      case html$.KeyCode.PAGE_UP:
>+      {
>+        return html$._KeyName.PAGE_UP;
>+      }
>+      case html$.KeyCode.PAUSE:
>+      {
>+        return html$._KeyName.PAUSE;
>+      }
>+      case html$.KeyCode.PRINT_SCREEN:
>+      {
>+        return html$._KeyName.PRINT_SCREEN;
>+      }
>+      case html$.KeyCode.RIGHT:
>+      {
>+        return html$._KeyName.RIGHT;
>+      }
>+      case html$.KeyCode.SCROLL_LOCK:
>+      {
>+        return html$._KeyName.SCROLL;
>+      }
>+      case html$.KeyCode.SHIFT:
>+      {
>+        return html$._KeyName.SHIFT;
>+      }
>+      case html$.KeyCode.SPACE:
>+      {
>+        return html$._KeyName.SPACEBAR;
>+      }
>+      case html$.KeyCode.TAB:
>+      {
>+        return html$._KeyName.TAB;
>+      }
>+      case html$.KeyCode.UP:
>+      {
>+        return html$._KeyName.UP;
>+      }
>+      case html$.KeyCode.WIN_IME:
>+      case html$.KeyCode.WIN_KEY:
>+      case html$.KeyCode.WIN_KEY_LEFT:
>+      case html$.KeyCode.WIN_KEY_RIGHT:
>+      {
>+        return html$._KeyName.WIN;
>+      }
>+      default:
>+      {
>+        return html$._KeyName.UNIDENTIFIED;
>+      }
>+    }
>+    return html$._KeyName.UNIDENTIFIED;
>+  }
>+};
>+(html$.KeyCode.new = function() {
>+}).prototype = html$.KeyCode.prototype;
>+dart.addTypeTests(html$.KeyCode);
>+dart.setLibraryUri(html$.KeyCode, "dart:html");
>+dart.defineLazy(html$.KeyCode, {
>+  /*html$.KeyCode.WIN_KEY_FF_LINUX*/get WIN_KEY_FF_LINUX() {
>+    return 0;
>+  },
>+  /*html$.KeyCode.MAC_ENTER*/get MAC_ENTER() {
>+    return 3;
>+  },
>+  /*html$.KeyCode.BACKSPACE*/get BACKSPACE() {
>+    return 8;
>+  },
>+  /*html$.KeyCode.TAB*/get TAB() {
>+    return 9;
>+  },
>+  /*html$.KeyCode.NUM_CENTER*/get NUM_CENTER() {
>+    return 12;
>+  },
>+  /*html$.KeyCode.ENTER*/get ENTER() {
>+    return 13;
>+  },
>+  /*html$.KeyCode.SHIFT*/get SHIFT() {
>+    return 16;
>+  },
>+  /*html$.KeyCode.CTRL*/get CTRL() {
>+    return 17;
>+  },
>+  /*html$.KeyCode.ALT*/get ALT() {
>+    return 18;
>+  },
>+  /*html$.KeyCode.PAUSE*/get PAUSE() {
>+    return 19;
>+  },
>+  /*html$.KeyCode.CAPS_LOCK*/get CAPS_LOCK() {
>+    return 20;
>+  },
>+  /*html$.KeyCode.ESC*/get ESC() {
>+    return 27;
>+  },
>+  /*html$.KeyCode.SPACE*/get SPACE() {
>+    return 32;
>+  },
>+  /*html$.KeyCode.PAGE_UP*/get PAGE_UP() {
>+    return 33;
>+  },
>+  /*html$.KeyCode.PAGE_DOWN*/get PAGE_DOWN() {
>+    return 34;
>+  },
>+  /*html$.KeyCode.END*/get END() {
>+    return 35;
>+  },
>+  /*html$.KeyCode.HOME*/get HOME() {
>+    return 36;
>+  },
>+  /*html$.KeyCode.LEFT*/get LEFT() {
>+    return 37;
>+  },
>+  /*html$.KeyCode.UP*/get UP() {
>+    return 38;
>+  },
>+  /*html$.KeyCode.RIGHT*/get RIGHT() {
>+    return 39;
>+  },
>+  /*html$.KeyCode.DOWN*/get DOWN() {
>+    return 40;
>+  },
>+  /*html$.KeyCode.NUM_NORTH_EAST*/get NUM_NORTH_EAST() {
>+    return 33;
>+  },
>+  /*html$.KeyCode.NUM_SOUTH_EAST*/get NUM_SOUTH_EAST() {
>+    return 34;
>+  },
>+  /*html$.KeyCode.NUM_SOUTH_WEST*/get NUM_SOUTH_WEST() {
>+    return 35;
>+  },
>+  /*html$.KeyCode.NUM_NORTH_WEST*/get NUM_NORTH_WEST() {
>+    return 36;
>+  },
>+  /*html$.KeyCode.NUM_WEST*/get NUM_WEST() {
>+    return 37;
>+  },
>+  /*html$.KeyCode.NUM_NORTH*/get NUM_NORTH() {
>+    return 38;
>+  },
>+  /*html$.KeyCode.NUM_EAST*/get NUM_EAST() {
>+    return 39;
>+  },
>+  /*html$.KeyCode.NUM_SOUTH*/get NUM_SOUTH() {
>+    return 40;
>+  },
>+  /*html$.KeyCode.PRINT_SCREEN*/get PRINT_SCREEN() {
>+    return 44;
>+  },
>+  /*html$.KeyCode.INSERT*/get INSERT() {
>+    return 45;
>+  },
>+  /*html$.KeyCode.NUM_INSERT*/get NUM_INSERT() {
>+    return 45;
>+  },
>+  /*html$.KeyCode.DELETE*/get DELETE() {
>+    return 46;
>+  },
>+  /*html$.KeyCode.NUM_DELETE*/get NUM_DELETE() {
>+    return 46;
>+  },
>+  /*html$.KeyCode.ZERO*/get ZERO() {
>+    return 48;
>+  },
>+  /*html$.KeyCode.ONE*/get ONE() {
>+    return 49;
>+  },
>+  /*html$.KeyCode.TWO*/get TWO() {
>+    return 50;
>+  },
>+  /*html$.KeyCode.THREE*/get THREE() {
>+    return 51;
>+  },
>+  /*html$.KeyCode.FOUR*/get FOUR() {
>+    return 52;
>+  },
>+  /*html$.KeyCode.FIVE*/get FIVE() {
>+    return 53;
>+  },
>+  /*html$.KeyCode.SIX*/get SIX() {
>+    return 54;
>+  },
>+  /*html$.KeyCode.SEVEN*/get SEVEN() {
>+    return 55;
>+  },
>+  /*html$.KeyCode.EIGHT*/get EIGHT() {
>+    return 56;
>+  },
>+  /*html$.KeyCode.NINE*/get NINE() {
>+    return 57;
>+  },
>+  /*html$.KeyCode.FF_SEMICOLON*/get FF_SEMICOLON() {
>+    return 59;
>+  },
>+  /*html$.KeyCode.FF_EQUALS*/get FF_EQUALS() {
>+    return 61;
>+  },
>+  /*html$.KeyCode.QUESTION_MARK*/get QUESTION_MARK() {
>+    return 63;
>+  },
>+  /*html$.KeyCode.A*/get A() {
>+    return 65;
>+  },
>+  /*html$.KeyCode.B*/get B() {
>+    return 66;
>+  },
>+  /*html$.KeyCode.C*/get C() {
>+    return 67;
>+  },
>+  /*html$.KeyCode.D*/get D() {
>+    return 68;
>+  },
>+  /*html$.KeyCode.E*/get E() {
>+    return 69;
>+  },
>+  /*html$.KeyCode.F*/get F() {
>+    return 70;
>+  },
>+  /*html$.KeyCode.G*/get G() {
>+    return 71;
>+  },
>+  /*html$.KeyCode.H*/get H() {
>+    return 72;
>+  },
>+  /*html$.KeyCode.I*/get I() {
>+    return 73;
>+  },
>+  /*html$.KeyCode.J*/get J() {
>+    return 74;
>+  },
>+  /*html$.KeyCode.K*/get K() {
>+    return 75;
>+  },
>+  /*html$.KeyCode.L*/get L() {
>+    return 76;
>+  },
>+  /*html$.KeyCode.M*/get M() {
>+    return 77;
>+  },
>+  /*html$.KeyCode.N*/get N() {
>+    return 78;
>+  },
>+  /*html$.KeyCode.O*/get O() {
>+    return 79;
>+  },
>+  /*html$.KeyCode.P*/get P() {
>+    return 80;
>+  },
>+  /*html$.KeyCode.Q*/get Q() {
>+    return 81;
>+  },
>+  /*html$.KeyCode.R*/get R() {
>+    return 82;
>+  },
>+  /*html$.KeyCode.S*/get S() {
>+    return 83;
>+  },
>+  /*html$.KeyCode.T*/get T() {
>+    return 84;
>+  },
>+  /*html$.KeyCode.U*/get U() {
>+    return 85;
>+  },
>+  /*html$.KeyCode.V*/get V() {
>+    return 86;
>+  },
>+  /*html$.KeyCode.W*/get W() {
>+    return 87;
>+  },
>+  /*html$.KeyCode.X*/get X() {
>+    return 88;
>+  },
>+  /*html$.KeyCode.Y*/get Y() {
>+    return 89;
>+  },
>+  /*html$.KeyCode.Z*/get Z() {
>+    return 90;
>+  },
>+  /*html$.KeyCode.META*/get META() {
>+    return 91;
>+  },
>+  /*html$.KeyCode.WIN_KEY_LEFT*/get WIN_KEY_LEFT() {
>+    return 91;
>+  },
>+  /*html$.KeyCode.WIN_KEY_RIGHT*/get WIN_KEY_RIGHT() {
>+    return 92;
>+  },
>+  /*html$.KeyCode.CONTEXT_MENU*/get CONTEXT_MENU() {
>+    return 93;
>+  },
>+  /*html$.KeyCode.NUM_ZERO*/get NUM_ZERO() {
>+    return 96;
>+  },
>+  /*html$.KeyCode.NUM_ONE*/get NUM_ONE() {
>+    return 97;
>+  },
>+  /*html$.KeyCode.NUM_TWO*/get NUM_TWO() {
>+    return 98;
>+  },
>+  /*html$.KeyCode.NUM_THREE*/get NUM_THREE() {
>+    return 99;
>+  },
>+  /*html$.KeyCode.NUM_FOUR*/get NUM_FOUR() {
>+    return 100;
>+  },
>+  /*html$.KeyCode.NUM_FIVE*/get NUM_FIVE() {
>+    return 101;
>+  },
>+  /*html$.KeyCode.NUM_SIX*/get NUM_SIX() {
>+    return 102;
>+  },
>+  /*html$.KeyCode.NUM_SEVEN*/get NUM_SEVEN() {
>+    return 103;
>+  },
>+  /*html$.KeyCode.NUM_EIGHT*/get NUM_EIGHT() {
>+    return 104;
>+  },
>+  /*html$.KeyCode.NUM_NINE*/get NUM_NINE() {
>+    return 105;
>+  },
>+  /*html$.KeyCode.NUM_MULTIPLY*/get NUM_MULTIPLY() {
>+    return 106;
>+  },
>+  /*html$.KeyCode.NUM_PLUS*/get NUM_PLUS() {
>+    return 107;
>+  },
>+  /*html$.KeyCode.NUM_MINUS*/get NUM_MINUS() {
>+    return 109;
>+  },
>+  /*html$.KeyCode.NUM_PERIOD*/get NUM_PERIOD() {
>+    return 110;
>+  },
>+  /*html$.KeyCode.NUM_DIVISION*/get NUM_DIVISION() {
>+    return 111;
>+  },
>+  /*html$.KeyCode.F1*/get F1() {
>+    return 112;
>+  },
>+  /*html$.KeyCode.F2*/get F2() {
>+    return 113;
>+  },
>+  /*html$.KeyCode.F3*/get F3() {
>+    return 114;
>+  },
>+  /*html$.KeyCode.F4*/get F4() {
>+    return 115;
>+  },
>+  /*html$.KeyCode.F5*/get F5() {
>+    return 116;
>+  },
>+  /*html$.KeyCode.F6*/get F6() {
>+    return 117;
>+  },
>+  /*html$.KeyCode.F7*/get F7() {
>+    return 118;
>+  },
>+  /*html$.KeyCode.F8*/get F8() {
>+    return 119;
>+  },
>+  /*html$.KeyCode.F9*/get F9() {
>+    return 120;
>+  },
>+  /*html$.KeyCode.F10*/get F10() {
>+    return 121;
>+  },
>+  /*html$.KeyCode.F11*/get F11() {
>+    return 122;
>+  },
>+  /*html$.KeyCode.F12*/get F12() {
>+    return 123;
>+  },
>+  /*html$.KeyCode.NUMLOCK*/get NUMLOCK() {
>+    return 144;
>+  },
>+  /*html$.KeyCode.SCROLL_LOCK*/get SCROLL_LOCK() {
>+    return 145;
>+  },
>+  /*html$.KeyCode.FIRST_MEDIA_KEY*/get FIRST_MEDIA_KEY() {
>+    return 166;
>+  },
>+  /*html$.KeyCode.LAST_MEDIA_KEY*/get LAST_MEDIA_KEY() {
>+    return 183;
>+  },
>+  /*html$.KeyCode.SEMICOLON*/get SEMICOLON() {
>+    return 186;
>+  },
>+  /*html$.KeyCode.DASH*/get DASH() {
>+    return 189;
>+  },
>+  /*html$.KeyCode.EQUALS*/get EQUALS() {
>+    return 187;
>+  },
>+  /*html$.KeyCode.COMMA*/get COMMA() {
>+    return 188;
>+  },
>+  /*html$.KeyCode.PERIOD*/get PERIOD() {
>+    return 190;
>+  },
>+  /*html$.KeyCode.SLASH*/get SLASH() {
>+    return 191;
>+  },
>+  /*html$.KeyCode.APOSTROPHE*/get APOSTROPHE() {
>+    return 192;
>+  },
>+  /*html$.KeyCode.TILDE*/get TILDE() {
>+    return 192;
>+  },
>+  /*html$.KeyCode.SINGLE_QUOTE*/get SINGLE_QUOTE() {
>+    return 222;
>+  },
>+  /*html$.KeyCode.OPEN_SQUARE_BRACKET*/get OPEN_SQUARE_BRACKET() {
>+    return 219;
>+  },
>+  /*html$.KeyCode.BACKSLASH*/get BACKSLASH() {
>+    return 220;
>+  },
>+  /*html$.KeyCode.CLOSE_SQUARE_BRACKET*/get CLOSE_SQUARE_BRACKET() {
>+    return 221;
>+  },
>+  /*html$.KeyCode.WIN_KEY*/get WIN_KEY() {
>+    return 224;
>+  },
>+  /*html$.KeyCode.MAC_FF_META*/get MAC_FF_META() {
>+    return 224;
>+  },
>+  /*html$.KeyCode.WIN_IME*/get WIN_IME() {
>+    return 229;
>+  },
>+  /*html$.KeyCode.UNKNOWN*/get UNKNOWN() {
>+    return -1;
>+  }
>+});
>+html$.KeyLocation = class KeyLocation extends core.Object {};
>+(html$.KeyLocation.new = function() {
>+}).prototype = html$.KeyLocation.prototype;
>+dart.addTypeTests(html$.KeyLocation);
>+dart.setLibraryUri(html$.KeyLocation, "dart:html");
>+dart.defineLazy(html$.KeyLocation, {
>+  /*html$.KeyLocation.STANDARD*/get STANDARD() {
>+    return 0;
>+  },
>+  /*html$.KeyLocation.LEFT*/get LEFT() {
>+    return 1;
>+  },
>+  /*html$.KeyLocation.RIGHT*/get RIGHT() {
>+    return 2;
>+  },
>+  /*html$.KeyLocation.NUMPAD*/get NUMPAD() {
>+    return 3;
>+  },
>+  /*html$.KeyLocation.MOBILE*/get MOBILE() {
>+    return 4;
>+  },
>+  /*html$.KeyLocation.JOYSTICK*/get JOYSTICK() {
>+    return 5;
>+  }
>+});
>+html$._KeyName = class _KeyName extends core.Object {};
>+(html$._KeyName.new = function() {
>+}).prototype = html$._KeyName.prototype;
>+dart.addTypeTests(html$._KeyName);
>+dart.setLibraryUri(html$._KeyName, "dart:html");
>+dart.defineLazy(html$._KeyName, {
>+  /*html$._KeyName.ACCEPT*/get ACCEPT() {
>+    return "Accept";
>+  },
>+  /*html$._KeyName.ADD*/get ADD() {
>+    return "Add";
>+  },
>+  /*html$._KeyName.AGAIN*/get AGAIN() {
>+    return "Again";
>+  },
>+  /*html$._KeyName.ALL_CANDIDATES*/get ALL_CANDIDATES() {
>+    return "AllCandidates";
>+  },
>+  /*html$._KeyName.ALPHANUMERIC*/get ALPHANUMERIC() {
>+    return "Alphanumeric";
>+  },
>+  /*html$._KeyName.ALT*/get ALT() {
>+    return "Alt";
>+  },
>+  /*html$._KeyName.ALT_GRAPH*/get ALT_GRAPH() {
>+    return "AltGraph";
>+  },
>+  /*html$._KeyName.APPS*/get APPS() {
>+    return "Apps";
>+  },
>+  /*html$._KeyName.ATTN*/get ATTN() {
>+    return "Attn";
>+  },
>+  /*html$._KeyName.BROWSER_BACK*/get BROWSER_BACK() {
>+    return "BrowserBack";
>+  },
>+  /*html$._KeyName.BROWSER_FAVORTIES*/get BROWSER_FAVORTIES() {
>+    return "BrowserFavorites";
>+  },
>+  /*html$._KeyName.BROWSER_FORWARD*/get BROWSER_FORWARD() {
>+    return "BrowserForward";
>+  },
>+  /*html$._KeyName.BROWSER_NAME*/get BROWSER_NAME() {
>+    return "BrowserHome";
>+  },
>+  /*html$._KeyName.BROWSER_REFRESH*/get BROWSER_REFRESH() {
>+    return "BrowserRefresh";
>+  },
>+  /*html$._KeyName.BROWSER_SEARCH*/get BROWSER_SEARCH() {
>+    return "BrowserSearch";
>+  },
>+  /*html$._KeyName.BROWSER_STOP*/get BROWSER_STOP() {
>+    return "BrowserStop";
>+  },
>+  /*html$._KeyName.CAMERA*/get CAMERA() {
>+    return "Camera";
>+  },
>+  /*html$._KeyName.CAPS_LOCK*/get CAPS_LOCK() {
>+    return "CapsLock";
>+  },
>+  /*html$._KeyName.CLEAR*/get CLEAR() {
>+    return "Clear";
>+  },
>+  /*html$._KeyName.CODE_INPUT*/get CODE_INPUT() {
>+    return "CodeInput";
>+  },
>+  /*html$._KeyName.COMPOSE*/get COMPOSE() {
>+    return "Compose";
>+  },
>+  /*html$._KeyName.CONTROL*/get CONTROL() {
>+    return "Control";
>+  },
>+  /*html$._KeyName.CRSEL*/get CRSEL() {
>+    return "Crsel";
>+  },
>+  /*html$._KeyName.CONVERT*/get CONVERT() {
>+    return "Convert";
>+  },
>+  /*html$._KeyName.COPY*/get COPY() {
>+    return "Copy";
>+  },
>+  /*html$._KeyName.CUT*/get CUT() {
>+    return "Cut";
>+  },
>+  /*html$._KeyName.DECIMAL*/get DECIMAL() {
>+    return "Decimal";
>+  },
>+  /*html$._KeyName.DIVIDE*/get DIVIDE() {
>+    return "Divide";
>+  },
>+  /*html$._KeyName.DOWN*/get DOWN() {
>+    return "Down";
>+  },
>+  /*html$._KeyName.DOWN_LEFT*/get DOWN_LEFT() {
>+    return "DownLeft";
>+  },
>+  /*html$._KeyName.DOWN_RIGHT*/get DOWN_RIGHT() {
>+    return "DownRight";
>+  },
>+  /*html$._KeyName.EJECT*/get EJECT() {
>+    return "Eject";
>+  },
>+  /*html$._KeyName.END*/get END() {
>+    return "End";
>+  },
>+  /*html$._KeyName.ENTER*/get ENTER() {
>+    return "Enter";
>+  },
>+  /*html$._KeyName.ERASE_EOF*/get ERASE_EOF() {
>+    return "EraseEof";
>+  },
>+  /*html$._KeyName.EXECUTE*/get EXECUTE() {
>+    return "Execute";
>+  },
>+  /*html$._KeyName.EXSEL*/get EXSEL() {
>+    return "Exsel";
>+  },
>+  /*html$._KeyName.FN*/get FN() {
>+    return "Fn";
>+  },
>+  /*html$._KeyName.F1*/get F1() {
>+    return "F1";
>+  },
>+  /*html$._KeyName.F2*/get F2() {
>+    return "F2";
>+  },
>+  /*html$._KeyName.F3*/get F3() {
>+    return "F3";
>+  },
>+  /*html$._KeyName.F4*/get F4() {
>+    return "F4";
>+  },
>+  /*html$._KeyName.F5*/get F5() {
>+    return "F5";
>+  },
>+  /*html$._KeyName.F6*/get F6() {
>+    return "F6";
>+  },
>+  /*html$._KeyName.F7*/get F7() {
>+    return "F7";
>+  },
>+  /*html$._KeyName.F8*/get F8() {
>+    return "F8";
>+  },
>+  /*html$._KeyName.F9*/get F9() {
>+    return "F9";
>+  },
>+  /*html$._KeyName.F10*/get F10() {
>+    return "F10";
>+  },
>+  /*html$._KeyName.F11*/get F11() {
>+    return "F11";
>+  },
>+  /*html$._KeyName.F12*/get F12() {
>+    return "F12";
>+  },
>+  /*html$._KeyName.F13*/get F13() {
>+    return "F13";
>+  },
>+  /*html$._KeyName.F14*/get F14() {
>+    return "F14";
>+  },
>+  /*html$._KeyName.F15*/get F15() {
>+    return "F15";
>+  },
>+  /*html$._KeyName.F16*/get F16() {
>+    return "F16";
>+  },
>+  /*html$._KeyName.F17*/get F17() {
>+    return "F17";
>+  },
>+  /*html$._KeyName.F18*/get F18() {
>+    return "F18";
>+  },
>+  /*html$._KeyName.F19*/get F19() {
>+    return "F19";
>+  },
>+  /*html$._KeyName.F20*/get F20() {
>+    return "F20";
>+  },
>+  /*html$._KeyName.F21*/get F21() {
>+    return "F21";
>+  },
>+  /*html$._KeyName.F22*/get F22() {
>+    return "F22";
>+  },
>+  /*html$._KeyName.F23*/get F23() {
>+    return "F23";
>+  },
>+  /*html$._KeyName.F24*/get F24() {
>+    return "F24";
>+  },
>+  /*html$._KeyName.FINAL_MODE*/get FINAL_MODE() {
>+    return "FinalMode";
>+  },
>+  /*html$._KeyName.FIND*/get FIND() {
>+    return "Find";
>+  },
>+  /*html$._KeyName.FULL_WIDTH*/get FULL_WIDTH() {
>+    return "FullWidth";
>+  },
>+  /*html$._KeyName.HALF_WIDTH*/get HALF_WIDTH() {
>+    return "HalfWidth";
>+  },
>+  /*html$._KeyName.HANGUL_MODE*/get HANGUL_MODE() {
>+    return "HangulMode";
>+  },
>+  /*html$._KeyName.HANJA_MODE*/get HANJA_MODE() {
>+    return "HanjaMode";
>+  },
>+  /*html$._KeyName.HELP*/get HELP() {
>+    return "Help";
>+  },
>+  /*html$._KeyName.HIRAGANA*/get HIRAGANA() {
>+    return "Hiragana";
>+  },
>+  /*html$._KeyName.HOME*/get HOME() {
>+    return "Home";
>+  },
>+  /*html$._KeyName.INSERT*/get INSERT() {
>+    return "Insert";
>+  },
>+  /*html$._KeyName.JAPANESE_HIRAGANA*/get JAPANESE_HIRAGANA() {
>+    return "JapaneseHiragana";
>+  },
>+  /*html$._KeyName.JAPANESE_KATAKANA*/get JAPANESE_KATAKANA() {
>+    return "JapaneseKatakana";
>+  },
>+  /*html$._KeyName.JAPANESE_ROMAJI*/get JAPANESE_ROMAJI() {
>+    return "JapaneseRomaji";
>+  },
>+  /*html$._KeyName.JUNJA_MODE*/get JUNJA_MODE() {
>+    return "JunjaMode";
>+  },
>+  /*html$._KeyName.KANA_MODE*/get KANA_MODE() {
>+    return "KanaMode";
>+  },
>+  /*html$._KeyName.KANJI_MODE*/get KANJI_MODE() {
>+    return "KanjiMode";
>+  },
>+  /*html$._KeyName.KATAKANA*/get KATAKANA() {
>+    return "Katakana";
>+  },
>+  /*html$._KeyName.LAUNCH_APPLICATION_1*/get LAUNCH_APPLICATION_1() {
>+    return "LaunchApplication1";
>+  },
>+  /*html$._KeyName.LAUNCH_APPLICATION_2*/get LAUNCH_APPLICATION_2() {
>+    return "LaunchApplication2";
>+  },
>+  /*html$._KeyName.LAUNCH_MAIL*/get LAUNCH_MAIL() {
>+    return "LaunchMail";
>+  },
>+  /*html$._KeyName.LEFT*/get LEFT() {
>+    return "Left";
>+  },
>+  /*html$._KeyName.MENU*/get MENU() {
>+    return "Menu";
>+  },
>+  /*html$._KeyName.META*/get META() {
>+    return "Meta";
>+  },
>+  /*html$._KeyName.MEDIA_NEXT_TRACK*/get MEDIA_NEXT_TRACK() {
>+    return "MediaNextTrack";
>+  },
>+  /*html$._KeyName.MEDIA_PAUSE_PLAY*/get MEDIA_PAUSE_PLAY() {
>+    return "MediaPlayPause";
>+  },
>+  /*html$._KeyName.MEDIA_PREVIOUS_TRACK*/get MEDIA_PREVIOUS_TRACK() {
>+    return "MediaPreviousTrack";
>+  },
>+  /*html$._KeyName.MEDIA_STOP*/get MEDIA_STOP() {
>+    return "MediaStop";
>+  },
>+  /*html$._KeyName.MODE_CHANGE*/get MODE_CHANGE() {
>+    return "ModeChange";
>+  },
>+  /*html$._KeyName.NEXT_CANDIDATE*/get NEXT_CANDIDATE() {
>+    return "NextCandidate";
>+  },
>+  /*html$._KeyName.NON_CONVERT*/get NON_CONVERT() {
>+    return "Nonconvert";
>+  },
>+  /*html$._KeyName.NUM_LOCK*/get NUM_LOCK() {
>+    return "NumLock";
>+  },
>+  /*html$._KeyName.PAGE_DOWN*/get PAGE_DOWN() {
>+    return "PageDown";
>+  },
>+  /*html$._KeyName.PAGE_UP*/get PAGE_UP() {
>+    return "PageUp";
>+  },
>+  /*html$._KeyName.PASTE*/get PASTE() {
>+    return "Paste";
>+  },
>+  /*html$._KeyName.PAUSE*/get PAUSE() {
>+    return "Pause";
>+  },
>+  /*html$._KeyName.PLAY*/get PLAY() {
>+    return "Play";
>+  },
>+  /*html$._KeyName.POWER*/get POWER() {
>+    return "Power";
>+  },
>+  /*html$._KeyName.PREVIOUS_CANDIDATE*/get PREVIOUS_CANDIDATE() {
>+    return "PreviousCandidate";
>+  },
>+  /*html$._KeyName.PRINT_SCREEN*/get PRINT_SCREEN() {
>+    return "PrintScreen";
>+  },
>+  /*html$._KeyName.PROCESS*/get PROCESS() {
>+    return "Process";
>+  },
>+  /*html$._KeyName.PROPS*/get PROPS() {
>+    return "Props";
>+  },
>+  /*html$._KeyName.RIGHT*/get RIGHT() {
>+    return "Right";
>+  },
>+  /*html$._KeyName.ROMAN_CHARACTERS*/get ROMAN_CHARACTERS() {
>+    return "RomanCharacters";
>+  },
>+  /*html$._KeyName.SCROLL*/get SCROLL() {
>+    return "Scroll";
>+  },
>+  /*html$._KeyName.SELECT*/get SELECT() {
>+    return "Select";
>+  },
>+  /*html$._KeyName.SELECT_MEDIA*/get SELECT_MEDIA() {
>+    return "SelectMedia";
>+  },
>+  /*html$._KeyName.SEPARATOR*/get SEPARATOR() {
>+    return "Separator";
>+  },
>+  /*html$._KeyName.SHIFT*/get SHIFT() {
>+    return "Shift";
>+  },
>+  /*html$._KeyName.SOFT_1*/get SOFT_1() {
>+    return "Soft1";
>+  },
>+  /*html$._KeyName.SOFT_2*/get SOFT_2() {
>+    return "Soft2";
>+  },
>+  /*html$._KeyName.SOFT_3*/get SOFT_3() {
>+    return "Soft3";
>+  },
>+  /*html$._KeyName.SOFT_4*/get SOFT_4() {
>+    return "Soft4";
>+  },
>+  /*html$._KeyName.STOP*/get STOP() {
>+    return "Stop";
>+  },
>+  /*html$._KeyName.SUBTRACT*/get SUBTRACT() {
>+    return "Subtract";
>+  },
>+  /*html$._KeyName.SYMBOL_LOCK*/get SYMBOL_LOCK() {
>+    return "SymbolLock";
>+  },
>+  /*html$._KeyName.UP*/get UP() {
>+    return "Up";
>+  },
>+  /*html$._KeyName.UP_LEFT*/get UP_LEFT() {
>+    return "UpLeft";
>+  },
>+  /*html$._KeyName.UP_RIGHT*/get UP_RIGHT() {
>+    return "UpRight";
>+  },
>+  /*html$._KeyName.UNDO*/get UNDO() {
>+    return "Undo";
>+  },
>+  /*html$._KeyName.VOLUME_DOWN*/get VOLUME_DOWN() {
>+    return "VolumeDown";
>+  },
>+  /*html$._KeyName.VOLUMN_MUTE*/get VOLUMN_MUTE() {
>+    return "VolumeMute";
>+  },
>+  /*html$._KeyName.VOLUMN_UP*/get VOLUMN_UP() {
>+    return "VolumeUp";
>+  },
>+  /*html$._KeyName.WIN*/get WIN() {
>+    return "Win";
>+  },
>+  /*html$._KeyName.ZOOM*/get ZOOM() {
>+    return "Zoom";
>+  },
>+  /*html$._KeyName.BACKSPACE*/get BACKSPACE() {
>+    return "Backspace";
>+  },
>+  /*html$._KeyName.TAB*/get TAB() {
>+    return "Tab";
>+  },
>+  /*html$._KeyName.CANCEL*/get CANCEL() {
>+    return "Cancel";
>+  },
>+  /*html$._KeyName.ESC*/get ESC() {
>+    return "Esc";
>+  },
>+  /*html$._KeyName.SPACEBAR*/get SPACEBAR() {
>+    return "Spacebar";
>+  },
>+  /*html$._KeyName.DEL*/get DEL() {
>+    return "Del";
>+  },
>+  /*html$._KeyName.DEAD_GRAVE*/get DEAD_GRAVE() {
>+    return "DeadGrave";
>+  },
>+  /*html$._KeyName.DEAD_EACUTE*/get DEAD_EACUTE() {
>+    return "DeadEacute";
>+  },
>+  /*html$._KeyName.DEAD_CIRCUMFLEX*/get DEAD_CIRCUMFLEX() {
>+    return "DeadCircumflex";
>+  },
>+  /*html$._KeyName.DEAD_TILDE*/get DEAD_TILDE() {
>+    return "DeadTilde";
>+  },
>+  /*html$._KeyName.DEAD_MACRON*/get DEAD_MACRON() {
>+    return "DeadMacron";
>+  },
>+  /*html$._KeyName.DEAD_BREVE*/get DEAD_BREVE() {
>+    return "DeadBreve";
>+  },
>+  /*html$._KeyName.DEAD_ABOVE_DOT*/get DEAD_ABOVE_DOT() {
>+    return "DeadAboveDot";
>+  },
>+  /*html$._KeyName.DEAD_UMLAUT*/get DEAD_UMLAUT() {
>+    return "DeadUmlaut";
>+  },
>+  /*html$._KeyName.DEAD_ABOVE_RING*/get DEAD_ABOVE_RING() {
>+    return "DeadAboveRing";
>+  },
>+  /*html$._KeyName.DEAD_DOUBLEACUTE*/get DEAD_DOUBLEACUTE() {
>+    return "DeadDoubleacute";
>+  },
>+  /*html$._KeyName.DEAD_CARON*/get DEAD_CARON() {
>+    return "DeadCaron";
>+  },
>+  /*html$._KeyName.DEAD_CEDILLA*/get DEAD_CEDILLA() {
>+    return "DeadCedilla";
>+  },
>+  /*html$._KeyName.DEAD_OGONEK*/get DEAD_OGONEK() {
>+    return "DeadOgonek";
>+  },
>+  /*html$._KeyName.DEAD_IOTA*/get DEAD_IOTA() {
>+    return "DeadIota";
>+  },
>+  /*html$._KeyName.DEAD_VOICED_SOUND*/get DEAD_VOICED_SOUND() {
>+    return "DeadVoicedSound";
>+  },
>+  /*html$._KeyName.DEC_SEMIVOICED_SOUND*/get DEC_SEMIVOICED_SOUND() {
>+    return "DeadSemivoicedSound";
>+  },
>+  /*html$._KeyName.UNIDENTIFIED*/get UNIDENTIFIED() {
>+    return "Unidentified";
>+  }
>+});
>+const _stream$0 = dart.privateName(html$, "_stream");
>+const _keyDownList = dart.privateName(html$, "_keyDownList");
>+const _capsLockOn = dart.privateName(html$, "_capsLockOn");
>+const _determineKeyCodeForKeypress = dart.privateName(html$, "_determineKeyCodeForKeypress");
>+const _findCharCodeKeyDown = dart.privateName(html$, "_findCharCodeKeyDown");
>+const _firesKeyPressEvent = dart.privateName(html$, "_firesKeyPressEvent");
>+const _normalizeKeyCodes = dart.privateName(html$, "_normalizeKeyCodes");
>+html$._KeyboardEventHandler = class _KeyboardEventHandler extends html$.EventStreamProvider$(html$.KeyEvent) {
>+  forTarget(e, opts) {
>+    let useCapture = opts && 'useCapture' in opts ? opts.useCapture : false;
>+    let handler = new html$._KeyboardEventHandler.initializeAllEventListeners(this[_type$1], e);
>+    return handler[_stream$0];
>+  }
>+  get [_capsLockOn]() {
>+    return this[_keyDownList][$any](dart.fn(element => element.keyCode === html$.KeyCode.CAPS_LOCK, KeyEventTobool()));
>+  }
>+  [_determineKeyCodeForKeypress](event) {
>+    for (let prevEvent of this[_keyDownList]) {
>+      if (prevEvent[_shadowCharCode] == event.charCode) {
>+        return prevEvent.keyCode;
>+      }
>+      if ((dart.test(event.shiftKey) || dart.test(this[_capsLockOn])) && dart.notNull(event.charCode) >= dart.notNull("A"[$codeUnits][$_get](0)) && dart.notNull(event.charCode) <= dart.notNull("Z"[$codeUnits][$_get](0)) && dart.notNull(event.charCode) + dart.notNull(html$._KeyboardEventHandler._ROMAN_ALPHABET_OFFSET) === prevEvent[_shadowCharCode]) {
>+        return prevEvent.keyCode;
>+      }
>+    }
>+    return html$.KeyCode.UNKNOWN;
>+  }
>+  [_findCharCodeKeyDown](event) {
>+    if (event.location === 3) {
>+      switch (event.keyCode) {
>+        case html$.KeyCode.NUM_ZERO:
>+        {
>+          return html$.KeyCode.ZERO;
>+        }
>+        case html$.KeyCode.NUM_ONE:
>+        {
>+          return html$.KeyCode.ONE;
>+        }
>+        case html$.KeyCode.NUM_TWO:
>+        {
>+          return html$.KeyCode.TWO;
>+        }
>+        case html$.KeyCode.NUM_THREE:
>+        {
>+          return html$.KeyCode.THREE;
>+        }
>+        case html$.KeyCode.NUM_FOUR:
>+        {
>+          return html$.KeyCode.FOUR;
>+        }
>+        case html$.KeyCode.NUM_FIVE:
>+        {
>+          return html$.KeyCode.FIVE;
>+        }
>+        case html$.KeyCode.NUM_SIX:
>+        {
>+          return html$.KeyCode.SIX;
>+        }
>+        case html$.KeyCode.NUM_SEVEN:
>+        {
>+          return html$.KeyCode.SEVEN;
>+        }
>+        case html$.KeyCode.NUM_EIGHT:
>+        {
>+          return html$.KeyCode.EIGHT;
>+        }
>+        case html$.KeyCode.NUM_NINE:
>+        {
>+          return html$.KeyCode.NINE;
>+        }
>+        case html$.KeyCode.NUM_MULTIPLY:
>+        {
>+          return 42;
>+        }
>+        case html$.KeyCode.NUM_PLUS:
>+        {
>+          return 43;
>+        }
>+        case html$.KeyCode.NUM_MINUS:
>+        {
>+          return 45;
>+        }
>+        case html$.KeyCode.NUM_PERIOD:
>+        {
>+          return 46;
>+        }
>+        case html$.KeyCode.NUM_DIVISION:
>+        {
>+          return 47;
>+        }
>+      }
>+    } else if (dart.notNull(event.keyCode) >= 65 && dart.notNull(event.keyCode) <= 90) {
>+      return dart.notNull(event.keyCode) + dart.notNull(html$._KeyboardEventHandler._ROMAN_ALPHABET_OFFSET);
>+    }
>+    switch (event.keyCode) {
>+      case html$.KeyCode.SEMICOLON:
>+      {
>+        return html$.KeyCode.FF_SEMICOLON;
>+      }
>+      case html$.KeyCode.EQUALS:
>+      {
>+        return html$.KeyCode.FF_EQUALS;
>+      }
>+      case html$.KeyCode.COMMA:
>+      {
>+        return 44;
>+      }
>+      case html$.KeyCode.DASH:
>+      {
>+        return 45;
>+      }
>+      case html$.KeyCode.PERIOD:
>+      {
>+        return 46;
>+      }
>+      case html$.KeyCode.SLASH:
>+      {
>+        return 47;
>+      }
>+      case html$.KeyCode.APOSTROPHE:
>+      {
>+        return 96;
>+      }
>+      case html$.KeyCode.OPEN_SQUARE_BRACKET:
>+      {
>+        return 91;
>+      }
>+      case html$.KeyCode.BACKSLASH:
>+      {
>+        return 92;
>+      }
>+      case html$.KeyCode.CLOSE_SQUARE_BRACKET:
>+      {
>+        return 93;
>+      }
>+      case html$.KeyCode.SINGLE_QUOTE:
>+      {
>+        return 39;
>+      }
>+    }
>+    return event.keyCode;
>+  }
>+  [_firesKeyPressEvent](event) {
>+    if (!dart.test(html_common.Device.isIE) && !dart.test(html_common.Device.isWebKit)) {
>+      return true;
>+    }
>+    if (html_common.Device.userAgent[$contains]("Mac") && dart.test(event.altKey)) {
>+      return html$.KeyCode.isCharacterKey(event.keyCode);
>+    }
>+    if (dart.test(event.altKey) && !dart.test(event.ctrlKey)) {
>+      return false;
>+    }
>+    if (!dart.test(event.shiftKey) && (this[_keyDownList][$last].keyCode === html$.KeyCode.CTRL || this[_keyDownList][$last].keyCode === html$.KeyCode.ALT || html_common.Device.userAgent[$contains]("Mac") && this[_keyDownList][$last].keyCode === html$.KeyCode.META)) {
>+      return false;
>+    }
>+    if (dart.test(html_common.Device.isWebKit) && dart.test(event.ctrlKey) && dart.test(event.shiftKey) && (event.keyCode === html$.KeyCode.BACKSLASH || event.keyCode === html$.KeyCode.OPEN_SQUARE_BRACKET || event.keyCode === html$.KeyCode.CLOSE_SQUARE_BRACKET || event.keyCode === html$.KeyCode.TILDE || event.keyCode === html$.KeyCode.SEMICOLON || event.keyCode === html$.KeyCode.DASH || event.keyCode === html$.KeyCode.EQUALS || event.keyCode === html$.KeyCode.COMMA || event.keyCode === html$.KeyCode.PERIOD || event.keyCode === html$.KeyCode.SLASH || event.keyCode === html$.KeyCode.APOSTROPHE || event.keyCode === html$.KeyCode.SINGLE_QUOTE)) {
>+      return false;
>+    }
>+    switch (event.keyCode) {
>+      case html$.KeyCode.ENTER:
>+      {
>+        return !dart.test(html_common.Device.isIE);
>+      }
>+      case html$.KeyCode.ESC:
>+      {
>+        return !dart.test(html_common.Device.isWebKit);
>+      }
>+    }
>+    return html$.KeyCode.isCharacterKey(event.keyCode);
>+  }
>+  [_normalizeKeyCodes](event) {
>+    if (dart.test(html_common.Device.isFirefox)) {
>+      switch (event.keyCode) {
>+        case html$.KeyCode.FF_EQUALS:
>+        {
>+          return html$.KeyCode.EQUALS;
>+        }
>+        case html$.KeyCode.FF_SEMICOLON:
>+        {
>+          return html$.KeyCode.SEMICOLON;
>+        }
>+        case html$.KeyCode.MAC_FF_META:
>+        {
>+          return html$.KeyCode.META;
>+        }
>+        case html$.KeyCode.WIN_KEY_FF_LINUX:
>+        {
>+          return html$.KeyCode.WIN_KEY;
>+        }
>+      }
>+    }
>+    return event.keyCode;
>+  }
>+  processKeyDown(e) {
>+    if (dart.notNull(this[_keyDownList][$length]) > 0 && (this[_keyDownList][$last].keyCode === html$.KeyCode.CTRL && !dart.test(e.ctrlKey) || this[_keyDownList][$last].keyCode === html$.KeyCode.ALT && !dart.test(e.altKey) || html_common.Device.userAgent[$contains]("Mac") && this[_keyDownList][$last].keyCode === html$.KeyCode.META && !dart.test(e.metaKey))) {
>+      this[_keyDownList][$clear]();
>+    }
>+    let event = new html$.KeyEvent.wrap(e);
>+    event[_shadowKeyCode] = this[_normalizeKeyCodes](event);
>+    event[_shadowCharCode] = this[_findCharCodeKeyDown](event);
>+    if (dart.notNull(this[_keyDownList][$length]) > 0 && event.keyCode != this[_keyDownList][$last].keyCode && !dart.test(this[_firesKeyPressEvent](event))) {
>+      this.processKeyPress(e);
>+    }
>+    this[_keyDownList][$add](event);
>+    this[_stream$0].add(event);
>+  }
>+  processKeyPress(event) {
>+    let e = new html$.KeyEvent.wrap(event);
>+    if (dart.test(html_common.Device.isIE)) {
>+      if (e.keyCode === html$.KeyCode.ENTER || e.keyCode === html$.KeyCode.ESC) {
>+        e[_shadowCharCode] = 0;
>+      } else {
>+        e[_shadowCharCode] = e.keyCode;
>+      }
>+    } else if (dart.test(html_common.Device.isOpera)) {
>+      e[_shadowCharCode] = dart.test(html$.KeyCode.isCharacterKey(e.keyCode)) ? e.keyCode : 0;
>+    }
>+    e[_shadowKeyCode] = this[_determineKeyCodeForKeypress](e);
>+    if (e[_shadowKeyIdentifier] != null && dart.test(html$._KeyboardEventHandler._keyIdentifier[$containsKey](e[_shadowKeyIdentifier]))) {
>+      e[_shadowKeyCode] = html$._KeyboardEventHandler._keyIdentifier[$_get](e[_shadowKeyIdentifier]);
>+    }
>+    e[_shadowAltKey] = this[_keyDownList][$any](dart.fn(element => element.altKey, KeyEventTobool()));
>+    this[_stream$0].add(e);
>+  }
>+  processKeyUp(event) {
>+    let e = new html$.KeyEvent.wrap(event);
>+    let toRemove = null;
>+    for (let key of this[_keyDownList]) {
>+      if (key.keyCode == e.keyCode) {
>+        toRemove = key;
>+      }
>+    }
>+    if (toRemove != null) {
>+      this[_keyDownList][$removeWhere](dart.fn(element => dart.equals(element, toRemove), KeyEventTobool()));
>+    } else if (dart.notNull(this[_keyDownList][$length]) > 0) {
>+      this[_keyDownList][$removeLast]();
>+    }
>+    this[_stream$0].add(e);
>+  }
>+};
>+(html$._KeyboardEventHandler.new = function(type) {
>+  this[_keyDownList] = JSArrayOfKeyEvent().of([]);
>+  this[_type$1] = type;
>+  this[_stream$0] = new html$._CustomKeyEventStreamImpl.new("event");
>+  this[_target$0] = null;
>+  html$._KeyboardEventHandler.__proto__.new.call(this, "KeyEvent");
>+}).prototype = html$._KeyboardEventHandler.prototype;
>+(html$._KeyboardEventHandler.initializeAllEventListeners = function(type, target) {
>+  this[_keyDownList] = JSArrayOfKeyEvent().of([]);
>+  this[_stream$0] = null;
>+  this[_type$1] = type;
>+  this[_target$0] = target;
>+  html$._KeyboardEventHandler.__proto__.new.call(this, "KeyEvent");
>+  html$.Element.keyDownEvent.forTarget(this[_target$0], {useCapture: true}).listen(dart.bind(this, 'processKeyDown'));
>+  html$.Element.keyPressEvent.forTarget(this[_target$0], {useCapture: true}).listen(dart.bind(this, 'processKeyPress'));
>+  html$.Element.keyUpEvent.forTarget(this[_target$0], {useCapture: true}).listen(dart.bind(this, 'processKeyUp'));
>+  this[_stream$0] = new html$._CustomKeyEventStreamImpl.new(this[_type$1]);
>+}).prototype = html$._KeyboardEventHandler.prototype;
>+dart.addTypeTests(html$._KeyboardEventHandler);
>+dart.setMethodSignature(html$._KeyboardEventHandler, () => ({
>+  __proto__: dart.getMethods(html$._KeyboardEventHandler.__proto__),
>+  forTarget: dart.fnType(html$.CustomStream$(html$.KeyEvent), [html$.EventTarget], {useCapture: core.bool}),
>+  [_determineKeyCodeForKeypress]: dart.fnType(core.int, [html$.KeyboardEvent]),
>+  [_findCharCodeKeyDown]: dart.fnType(core.int, [html$.KeyboardEvent]),
>+  [_firesKeyPressEvent]: dart.fnType(core.bool, [html$.KeyEvent]),
>+  [_normalizeKeyCodes]: dart.fnType(core.int, [html$.KeyboardEvent]),
>+  processKeyDown: dart.fnType(dart.void, [html$.KeyboardEvent]),
>+  processKeyPress: dart.fnType(dart.void, [html$.KeyboardEvent]),
>+  processKeyUp: dart.fnType(dart.void, [html$.KeyboardEvent])
>+}));
>+dart.setGetterSignature(html$._KeyboardEventHandler, () => ({
>+  __proto__: dart.getGetters(html$._KeyboardEventHandler.__proto__),
>+  [_capsLockOn]: core.bool
>+}));
>+dart.setLibraryUri(html$._KeyboardEventHandler, "dart:html");
>+dart.setFieldSignature(html$._KeyboardEventHandler, () => ({
>+  __proto__: dart.getFields(html$._KeyboardEventHandler.__proto__),
>+  [_keyDownList]: dart.finalFieldType(ListOfKeyEvent()),
>+  [_type$1]: dart.finalFieldType(core.String),
>+  [_target$0]: dart.finalFieldType(html$.EventTarget),
>+  [_stream$0]: dart.fieldType(html$._CustomKeyEventStreamImpl)
>+}));
>+dart.defineLazy(html$._KeyboardEventHandler, {
>+  /*html$._KeyboardEventHandler._ROMAN_ALPHABET_OFFSET*/get _ROMAN_ALPHABET_OFFSET() {
>+    return dart.notNull("a"[$codeUnits][$_get](0)) - dart.notNull("A"[$codeUnits][$_get](0));
>+  },
>+  /*html$._KeyboardEventHandler._EVENT_TYPE*/get _EVENT_TYPE() {
>+    return "KeyEvent";
>+  },
>+  /*html$._KeyboardEventHandler._keyIdentifier*/get _keyIdentifier() {
>+    return dart.constMap(core.String, core.int, ["Up", html$.KeyCode.UP, "Down", html$.KeyCode.DOWN, "Left", html$.KeyCode.LEFT, "Right", html$.KeyCode.RIGHT, "Enter", html$.KeyCode.ENTER, "F1", html$.KeyCode.F1, "F2", html$.KeyCode.F2, "F3", html$.KeyCode.F3, "F4", html$.KeyCode.F4, "F5", html$.KeyCode.F5, "F6", html$.KeyCode.F6, "F7", html$.KeyCode.F7, "F8", html$.KeyCode.F8, "F9", html$.KeyCode.F9, "F10", html$.KeyCode.F10, "F11", html$.KeyCode.F11, "F12", html$.KeyCode.F12, "U+007F", html$.KeyCode.DELETE, "Home", html$.KeyCode.HOME, "End", html$.KeyCode.END, "PageUp", html$.KeyCode.PAGE_UP, "PageDown", html$.KeyCode.PAGE_DOWN, "Insert", html$.KeyCode.INSERT]);
>+  }
>+});
>+html$.KeyboardEventStream = class KeyboardEventStream extends core.Object {
>+  static onKeyPress(target) {
>+    return new html$._KeyboardEventHandler.new("keypress").forTarget(target);
>+  }
>+  static onKeyUp(target) {
>+    return new html$._KeyboardEventHandler.new("keyup").forTarget(target);
>+  }
>+  static onKeyDown(target) {
>+    return new html$._KeyboardEventHandler.new("keydown").forTarget(target);
>+  }
>+};
>+(html$.KeyboardEventStream.new = function() {
>+}).prototype = html$.KeyboardEventStream.prototype;
>+dart.addTypeTests(html$.KeyboardEventStream);
>+dart.setLibraryUri(html$.KeyboardEventStream, "dart:html");
>+const _validators = dart.privateName(html$, "_validators");
>+html$.NodeValidatorBuilder = class NodeValidatorBuilder extends core.Object {
>+  allowNavigation(uriPolicy) {
>+    if (uriPolicy === void 0) uriPolicy = null;
>+    if (uriPolicy == null) {
>+      uriPolicy = html$.UriPolicy.new();
>+    }
>+    this.add(html$._SimpleNodeValidator.allowNavigation(uriPolicy));
>+  }
>+  allowImages(uriPolicy) {
>+    if (uriPolicy === void 0) uriPolicy = null;
>+    if (uriPolicy == null) {
>+      uriPolicy = html$.UriPolicy.new();
>+    }
>+    this.add(html$._SimpleNodeValidator.allowImages(uriPolicy));
>+  }
>+  allowTextElements() {
>+    this.add(html$._SimpleNodeValidator.allowTextElements());
>+  }
>+  allowInlineStyles(opts) {
>+    let tagName = opts && 'tagName' in opts ? opts.tagName : null;
>+    if (tagName == null) {
>+      tagName = "*";
>+    } else {
>+      tagName = tagName[$toUpperCase]();
>+    }
>+    this.add(new html$._SimpleNodeValidator.new(null, {allowedAttributes: JSArrayOfString().of([dart.str(tagName) + "::style"])}));
>+  }
>+  allowHtml5(opts) {
>+    let uriPolicy = opts && 'uriPolicy' in opts ? opts.uriPolicy : null;
>+    this.add(new html$._Html5NodeValidator.new({uriPolicy: uriPolicy}));
>+  }
>+  allowSvg() {
>+    this.add(new html$._SvgNodeValidator.new());
>+  }
>+  allowCustomElement(tagName, opts) {
>+    let uriPolicy = opts && 'uriPolicy' in opts ? opts.uriPolicy : null;
>+    let attributes = opts && 'attributes' in opts ? opts.attributes : null;
>+    let uriAttributes = opts && 'uriAttributes' in opts ? opts.uriAttributes : null;
>+    let tagNameUpper = tagName[$toUpperCase]();
>+    let attrs = IterableOfString()._check(attributes == null ? null : attributes[$map](core.String, dart.fn(name => tagNameUpper + "::" + name[$toLowerCase](), StringToString())));
>+    let uriAttrs = IterableOfString()._check(uriAttributes == null ? null : uriAttributes[$map](core.String, dart.fn(name => tagNameUpper + "::" + name[$toLowerCase](), StringToString())));
>+    if (uriPolicy == null) {
>+      uriPolicy = html$.UriPolicy.new();
>+    }
>+    this.add(new html$._CustomElementNodeValidator.new(uriPolicy, JSArrayOfString().of([tagNameUpper]), attrs, uriAttrs, false, true));
>+  }
>+  allowTagExtension(tagName, baseName, opts) {
>+    let uriPolicy = opts && 'uriPolicy' in opts ? opts.uriPolicy : null;
>+    let attributes = opts && 'attributes' in opts ? opts.attributes : null;
>+    let uriAttributes = opts && 'uriAttributes' in opts ? opts.uriAttributes : null;
>+    let baseNameUpper = baseName[$toUpperCase]();
>+    let tagNameUpper = tagName[$toUpperCase]();
>+    let attrs = IterableOfString()._check(attributes == null ? null : attributes[$map](core.String, dart.fn(name => baseNameUpper + "::" + name[$toLowerCase](), StringToString())));
>+    let uriAttrs = IterableOfString()._check(uriAttributes == null ? null : uriAttributes[$map](core.String, dart.fn(name => baseNameUpper + "::" + name[$toLowerCase](), StringToString())));
>+    if (uriPolicy == null) {
>+      uriPolicy = html$.UriPolicy.new();
>+    }
>+    this.add(new html$._CustomElementNodeValidator.new(uriPolicy, JSArrayOfString().of([tagNameUpper, baseNameUpper]), attrs, uriAttrs, true, false));
>+  }
>+  allowElement(tagName, opts) {
>+    let uriPolicy = opts && 'uriPolicy' in opts ? opts.uriPolicy : null;
>+    let attributes = opts && 'attributes' in opts ? opts.attributes : null;
>+    let uriAttributes = opts && 'uriAttributes' in opts ? opts.uriAttributes : null;
>+    this.allowCustomElement(tagName, {uriPolicy: uriPolicy, attributes: attributes, uriAttributes: uriAttributes});
>+  }
>+  allowTemplating() {
>+    this.add(new html$._TemplatingNodeValidator.new());
>+  }
>+  add(validator) {
>+    this[_validators][$add](validator);
>+  }
>+  allowsElement(element) {
>+    return this[_validators][$any](dart.fn(v => v.allowsElement(element), NodeValidatorTobool()));
>+  }
>+  allowsAttribute(element, attributeName, value) {
>+    return this[_validators][$any](dart.fn(v => v.allowsAttribute(element, attributeName, value), NodeValidatorTobool()));
>+  }
>+};
>+(html$.NodeValidatorBuilder.new = function() {
>+  this[_validators] = JSArrayOfNodeValidator().of([]);
>+}).prototype = html$.NodeValidatorBuilder.prototype;
>+(html$.NodeValidatorBuilder.common = function() {
>+  this[_validators] = JSArrayOfNodeValidator().of([]);
>+  this.allowHtml5();
>+  this.allowTemplating();
>+}).prototype = html$.NodeValidatorBuilder.prototype;
>+dart.addTypeTests(html$.NodeValidatorBuilder);
>+html$.NodeValidatorBuilder[dart.implements] = () => [html$.NodeValidator];
>+dart.setMethodSignature(html$.NodeValidatorBuilder, () => ({
>+  __proto__: dart.getMethods(html$.NodeValidatorBuilder.__proto__),
>+  allowNavigation: dart.fnType(dart.void, [], [html$.UriPolicy]),
>+  allowImages: dart.fnType(dart.void, [], [html$.UriPolicy]),
>+  allowTextElements: dart.fnType(dart.void, []),
>+  allowInlineStyles: dart.fnType(dart.void, [], {tagName: core.String}),
>+  allowHtml5: dart.fnType(dart.void, [], {uriPolicy: html$.UriPolicy}),
>+  allowSvg: dart.fnType(dart.void, []),
>+  allowCustomElement: dart.fnType(dart.void, [core.String], {uriPolicy: html$.UriPolicy, attributes: core.Iterable$(core.String), uriAttributes: core.Iterable$(core.String)}),
>+  allowTagExtension: dart.fnType(dart.void, [core.String, core.String], {uriPolicy: html$.UriPolicy, attributes: core.Iterable$(core.String), uriAttributes: core.Iterable$(core.String)}),
>+  allowElement: dart.fnType(dart.void, [core.String], {uriPolicy: html$.UriPolicy, attributes: core.Iterable$(core.String), uriAttributes: core.Iterable$(core.String)}),
>+  allowTemplating: dart.fnType(dart.void, []),
>+  add: dart.fnType(dart.void, [html$.NodeValidator]),
>+  allowsElement: dart.fnType(core.bool, [html$.Element]),
>+  allowsAttribute: dart.fnType(core.bool, [html$.Element, core.String, core.String])
>+}));
>+dart.setLibraryUri(html$.NodeValidatorBuilder, "dart:html");
>+dart.setFieldSignature(html$.NodeValidatorBuilder, () => ({
>+  __proto__: dart.getFields(html$.NodeValidatorBuilder.__proto__),
>+  [_validators]: dart.finalFieldType(ListOfNodeValidator())
>+}));
>+let const$79;
>+let const$80;
>+let const$81;
>+let const$82;
>+let const$83;
>+let const$84;
>+let const$85;
>+let const$86;
>+let const$87;
>+let const$88;
>+html$._SimpleNodeValidator = class _SimpleNodeValidator extends core.Object {
>+  static allowNavigation(uriPolicy) {
>+    return new html$._SimpleNodeValidator.new(uriPolicy, {allowedElements: const$82 || (const$82 = dart.constList(["A", "FORM"], core.String)), allowedAttributes: const$83 || (const$83 = dart.constList(["A::accesskey", "A::coords", "A::hreflang", "A::name", "A::shape", "A::tabindex", "A::target", "A::type", "FORM::accept", "FORM::autocomplete", "FORM::enctype", "FORM::method", "FORM::name", "FORM::novalidate", "FORM::target"], core.String)), allowedUriAttributes: const$84 || (const$84 = dart.constList(["A::href", "FORM::action"], core.String))});
>+  }
>+  static allowImages(uriPolicy) {
>+    return new html$._SimpleNodeValidator.new(uriPolicy, {allowedElements: const$85 || (const$85 = dart.constList(["IMG"], core.String)), allowedAttributes: const$86 || (const$86 = dart.constList(["IMG::align", "IMG::alt", "IMG::border", "IMG::height", "IMG::hspace", "IMG::ismap", "IMG::name", "IMG::usemap", "IMG::vspace", "IMG::width"], core.String)), allowedUriAttributes: const$87 || (const$87 = dart.constList(["IMG::src"], core.String))});
>+  }
>+  static allowTextElements() {
>+    return new html$._SimpleNodeValidator.new(null, {allowedElements: const$88 || (const$88 = dart.constList(["B", "BLOCKQUOTE", "BR", "EM", "H1", "H2", "H3", "H4", "H5", "H6", "HR", "I", "LI", "OL", "P", "SPAN", "UL"], core.String))});
>+  }
>+  allowsElement(element) {
>+    return this.allowedElements.contains(html$.Element._safeTagName(element));
>+  }
>+  allowsAttribute(element, attributeName, value) {
>+    let tagName = html$.Element._safeTagName(element);
>+    if (dart.test(this.allowedUriAttributes.contains(dart.str(tagName) + "::" + dart.str(attributeName)))) {
>+      return this.uriPolicy.allowsUri(value);
>+    } else if (dart.test(this.allowedUriAttributes.contains("*::" + dart.str(attributeName)))) {
>+      return this.uriPolicy.allowsUri(value);
>+    } else if (dart.test(this.allowedAttributes.contains(dart.str(tagName) + "::" + dart.str(attributeName)))) {
>+      return true;
>+    } else if (dart.test(this.allowedAttributes.contains("*::" + dart.str(attributeName)))) {
>+      return true;
>+    } else if (dart.test(this.allowedAttributes.contains(dart.str(tagName) + "::*"))) {
>+      return true;
>+    } else if (dart.test(this.allowedAttributes.contains("*::*"))) {
>+      return true;
>+    }
>+    return false;
>+  }
>+};
>+(html$._SimpleNodeValidator.new = function(uriPolicy, opts) {
>+  let allowedElements = opts && 'allowedElements' in opts ? opts.allowedElements : null;
>+  let allowedAttributes = opts && 'allowedAttributes' in opts ? opts.allowedAttributes : null;
>+  let allowedUriAttributes = opts && 'allowedUriAttributes' in opts ? opts.allowedUriAttributes : null;
>+  this.allowedElements = new (_IdentityHashSetOfString()).new();
>+  this.allowedAttributes = new (_IdentityHashSetOfString()).new();
>+  this.allowedUriAttributes = new (_IdentityHashSetOfString()).new();
>+  this.uriPolicy = uriPolicy;
>+  this.allowedElements.addAll(allowedElements != null ? allowedElements : const$79 || (const$79 = dart.constList([], core.String)));
>+  allowedAttributes = allowedAttributes != null ? allowedAttributes : const$80 || (const$80 = dart.constList([], core.String));
>+  allowedUriAttributes = allowedUriAttributes != null ? allowedUriAttributes : const$81 || (const$81 = dart.constList([], core.String));
>+  let legalAttributes = allowedAttributes[$where](dart.fn(x => !dart.test(html$._Html5NodeValidator._uriAttributes[$contains](x)), StringTobool()));
>+  let extraUriAttributes = allowedAttributes[$where](dart.fn(x => html$._Html5NodeValidator._uriAttributes[$contains](x), StringTobool()));
>+  this.allowedAttributes.addAll(legalAttributes);
>+  this.allowedUriAttributes.addAll(allowedUriAttributes);
>+  this.allowedUriAttributes.addAll(extraUriAttributes);
>+}).prototype = html$._SimpleNodeValidator.prototype;
>+dart.addTypeTests(html$._SimpleNodeValidator);
>+html$._SimpleNodeValidator[dart.implements] = () => [html$.NodeValidator];
>+dart.setMethodSignature(html$._SimpleNodeValidator, () => ({
>+  __proto__: dart.getMethods(html$._SimpleNodeValidator.__proto__),
>+  allowsElement: dart.fnType(core.bool, [html$.Element]),
>+  allowsAttribute: dart.fnType(core.bool, [html$.Element, core.String, core.String])
>+}));
>+dart.setLibraryUri(html$._SimpleNodeValidator, "dart:html");
>+dart.setFieldSignature(html$._SimpleNodeValidator, () => ({
>+  __proto__: dart.getFields(html$._SimpleNodeValidator.__proto__),
>+  allowedElements: dart.finalFieldType(SetOfString()),
>+  allowedAttributes: dart.finalFieldType(SetOfString()),
>+  allowedUriAttributes: dart.finalFieldType(SetOfString()),
>+  uriPolicy: dart.finalFieldType(html$.UriPolicy)
>+}));
>+html$._CustomElementNodeValidator = class _CustomElementNodeValidator extends html$._SimpleNodeValidator {
>+  allowsElement(element) {
>+    if (dart.test(this.allowTypeExtension)) {
>+      let isAttr = element[$attributes][$_get]("is");
>+      if (isAttr != null) {
>+        return dart.test(this.allowedElements.contains(isAttr[$toUpperCase]())) && dart.test(this.allowedElements.contains(html$.Element._safeTagName(element)));
>+      }
>+    }
>+    return dart.test(this.allowCustomTag) && dart.test(this.allowedElements.contains(html$.Element._safeTagName(element)));
>+  }
>+  allowsAttribute(element, attributeName, value) {
>+    if (dart.test(this.allowsElement(element))) {
>+      if (dart.test(this.allowTypeExtension) && attributeName === "is" && dart.test(this.allowedElements.contains(value[$toUpperCase]()))) {
>+        return true;
>+      }
>+      return super.allowsAttribute(element, attributeName, value);
>+    }
>+    return false;
>+  }
>+};
>+(html$._CustomElementNodeValidator.new = function(uriPolicy, allowedElements, allowedAttributes, allowedUriAttributes, allowTypeExtension, allowCustomTag) {
>+  this.allowTypeExtension = allowTypeExtension === true;
>+  this.allowCustomTag = allowCustomTag === true;
>+  html$._CustomElementNodeValidator.__proto__.new.call(this, uriPolicy, {allowedElements: allowedElements, allowedAttributes: allowedAttributes, allowedUriAttributes: allowedUriAttributes});
>+}).prototype = html$._CustomElementNodeValidator.prototype;
>+dart.addTypeTests(html$._CustomElementNodeValidator);
>+dart.setLibraryUri(html$._CustomElementNodeValidator, "dart:html");
>+dart.setFieldSignature(html$._CustomElementNodeValidator, () => ({
>+  __proto__: dart.getFields(html$._CustomElementNodeValidator.__proto__),
>+  allowTypeExtension: dart.finalFieldType(core.bool),
>+  allowCustomTag: dart.finalFieldType(core.bool)
>+}));
>+const _templateAttrs = dart.privateName(html$, "_templateAttrs");
>+html$._TemplatingNodeValidator = class _TemplatingNodeValidator extends html$._SimpleNodeValidator {
>+  allowsAttribute(element, attributeName, value) {
>+    if (dart.test(super.allowsAttribute(element, attributeName, value))) {
>+      return true;
>+    }
>+    if (attributeName === "template" && value === "") {
>+      return true;
>+    }
>+    if (element[$attributes][$_get]("template") === "") {
>+      return this[_templateAttrs].contains(attributeName);
>+    }
>+    return false;
>+  }
>+};
>+(html$._TemplatingNodeValidator.new = function() {
>+  this[_templateAttrs] = SetOfString().from(html$._TemplatingNodeValidator._TEMPLATE_ATTRS);
>+  html$._TemplatingNodeValidator.__proto__.new.call(this, null, {allowedElements: JSArrayOfString().of(["TEMPLATE"]), allowedAttributes: IterableOfString()._check(html$._TemplatingNodeValidator._TEMPLATE_ATTRS[$map](core.String, dart.fn(attr => "TEMPLATE::" + dart.str(attr), StringToString())))});
>+}).prototype = html$._TemplatingNodeValidator.prototype;
>+dart.addTypeTests(html$._TemplatingNodeValidator);
>+dart.setLibraryUri(html$._TemplatingNodeValidator, "dart:html");
>+dart.setFieldSignature(html$._TemplatingNodeValidator, () => ({
>+  __proto__: dart.getFields(html$._TemplatingNodeValidator.__proto__),
>+  [_templateAttrs]: dart.finalFieldType(SetOfString())
>+}));
>+dart.defineLazy(html$._TemplatingNodeValidator, {
>+  /*html$._TemplatingNodeValidator._TEMPLATE_ATTRS*/get _TEMPLATE_ATTRS() {
>+    return dart.constList(["bind", "if", "ref", "repeat", "syntax"], core.String);
>+  }
>+});
>+html$._SvgNodeValidator = class _SvgNodeValidator extends core.Object {
>+  allowsElement(element) {
>+    if (svg$.ScriptElement.is(element)) {
>+      return false;
>+    }
>+    if (svg$.SvgElement.is(element) && html$.Element._safeTagName(element) === "foreignObject") {
>+      return false;
>+    }
>+    if (svg$.SvgElement.is(element)) {
>+      return true;
>+    }
>+    return false;
>+  }
>+  allowsAttribute(element, attributeName, value) {
>+    if (attributeName === "is" || attributeName[$startsWith]("on")) {
>+      return false;
>+    }
>+    return this.allowsElement(element);
>+  }
>+};
>+(html$._SvgNodeValidator.new = function() {
>+}).prototype = html$._SvgNodeValidator.prototype;
>+dart.addTypeTests(html$._SvgNodeValidator);
>+html$._SvgNodeValidator[dart.implements] = () => [html$.NodeValidator];
>+dart.setMethodSignature(html$._SvgNodeValidator, () => ({
>+  __proto__: dart.getMethods(html$._SvgNodeValidator.__proto__),
>+  allowsElement: dart.fnType(core.bool, [html$.Element]),
>+  allowsAttribute: dart.fnType(core.bool, [html$.Element, core.String, core.String])
>+}));
>+dart.setLibraryUri(html$._SvgNodeValidator, "dart:html");
>+html$.ReadyState = class ReadyState extends core.Object {};
>+(html$.ReadyState.new = function() {
>+}).prototype = html$.ReadyState.prototype;
>+dart.addTypeTests(html$.ReadyState);
>+dart.setLibraryUri(html$.ReadyState, "dart:html");
>+dart.defineLazy(html$.ReadyState, {
>+  /*html$.ReadyState.LOADING*/get LOADING() {
>+    return "loading";
>+  },
>+  /*html$.ReadyState.INTERACTIVE*/get INTERACTIVE() {
>+    return "interactive";
>+  },
>+  /*html$.ReadyState.COMPLETE*/get COMPLETE() {
>+    return "complete";
>+  }
>+});
>+const _list$1 = dart.privateName(html$, "_list");
>+const _is__WrappedList_default = Symbol('_is__WrappedList_default');
>+html$._WrappedList$ = dart.generic(E => {
>+  let _WrappedIteratorOfE = () => (_WrappedIteratorOfE = dart.constFn(html$._WrappedIterator$(E)))();
>+  let IterableOfE = () => (IterableOfE = dart.constFn(core.Iterable$(E)))();
>+  class _WrappedList extends collection.ListBase$(E) {
>+    get iterator() {
>+      return new (_WrappedIteratorOfE()).new(this[_list$1][$iterator]);
>+    }
>+    get length() {
>+      return this[_list$1][$length];
>+    }
>+    add(element) {
>+      E._check(element);
>+      this[_list$1][$add](element);
>+    }
>+    remove(element) {
>+      return this[_list$1][$remove](element);
>+    }
>+    clear() {
>+      this[_list$1][$clear]();
>+    }
>+    _get(index) {
>+      return E._check(this[_list$1][$_get](index));
>+    }
>+    _set(index, value) {
>+      E._check(value);
>+      this[_list$1][$_set](index, value);
>+      return value;
>+    }
>+    set length(newLength) {
>+      this[_list$1][$length] = newLength;
>+    }
>+    sort(compare) {
>+      if (compare === void 0) compare = null;
>+      this[_list$1][$sort](dart.fn((a, b) => compare(E._check(a), E._check(b)), NodeAndNodeToint()));
>+    }
>+    indexOf(element, start) {
>+      if (start === void 0) start = 0;
>+      return this[_list$1][$indexOf](html$.Node._check(element), start);
>+    }
>+    lastIndexOf(element, start) {
>+      if (start === void 0) start = null;
>+      return this[_list$1][$lastIndexOf](html$.Node._check(element), start);
>+    }
>+    insert(index, element) {
>+      E._check(element);
>+      return this[_list$1][$insert](index, element);
>+    }
>+    removeAt(index) {
>+      return E._check(this[_list$1][$removeAt](index));
>+    }
>+    setRange(start, end, iterable, skipCount) {
>+      IterableOfE()._check(iterable);
>+      if (skipCount === void 0) skipCount = 0;
>+      this[_list$1][$setRange](start, end, iterable, skipCount);
>+    }
>+    removeRange(start, end) {
>+      this[_list$1][$removeRange](start, end);
>+    }
>+    replaceRange(start, end, iterable) {
>+      IterableOfE()._check(iterable);
>+      this[_list$1][$replaceRange](start, end, iterable);
>+    }
>+    fillRange(start, end, fillValue) {
>+      if (fillValue === void 0) fillValue = null;
>+      E._check(fillValue);
>+      this[_list$1][$fillRange](start, end, fillValue);
>+    }
>+    get rawList() {
>+      return this[_list$1];
>+    }
>+  }
>+  (_WrappedList.new = function(list) {
>+    this[_list$1] = list;
>+  }).prototype = _WrappedList.prototype;
>+  dart.addTypeTests(_WrappedList);
>+  _WrappedList.prototype[_is__WrappedList_default] = true;
>+  _WrappedList[dart.implements] = () => [html_common.NodeListWrapper];
>+  dart.setMethodSignature(_WrappedList, () => ({
>+    __proto__: dart.getMethods(_WrappedList.__proto__),
>+    add: dart.fnType(dart.void, [core.Object]),
>+    [$add]: dart.fnType(dart.void, [core.Object]),
>+    _get: dart.fnType(E, [core.int]),
>+    [$_get]: dart.fnType(E, [core.int]),
>+    _set: dart.fnType(dart.void, [core.int, core.Object]),
>+    [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+    insert: dart.fnType(dart.void, [core.int, core.Object]),
>+    [$insert]: dart.fnType(dart.void, [core.int, core.Object]),
>+    setRange: dart.fnType(dart.void, [core.int, core.int, core.Object], [core.int]),
>+    [$setRange]: dart.fnType(dart.void, [core.int, core.int, core.Object], [core.int]),
>+    replaceRange: dart.fnType(dart.void, [core.int, core.int, core.Object]),
>+    [$replaceRange]: dart.fnType(dart.void, [core.int, core.int, core.Object]),
>+    fillRange: dart.fnType(dart.void, [core.int, core.int], [core.Object]),
>+    [$fillRange]: dart.fnType(dart.void, [core.int, core.int], [core.Object])
>+  }));
>+  dart.setGetterSignature(_WrappedList, () => ({
>+    __proto__: dart.getGetters(_WrappedList.__proto__),
>+    length: core.int,
>+    [$length]: core.int,
>+    rawList: core.List$(html$.Node)
>+  }));
>+  dart.setSetterSignature(_WrappedList, () => ({
>+    __proto__: dart.getSetters(_WrappedList.__proto__),
>+    length: core.int,
>+    [$length]: core.int
>+  }));
>+  dart.setLibraryUri(_WrappedList, "dart:html");
>+  dart.setFieldSignature(_WrappedList, () => ({
>+    __proto__: dart.getFields(_WrappedList.__proto__),
>+    [_list$1]: dart.finalFieldType(ListOfNode())
>+  }));
>+  dart.defineExtensionMethods(_WrappedList, [
>+    'add',
>+    'remove',
>+    'clear',
>+    '_get',
>+    '_set',
>+    'sort',
>+    'indexOf',
>+    'lastIndexOf',
>+    'insert',
>+    'removeAt',
>+    'setRange',
>+    'removeRange',
>+    'replaceRange',
>+    'fillRange'
>+  ]);
>+  dart.defineExtensionAccessors(_WrappedList, ['iterator', 'length']);
>+  return _WrappedList;
>+});
>+html$._WrappedList = html$._WrappedList$();
>+dart.addTypeTests(html$._WrappedList, _is__WrappedList_default);
>+const _iterator$1 = dart.privateName(html$, "_iterator");
>+const _is__WrappedIterator_default = Symbol('_is__WrappedIterator_default');
>+html$._WrappedIterator$ = dart.generic(E => {
>+  let IteratorOfE = () => (IteratorOfE = dart.constFn(core.Iterator$(E)))();
>+  class _WrappedIterator extends core.Object {
>+    moveNext() {
>+      return this[_iterator$1].moveNext();
>+    }
>+    get current() {
>+      return E._check(this[_iterator$1].current);
>+    }
>+  }
>+  (_WrappedIterator.new = function(iterator) {
>+    this[_iterator$1] = iterator;
>+  }).prototype = _WrappedIterator.prototype;
>+  dart.addTypeTests(_WrappedIterator);
>+  _WrappedIterator.prototype[_is__WrappedIterator_default] = true;
>+  _WrappedIterator[dart.implements] = () => [IteratorOfE()];
>+  dart.setMethodSignature(_WrappedIterator, () => ({
>+    __proto__: dart.getMethods(_WrappedIterator.__proto__),
>+    moveNext: dart.fnType(core.bool, [])
>+  }));
>+  dart.setGetterSignature(_WrappedIterator, () => ({
>+    __proto__: dart.getGetters(_WrappedIterator.__proto__),
>+    current: E
>+  }));
>+  dart.setLibraryUri(_WrappedIterator, "dart:html");
>+  dart.setFieldSignature(_WrappedIterator, () => ({
>+    __proto__: dart.getFields(_WrappedIterator.__proto__),
>+    [_iterator$1]: dart.fieldType(IteratorOfNode())
>+  }));
>+  return _WrappedIterator;
>+});
>+html$._WrappedIterator = html$._WrappedIterator$();
>+dart.addTypeTests(html$._WrappedIterator, _is__WrappedIterator_default);
>+html$._HttpRequestUtils = class _HttpRequestUtils extends core.Object {
>+  static get(url, onComplete, withCredentials) {
>+    let request = html$.HttpRequest.new();
>+    request.open("GET", url, {async: true});
>+    request.withCredentials = withCredentials;
>+    request[$onReadyStateChange].listen(dart.fn(e => {
>+      if (request.readyState === html$.HttpRequest.DONE) {
>+        onComplete(request);
>+      }
>+    }, EventToNull()));
>+    request.send();
>+    return request;
>+  }
>+};
>+(html$._HttpRequestUtils.new = function() {
>+}).prototype = html$._HttpRequestUtils.prototype;
>+dart.addTypeTests(html$._HttpRequestUtils);
>+dart.setLibraryUri(html$._HttpRequestUtils, "dart:html");
>+const _array = dart.privateName(html$, "_array");
>+const _current$2 = dart.privateName(html$, "_current");
>+const _is_FixedSizeListIterator_default = Symbol('_is_FixedSizeListIterator_default');
>+html$.FixedSizeListIterator$ = dart.generic(T => {
>+  let IteratorOfT = () => (IteratorOfT = dart.constFn(core.Iterator$(T)))();
>+  let ListOfT = () => (ListOfT = dart.constFn(core.List$(T)))();
>+  class FixedSizeListIterator extends core.Object {
>+    moveNext() {
>+      let nextPosition = dart.notNull(this[_position$1]) + 1;
>+      if (nextPosition < dart.notNull(this[_length$2])) {
>+        this[_current$2] = this[_array][$_get](nextPosition);
>+        this[_position$1] = nextPosition;
>+        return true;
>+      }
>+      this[_current$2] = null;
>+      this[_position$1] = this[_length$2];
>+      return false;
>+    }
>+    get current() {
>+      return this[_current$2];
>+    }
>+  }
>+  (FixedSizeListIterator.new = function(array) {
>+    this[_current$2] = null;
>+    this[_array] = array;
>+    this[_position$1] = -1;
>+    this[_length$2] = array[$length];
>+  }).prototype = FixedSizeListIterator.prototype;
>+  dart.addTypeTests(FixedSizeListIterator);
>+  FixedSizeListIterator.prototype[_is_FixedSizeListIterator_default] = true;
>+  FixedSizeListIterator[dart.implements] = () => [IteratorOfT()];
>+  dart.setMethodSignature(FixedSizeListIterator, () => ({
>+    __proto__: dart.getMethods(FixedSizeListIterator.__proto__),
>+    moveNext: dart.fnType(core.bool, [])
>+  }));
>+  dart.setGetterSignature(FixedSizeListIterator, () => ({
>+    __proto__: dart.getGetters(FixedSizeListIterator.__proto__),
>+    current: T
>+  }));
>+  dart.setLibraryUri(FixedSizeListIterator, "dart:html");
>+  dart.setFieldSignature(FixedSizeListIterator, () => ({
>+    __proto__: dart.getFields(FixedSizeListIterator.__proto__),
>+    [_array]: dart.finalFieldType(ListOfT()),
>+    [_length$2]: dart.finalFieldType(core.int),
>+    [_position$1]: dart.fieldType(core.int),
>+    [_current$2]: dart.fieldType(T)
>+  }));
>+  return FixedSizeListIterator;
>+});
>+html$.FixedSizeListIterator = html$.FixedSizeListIterator$();
>+dart.addTypeTests(html$.FixedSizeListIterator, _is_FixedSizeListIterator_default);
>+const _is__VariableSizeListIterator_default = Symbol('_is__VariableSizeListIterator_default');
>+html$._VariableSizeListIterator$ = dart.generic(T => {
>+  let IteratorOfT = () => (IteratorOfT = dart.constFn(core.Iterator$(T)))();
>+  let ListOfT = () => (ListOfT = dart.constFn(core.List$(T)))();
>+  class _VariableSizeListIterator extends core.Object {
>+    moveNext() {
>+      let nextPosition = dart.notNull(this[_position$1]) + 1;
>+      if (nextPosition < dart.notNull(this[_array][$length])) {
>+        this[_current$2] = this[_array][$_get](nextPosition);
>+        this[_position$1] = nextPosition;
>+        return true;
>+      }
>+      this[_current$2] = null;
>+      this[_position$1] = this[_array][$length];
>+      return false;
>+    }
>+    get current() {
>+      return this[_current$2];
>+    }
>+  }
>+  (_VariableSizeListIterator.new = function(array) {
>+    this[_current$2] = null;
>+    this[_array] = array;
>+    this[_position$1] = -1;
>+  }).prototype = _VariableSizeListIterator.prototype;
>+  dart.addTypeTests(_VariableSizeListIterator);
>+  _VariableSizeListIterator.prototype[_is__VariableSizeListIterator_default] = true;
>+  _VariableSizeListIterator[dart.implements] = () => [IteratorOfT()];
>+  dart.setMethodSignature(_VariableSizeListIterator, () => ({
>+    __proto__: dart.getMethods(_VariableSizeListIterator.__proto__),
>+    moveNext: dart.fnType(core.bool, [])
>+  }));
>+  dart.setGetterSignature(_VariableSizeListIterator, () => ({
>+    __proto__: dart.getGetters(_VariableSizeListIterator.__proto__),
>+    current: T
>+  }));
>+  dart.setLibraryUri(_VariableSizeListIterator, "dart:html");
>+  dart.setFieldSignature(_VariableSizeListIterator, () => ({
>+    __proto__: dart.getFields(_VariableSizeListIterator.__proto__),
>+    [_array]: dart.finalFieldType(ListOfT()),
>+    [_position$1]: dart.fieldType(core.int),
>+    [_current$2]: dart.fieldType(T)
>+  }));
>+  return _VariableSizeListIterator;
>+});
>+html$._VariableSizeListIterator = html$._VariableSizeListIterator$();
>+dart.addTypeTests(html$._VariableSizeListIterator, _is__VariableSizeListIterator_default);
>+const _isConsoleDefined = dart.privateName(html$, "_isConsoleDefined");
>+html$.Console = class Console extends core.Object {
>+  get [_isConsoleDefined]() {
>+    return typeof console != "undefined";
>+  }
>+  get memory() {
>+    return dart.test(this[_isConsoleDefined]) ? window.console.memory : null;
>+  }
>+  assertCondition(condition, arg) {
>+    return dart.test(this[_isConsoleDefined]) ? window.console.assertCondition(condition, arg) : null;
>+  }
>+  clear(arg) {
>+    return dart.test(this[_isConsoleDefined]) ? window.console.clear(arg) : null;
>+  }
>+  count(arg) {
>+    return dart.test(this[_isConsoleDefined]) ? window.console.count(arg) : null;
>+  }
>+  debug(arg) {
>+    return dart.test(this[_isConsoleDefined]) ? window.console.debug(arg) : null;
>+  }
>+  dir(arg) {
>+    return dart.test(this[_isConsoleDefined]) ? window.console.dir(arg) : null;
>+  }
>+  dirxml(arg) {
>+    return dart.test(this[_isConsoleDefined]) ? window.console.dirxml(arg) : null;
>+  }
>+  error(arg) {
>+    return dart.test(this[_isConsoleDefined]) ? window.console.error(arg) : null;
>+  }
>+  group(arg) {
>+    return dart.test(this[_isConsoleDefined]) ? window.console.group(arg) : null;
>+  }
>+  groupCollapsed(arg) {
>+    return dart.test(this[_isConsoleDefined]) ? window.console.groupCollapsed(arg) : null;
>+  }
>+  groupEnd() {
>+    return dart.test(this[_isConsoleDefined]) ? window.console.groupEnd() : null;
>+  }
>+  info(arg) {
>+    return dart.test(this[_isConsoleDefined]) ? window.console.info(arg) : null;
>+  }
>+  log(arg) {
>+    return dart.test(this[_isConsoleDefined]) ? window.console.log(arg) : null;
>+  }
>+  markTimeline(arg) {
>+    return dart.test(this[_isConsoleDefined]) ? window.console.markTimeline(arg) : null;
>+  }
>+  profile(title) {
>+    return dart.test(this[_isConsoleDefined]) ? window.console.profile(title) : null;
>+  }
>+  profileEnd(title) {
>+    return dart.test(this[_isConsoleDefined]) ? window.console.profileEnd(title) : null;
>+  }
>+  table(arg) {
>+    return dart.test(this[_isConsoleDefined]) ? window.console.table(arg) : null;
>+  }
>+  time(title) {
>+    return dart.test(this[_isConsoleDefined]) ? window.console.time(title) : null;
>+  }
>+  timeEnd(title) {
>+    return dart.test(this[_isConsoleDefined]) ? window.console.timeEnd(title) : null;
>+  }
>+  timeStamp(arg) {
>+    return dart.test(this[_isConsoleDefined]) ? window.console.timeStamp(arg) : null;
>+  }
>+  trace(arg) {
>+    return dart.test(this[_isConsoleDefined]) ? window.console.trace(arg) : null;
>+  }
>+  warn(arg) {
>+    return dart.test(this[_isConsoleDefined]) ? window.console.warn(arg) : null;
>+  }
>+};
>+(html$.Console._safe = function() {
>+}).prototype = html$.Console.prototype;
>+dart.addTypeTests(html$.Console);
>+dart.setMethodSignature(html$.Console, () => ({
>+  __proto__: dart.getMethods(html$.Console.__proto__),
>+  assertCondition: dart.fnType(dart.void, [core.bool, core.Object]),
>+  clear: dart.fnType(dart.void, [core.Object]),
>+  count: dart.fnType(dart.void, [core.Object]),
>+  debug: dart.fnType(dart.void, [core.Object]),
>+  dir: dart.fnType(dart.void, [core.Object]),
>+  dirxml: dart.fnType(dart.void, [core.Object]),
>+  error: dart.fnType(dart.void, [core.Object]),
>+  group: dart.fnType(dart.void, [core.Object]),
>+  groupCollapsed: dart.fnType(dart.void, [core.Object]),
>+  groupEnd: dart.fnType(dart.void, []),
>+  info: dart.fnType(dart.void, [core.Object]),
>+  log: dart.fnType(dart.void, [core.Object]),
>+  markTimeline: dart.fnType(dart.void, [core.Object]),
>+  profile: dart.fnType(dart.void, [core.String]),
>+  profileEnd: dart.fnType(dart.void, [core.String]),
>+  table: dart.fnType(dart.void, [core.Object]),
>+  time: dart.fnType(dart.void, [core.String]),
>+  timeEnd: dart.fnType(dart.void, [core.String]),
>+  timeStamp: dart.fnType(dart.void, [core.Object]),
>+  trace: dart.fnType(dart.void, [core.Object]),
>+  warn: dart.fnType(dart.void, [core.Object])
>+}));
>+dart.setGetterSignature(html$.Console, () => ({
>+  __proto__: dart.getGetters(html$.Console.__proto__),
>+  [_isConsoleDefined]: core.bool,
>+  memory: html$.MemoryInfo
>+}));
>+dart.setLibraryUri(html$.Console, "dart:html");
>+dart.defineLazy(html$.Console, {
>+  /*html$.Console._safeConsole*/get _safeConsole() {
>+    return dart.const(new html$.Console._safe());
>+  }
>+});
>+html$._convertNativeToDart_Window = function(win) {
>+  if (win == null) return null;
>+  return html$._DOMWindowCrossFrame._createSafe(win);
>+};
>+html$._convertNativeToDart_EventTarget = function(e) {
>+  if (e == null) {
>+    return null;
>+  }
>+  if ("postMessage" in e) {
>+    let window = html$._DOMWindowCrossFrame._createSafe(e);
>+    if (html$.EventTarget.is(window)) {
>+      return window;
>+    }
>+    return null;
>+  } else
>+    return html$.EventTarget._check(e);
>+};
>+const _window = dart.privateName(html$, "_window");
>+html$._convertDartToNative_EventTarget = function(e) {
>+  if (html$._DOMWindowCrossFrame.is(e)) {
>+    return html$.EventTarget._check(e[_window]);
>+  } else {
>+    return html$.EventTarget._check(e);
>+  }
>+};
>+html$._convertNativeToDart_XHR_Response = function(o) {
>+  if (html$.Document.is(o)) {
>+    return o;
>+  }
>+  return html_common.convertNativeToDart_SerializedScriptValue(o);
>+};
>+html$._callConstructor = function(constructor, interceptor) {
>+  return dart.fn(receiver => {
>+    _js_helper.setNativeSubclassDispatchRecord(receiver, interceptor);
>+    receiver.constructor = receiver.__proto__.constructor;
>+    return constructor(receiver);
>+  }, dynamicTodynamic());
>+};
>+html$._callAttached = function(receiver) {
>+  return dart.dsend(receiver, 'attached', []);
>+};
>+html$._callDetached = function(receiver) {
>+  return dart.dsend(receiver, 'detached', []);
>+};
>+html$._callAttributeChanged = function(receiver, name, oldValue, newValue) {
>+  return dart.dsend(receiver, 'attributeChanged', [name, oldValue, newValue]);
>+};
>+html$._makeCallbackMethod = function(callback) {
>+  return (function(invokeCallback) {
>+    return function() {
>+      return invokeCallback(this);
>+    };
>+  })(_js_helper.convertDartClosureToJS(dart.dynamic, callback, 1));
>+};
>+html$._makeCallbackMethod3 = function(callback) {
>+  return (function(invokeCallback) {
>+    return function(arg1, arg2, arg3) {
>+      return invokeCallback(this, arg1, arg2, arg3);
>+    };
>+  })(_js_helper.convertDartClosureToJS(dart.dynamic, callback, 4));
>+};
>+html$._checkExtendsNativeClassOrTemplate = function(element, extendsTag, baseClassName) {
>+  if (!(element instanceof window[baseClassName]) && !(extendsTag === "template" && element instanceof window.HTMLUnknownElement)) {
>+    dart.throw(new core.UnsupportedError.new("extendsTag does not match base native class"));
>+  }
>+};
>+html$._registerCustomElement = function(context, document, tag, options) {
>+  if (options === void 0) options = null;
>+  let extendsTagName = "";
>+  let type = null;
>+  if (options != null) {
>+    extendsTagName = core.String._check(options[$_get]("extends"));
>+    type = core.Type._check(options[$_get]("prototype"));
>+  }
>+  let interceptorClass = _interceptors.findInterceptorConstructorForType(type);
>+  if (interceptorClass == null) {
>+    dart.throw(new core.ArgumentError.new(type));
>+  }
>+  let interceptor = interceptorClass.prototype;
>+  let constructor = _interceptors.findConstructorForNativeSubclassType(type, "created");
>+  if (constructor == null) {
>+    dart.throw(new core.ArgumentError.new(dart.str(type) + " has no constructor called 'created'"));
>+  }
>+  _interceptors.getNativeInterceptor(html$.Element.tag("article"));
>+  let baseClassName = core.String._check(_js_helper.findDispatchTagForInterceptorClass(interceptorClass));
>+  if (baseClassName == null) {
>+    dart.throw(new core.ArgumentError.new(type));
>+  }
>+  if (extendsTagName == null) {
>+    if (baseClassName !== "HTMLElement") {
>+      dart.throw(new core.UnsupportedError.new("Class must provide extendsTag if base " + "native class is not HtmlElement"));
>+    }
>+  } else {
>+    let element = dart.dsend(document, 'createElement', [extendsTagName]);
>+    html$._checkExtendsNativeClassOrTemplate(html$.Element._check(element), extendsTagName, baseClassName);
>+  }
>+  let baseConstructor = context[baseClassName];
>+  let properties = {};
>+  properties.createdCallback = {value: html$._makeCallbackMethod(html$._callConstructor(constructor, interceptor))};
>+  properties.attachedCallback = {value: html$._makeCallbackMethod(html$._callAttached)};
>+  properties.detachedCallback = {value: html$._makeCallbackMethod(html$._callDetached)};
>+  properties.attributeChangedCallback = {value: html$._makeCallbackMethod3(html$._callAttributeChanged)};
>+  let baseProto = baseConstructor.prototype;
>+  let proto = Object.create(baseProto, properties);
>+  _js_helper.setNativeSubclassDispatchRecord(proto, interceptor);
>+  let opts = {prototype: proto};
>+  if (extendsTagName != null) {
>+    opts.extends = extendsTagName;
>+  }
>+  return document.registerElement(tag, opts);
>+};
>+html$._initializeCustomElement = function(e) {
>+};
>+const _interceptor = dart.privateName(html$, "_interceptor");
>+const _constructor = dart.privateName(html$, "_constructor");
>+const _nativeType = dart.privateName(html$, "_nativeType");
>+html$._JSElementUpgrader = class _JSElementUpgrader extends core.Object {
>+  upgrade(element) {
>+    if (!dart.equals(dart.runtimeType(element), this[_nativeType])) {
>+      if (!dart.equals(this[_nativeType], dart.wrapType(html$.HtmlElement)) || !dart.equals(dart.runtimeType(element), dart.wrapType(html$.UnknownElement))) {
>+        dart.throw(new core.ArgumentError.new("element is not subclass of " + dart.str(this[_nativeType])));
>+      }
>+    }
>+    _js_helper.setNativeSubclassDispatchRecord(element, this[_interceptor]);
>+    this[_constructor](element);
>+    return element;
>+  }
>+};
>+(html$._JSElementUpgrader.new = function(document, type, extendsTag) {
>+  this[_interceptor] = null;
>+  this[_constructor] = null;
>+  this[_nativeType] = null;
>+  let interceptorClass = _interceptors.findInterceptorConstructorForType(type);
>+  if (interceptorClass == null) {
>+    dart.throw(new core.ArgumentError.new(type));
>+  }
>+  this[_constructor] = _interceptors.findConstructorForNativeSubclassType(type, "created");
>+  if (this[_constructor] == null) {
>+    dart.throw(new core.ArgumentError.new(dart.str(type) + " has no constructor called 'created'"));
>+  }
>+  _interceptors.getNativeInterceptor(html$.Element.tag("article"));
>+  let baseClassName = _js_helper.findDispatchTagForInterceptorClass(interceptorClass);
>+  if (baseClassName == null) {
>+    dart.throw(new core.ArgumentError.new(type));
>+  }
>+  if (extendsTag == null) {
>+    if (!dart.equals(baseClassName, "HTMLElement")) {
>+      dart.throw(new core.UnsupportedError.new("Class must provide extendsTag if base " + "native class is not HtmlElement"));
>+    }
>+    this[_nativeType] = dart.wrapType(html$.HtmlElement);
>+  } else {
>+    let element = document[$createElement](extendsTag);
>+    html$._checkExtendsNativeClassOrTemplate(element, extendsTag, core.String._check(baseClassName));
>+    this[_nativeType] = dart.runtimeType(element);
>+  }
>+  this[_interceptor] = interceptorClass.prototype;
>+}).prototype = html$._JSElementUpgrader.prototype;
>+dart.addTypeTests(html$._JSElementUpgrader);
>+html$._JSElementUpgrader[dart.implements] = () => [html$.ElementUpgrader];
>+dart.setMethodSignature(html$._JSElementUpgrader, () => ({
>+  __proto__: dart.getMethods(html$._JSElementUpgrader.__proto__),
>+  upgrade: dart.fnType(html$.Element, [html$.Element])
>+}));
>+dart.setLibraryUri(html$._JSElementUpgrader, "dart:html");
>+dart.setFieldSignature(html$._JSElementUpgrader, () => ({
>+  __proto__: dart.getFields(html$._JSElementUpgrader.__proto__),
>+  [_interceptor]: dart.fieldType(dart.dynamic),
>+  [_constructor]: dart.fieldType(dart.dynamic),
>+  [_nativeType]: dart.fieldType(dart.dynamic)
>+}));
>+html$._DOMWindowCrossFrame = class _DOMWindowCrossFrame extends core.Object {
>+  get history() {
>+    return html$._HistoryCrossFrame._createSafe(this[_window].history);
>+  }
>+  get location() {
>+    return html$._LocationCrossFrame._createSafe(this[_window].location);
>+  }
>+  get closed() {
>+    return this[_window].closed;
>+  }
>+  get opener() {
>+    return html$._DOMWindowCrossFrame._createSafe(this[_window].opener);
>+  }
>+  get parent() {
>+    return html$._DOMWindowCrossFrame._createSafe(this[_window].parent);
>+  }
>+  get top() {
>+    return html$._DOMWindowCrossFrame._createSafe(this[_window].top);
>+  }
>+  close() {
>+    return this[_window].close();
>+  }
>+  postMessage(message, targetOrigin, messagePorts) {
>+    if (messagePorts === void 0) messagePorts = null;
>+    if (messagePorts == null) {
>+      this[_window].postMessage(html_common.convertDartToNative_SerializedScriptValue(message), targetOrigin);
>+    } else {
>+      this[_window].postMessage(html_common.convertDartToNative_SerializedScriptValue(message), targetOrigin, messagePorts);
>+    }
>+  }
>+  static _createSafe(w) {
>+    if (core.identical(w, html$.window)) {
>+      return html$.WindowBase._check(w);
>+    } else {
>+      _js_helper.registerGlobalObject(w);
>+      return new html$._DOMWindowCrossFrame.new(w);
>+    }
>+  }
>+  get on() {
>+    return dart.throw(new core.UnsupportedError.new("You can only attach EventListeners to your own window."));
>+  }
>+  [_addEventListener](type, listener, useCapture) {
>+    if (useCapture === void 0) useCapture = null;
>+    return dart.throw(new core.UnsupportedError.new("You can only attach EventListeners to your own window."));
>+  }
>+  addEventListener(type, listener, useCapture) {
>+    if (useCapture === void 0) useCapture = null;
>+    return dart.throw(new core.UnsupportedError.new("You can only attach EventListeners to your own window."));
>+  }
>+  dispatchEvent(event) {
>+    return dart.throw(new core.UnsupportedError.new("You can only attach EventListeners to your own window."));
>+  }
>+  [_removeEventListener](type, listener, useCapture) {
>+    if (useCapture === void 0) useCapture = null;
>+    return dart.throw(new core.UnsupportedError.new("You can only attach EventListeners to your own window."));
>+  }
>+  removeEventListener(type, listener, useCapture) {
>+    if (useCapture === void 0) useCapture = null;
>+    return dart.throw(new core.UnsupportedError.new("You can only attach EventListeners to your own window."));
>+  }
>+};
>+(html$._DOMWindowCrossFrame.new = function(window) {
>+  this[_window] = window;
>+}).prototype = html$._DOMWindowCrossFrame.prototype;
>+dart.addTypeTests(html$._DOMWindowCrossFrame);
>+html$._DOMWindowCrossFrame[dart.implements] = () => [html$.WindowBase];
>+dart.setMethodSignature(html$._DOMWindowCrossFrame, () => ({
>+  __proto__: dart.getMethods(html$._DOMWindowCrossFrame.__proto__),
>+  close: dart.fnType(dart.void, []),
>+  [$close]: dart.fnType(dart.void, []),
>+  postMessage: dart.fnType(dart.void, [dart.dynamic, core.String], [core.List]),
>+  [$postMessage]: dart.fnType(dart.void, [dart.dynamic, core.String], [core.List]),
>+  [_addEventListener]: dart.fnType(dart.void, [core.String, dart.fnType(dart.dynamic, [html$.Event])], [core.bool]),
>+  addEventListener: dart.fnType(dart.void, [core.String, dart.fnType(dart.dynamic, [html$.Event])], [core.bool]),
>+  [$addEventListener]: dart.fnType(dart.void, [core.String, dart.fnType(dart.dynamic, [html$.Event])], [core.bool]),
>+  dispatchEvent: dart.fnType(core.bool, [html$.Event]),
>+  [$dispatchEvent]: dart.fnType(core.bool, [html$.Event]),
>+  [_removeEventListener]: dart.fnType(dart.void, [core.String, dart.fnType(dart.dynamic, [html$.Event])], [core.bool]),
>+  removeEventListener: dart.fnType(dart.void, [core.String, dart.fnType(dart.dynamic, [html$.Event])], [core.bool]),
>+  [$removeEventListener]: dart.fnType(dart.void, [core.String, dart.fnType(dart.dynamic, [html$.Event])], [core.bool])
>+}));
>+dart.setGetterSignature(html$._DOMWindowCrossFrame, () => ({
>+  __proto__: dart.getGetters(html$._DOMWindowCrossFrame.__proto__),
>+  history: html$.HistoryBase,
>+  [$history]: html$.HistoryBase,
>+  location: html$.LocationBase,
>+  [$location]: html$.LocationBase,
>+  closed: core.bool,
>+  [$closed]: core.bool,
>+  opener: html$.WindowBase,
>+  [$opener]: html$.WindowBase,
>+  parent: html$.WindowBase,
>+  [$parent]: html$.WindowBase,
>+  top: html$.WindowBase,
>+  [$top]: html$.WindowBase,
>+  on: html$.Events,
>+  [$on]: html$.Events
>+}));
>+dart.setLibraryUri(html$._DOMWindowCrossFrame, "dart:html");
>+dart.setFieldSignature(html$._DOMWindowCrossFrame, () => ({
>+  __proto__: dart.getFields(html$._DOMWindowCrossFrame.__proto__),
>+  [_window]: dart.finalFieldType(dart.dynamic)
>+}));
>+dart.defineExtensionMethods(html$._DOMWindowCrossFrame, [
>+  'close',
>+  'postMessage',
>+  'addEventListener',
>+  'dispatchEvent',
>+  'removeEventListener'
>+]);
>+dart.defineExtensionAccessors(html$._DOMWindowCrossFrame, [
>+  'history',
>+  'location',
>+  'closed',
>+  'opener',
>+  'parent',
>+  'top',
>+  'on'
>+]);
>+html$._LocationCrossFrame = class _LocationCrossFrame extends core.Object {
>+  set href(val) {
>+    return html$._LocationCrossFrame._setHref(this[_location], val);
>+  }
>+  static _setHref(location, val) {
>+    location.href = val;
>+  }
>+  static _createSafe(location) {
>+    if (core.identical(location, html$.window[$location])) {
>+      return html$.LocationBase._check(location);
>+    } else {
>+      return new html$._LocationCrossFrame.new(location);
>+    }
>+  }
>+};
>+(html$._LocationCrossFrame.new = function(location) {
>+  this[_location] = location;
>+}).prototype = html$._LocationCrossFrame.prototype;
>+dart.addTypeTests(html$._LocationCrossFrame);
>+html$._LocationCrossFrame[dart.implements] = () => [html$.LocationBase];
>+dart.setSetterSignature(html$._LocationCrossFrame, () => ({
>+  __proto__: dart.getSetters(html$._LocationCrossFrame.__proto__),
>+  href: core.String,
>+  [$href]: core.String
>+}));
>+dart.setLibraryUri(html$._LocationCrossFrame, "dart:html");
>+dart.setFieldSignature(html$._LocationCrossFrame, () => ({
>+  __proto__: dart.getFields(html$._LocationCrossFrame.__proto__),
>+  [_location]: dart.fieldType(dart.dynamic)
>+}));
>+dart.defineExtensionAccessors(html$._LocationCrossFrame, ['href']);
>+const _history = dart.privateName(html$, "_history");
>+html$._HistoryCrossFrame = class _HistoryCrossFrame extends core.Object {
>+  back() {
>+    return this[_history].back();
>+  }
>+  forward() {
>+    return this[_history].forward();
>+  }
>+  go(distance) {
>+    return this[_history].go(distance);
>+  }
>+  static _createSafe(h) {
>+    if (core.identical(h, html$.window.history)) {
>+      return html$.HistoryBase._check(h);
>+    } else {
>+      return new html$._HistoryCrossFrame.new(h);
>+    }
>+  }
>+};
>+(html$._HistoryCrossFrame.new = function(history) {
>+  this[_history] = history;
>+}).prototype = html$._HistoryCrossFrame.prototype;
>+dart.addTypeTests(html$._HistoryCrossFrame);
>+html$._HistoryCrossFrame[dart.implements] = () => [html$.HistoryBase];
>+dart.setMethodSignature(html$._HistoryCrossFrame, () => ({
>+  __proto__: dart.getMethods(html$._HistoryCrossFrame.__proto__),
>+  back: dart.fnType(dart.void, []),
>+  [$back]: dart.fnType(dart.void, []),
>+  forward: dart.fnType(dart.void, []),
>+  [$forward]: dart.fnType(dart.void, []),
>+  go: dart.fnType(dart.void, [core.int]),
>+  [$go]: dart.fnType(dart.void, [core.int])
>+}));
>+dart.setLibraryUri(html$._HistoryCrossFrame, "dart:html");
>+dart.setFieldSignature(html$._HistoryCrossFrame, () => ({
>+  __proto__: dart.getFields(html$._HistoryCrossFrame.__proto__),
>+  [_history]: dart.fieldType(dart.dynamic)
>+}));
>+dart.defineExtensionMethods(html$._HistoryCrossFrame, ['back', 'forward', 'go']);
>+html$.Platform = class Platform extends core.Object {};
>+(html$.Platform.new = function() {
>+}).prototype = html$.Platform.prototype;
>+dart.addTypeTests(html$.Platform);
>+dart.setLibraryUri(html$.Platform, "dart:html");
>+dart.defineLazy(html$.Platform, {
>+  /*html$.Platform.supportsTypedData*/get supportsTypedData() {
>+    return !!window.ArrayBuffer;
>+  },
>+  /*html$.Platform.supportsSimd*/get supportsSimd() {
>+    return false;
>+  }
>+});
>+html$._wrapZone = function(T, callback) {
>+  if (dart.equals(async.Zone.current, async.Zone.root)) return callback;
>+  if (callback == null) return null;
>+  return async.Zone.current.bindUnaryCallbackGuarded(T, callback);
>+};
>+html$._wrapBinaryZone = function(T1, T2, callback) {
>+  if (dart.equals(async.Zone.current, async.Zone.root)) return callback;
>+  if (callback == null) return null;
>+  return async.Zone.current.bindBinaryCallbackGuarded(T1, T2, callback);
>+};
>+html$.querySelector = function(selectors) {
>+  return html$.document.querySelector(selectors);
>+};
>+html$.querySelectorAll = function(T, selectors) {
>+  return html$.document[$querySelectorAll](T, selectors);
>+};
>+html$.ElementUpgrader = class ElementUpgrader extends core.Object {};
>+(html$.ElementUpgrader.new = function() {
>+}).prototype = html$.ElementUpgrader.prototype;
>+dart.addTypeTests(html$.ElementUpgrader);
>+dart.setLibraryUri(html$.ElementUpgrader, "dart:html");
>+html$.NodeValidator = class NodeValidator extends core.Object {
>+  static new(opts) {
>+    let uriPolicy = opts && 'uriPolicy' in opts ? opts.uriPolicy : null;
>+    return new html$._Html5NodeValidator.new({uriPolicy: uriPolicy});
>+  }
>+  static throws(base) {
>+    return new html$._ThrowsNodeValidator.new(base);
>+  }
>+};
>+(html$.NodeValidator[dart.mixinNew] = function() {
>+}).prototype = html$.NodeValidator.prototype;
>+dart.addTypeTests(html$.NodeValidator);
>+dart.setLibraryUri(html$.NodeValidator, "dart:html");
>+html$.NodeTreeSanitizer = class NodeTreeSanitizer extends core.Object {
>+  static new(validator) {
>+    return new html$._ValidatingTreeSanitizer.new(validator);
>+  }
>+};
>+(html$.NodeTreeSanitizer[dart.mixinNew] = function() {
>+}).prototype = html$.NodeTreeSanitizer.prototype;
>+dart.addTypeTests(html$.NodeTreeSanitizer);
>+dart.setLibraryUri(html$.NodeTreeSanitizer, "dart:html");
>+dart.defineLazy(html$.NodeTreeSanitizer, {
>+  /*html$.NodeTreeSanitizer.trusted*/get trusted() {
>+    return dart.const(new html$._TrustedHtmlTreeSanitizer.new());
>+  }
>+});
>+html$._TrustedHtmlTreeSanitizer = class _TrustedHtmlTreeSanitizer extends core.Object {
>+  sanitizeTree(node) {}
>+};
>+(html$._TrustedHtmlTreeSanitizer.new = function() {
>+}).prototype = html$._TrustedHtmlTreeSanitizer.prototype;
>+dart.addTypeTests(html$._TrustedHtmlTreeSanitizer);
>+html$._TrustedHtmlTreeSanitizer[dart.implements] = () => [html$.NodeTreeSanitizer];
>+dart.setMethodSignature(html$._TrustedHtmlTreeSanitizer, () => ({
>+  __proto__: dart.getMethods(html$._TrustedHtmlTreeSanitizer.__proto__),
>+  sanitizeTree: dart.fnType(dart.void, [html$.Node])
>+}));
>+dart.setLibraryUri(html$._TrustedHtmlTreeSanitizer, "dart:html");
>+html$.UriPolicy = class UriPolicy extends core.Object {
>+  static new() {
>+    return new html$._SameOriginUriPolicy.new();
>+  }
>+};
>+(html$.UriPolicy[dart.mixinNew] = function() {
>+}).prototype = html$.UriPolicy.prototype;
>+dart.addTypeTests(html$.UriPolicy);
>+dart.setLibraryUri(html$.UriPolicy, "dart:html");
>+const _hiddenAnchor = dart.privateName(html$, "_hiddenAnchor");
>+const _loc = dart.privateName(html$, "_loc");
>+html$._SameOriginUriPolicy = class _SameOriginUriPolicy extends core.Object {
>+  allowsUri(uri) {
>+    this[_hiddenAnchor].href = uri;
>+    return this[_hiddenAnchor].hostname == this[_loc].hostname && this[_hiddenAnchor].port == this[_loc].port && this[_hiddenAnchor].protocol == this[_loc].protocol || this[_hiddenAnchor].hostname === "" && this[_hiddenAnchor].port === "" && (this[_hiddenAnchor].protocol === ":" || this[_hiddenAnchor].protocol === "");
>+  }
>+};
>+(html$._SameOriginUriPolicy.new = function() {
>+  this[_hiddenAnchor] = html$.AnchorElement.new();
>+  this[_loc] = html$.window[$location];
>+}).prototype = html$._SameOriginUriPolicy.prototype;
>+dart.addTypeTests(html$._SameOriginUriPolicy);
>+html$._SameOriginUriPolicy[dart.implements] = () => [html$.UriPolicy];
>+dart.setMethodSignature(html$._SameOriginUriPolicy, () => ({
>+  __proto__: dart.getMethods(html$._SameOriginUriPolicy.__proto__),
>+  allowsUri: dart.fnType(core.bool, [core.String])
>+}));
>+dart.setLibraryUri(html$._SameOriginUriPolicy, "dart:html");
>+dart.setFieldSignature(html$._SameOriginUriPolicy, () => ({
>+  __proto__: dart.getFields(html$._SameOriginUriPolicy.__proto__),
>+  [_hiddenAnchor]: dart.finalFieldType(html$.AnchorElement),
>+  [_loc]: dart.finalFieldType(html$.Location)
>+}));
>+html$._ThrowsNodeValidator = class _ThrowsNodeValidator extends core.Object {
>+  allowsElement(element) {
>+    if (!dart.test(this.validator.allowsElement(element))) {
>+      dart.throw(new core.ArgumentError.new(html$.Element._safeTagName(element)));
>+    }
>+    return true;
>+  }
>+  allowsAttribute(element, attributeName, value) {
>+    if (!dart.test(this.validator.allowsAttribute(element, attributeName, value))) {
>+      dart.throw(new core.ArgumentError.new(dart.str(html$.Element._safeTagName(element)) + "[" + dart.str(attributeName) + "=\"" + dart.str(value) + "\"]"));
>+    }
>+  }
>+};
>+(html$._ThrowsNodeValidator.new = function(validator) {
>+  this.validator = validator;
>+}).prototype = html$._ThrowsNodeValidator.prototype;
>+dart.addTypeTests(html$._ThrowsNodeValidator);
>+html$._ThrowsNodeValidator[dart.implements] = () => [html$.NodeValidator];
>+dart.setMethodSignature(html$._ThrowsNodeValidator, () => ({
>+  __proto__: dart.getMethods(html$._ThrowsNodeValidator.__proto__),
>+  allowsElement: dart.fnType(core.bool, [html$.Element]),
>+  allowsAttribute: dart.fnType(core.bool, [html$.Element, core.String, core.String])
>+}));
>+dart.setLibraryUri(html$._ThrowsNodeValidator, "dart:html");
>+dart.setFieldSignature(html$._ThrowsNodeValidator, () => ({
>+  __proto__: dart.getFields(html$._ThrowsNodeValidator.__proto__),
>+  validator: dart.finalFieldType(html$.NodeValidator)
>+}));
>+const _removeNode = dart.privateName(html$, "_removeNode");
>+const _sanitizeElement = dart.privateName(html$, "_sanitizeElement");
>+const _sanitizeUntrustedElement = dart.privateName(html$, "_sanitizeUntrustedElement");
>+html$._ValidatingTreeSanitizer = class _ValidatingTreeSanitizer extends core.Object {
>+  sanitizeTree(node) {
>+    const walk = (node, parent) => {
>+      this.sanitizeNode(node, parent);
>+      let child = node.lastChild;
>+      while (null != child) {
>+        let nextChild = null;
>+        try {
>+          nextChild = child[$previousNode];
>+        } catch (e$) {
>+          let e = dart.getThrown(e$);
>+          this[_removeNode](child, node);
>+          child = null;
>+          nextChild = node.lastChild;
>+        }
>+        if (child != null) walk(child, node);
>+        child = html$.Node._check(nextChild);
>+      }
>+    };
>+    dart.fn(walk, NodeAndNodeTovoid());
>+    walk(node, null);
>+  }
>+  [_removeNode](node, parent) {
>+    if (parent == null) {
>+      node[$remove]();
>+    } else {
>+      parent[_removeChild](node);
>+    }
>+  }
>+  [_sanitizeUntrustedElement](element, parent) {
>+    let corrupted = true;
>+    let attrs = null;
>+    let isAttr = null;
>+    try {
>+      attrs = dart.dload(element, 'attributes');
>+      isAttr = dart.dindex(attrs, "is");
>+      let corruptedTest1 = html$.Element._hasCorruptedAttributes(html$.Element._check(element));
>+      corrupted = dart.test(corruptedTest1) ? true : html$.Element._hasCorruptedAttributesAdditionalCheck(html$.Element._check(element));
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+    }
>+    let elementText = "element unprintable";
>+    try {
>+      elementText = dart.toString(element);
>+    } catch (e$0) {
>+      let e = dart.getThrown(e$0);
>+    }
>+    try {
>+      let elementTagName = html$.Element._safeTagName(element);
>+      this[_sanitizeElement](html$.Element._check(element), parent, corrupted, elementText, elementTagName, core.Map._check(attrs), core.String._check(isAttr));
>+    } catch (e$1) {
>+      let ex = dart.getThrown(e$1);
>+      if (core.ArgumentError.is(ex)) {
>+        dart.rethrow(e$1);
>+      } else {
>+        let e = ex;
>+        this[_removeNode](html$.Node._check(element), parent);
>+        html$.window[$console].warn("Removing corrupted element " + dart.str(elementText));
>+      }
>+    }
>+  }
>+  [_sanitizeElement](element, parent, corrupted, text, tag, attrs, isAttr) {
>+    if (false !== corrupted) {
>+      this[_removeNode](element, parent);
>+      html$.window[$console].warn("Removing element due to corrupted attributes on <" + dart.str(text) + ">");
>+      return;
>+    }
>+    if (!dart.test(this.validator.allowsElement(element))) {
>+      this[_removeNode](element, parent);
>+      html$.window[$console].warn("Removing disallowed element <" + dart.str(tag) + "> from " + dart.str(parent));
>+      return;
>+    }
>+    if (isAttr != null) {
>+      if (!dart.test(this.validator.allowsAttribute(element, "is", isAttr))) {
>+        this[_removeNode](element, parent);
>+        html$.window[$console].warn("Removing disallowed type extension " + ("<" + dart.str(tag) + " is=\"" + dart.str(isAttr) + "\">"));
>+        return;
>+      }
>+    }
>+    let keys = attrs[$keys][$toList]();
>+    for (let i = dart.notNull(attrs[$length]) - 1; i >= 0; --i) {
>+      let name = keys[$_get](i);
>+      if (!dart.test(this.validator.allowsAttribute(element, core.String._check(dart.dsend(name, 'toLowerCase', [])), core.String._check(attrs[$_get](name))))) {
>+        html$.window[$console].warn("Removing disallowed attribute " + ("<" + dart.str(tag) + " " + dart.str(name) + "=\"" + dart.str(attrs[$_get](name)) + "\">"));
>+        attrs[$remove](name);
>+      }
>+    }
>+    if (html$.TemplateElement.is(element)) {
>+      let template = element;
>+      this.sanitizeTree(template.content);
>+    }
>+  }
>+  sanitizeNode(node, parent) {
>+    switch (node.nodeType) {
>+      case html$.Node.ELEMENT_NODE:
>+      {
>+        this[_sanitizeUntrustedElement](node, parent);
>+        break;
>+      }
>+      case html$.Node.COMMENT_NODE:
>+      case html$.Node.DOCUMENT_FRAGMENT_NODE:
>+      case html$.Node.TEXT_NODE:
>+      case html$.Node.CDATA_SECTION_NODE:
>+      {
>+        break;
>+      }
>+      default:
>+      {
>+        this[_removeNode](node, parent);
>+      }
>+    }
>+  }
>+};
>+(html$._ValidatingTreeSanitizer.new = function(validator) {
>+  this.validator = validator;
>+}).prototype = html$._ValidatingTreeSanitizer.prototype;
>+dart.addTypeTests(html$._ValidatingTreeSanitizer);
>+html$._ValidatingTreeSanitizer[dart.implements] = () => [html$.NodeTreeSanitizer];
>+dart.setMethodSignature(html$._ValidatingTreeSanitizer, () => ({
>+  __proto__: dart.getMethods(html$._ValidatingTreeSanitizer.__proto__),
>+  sanitizeTree: dart.fnType(dart.void, [html$.Node]),
>+  [_removeNode]: dart.fnType(dart.void, [html$.Node, html$.Node]),
>+  [_sanitizeUntrustedElement]: dart.fnType(dart.void, [dart.dynamic, html$.Node]),
>+  [_sanitizeElement]: dart.fnType(dart.void, [html$.Element, html$.Node, core.bool, core.String, core.String, core.Map, core.String]),
>+  sanitizeNode: dart.fnType(dart.void, [html$.Node, html$.Node])
>+}));
>+dart.setLibraryUri(html$._ValidatingTreeSanitizer, "dart:html");
>+dart.setFieldSignature(html$._ValidatingTreeSanitizer, () => ({
>+  __proto__: dart.getFields(html$._ValidatingTreeSanitizer.__proto__),
>+  validator: dart.fieldType(html$.NodeValidator)
>+}));
>+html_common.convertDartToNative_SerializedScriptValue = function(value) {
>+  return html_common.convertDartToNative_PrepareForStructuredClone(value);
>+};
>+html_common.convertNativeToDart_SerializedScriptValue = function(object) {
>+  return html_common.convertNativeToDart_AcceptStructuredClone(object, {mustCopy: true});
>+};
>+html_common._StructuredClone = class _StructuredClone extends core.Object {
>+  findSlot(value) {
>+    let length = this.values[$length];
>+    for (let i = 0; i < dart.notNull(length); i++) {
>+      if (core.identical(this.values[$_get](i), value)) return i;
>+    }
>+    this.values[$add](value);
>+    this.copies[$add](null);
>+    return length;
>+  }
>+  readSlot(i) {
>+    return this.copies[$_get](i);
>+  }
>+  writeSlot(i, x) {
>+    this.copies[$_set](i, x);
>+  }
>+  cleanupSlots() {}
>+  walk(e) {
>+    if (e == null) return e;
>+    if (typeof e == 'boolean') return e;
>+    if (typeof e == 'number') return e;
>+    if (typeof e == 'string') return e;
>+    if (core.DateTime.is(e)) {
>+      return html_common.convertDartToNative_DateTime(e);
>+    }
>+    if (core.RegExp.is(e)) {
>+      dart.throw(new core.UnimplementedError.new("structured clone of RegExp"));
>+    }
>+    if (html$.File.is(e)) return e;
>+    if (html$.Blob.is(e)) return e;
>+    if (html$.FileList.is(e)) return e;
>+    if (html$.ImageData.is(e)) return e;
>+    if (dart.test(this.cloneNotRequired(e))) return e;
>+    if (core.Map.is(e)) {
>+      let slot = this.findSlot(e);
>+      let copy = this.readSlot(slot);
>+      if (copy != null) return copy;
>+      copy = this.newJsMap();
>+      this.writeSlot(slot, copy);
>+      e[$forEach](dart.fn((key, value) => {
>+        this.putIntoMap(copy, key, this.walk(value));
>+      }, dynamicAnddynamicToNull()));
>+      return copy;
>+    }
>+    if (core.List.is(e)) {
>+      let slot = this.findSlot(e);
>+      let copy = this.readSlot(slot);
>+      if (copy != null) return copy;
>+      copy = this.copyList(e, slot);
>+      return copy;
>+    }
>+    dart.throw(new core.UnimplementedError.new("structured clone of other type"));
>+  }
>+  copyList(e, slot) {
>+    let i = 0;
>+    let length = e[$length];
>+    let copy = this.newJsList(length);
>+    this.writeSlot(slot, copy);
>+    for (; i < dart.notNull(length); i++) {
>+      copy[$_set](i, this.walk(e[$_get](i)));
>+    }
>+    return copy;
>+  }
>+  convertDartToNative_PrepareForStructuredClone(value) {
>+    let copy = this.walk(value);
>+    this.cleanupSlots();
>+    return copy;
>+  }
>+};
>+(html_common._StructuredClone.new = function() {
>+  this.values = [];
>+  this.copies = [];
>+}).prototype = html_common._StructuredClone.prototype;
>+dart.addTypeTests(html_common._StructuredClone);
>+dart.setMethodSignature(html_common._StructuredClone, () => ({
>+  __proto__: dart.getMethods(html_common._StructuredClone.__proto__),
>+  findSlot: dart.fnType(core.int, [dart.dynamic]),
>+  readSlot: dart.fnType(dart.dynamic, [core.int]),
>+  writeSlot: dart.fnType(dart.dynamic, [core.int, dart.dynamic]),
>+  cleanupSlots: dart.fnType(dart.dynamic, []),
>+  walk: dart.fnType(dart.dynamic, [dart.dynamic]),
>+  copyList: dart.fnType(core.List, [core.List, core.int]),
>+  convertDartToNative_PrepareForStructuredClone: dart.fnType(dart.dynamic, [dart.dynamic])
>+}));
>+dart.setLibraryUri(html_common._StructuredClone, "dart:html_common");
>+dart.setFieldSignature(html_common._StructuredClone, () => ({
>+  __proto__: dart.getFields(html_common._StructuredClone.__proto__),
>+  values: dart.fieldType(core.List),
>+  copies: dart.fieldType(core.List)
>+}));
>+html_common._AcceptStructuredClone = class _AcceptStructuredClone extends core.Object {
>+  findSlot(value) {
>+    let length = this.values[$length];
>+    for (let i = 0; i < dart.notNull(length); i++) {
>+      if (dart.test(this.identicalInJs(this.values[$_get](i), value))) return i;
>+    }
>+    this.values[$add](value);
>+    this.copies[$add](null);
>+    return length;
>+  }
>+  readSlot(i) {
>+    return this.copies[$_get](i);
>+  }
>+  writeSlot(i, x) {
>+    this.copies[$_set](i, x);
>+  }
>+  walk(e) {
>+    if (e == null) return e;
>+    if (typeof e == 'boolean') return e;
>+    if (typeof e == 'number') return e;
>+    if (typeof e == 'string') return e;
>+    if (dart.test(html_common.isJavaScriptDate(e))) {
>+      return html_common.convertNativeToDart_DateTime(e);
>+    }
>+    if (dart.test(html_common.isJavaScriptRegExp(e))) {
>+      dart.throw(new core.UnimplementedError.new("structured clone of RegExp"));
>+    }
>+    if (dart.test(html_common.isJavaScriptPromise(e))) {
>+      return html_common.convertNativePromiseToDartFuture(e);
>+    }
>+    if (dart.test(html_common.isJavaScriptSimpleObject(e))) {
>+      let slot = this.findSlot(e);
>+      let copy = this.readSlot(slot);
>+      if (copy != null) return copy;
>+      copy = new _js_helper.LinkedMap.new();
>+      this.writeSlot(slot, copy);
>+      this.forEachJsField(e, dart.fn((key, value) => dart.dsetindex(copy, key, this.walk(value)), dynamicAnddynamicTodynamic()));
>+      return copy;
>+    }
>+    if (dart.test(html_common.isJavaScriptArray(e))) {
>+      let l = e;
>+      let slot = this.findSlot(l);
>+      let copy = this.readSlot(slot);
>+      if (copy != null) return copy;
>+      let length = core.int._check(dart.dload(l, 'length'));
>+      copy = dart.test(this.mustCopy) ? this.newDartList(length) : l;
>+      this.writeSlot(slot, copy);
>+      for (let i = 0; i < dart.notNull(length); i++) {
>+        dart.dsetindex(copy, i, this.walk(dart.dindex(l, i)));
>+      }
>+      return copy;
>+    }
>+    return e;
>+  }
>+  convertNativeToDart_AcceptStructuredClone(object, opts) {
>+    let mustCopy = opts && 'mustCopy' in opts ? opts.mustCopy : false;
>+    this.mustCopy = core.bool._check(mustCopy);
>+    let copy = this.walk(object);
>+    return copy;
>+  }
>+};
>+(html_common._AcceptStructuredClone.new = function() {
>+  this.values = [];
>+  this.copies = [];
>+  this.mustCopy = false;
>+}).prototype = html_common._AcceptStructuredClone.prototype;
>+dart.addTypeTests(html_common._AcceptStructuredClone);
>+dart.setMethodSignature(html_common._AcceptStructuredClone, () => ({
>+  __proto__: dart.getMethods(html_common._AcceptStructuredClone.__proto__),
>+  findSlot: dart.fnType(core.int, [dart.dynamic]),
>+  readSlot: dart.fnType(dart.dynamic, [core.int]),
>+  writeSlot: dart.fnType(dart.dynamic, [core.int, dart.dynamic]),
>+  walk: dart.fnType(dart.dynamic, [dart.dynamic]),
>+  convertNativeToDart_AcceptStructuredClone: dart.fnType(dart.dynamic, [dart.dynamic], {mustCopy: dart.dynamic})
>+}));
>+dart.setLibraryUri(html_common._AcceptStructuredClone, "dart:html_common");
>+dart.setFieldSignature(html_common._AcceptStructuredClone, () => ({
>+  __proto__: dart.getFields(html_common._AcceptStructuredClone.__proto__),
>+  values: dart.fieldType(core.List),
>+  copies: dart.fieldType(core.List),
>+  mustCopy: dart.fieldType(core.bool)
>+}));
>+html_common.ContextAttributes = class ContextAttributes extends core.Object {
>+  get alpha() {
>+    return this[alpha$0];
>+  }
>+  set alpha(value) {
>+    this[alpha$0] = value;
>+  }
>+  get antialias() {
>+    return this[antialias$];
>+  }
>+  set antialias(value) {
>+    this[antialias$] = value;
>+  }
>+  get depth() {
>+    return this[depth$];
>+  }
>+  set depth(value) {
>+    this[depth$] = value;
>+  }
>+  get premultipliedAlpha() {
>+    return this[premultipliedAlpha$];
>+  }
>+  set premultipliedAlpha(value) {
>+    this[premultipliedAlpha$] = value;
>+  }
>+  get preserveDrawingBuffer() {
>+    return this[preserveDrawingBuffer$];
>+  }
>+  set preserveDrawingBuffer(value) {
>+    this[preserveDrawingBuffer$] = value;
>+  }
>+  get stencil() {
>+    return this[stencil$];
>+  }
>+  set stencil(value) {
>+    this[stencil$] = value;
>+  }
>+  get failIfMajorPerformanceCaveat() {
>+    return this[failIfMajorPerformanceCaveat$];
>+  }
>+  set failIfMajorPerformanceCaveat(value) {
>+    this[failIfMajorPerformanceCaveat$] = value;
>+  }
>+};
>+(html_common.ContextAttributes.new = function(alpha, antialias, depth, failIfMajorPerformanceCaveat, premultipliedAlpha, preserveDrawingBuffer, stencil) {
>+  this[alpha$0] = alpha;
>+  this[antialias$] = antialias;
>+  this[depth$] = depth;
>+  this[failIfMajorPerformanceCaveat$] = failIfMajorPerformanceCaveat;
>+  this[premultipliedAlpha$] = premultipliedAlpha;
>+  this[preserveDrawingBuffer$] = preserveDrawingBuffer;
>+  this[stencil$] = stencil;
>+}).prototype = html_common.ContextAttributes.prototype;
>+dart.addTypeTests(html_common.ContextAttributes);
>+const alpha$0 = Symbol("ContextAttributes.alpha");
>+const antialias$ = Symbol("ContextAttributes.antialias");
>+const depth$ = Symbol("ContextAttributes.depth");
>+const premultipliedAlpha$ = Symbol("ContextAttributes.premultipliedAlpha");
>+const preserveDrawingBuffer$ = Symbol("ContextAttributes.preserveDrawingBuffer");
>+const stencil$ = Symbol("ContextAttributes.stencil");
>+const failIfMajorPerformanceCaveat$ = Symbol("ContextAttributes.failIfMajorPerformanceCaveat");
>+dart.setLibraryUri(html_common.ContextAttributes, "dart:html_common");
>+dart.setFieldSignature(html_common.ContextAttributes, () => ({
>+  __proto__: dart.getFields(html_common.ContextAttributes.__proto__),
>+  alpha: dart.fieldType(core.bool),
>+  antialias: dart.fieldType(core.bool),
>+  depth: dart.fieldType(core.bool),
>+  premultipliedAlpha: dart.fieldType(core.bool),
>+  preserveDrawingBuffer: dart.fieldType(core.bool),
>+  stencil: dart.fieldType(core.bool),
>+  failIfMajorPerformanceCaveat: dart.fieldType(core.bool)
>+}));
>+html_common.convertNativeToDart_ContextAttributes = function(nativeContextAttributes) {
>+  return new html_common.ContextAttributes.new(nativeContextAttributes.alpha, nativeContextAttributes.antialias, nativeContextAttributes.depth, nativeContextAttributes.failIfMajorPerformanceCaveat, nativeContextAttributes.premultipliedAlpha, nativeContextAttributes.preserveDrawingBuffer, nativeContextAttributes.stencil);
>+};
>+html_common._TypedImageData = class _TypedImageData extends core.Object {
>+  get data() {
>+    return this[data$9];
>+  }
>+  set data(value) {
>+    super.data = value;
>+  }
>+  get height() {
>+    return this[height$13];
>+  }
>+  set height(value) {
>+    super.height = value;
>+  }
>+  get width() {
>+    return this[width$15];
>+  }
>+  set width(value) {
>+    super.width = value;
>+  }
>+};
>+(html_common._TypedImageData.new = function(data, height, width) {
>+  this[data$9] = data;
>+  this[height$13] = height;
>+  this[width$15] = width;
>+}).prototype = html_common._TypedImageData.prototype;
>+dart.addTypeTests(html_common._TypedImageData);
>+const data$9 = Symbol("_TypedImageData.data");
>+const height$13 = Symbol("_TypedImageData.height");
>+const width$15 = Symbol("_TypedImageData.width");
>+html_common._TypedImageData[dart.implements] = () => [html$.ImageData];
>+dart.setLibraryUri(html_common._TypedImageData, "dart:html_common");
>+dart.setFieldSignature(html_common._TypedImageData, () => ({
>+  __proto__: dart.getFields(html_common._TypedImageData.__proto__),
>+  data: dart.finalFieldType(typed_data.Uint8ClampedList),
>+  height: dart.finalFieldType(core.int),
>+  width: dart.finalFieldType(core.int)
>+}));
>+dart.defineExtensionAccessors(html_common._TypedImageData, ['data', 'height', 'width']);
>+html_common.convertNativeToDart_ImageData = function(nativeImageData) {
>+  0;
>+  if (html$.ImageData.is(nativeImageData)) {
>+    let data = nativeImageData.data;
>+    if (data.constructor === Array) {
>+      if (typeof CanvasPixelArray !== "undefined") {
>+        data.constructor = CanvasPixelArray;
>+        data.BYTES_PER_ELEMENT = 1;
>+      }
>+    }
>+    return nativeImageData;
>+  }
>+  return new html_common._TypedImageData.new(nativeImageData.data, nativeImageData.height, nativeImageData.width);
>+};
>+html_common.convertDartToNative_ImageData = function(imageData) {
>+  if (html_common._TypedImageData.is(imageData)) {
>+    return {data: imageData.data, height: imageData.height, width: imageData.width};
>+  }
>+  return imageData;
>+};
>+html_common.convertNativeToDart_Dictionary = function(object) {
>+  if (object == null) return null;
>+  let dict = new (IdentityMapOfString$dynamic()).new();
>+  let keys = Object.getOwnPropertyNames(object);
>+  for (let key of core.Iterable._check(keys)) {
>+    dict[$_set](core.String._check(key), object[key]);
>+  }
>+  return dict;
>+};
>+html_common.convertDartToNative_Dictionary = function(dict, postCreate) {
>+  if (postCreate === void 0) postCreate = null;
>+  if (dict == null) return null;
>+  let object = {};
>+  if (postCreate != null) {
>+    postCreate(object);
>+  }
>+  dict[$forEach](dart.fn((key, value) => {
>+    object[key] = value;
>+  }, dynamicAnddynamicToNull()));
>+  return object;
>+};
>+html_common.convertDartToNative_StringArray = function(input) {
>+  return input;
>+};
>+html_common.convertNativeToDart_DateTime = function(date) {
>+  let millisSinceEpoch = date.getTime();
>+  return new core.DateTime.fromMillisecondsSinceEpoch(millisSinceEpoch, {isUtc: true});
>+};
>+html_common.convertDartToNative_DateTime = function(date) {
>+  return new Date(date.millisecondsSinceEpoch);
>+};
>+html_common.convertDartToNative_PrepareForStructuredClone = function(value) {
>+  return new html_common._StructuredCloneDart2Js.new().convertDartToNative_PrepareForStructuredClone(value);
>+};
>+html_common.convertNativeToDart_AcceptStructuredClone = function(object, opts) {
>+  let mustCopy = opts && 'mustCopy' in opts ? opts.mustCopy : false;
>+  return new html_common._AcceptStructuredCloneDart2Js.new().convertNativeToDart_AcceptStructuredClone(object, {mustCopy: mustCopy});
>+};
>+html_common._StructuredCloneDart2Js = class _StructuredCloneDart2Js extends html_common._StructuredClone {
>+  newJsMap() {
>+    return {};
>+  }
>+  putIntoMap(map, key, value) {
>+    return map[key] = value;
>+  }
>+  newJsList(length) {
>+    return new Array(length);
>+  }
>+  cloneNotRequired(e) {
>+    return _native_typed_data.NativeByteBuffer.is(e) || _native_typed_data.NativeTypedData.is(e) || html$.MessagePort.is(e);
>+  }
>+};
>+(html_common._StructuredCloneDart2Js.new = function() {
>+  html_common._StructuredCloneDart2Js.__proto__.new.call(this);
>+}).prototype = html_common._StructuredCloneDart2Js.prototype;
>+dart.addTypeTests(html_common._StructuredCloneDart2Js);
>+dart.setMethodSignature(html_common._StructuredCloneDart2Js, () => ({
>+  __proto__: dart.getMethods(html_common._StructuredCloneDart2Js.__proto__),
>+  newJsMap: dart.fnType(dart.dynamic, []),
>+  putIntoMap: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic]),
>+  newJsList: dart.fnType(core.List, [dart.dynamic]),
>+  cloneNotRequired: dart.fnType(core.bool, [dart.dynamic])
>+}));
>+dart.setLibraryUri(html_common._StructuredCloneDart2Js, "dart:html_common");
>+html_common._AcceptStructuredCloneDart2Js = class _AcceptStructuredCloneDart2Js extends html_common._AcceptStructuredClone {
>+  newJsList(length) {
>+    return new Array(length);
>+  }
>+  newDartList(length) {
>+    return this.newJsList(length);
>+  }
>+  identicalInJs(a, b) {
>+    return core.identical(a, b);
>+  }
>+  forEachJsField(object, action) {
>+    for (let key of Object.keys(object)) {
>+      action(key, object[key]);
>+    }
>+  }
>+};
>+(html_common._AcceptStructuredCloneDart2Js.new = function() {
>+  html_common._AcceptStructuredCloneDart2Js.__proto__.new.call(this);
>+}).prototype = html_common._AcceptStructuredCloneDart2Js.prototype;
>+dart.addTypeTests(html_common._AcceptStructuredCloneDart2Js);
>+dart.setMethodSignature(html_common._AcceptStructuredCloneDart2Js, () => ({
>+  __proto__: dart.getMethods(html_common._AcceptStructuredCloneDart2Js.__proto__),
>+  newJsList: dart.fnType(core.List, [dart.dynamic]),
>+  newDartList: dart.fnType(core.List, [dart.dynamic]),
>+  identicalInJs: dart.fnType(core.bool, [dart.dynamic, dart.dynamic]),
>+  forEachJsField: dart.fnType(dart.void, [dart.dynamic, dart.fnType(dart.dynamic, [dart.dynamic, dart.dynamic])])
>+}));
>+dart.setLibraryUri(html_common._AcceptStructuredCloneDart2Js, "dart:html_common");
>+html_common.isJavaScriptDate = function(value) {
>+  return value instanceof Date;
>+};
>+html_common.isJavaScriptRegExp = function(value) {
>+  return value instanceof RegExp;
>+};
>+html_common.isJavaScriptArray = function(value) {
>+  return value instanceof Array;
>+};
>+html_common.isJavaScriptSimpleObject = function(value) {
>+  let proto = Object.getPrototypeOf(value);
>+  return proto === Object.prototype || proto === null;
>+};
>+html_common.isImmutableJavaScriptArray = function(value) {
>+  return !!value.immutable$list;
>+};
>+html_common.isJavaScriptPromise = function(value) {
>+  return typeof Promise != "undefined" && value instanceof Promise;
>+};
>+html_common.convertNativePromiseToDartFuture = function(promise) {
>+  let completer = async.Completer.new();
>+  let then = _js_helper.convertDartClosureToJS(dynamicTovoid(), dart.fn(result => completer.complete(result), dynamicTovoid()), 1);
>+  let error = _js_helper.convertDartClosureToJS(dynamicTovoid(), dart.fn(result => completer.completeError(result), dynamicTovoid()), 1);
>+  let newPromise = promise.then(then).catch(error);
>+  return completer.future;
>+};
>+dart.defineLazy(html_common, {
>+  /*html_common._serializedScriptValue*/get _serializedScriptValue() {
>+    return "num|String|bool|" + "JSExtendableArray|=Object|" + "Blob|File|NativeByteBuffer|NativeTypedData|MessagePort";
>+  },
>+  /*html_common.annotation_Creates_SerializedScriptValue*/get annotation_Creates_SerializedScriptValue() {
>+    return dart.const(new _js_helper.Creates.new("num|String|bool|JSExtendableArray|=Object|Blob|File|NativeByteBuffer|NativeTypedData|MessagePort"));
>+  },
>+  /*html_common.annotation_Returns_SerializedScriptValue*/get annotation_Returns_SerializedScriptValue() {
>+    return dart.const(new _js_helper.Returns.new("num|String|bool|JSExtendableArray|=Object|Blob|File|NativeByteBuffer|NativeTypedData|MessagePort"));
>+  }
>+});
>+html_common.Device = class Device extends core.Object {
>+  static get userAgent() {
>+    return html$.window.navigator.userAgent;
>+  }
>+  static get isOpera() {
>+    if (html_common.Device._isOpera == null) {
>+      html_common.Device._isOpera = html_common.Device.userAgent[$contains]("Opera", 0);
>+    }
>+    return html_common.Device._isOpera;
>+  }
>+  static get isIE() {
>+    if (html_common.Device._isIE == null) {
>+      html_common.Device._isIE = !dart.test(html_common.Device.isOpera) && html_common.Device.userAgent[$contains]("Trident/", 0);
>+    }
>+    return html_common.Device._isIE;
>+  }
>+  static get isFirefox() {
>+    if (html_common.Device._isFirefox == null) {
>+      html_common.Device._isFirefox = html_common.Device.userAgent[$contains]("Firefox", 0);
>+    }
>+    return html_common.Device._isFirefox;
>+  }
>+  static get isWebKit() {
>+    if (html_common.Device._isWebKit == null) {
>+      html_common.Device._isWebKit = !dart.test(html_common.Device.isOpera) && html_common.Device.userAgent[$contains]("WebKit", 0);
>+    }
>+    return html_common.Device._isWebKit;
>+  }
>+  static get cssPrefix() {
>+    let prefix = html_common.Device._cachedCssPrefix;
>+    if (prefix != null) return prefix;
>+    if (dart.test(html_common.Device.isFirefox)) {
>+      prefix = "-moz-";
>+    } else if (dart.test(html_common.Device.isIE)) {
>+      prefix = "-ms-";
>+    } else if (dart.test(html_common.Device.isOpera)) {
>+      prefix = "-o-";
>+    } else {
>+      prefix = "-webkit-";
>+    }
>+    return html_common.Device._cachedCssPrefix = prefix;
>+  }
>+  static get propertyPrefix() {
>+    let prefix = html_common.Device._cachedPropertyPrefix;
>+    if (prefix != null) return prefix;
>+    if (dart.test(html_common.Device.isFirefox)) {
>+      prefix = "moz";
>+    } else if (dart.test(html_common.Device.isIE)) {
>+      prefix = "ms";
>+    } else if (dart.test(html_common.Device.isOpera)) {
>+      prefix = "o";
>+    } else {
>+      prefix = "webkit";
>+    }
>+    return html_common.Device._cachedPropertyPrefix = prefix;
>+  }
>+  static isEventTypeSupported(eventType) {
>+    try {
>+      let e = html$.Event.eventType(eventType, "");
>+      return html$.Event.is(e);
>+    } catch (e$) {
>+      let _ = dart.getThrown(e$);
>+    }
>+    return false;
>+  }
>+};
>+(html_common.Device.new = function() {
>+}).prototype = html_common.Device.prototype;
>+dart.addTypeTests(html_common.Device);
>+dart.setLibraryUri(html_common.Device, "dart:html_common");
>+dart.defineLazy(html_common.Device, {
>+  /*html_common.Device._isOpera*/get _isOpera() {
>+    return null;
>+  },
>+  set _isOpera(_) {},
>+  /*html_common.Device._isIE*/get _isIE() {
>+    return null;
>+  },
>+  set _isIE(_) {},
>+  /*html_common.Device._isFirefox*/get _isFirefox() {
>+    return null;
>+  },
>+  set _isFirefox(_) {},
>+  /*html_common.Device._isWebKit*/get _isWebKit() {
>+    return null;
>+  },
>+  set _isWebKit(_) {},
>+  /*html_common.Device._cachedCssPrefix*/get _cachedCssPrefix() {
>+    return null;
>+  },
>+  set _cachedCssPrefix(_) {},
>+  /*html_common.Device._cachedPropertyPrefix*/get _cachedPropertyPrefix() {
>+    return null;
>+  },
>+  set _cachedPropertyPrefix(_) {}
>+});
>+const _childNodes = dart.privateName(html_common, "_childNodes");
>+const _node = dart.privateName(html_common, "_node");
>+const _iterable$0 = dart.privateName(html_common, "_iterable");
>+const _filtered = dart.privateName(html_common, "_filtered");
>+html_common.FilteredElementList = class FilteredElementList extends collection.ListBase$(html$.Element) {
>+  get [_iterable$0]() {
>+    return IterableOfElement()._check(this[_childNodes][$where](dart.fn(n => html$.Element.is(n), NodeTobool()))[$map](html$.Element, dart.fn(n => html$.Element.as(n), NodeToElement())));
>+  }
>+  get [_filtered]() {
>+    return ListOfElement().from(this[_iterable$0], {growable: false});
>+  }
>+  forEach(f) {
>+    this[_filtered][$forEach](f);
>+  }
>+  _set(index, value) {
>+    html$.Element._check(value);
>+    this._get(index)[$replaceWith](value);
>+    return value;
>+  }
>+  set length(newLength) {
>+    let len = this.length;
>+    if (dart.notNull(newLength) >= dart.notNull(len)) {
>+      return;
>+    } else if (dart.notNull(newLength) < 0) {
>+      dart.throw(new core.ArgumentError.new("Invalid list length"));
>+    }
>+    this.removeRange(newLength, len);
>+  }
>+  add(value) {
>+    html$.Element._check(value);
>+    this[_childNodes][$add](value);
>+  }
>+  addAll(iterable) {
>+    IterableOfElement()._check(iterable);
>+    for (let element of iterable) {
>+      this.add(element);
>+    }
>+  }
>+  contains(needle) {
>+    if (!html$.Element.is(needle)) return false;
>+    let element = html$.Element._check(needle);
>+    return dart.equals(element.parentNode, this[_node]);
>+  }
>+  get reversed() {
>+    return this[_filtered][$reversed];
>+  }
>+  sort(compare) {
>+    if (compare === void 0) compare = null;
>+    dart.throw(new core.UnsupportedError.new("Cannot sort filtered list"));
>+  }
>+  setRange(start, end, iterable, skipCount) {
>+    IterableOfElement()._check(iterable);
>+    if (skipCount === void 0) skipCount = 0;
>+    dart.throw(new core.UnsupportedError.new("Cannot setRange on filtered list"));
>+  }
>+  fillRange(start, end, fillValue) {
>+    if (fillValue === void 0) fillValue = null;
>+    html$.Element._check(fillValue);
>+    dart.throw(new core.UnsupportedError.new("Cannot fillRange on filtered list"));
>+  }
>+  replaceRange(start, end, iterable) {
>+    IterableOfElement()._check(iterable);
>+    dart.throw(new core.UnsupportedError.new("Cannot replaceRange on filtered list"));
>+  }
>+  removeRange(start, end) {
>+    core.List.from(this[_iterable$0][$skip](start)[$take](dart.notNull(end) - dart.notNull(start)))[$forEach](dart.fn(el => dart.dsend(el, 'remove', []), dynamicTodynamic()));
>+  }
>+  clear() {
>+    this[_childNodes][$clear]();
>+  }
>+  removeLast() {
>+    let result = this[_iterable$0][$last];
>+    if (result != null) {
>+      result[$remove]();
>+    }
>+    return result;
>+  }
>+  insert(index, value) {
>+    html$.Element._check(value);
>+    if (index == this.length) {
>+      this.add(value);
>+    } else {
>+      let element = this[_iterable$0][$elementAt](index);
>+      element.parentNode.insertBefore(value, element);
>+    }
>+  }
>+  insertAll(index, iterable) {
>+    IterableOfElement()._check(iterable);
>+    if (index == this.length) {
>+      this.addAll(iterable);
>+    } else {
>+      let element = this[_iterable$0][$elementAt](index);
>+      element.parentNode[$insertAllBefore](iterable, element);
>+    }
>+  }
>+  removeAt(index) {
>+    let result = this._get(index);
>+    result[$remove]();
>+    return result;
>+  }
>+  remove(element) {
>+    if (!html$.Element.is(element)) return false;
>+    if (dart.test(this.contains(element))) {
>+      html$.Element.as(element)[$remove]();
>+      return true;
>+    } else {
>+      return false;
>+    }
>+  }
>+  get length() {
>+    return this[_iterable$0][$length];
>+  }
>+  _get(index) {
>+    return this[_iterable$0][$elementAt](index);
>+  }
>+  get iterator() {
>+    return this[_filtered][$iterator];
>+  }
>+  get rawList() {
>+    return this[_node].childNodes;
>+  }
>+};
>+(html_common.FilteredElementList.new = function(node) {
>+  this[_childNodes] = node[$nodes];
>+  this[_node] = node;
>+}).prototype = html_common.FilteredElementList.prototype;
>+dart.addTypeTests(html_common.FilteredElementList);
>+html_common.FilteredElementList[dart.implements] = () => [html_common.NodeListWrapper];
>+dart.setMethodSignature(html_common.FilteredElementList, () => ({
>+  __proto__: dart.getMethods(html_common.FilteredElementList.__proto__),
>+  forEach: dart.fnType(dart.void, [dart.fnType(dart.void, [html$.Element])]),
>+  [$forEach]: dart.fnType(dart.void, [dart.fnType(dart.void, [html$.Element])]),
>+  _set: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  add: dart.fnType(dart.void, [core.Object]),
>+  [$add]: dart.fnType(dart.void, [core.Object]),
>+  addAll: dart.fnType(dart.void, [core.Object]),
>+  [$addAll]: dart.fnType(dart.void, [core.Object]),
>+  contains: dart.fnType(core.bool, [core.Object]),
>+  [$contains]: dart.fnType(core.bool, [core.Object]),
>+  sort: dart.fnType(dart.void, [], [dart.fnType(core.int, [html$.Element, html$.Element])]),
>+  [$sort]: dart.fnType(dart.void, [], [dart.fnType(core.int, [html$.Element, html$.Element])]),
>+  setRange: dart.fnType(dart.void, [core.int, core.int, core.Object], [core.int]),
>+  [$setRange]: dart.fnType(dart.void, [core.int, core.int, core.Object], [core.int]),
>+  fillRange: dart.fnType(dart.void, [core.int, core.int], [core.Object]),
>+  [$fillRange]: dart.fnType(dart.void, [core.int, core.int], [core.Object]),
>+  replaceRange: dart.fnType(dart.void, [core.int, core.int, core.Object]),
>+  [$replaceRange]: dart.fnType(dart.void, [core.int, core.int, core.Object]),
>+  removeRange: dart.fnType(dart.void, [core.int, core.int]),
>+  [$removeRange]: dart.fnType(dart.void, [core.int, core.int]),
>+  clear: dart.fnType(dart.void, []),
>+  [$clear]: dart.fnType(dart.void, []),
>+  removeLast: dart.fnType(html$.Element, []),
>+  [$removeLast]: dart.fnType(html$.Element, []),
>+  insert: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$insert]: dart.fnType(dart.void, [core.int, core.Object]),
>+  insertAll: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$insertAll]: dart.fnType(dart.void, [core.int, core.Object]),
>+  removeAt: dart.fnType(html$.Element, [core.int]),
>+  [$removeAt]: dart.fnType(html$.Element, [core.int]),
>+  remove: dart.fnType(core.bool, [core.Object]),
>+  [$remove]: dart.fnType(core.bool, [core.Object]),
>+  _get: dart.fnType(html$.Element, [core.int]),
>+  [$_get]: dart.fnType(html$.Element, [core.int])
>+}));
>+dart.setGetterSignature(html_common.FilteredElementList, () => ({
>+  __proto__: dart.getGetters(html_common.FilteredElementList.__proto__),
>+  [_iterable$0]: core.Iterable$(html$.Element),
>+  [_filtered]: core.List$(html$.Element),
>+  reversed: core.Iterable$(html$.Element),
>+  [$reversed]: core.Iterable$(html$.Element),
>+  length: core.int,
>+  [$length]: core.int,
>+  iterator: core.Iterator$(html$.Element),
>+  [$iterator]: core.Iterator$(html$.Element),
>+  rawList: core.List$(html$.Node)
>+}));
>+dart.setSetterSignature(html_common.FilteredElementList, () => ({
>+  __proto__: dart.getSetters(html_common.FilteredElementList.__proto__),
>+  length: core.int,
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(html_common.FilteredElementList, "dart:html_common");
>+dart.setFieldSignature(html_common.FilteredElementList, () => ({
>+  __proto__: dart.getFields(html_common.FilteredElementList.__proto__),
>+  [_node]: dart.finalFieldType(html$.Node),
>+  [_childNodes]: dart.finalFieldType(ListOfNode())
>+}));
>+dart.defineExtensionMethods(html_common.FilteredElementList, [
>+  'forEach',
>+  '_set',
>+  'add',
>+  'addAll',
>+  'contains',
>+  'sort',
>+  'setRange',
>+  'fillRange',
>+  'replaceRange',
>+  'removeRange',
>+  'clear',
>+  'removeLast',
>+  'insert',
>+  'insertAll',
>+  'removeAt',
>+  'remove',
>+  '_get'
>+]);
>+dart.defineExtensionAccessors(html_common.FilteredElementList, ['length', 'reversed', 'iterator']);
>+html_common.Lists = class Lists extends core.Object {
>+  static indexOf(a, element, startIndex, endIndex) {
>+    if (dart.notNull(startIndex) >= dart.notNull(a[$length])) {
>+      return -1;
>+    }
>+    if (dart.notNull(startIndex) < 0) {
>+      startIndex = 0;
>+    }
>+    for (let i = startIndex; dart.notNull(i) < dart.notNull(endIndex); i = dart.notNull(i) + 1) {
>+      if (dart.equals(a[$_get](i), element)) {
>+        return i;
>+      }
>+    }
>+    return -1;
>+  }
>+  static lastIndexOf(a, element, startIndex) {
>+    if (dart.notNull(startIndex) < 0) {
>+      return -1;
>+    }
>+    if (dart.notNull(startIndex) >= dart.notNull(a[$length])) {
>+      startIndex = dart.notNull(a[$length]) - 1;
>+    }
>+    for (let i = startIndex; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
>+      if (dart.equals(a[$_get](i), element)) {
>+        return i;
>+      }
>+    }
>+    return -1;
>+  }
>+  static getRange(a, start, end, accumulator) {
>+    if (dart.notNull(start) < 0) dart.throw(new core.RangeError.value(start));
>+    if (dart.notNull(end) < dart.notNull(start)) dart.throw(new core.RangeError.value(end));
>+    if (dart.notNull(end) > dart.notNull(a[$length])) dart.throw(new core.RangeError.value(end));
>+    for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
>+      accumulator[$add](a[$_get](i));
>+    }
>+    return accumulator;
>+  }
>+};
>+(html_common.Lists.new = function() {
>+}).prototype = html_common.Lists.prototype;
>+dart.addTypeTests(html_common.Lists);
>+dart.setLibraryUri(html_common.Lists, "dart:html_common");
>+html_common.NodeListWrapper = class NodeListWrapper extends core.Object {};
>+(html_common.NodeListWrapper.new = function() {
>+}).prototype = html_common.NodeListWrapper.prototype;
>+dart.addTypeTests(html_common.NodeListWrapper);
>+dart.setLibraryUri(html_common.NodeListWrapper, "dart:html_common");
>+svg$._SvgElementFactoryProvider = class _SvgElementFactoryProvider extends core.Object {
>+  static createSvgElement_tag(tag) {
>+    let temp = html$.document[$createElementNS]("http://www.w3.org/2000/svg", tag);
>+    return svg$.SvgElement._check(temp);
>+  }
>+};
>+(svg$._SvgElementFactoryProvider.new = function() {
>+}).prototype = svg$._SvgElementFactoryProvider.prototype;
>+dart.addTypeTests(svg$._SvgElementFactoryProvider);
>+dart.setLibraryUri(svg$._SvgElementFactoryProvider, "dart:svg");
>+const _children$ = dart.privateName(svg$, "_children");
>+const _svgClassName = dart.privateName(svg$, "_svgClassName");
>+svg$.SvgElement = class SvgElement extends html$.Element {
>+  static tag(tag) {
>+    return svg$.SvgElement._check(html$.document[$createElementNS]("http://www.w3.org/2000/svg", tag));
>+  }
>+  static svg(svg, opts) {
>+    let validator = opts && 'validator' in opts ? opts.validator : null;
>+    let treeSanitizer = opts && 'treeSanitizer' in opts ? opts.treeSanitizer : null;
>+    if (validator == null && treeSanitizer == null) {
>+      validator = new html$.NodeValidatorBuilder.common();
>+      validator.allowSvg();
>+    }
>+    let match = svg$.SvgElement._START_TAG_REGEXP.firstMatch(svg);
>+    let parentElement = null;
>+    if (match != null && match.group(1)[$toLowerCase]() === "svg") {
>+      parentElement = html$.document.body;
>+    } else {
>+      parentElement = svg$.SvgSvgElement.new();
>+    }
>+    let fragment = dart.dsend(parentElement, 'createFragment', [svg], {validator: validator, treeSanitizer: treeSanitizer});
>+    return svg$.SvgElement._check(dart.dload(dart.dsend(dart.dload(fragment, 'nodes'), 'where', [dart.fn(e => svg$.SvgElement.is(e), dynamicTobool())]), 'single'));
>+  }
>+  get [$classes]() {
>+    return new svg$.AttributeClassSet.new(this);
>+  }
>+  set [$classes](value) {
>+    super[$classes] = value;
>+  }
>+  get [$children]() {
>+    return new html_common.FilteredElementList.new(this);
>+  }
>+  set [$children](value) {
>+    let children = this[$children];
>+    children[$clear]();
>+    children[$addAll](value);
>+  }
>+  get [$outerHtml]() {
>+    let container = html$.DivElement.new();
>+    let cloned = svg$.SvgElement._check(this[$clone](true));
>+    container[$children][$add](cloned);
>+    return container[$innerHtml];
>+  }
>+  get [$innerHtml]() {
>+    let container = html$.DivElement.new();
>+    let cloned = svg$.SvgElement._check(this[$clone](true));
>+    container[$children][$addAll](cloned[$children]);
>+    return container[$innerHtml];
>+  }
>+  set [$innerHtml](value) {
>+    this[$setInnerHtml](value);
>+  }
>+  [$createFragment](svg, opts) {
>+    let validator = opts && 'validator' in opts ? opts.validator : null;
>+    let treeSanitizer = opts && 'treeSanitizer' in opts ? opts.treeSanitizer : null;
>+    if (treeSanitizer == null) {
>+      if (validator == null) {
>+        validator = new html$.NodeValidatorBuilder.common();
>+        validator.allowSvg();
>+      }
>+      treeSanitizer = html$.NodeTreeSanitizer.new(validator);
>+    }
>+    let html = "<svg version=\"1.1\">" + dart.str(svg) + "</svg>";
>+    let fragment = html$.document.body[$createFragment](html, {treeSanitizer: treeSanitizer});
>+    let svgFragment = html$.DocumentFragment.new();
>+    let root = fragment[$nodes][$single];
>+    while (root.firstChild != null) {
>+      svgFragment[$append](root.firstChild);
>+    }
>+    return svgFragment;
>+  }
>+  [$insertAdjacentText](where, text) {
>+    dart.throw(new core.UnsupportedError.new("Cannot invoke insertAdjacentText on SVG."));
>+  }
>+  [$insertAdjacentHtml](where, text, opts) {
>+    let validator = opts && 'validator' in opts ? opts.validator : null;
>+    let treeSanitizer = opts && 'treeSanitizer' in opts ? opts.treeSanitizer : null;
>+    dart.throw(new core.UnsupportedError.new("Cannot invoke insertAdjacentHtml on SVG."));
>+  }
>+  [$insertAdjacentElement](where, element) {
>+    dart.throw(new core.UnsupportedError.new("Cannot invoke insertAdjacentElement on SVG."));
>+  }
>+  get [_children$]() {
>+    dart.throw(new core.UnsupportedError.new("Cannot get _children on SVG."));
>+  }
>+  get [$isContentEditable]() {
>+    return false;
>+  }
>+  [$click]() {
>+    dart.throw(new core.UnsupportedError.new("Cannot invoke click SVG."));
>+  }
>+  static isTagSupported(tag) {
>+    let e = svg$.SvgElement.tag(tag);
>+    return svg$.SvgElement.is(e) && !html$.UnknownElement.is(e);
>+  }
>+  get [_svgClassName]() {
>+    return this.className;
>+  }
>+  get [$ownerSvgElement]() {
>+    return this.ownerSVGElement;
>+  }
>+  get [$viewportElement]() {
>+    return this.viewportElement;
>+  }
>+  [$blur](...args) {
>+    return this.blur.apply(this, args);
>+  }
>+  [$focus](...args) {
>+    return this.focus.apply(this, args);
>+  }
>+  get [$nonce]() {
>+    return this.nonce;
>+  }
>+  set [$nonce](value) {
>+    this.nonce = value;
>+  }
>+  get [$onAbort]() {
>+    return svg$.SvgElement.abortEvent.forElement(this);
>+  }
>+  get [$onBlur]() {
>+    return svg$.SvgElement.blurEvent.forElement(this);
>+  }
>+  get [$onCanPlay]() {
>+    return svg$.SvgElement.canPlayEvent.forElement(this);
>+  }
>+  get [$onCanPlayThrough]() {
>+    return svg$.SvgElement.canPlayThroughEvent.forElement(this);
>+  }
>+  get [$onChange]() {
>+    return svg$.SvgElement.changeEvent.forElement(this);
>+  }
>+  get [$onClick]() {
>+    return svg$.SvgElement.clickEvent.forElement(this);
>+  }
>+  get [$onContextMenu]() {
>+    return svg$.SvgElement.contextMenuEvent.forElement(this);
>+  }
>+  get [$onDoubleClick]() {
>+    return svg$.SvgElement.doubleClickEvent.forElement(this);
>+  }
>+  get [$onDrag]() {
>+    return svg$.SvgElement.dragEvent.forElement(this);
>+  }
>+  get [$onDragEnd]() {
>+    return svg$.SvgElement.dragEndEvent.forElement(this);
>+  }
>+  get [$onDragEnter]() {
>+    return svg$.SvgElement.dragEnterEvent.forElement(this);
>+  }
>+  get [$onDragLeave]() {
>+    return svg$.SvgElement.dragLeaveEvent.forElement(this);
>+  }
>+  get [$onDragOver]() {
>+    return svg$.SvgElement.dragOverEvent.forElement(this);
>+  }
>+  get [$onDragStart]() {
>+    return svg$.SvgElement.dragStartEvent.forElement(this);
>+  }
>+  get [$onDrop]() {
>+    return svg$.SvgElement.dropEvent.forElement(this);
>+  }
>+  get [$onDurationChange]() {
>+    return svg$.SvgElement.durationChangeEvent.forElement(this);
>+  }
>+  get [$onEmptied]() {
>+    return svg$.SvgElement.emptiedEvent.forElement(this);
>+  }
>+  get [$onEnded]() {
>+    return svg$.SvgElement.endedEvent.forElement(this);
>+  }
>+  get [$onError]() {
>+    return svg$.SvgElement.errorEvent.forElement(this);
>+  }
>+  get [$onFocus]() {
>+    return svg$.SvgElement.focusEvent.forElement(this);
>+  }
>+  get [$onInput]() {
>+    return svg$.SvgElement.inputEvent.forElement(this);
>+  }
>+  get [$onInvalid]() {
>+    return svg$.SvgElement.invalidEvent.forElement(this);
>+  }
>+  get [$onKeyDown]() {
>+    return svg$.SvgElement.keyDownEvent.forElement(this);
>+  }
>+  get [$onKeyPress]() {
>+    return svg$.SvgElement.keyPressEvent.forElement(this);
>+  }
>+  get [$onKeyUp]() {
>+    return svg$.SvgElement.keyUpEvent.forElement(this);
>+  }
>+  get [$onLoad]() {
>+    return svg$.SvgElement.loadEvent.forElement(this);
>+  }
>+  get [$onLoadedData]() {
>+    return svg$.SvgElement.loadedDataEvent.forElement(this);
>+  }
>+  get [$onLoadedMetadata]() {
>+    return svg$.SvgElement.loadedMetadataEvent.forElement(this);
>+  }
>+  get [$onMouseDown]() {
>+    return svg$.SvgElement.mouseDownEvent.forElement(this);
>+  }
>+  get [$onMouseEnter]() {
>+    return svg$.SvgElement.mouseEnterEvent.forElement(this);
>+  }
>+  get [$onMouseLeave]() {
>+    return svg$.SvgElement.mouseLeaveEvent.forElement(this);
>+  }
>+  get [$onMouseMove]() {
>+    return svg$.SvgElement.mouseMoveEvent.forElement(this);
>+  }
>+  get [$onMouseOut]() {
>+    return svg$.SvgElement.mouseOutEvent.forElement(this);
>+  }
>+  get [$onMouseOver]() {
>+    return svg$.SvgElement.mouseOverEvent.forElement(this);
>+  }
>+  get [$onMouseUp]() {
>+    return svg$.SvgElement.mouseUpEvent.forElement(this);
>+  }
>+  get [$onMouseWheel]() {
>+    return svg$.SvgElement.mouseWheelEvent.forElement(this);
>+  }
>+  get [$onPause]() {
>+    return svg$.SvgElement.pauseEvent.forElement(this);
>+  }
>+  get [$onPlay]() {
>+    return svg$.SvgElement.playEvent.forElement(this);
>+  }
>+  get [$onPlaying]() {
>+    return svg$.SvgElement.playingEvent.forElement(this);
>+  }
>+  get [$onRateChange]() {
>+    return svg$.SvgElement.rateChangeEvent.forElement(this);
>+  }
>+  get [$onReset]() {
>+    return svg$.SvgElement.resetEvent.forElement(this);
>+  }
>+  get [$onResize]() {
>+    return svg$.SvgElement.resizeEvent.forElement(this);
>+  }
>+  get [$onScroll]() {
>+    return svg$.SvgElement.scrollEvent.forElement(this);
>+  }
>+  get [$onSeeked]() {
>+    return svg$.SvgElement.seekedEvent.forElement(this);
>+  }
>+  get [$onSeeking]() {
>+    return svg$.SvgElement.seekingEvent.forElement(this);
>+  }
>+  get [$onSelect]() {
>+    return svg$.SvgElement.selectEvent.forElement(this);
>+  }
>+  get [$onStalled]() {
>+    return svg$.SvgElement.stalledEvent.forElement(this);
>+  }
>+  get [$onSubmit]() {
>+    return svg$.SvgElement.submitEvent.forElement(this);
>+  }
>+  get [$onSuspend]() {
>+    return svg$.SvgElement.suspendEvent.forElement(this);
>+  }
>+  get [$onTimeUpdate]() {
>+    return svg$.SvgElement.timeUpdateEvent.forElement(this);
>+  }
>+  get [$onTouchCancel]() {
>+    return svg$.SvgElement.touchCancelEvent.forElement(this);
>+  }
>+  get [$onTouchEnd]() {
>+    return svg$.SvgElement.touchEndEvent.forElement(this);
>+  }
>+  get [$onTouchMove]() {
>+    return svg$.SvgElement.touchMoveEvent.forElement(this);
>+  }
>+  get [$onTouchStart]() {
>+    return svg$.SvgElement.touchStartEvent.forElement(this);
>+  }
>+  get [$onVolumeChange]() {
>+    return svg$.SvgElement.volumeChangeEvent.forElement(this);
>+  }
>+  get [$onWaiting]() {
>+    return svg$.SvgElement.waitingEvent.forElement(this);
>+  }
>+  get [$onWheel]() {
>+    return svg$.SvgElement.wheelEvent.forElement(this);
>+  }
>+};
>+(svg$.SvgElement.created = function() {
>+  this[ownerSvgElement] = null;
>+  this[viewportElement] = null;
>+  this[nonce$0] = null;
>+  svg$.SvgElement.__proto__.created.call(this);
>+}).prototype = svg$.SvgElement.prototype;
>+dart.addTypeTests(svg$.SvgElement);
>+const ownerSvgElement = Symbol("SvgElement.ownerSvgElement");
>+const viewportElement = Symbol("SvgElement.viewportElement");
>+const nonce$0 = Symbol("SvgElement.nonce");
>+svg$.SvgElement[dart.implements] = () => [html$.GlobalEventHandlers, html$.NoncedElement];
>+dart.setGetterSignature(svg$.SvgElement, () => ({
>+  __proto__: dart.getGetters(svg$.SvgElement.__proto__),
>+  [_children$]: html$.HtmlCollection,
>+  [_svgClassName]: svg$.AnimatedString
>+}));
>+dart.setLibraryUri(svg$.SvgElement, "dart:svg");
>+dart.setFieldSignature(svg$.SvgElement, () => ({
>+  __proto__: dart.getFields(svg$.SvgElement.__proto__),
>+  [$ownerSvgElement]: dart.finalFieldType(svg$.SvgSvgElement),
>+  [$viewportElement]: dart.finalFieldType(svg$.SvgElement),
>+  [$nonce]: dart.fieldType(core.String)
>+}));
>+dart.defineLazy(svg$.SvgElement, {
>+  /*svg$.SvgElement._START_TAG_REGEXP*/get _START_TAG_REGEXP() {
>+    return core.RegExp.new("<(\\w+)");
>+  },
>+  /*svg$.SvgElement.abortEvent*/get abortEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("abort"));
>+  },
>+  /*svg$.SvgElement.blurEvent*/get blurEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("blur"));
>+  },
>+  /*svg$.SvgElement.canPlayEvent*/get canPlayEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("canplay"));
>+  },
>+  /*svg$.SvgElement.canPlayThroughEvent*/get canPlayThroughEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("canplaythrough"));
>+  },
>+  /*svg$.SvgElement.changeEvent*/get changeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("change"));
>+  },
>+  /*svg$.SvgElement.clickEvent*/get clickEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("click"));
>+  },
>+  /*svg$.SvgElement.contextMenuEvent*/get contextMenuEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("contextmenu"));
>+  },
>+  /*svg$.SvgElement.doubleClickEvent*/get doubleClickEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("dblclick"));
>+  },
>+  /*svg$.SvgElement.dragEvent*/get dragEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("drag"));
>+  },
>+  /*svg$.SvgElement.dragEndEvent*/get dragEndEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("dragend"));
>+  },
>+  /*svg$.SvgElement.dragEnterEvent*/get dragEnterEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("dragenter"));
>+  },
>+  /*svg$.SvgElement.dragLeaveEvent*/get dragLeaveEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("dragleave"));
>+  },
>+  /*svg$.SvgElement.dragOverEvent*/get dragOverEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("dragover"));
>+  },
>+  /*svg$.SvgElement.dragStartEvent*/get dragStartEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("dragstart"));
>+  },
>+  /*svg$.SvgElement.dropEvent*/get dropEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("drop"));
>+  },
>+  /*svg$.SvgElement.durationChangeEvent*/get durationChangeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("durationchange"));
>+  },
>+  /*svg$.SvgElement.emptiedEvent*/get emptiedEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("emptied"));
>+  },
>+  /*svg$.SvgElement.endedEvent*/get endedEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("ended"));
>+  },
>+  /*svg$.SvgElement.errorEvent*/get errorEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("error"));
>+  },
>+  /*svg$.SvgElement.focusEvent*/get focusEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("focus"));
>+  },
>+  /*svg$.SvgElement.inputEvent*/get inputEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("input"));
>+  },
>+  /*svg$.SvgElement.invalidEvent*/get invalidEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("invalid"));
>+  },
>+  /*svg$.SvgElement.keyDownEvent*/get keyDownEvent() {
>+    return dart.const(new (EventStreamProviderOfKeyboardEvent()).new("keydown"));
>+  },
>+  /*svg$.SvgElement.keyPressEvent*/get keyPressEvent() {
>+    return dart.const(new (EventStreamProviderOfKeyboardEvent()).new("keypress"));
>+  },
>+  /*svg$.SvgElement.keyUpEvent*/get keyUpEvent() {
>+    return dart.const(new (EventStreamProviderOfKeyboardEvent()).new("keyup"));
>+  },
>+  /*svg$.SvgElement.loadEvent*/get loadEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("load"));
>+  },
>+  /*svg$.SvgElement.loadedDataEvent*/get loadedDataEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("loadeddata"));
>+  },
>+  /*svg$.SvgElement.loadedMetadataEvent*/get loadedMetadataEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("loadedmetadata"));
>+  },
>+  /*svg$.SvgElement.mouseDownEvent*/get mouseDownEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("mousedown"));
>+  },
>+  /*svg$.SvgElement.mouseEnterEvent*/get mouseEnterEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("mouseenter"));
>+  },
>+  /*svg$.SvgElement.mouseLeaveEvent*/get mouseLeaveEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("mouseleave"));
>+  },
>+  /*svg$.SvgElement.mouseMoveEvent*/get mouseMoveEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("mousemove"));
>+  },
>+  /*svg$.SvgElement.mouseOutEvent*/get mouseOutEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("mouseout"));
>+  },
>+  /*svg$.SvgElement.mouseOverEvent*/get mouseOverEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("mouseover"));
>+  },
>+  /*svg$.SvgElement.mouseUpEvent*/get mouseUpEvent() {
>+    return dart.const(new (EventStreamProviderOfMouseEvent()).new("mouseup"));
>+  },
>+  /*svg$.SvgElement.mouseWheelEvent*/get mouseWheelEvent() {
>+    return dart.const(new (EventStreamProviderOfWheelEvent()).new("mousewheel"));
>+  },
>+  /*svg$.SvgElement.pauseEvent*/get pauseEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("pause"));
>+  },
>+  /*svg$.SvgElement.playEvent*/get playEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("play"));
>+  },
>+  /*svg$.SvgElement.playingEvent*/get playingEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("playing"));
>+  },
>+  /*svg$.SvgElement.rateChangeEvent*/get rateChangeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("ratechange"));
>+  },
>+  /*svg$.SvgElement.resetEvent*/get resetEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("reset"));
>+  },
>+  /*svg$.SvgElement.resizeEvent*/get resizeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("resize"));
>+  },
>+  /*svg$.SvgElement.scrollEvent*/get scrollEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("scroll"));
>+  },
>+  /*svg$.SvgElement.seekedEvent*/get seekedEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("seeked"));
>+  },
>+  /*svg$.SvgElement.seekingEvent*/get seekingEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("seeking"));
>+  },
>+  /*svg$.SvgElement.selectEvent*/get selectEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("select"));
>+  },
>+  /*svg$.SvgElement.stalledEvent*/get stalledEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("stalled"));
>+  },
>+  /*svg$.SvgElement.submitEvent*/get submitEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("submit"));
>+  },
>+  /*svg$.SvgElement.suspendEvent*/get suspendEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("suspend"));
>+  },
>+  /*svg$.SvgElement.timeUpdateEvent*/get timeUpdateEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("timeupdate"));
>+  },
>+  /*svg$.SvgElement.touchCancelEvent*/get touchCancelEvent() {
>+    return dart.const(new (EventStreamProviderOfTouchEvent()).new("touchcancel"));
>+  },
>+  /*svg$.SvgElement.touchEndEvent*/get touchEndEvent() {
>+    return dart.const(new (EventStreamProviderOfTouchEvent()).new("touchend"));
>+  },
>+  /*svg$.SvgElement.touchMoveEvent*/get touchMoveEvent() {
>+    return dart.const(new (EventStreamProviderOfTouchEvent()).new("touchmove"));
>+  },
>+  /*svg$.SvgElement.touchStartEvent*/get touchStartEvent() {
>+    return dart.const(new (EventStreamProviderOfTouchEvent()).new("touchstart"));
>+  },
>+  /*svg$.SvgElement.volumeChangeEvent*/get volumeChangeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("volumechange"));
>+  },
>+  /*svg$.SvgElement.waitingEvent*/get waitingEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("waiting"));
>+  },
>+  /*svg$.SvgElement.wheelEvent*/get wheelEvent() {
>+    return dart.const(new (EventStreamProviderOfWheelEvent()).new("wheel"));
>+  }
>+});
>+dart.registerExtension("SVGElement", svg$.SvgElement);
>+svg$.GraphicsElement = class GraphicsElement extends svg$.SvgElement {
>+  get [$farthestViewportElement]() {
>+    return this.farthestViewportElement;
>+  }
>+  get [$nearestViewportElement]() {
>+    return this.nearestViewportElement;
>+  }
>+  get [$transform]() {
>+    return this.transform;
>+  }
>+  [$getBBox](...args) {
>+    return this.getBBox.apply(this, args);
>+  }
>+  [$getCtm](...args) {
>+    return this.getCTM.apply(this, args);
>+  }
>+  [$getScreenCtm](...args) {
>+    return this.getScreenCTM.apply(this, args);
>+  }
>+  get [$requiredExtensions]() {
>+    return this.requiredExtensions;
>+  }
>+  get [$systemLanguage]() {
>+    return this.systemLanguage;
>+  }
>+};
>+(svg$.GraphicsElement.created = function() {
>+  this[farthestViewportElement] = null;
>+  this[nearestViewportElement] = null;
>+  this[transform] = null;
>+  this[requiredExtensions] = null;
>+  this[systemLanguage] = null;
>+  svg$.GraphicsElement.__proto__.created.call(this);
>+}).prototype = svg$.GraphicsElement.prototype;
>+dart.addTypeTests(svg$.GraphicsElement);
>+const farthestViewportElement = Symbol("GraphicsElement.farthestViewportElement");
>+const nearestViewportElement = Symbol("GraphicsElement.nearestViewportElement");
>+const transform = Symbol("GraphicsElement.transform");
>+const requiredExtensions = Symbol("GraphicsElement.requiredExtensions");
>+const systemLanguage = Symbol("GraphicsElement.systemLanguage");
>+svg$.GraphicsElement[dart.implements] = () => [svg$.Tests];
>+dart.setMethodSignature(svg$.GraphicsElement, () => ({
>+  __proto__: dart.getMethods(svg$.GraphicsElement.__proto__),
>+  [$getBBox]: dart.fnType(svg$.Rect, []),
>+  [$getCtm]: dart.fnType(svg$.Matrix, []),
>+  [$getScreenCtm]: dart.fnType(svg$.Matrix, [])
>+}));
>+dart.setLibraryUri(svg$.GraphicsElement, "dart:svg");
>+dart.setFieldSignature(svg$.GraphicsElement, () => ({
>+  __proto__: dart.getFields(svg$.GraphicsElement.__proto__),
>+  [$farthestViewportElement]: dart.finalFieldType(svg$.SvgElement),
>+  [$nearestViewportElement]: dart.finalFieldType(svg$.SvgElement),
>+  [$transform]: dart.finalFieldType(svg$.AnimatedTransformList),
>+  [$requiredExtensions]: dart.finalFieldType(svg$.StringList),
>+  [$systemLanguage]: dart.finalFieldType(svg$.StringList)
>+}));
>+dart.registerExtension("SVGGraphicsElement", svg$.GraphicsElement);
>+svg$.AElement = class AElement extends svg$.GraphicsElement {
>+  static new() {
>+    return svg$.AElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("a"));
>+  }
>+  get [$target]() {
>+    return this.target;
>+  }
>+  get [$href]() {
>+    return this.href;
>+  }
>+};
>+(svg$.AElement.created = function() {
>+  this[target$7] = null;
>+  this[href$8] = null;
>+  svg$.AElement.__proto__.created.call(this);
>+}).prototype = svg$.AElement.prototype;
>+dart.addTypeTests(svg$.AElement);
>+const target$7 = Symbol("AElement.target");
>+const href$8 = Symbol("AElement.href");
>+svg$.AElement[dart.implements] = () => [svg$.UriReference];
>+dart.setLibraryUri(svg$.AElement, "dart:svg");
>+dart.setFieldSignature(svg$.AElement, () => ({
>+  __proto__: dart.getFields(svg$.AElement.__proto__),
>+  [$target]: dart.finalFieldType(svg$.AnimatedString),
>+  [$href]: dart.finalFieldType(svg$.AnimatedString)
>+}));
>+dart.registerExtension("SVGAElement", svg$.AElement);
>+svg$.Angle = class Angle extends _interceptors.Interceptor {
>+  get [$unitType]() {
>+    return this.unitType;
>+  }
>+  get [$value]() {
>+    return this.value;
>+  }
>+  set [$value](value) {
>+    this.value = value;
>+  }
>+  get [$valueAsString]() {
>+    return this.valueAsString;
>+  }
>+  set [$valueAsString](value) {
>+    this.valueAsString = value;
>+  }
>+  get [$valueInSpecifiedUnits]() {
>+    return this.valueInSpecifiedUnits;
>+  }
>+  set [$valueInSpecifiedUnits](value) {
>+    this.valueInSpecifiedUnits = value;
>+  }
>+  [$convertToSpecifiedUnits](...args) {
>+    return this.convertToSpecifiedUnits.apply(this, args);
>+  }
>+  [$newValueSpecifiedUnits](...args) {
>+    return this.newValueSpecifiedUnits.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(svg$.Angle);
>+const unitType = Symbol("Angle.unitType");
>+const value$18 = Symbol("Angle.value");
>+const valueAsString = Symbol("Angle.valueAsString");
>+const valueInSpecifiedUnits = Symbol("Angle.valueInSpecifiedUnits");
>+dart.setMethodSignature(svg$.Angle, () => ({
>+  __proto__: dart.getMethods(svg$.Angle.__proto__),
>+  [$convertToSpecifiedUnits]: dart.fnType(dart.void, [core.int]),
>+  [$newValueSpecifiedUnits]: dart.fnType(dart.void, [core.int, core.num])
>+}));
>+dart.setLibraryUri(svg$.Angle, "dart:svg");
>+dart.setFieldSignature(svg$.Angle, () => ({
>+  __proto__: dart.getFields(svg$.Angle.__proto__),
>+  [$unitType]: dart.finalFieldType(core.int),
>+  [$value]: dart.fieldType(core.num),
>+  [$valueAsString]: dart.fieldType(core.String),
>+  [$valueInSpecifiedUnits]: dart.fieldType(core.num)
>+}));
>+dart.defineLazy(svg$.Angle, {
>+  /*svg$.Angle.SVG_ANGLETYPE_DEG*/get SVG_ANGLETYPE_DEG() {
>+    return 2;
>+  },
>+  /*svg$.Angle.SVG_ANGLETYPE_GRAD*/get SVG_ANGLETYPE_GRAD() {
>+    return 4;
>+  },
>+  /*svg$.Angle.SVG_ANGLETYPE_RAD*/get SVG_ANGLETYPE_RAD() {
>+    return 3;
>+  },
>+  /*svg$.Angle.SVG_ANGLETYPE_UNKNOWN*/get SVG_ANGLETYPE_UNKNOWN() {
>+    return 0;
>+  },
>+  /*svg$.Angle.SVG_ANGLETYPE_UNSPECIFIED*/get SVG_ANGLETYPE_UNSPECIFIED() {
>+    return 1;
>+  }
>+});
>+dart.registerExtension("SVGAngle", svg$.Angle);
>+svg$.AnimationElement = class AnimationElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.AnimationElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("animation"));
>+  }
>+  get [$targetElement]() {
>+    return this.targetElement;
>+  }
>+  [$beginElement](...args) {
>+    return this.beginElement.apply(this, args);
>+  }
>+  [$beginElementAt](...args) {
>+    return this.beginElementAt.apply(this, args);
>+  }
>+  [$endElement](...args) {
>+    return this.endElement.apply(this, args);
>+  }
>+  [$endElementAt](...args) {
>+    return this.endElementAt.apply(this, args);
>+  }
>+  [$getCurrentTime](...args) {
>+    return this.getCurrentTime.apply(this, args);
>+  }
>+  [$getSimpleDuration](...args) {
>+    return this.getSimpleDuration.apply(this, args);
>+  }
>+  [$getStartTime](...args) {
>+    return this.getStartTime.apply(this, args);
>+  }
>+  get [$requiredExtensions]() {
>+    return this.requiredExtensions;
>+  }
>+  get [$systemLanguage]() {
>+    return this.systemLanguage;
>+  }
>+};
>+(svg$.AnimationElement.created = function() {
>+  this[targetElement] = null;
>+  this[requiredExtensions$] = null;
>+  this[systemLanguage$] = null;
>+  svg$.AnimationElement.__proto__.created.call(this);
>+}).prototype = svg$.AnimationElement.prototype;
>+dart.addTypeTests(svg$.AnimationElement);
>+const targetElement = Symbol("AnimationElement.targetElement");
>+const requiredExtensions$ = Symbol("AnimationElement.requiredExtensions");
>+const systemLanguage$ = Symbol("AnimationElement.systemLanguage");
>+svg$.AnimationElement[dart.implements] = () => [svg$.Tests];
>+dart.setMethodSignature(svg$.AnimationElement, () => ({
>+  __proto__: dart.getMethods(svg$.AnimationElement.__proto__),
>+  [$beginElement]: dart.fnType(dart.void, []),
>+  [$beginElementAt]: dart.fnType(dart.void, [core.num]),
>+  [$endElement]: dart.fnType(dart.void, []),
>+  [$endElementAt]: dart.fnType(dart.void, [core.num]),
>+  [$getCurrentTime]: dart.fnType(core.double, []),
>+  [$getSimpleDuration]: dart.fnType(core.double, []),
>+  [$getStartTime]: dart.fnType(core.double, [])
>+}));
>+dart.setLibraryUri(svg$.AnimationElement, "dart:svg");
>+dart.setFieldSignature(svg$.AnimationElement, () => ({
>+  __proto__: dart.getFields(svg$.AnimationElement.__proto__),
>+  [$targetElement]: dart.finalFieldType(svg$.SvgElement),
>+  [$requiredExtensions]: dart.finalFieldType(svg$.StringList),
>+  [$systemLanguage]: dart.finalFieldType(svg$.StringList)
>+}));
>+dart.registerExtension("SVGAnimationElement", svg$.AnimationElement);
>+svg$.AnimateElement = class AnimateElement extends svg$.AnimationElement {
>+  static new() {
>+    return svg$.AnimateElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("animate"));
>+  }
>+  static get supported() {
>+    return dart.test(svg$.SvgElement.isTagSupported("animate")) && svg$.AnimateElement.is(svg$.SvgElement.tag("animate"));
>+  }
>+};
>+(svg$.AnimateElement.created = function() {
>+  svg$.AnimateElement.__proto__.created.call(this);
>+}).prototype = svg$.AnimateElement.prototype;
>+dart.addTypeTests(svg$.AnimateElement);
>+dart.setLibraryUri(svg$.AnimateElement, "dart:svg");
>+dart.registerExtension("SVGAnimateElement", svg$.AnimateElement);
>+svg$.AnimateMotionElement = class AnimateMotionElement extends svg$.AnimationElement {
>+  static new() {
>+    return svg$.AnimateMotionElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("animateMotion"));
>+  }
>+  static get supported() {
>+    return dart.test(svg$.SvgElement.isTagSupported("animateMotion")) && svg$.AnimateMotionElement.is(svg$.SvgElement.tag("animateMotion"));
>+  }
>+};
>+(svg$.AnimateMotionElement.created = function() {
>+  svg$.AnimateMotionElement.__proto__.created.call(this);
>+}).prototype = svg$.AnimateMotionElement.prototype;
>+dart.addTypeTests(svg$.AnimateMotionElement);
>+dart.setLibraryUri(svg$.AnimateMotionElement, "dart:svg");
>+dart.registerExtension("SVGAnimateMotionElement", svg$.AnimateMotionElement);
>+svg$.AnimateTransformElement = class AnimateTransformElement extends svg$.AnimationElement {
>+  static new() {
>+    return svg$.AnimateTransformElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("animateTransform"));
>+  }
>+  static get supported() {
>+    return dart.test(svg$.SvgElement.isTagSupported("animateTransform")) && svg$.AnimateTransformElement.is(svg$.SvgElement.tag("animateTransform"));
>+  }
>+};
>+(svg$.AnimateTransformElement.created = function() {
>+  svg$.AnimateTransformElement.__proto__.created.call(this);
>+}).prototype = svg$.AnimateTransformElement.prototype;
>+dart.addTypeTests(svg$.AnimateTransformElement);
>+dart.setLibraryUri(svg$.AnimateTransformElement, "dart:svg");
>+dart.registerExtension("SVGAnimateTransformElement", svg$.AnimateTransformElement);
>+svg$.AnimatedAngle = class AnimatedAngle extends _interceptors.Interceptor {
>+  get [$animVal]() {
>+    return this.animVal;
>+  }
>+  get [$baseVal]() {
>+    return this.baseVal;
>+  }
>+};
>+dart.addTypeTests(svg$.AnimatedAngle);
>+const animVal = Symbol("AnimatedAngle.animVal");
>+const baseVal = Symbol("AnimatedAngle.baseVal");
>+dart.setLibraryUri(svg$.AnimatedAngle, "dart:svg");
>+dart.setFieldSignature(svg$.AnimatedAngle, () => ({
>+  __proto__: dart.getFields(svg$.AnimatedAngle.__proto__),
>+  [$animVal]: dart.finalFieldType(svg$.Angle),
>+  [$baseVal]: dart.finalFieldType(svg$.Angle)
>+}));
>+dart.registerExtension("SVGAnimatedAngle", svg$.AnimatedAngle);
>+svg$.AnimatedBoolean = class AnimatedBoolean extends _interceptors.Interceptor {
>+  get [$animVal]() {
>+    return this.animVal;
>+  }
>+  get [$baseVal]() {
>+    return this.baseVal;
>+  }
>+  set [$baseVal](value) {
>+    this.baseVal = value;
>+  }
>+};
>+dart.addTypeTests(svg$.AnimatedBoolean);
>+const animVal$ = Symbol("AnimatedBoolean.animVal");
>+const baseVal$ = Symbol("AnimatedBoolean.baseVal");
>+dart.setLibraryUri(svg$.AnimatedBoolean, "dart:svg");
>+dart.setFieldSignature(svg$.AnimatedBoolean, () => ({
>+  __proto__: dart.getFields(svg$.AnimatedBoolean.__proto__),
>+  [$animVal]: dart.finalFieldType(core.bool),
>+  [$baseVal]: dart.fieldType(core.bool)
>+}));
>+dart.registerExtension("SVGAnimatedBoolean", svg$.AnimatedBoolean);
>+svg$.AnimatedEnumeration = class AnimatedEnumeration extends _interceptors.Interceptor {
>+  get [$animVal]() {
>+    return this.animVal;
>+  }
>+  get [$baseVal]() {
>+    return this.baseVal;
>+  }
>+  set [$baseVal](value) {
>+    this.baseVal = value;
>+  }
>+};
>+dart.addTypeTests(svg$.AnimatedEnumeration);
>+const animVal$0 = Symbol("AnimatedEnumeration.animVal");
>+const baseVal$0 = Symbol("AnimatedEnumeration.baseVal");
>+dart.setLibraryUri(svg$.AnimatedEnumeration, "dart:svg");
>+dart.setFieldSignature(svg$.AnimatedEnumeration, () => ({
>+  __proto__: dart.getFields(svg$.AnimatedEnumeration.__proto__),
>+  [$animVal]: dart.finalFieldType(core.int),
>+  [$baseVal]: dart.fieldType(core.int)
>+}));
>+dart.registerExtension("SVGAnimatedEnumeration", svg$.AnimatedEnumeration);
>+svg$.AnimatedInteger = class AnimatedInteger extends _interceptors.Interceptor {
>+  get [$animVal]() {
>+    return this.animVal;
>+  }
>+  get [$baseVal]() {
>+    return this.baseVal;
>+  }
>+  set [$baseVal](value) {
>+    this.baseVal = value;
>+  }
>+};
>+dart.addTypeTests(svg$.AnimatedInteger);
>+const animVal$1 = Symbol("AnimatedInteger.animVal");
>+const baseVal$1 = Symbol("AnimatedInteger.baseVal");
>+dart.setLibraryUri(svg$.AnimatedInteger, "dart:svg");
>+dart.setFieldSignature(svg$.AnimatedInteger, () => ({
>+  __proto__: dart.getFields(svg$.AnimatedInteger.__proto__),
>+  [$animVal]: dart.finalFieldType(core.int),
>+  [$baseVal]: dart.fieldType(core.int)
>+}));
>+dart.registerExtension("SVGAnimatedInteger", svg$.AnimatedInteger);
>+svg$.AnimatedLength = class AnimatedLength extends _interceptors.Interceptor {
>+  get [$animVal]() {
>+    return this.animVal;
>+  }
>+  get [$baseVal]() {
>+    return this.baseVal;
>+  }
>+};
>+dart.addTypeTests(svg$.AnimatedLength);
>+const animVal$2 = Symbol("AnimatedLength.animVal");
>+const baseVal$2 = Symbol("AnimatedLength.baseVal");
>+dart.setLibraryUri(svg$.AnimatedLength, "dart:svg");
>+dart.setFieldSignature(svg$.AnimatedLength, () => ({
>+  __proto__: dart.getFields(svg$.AnimatedLength.__proto__),
>+  [$animVal]: dart.finalFieldType(svg$.Length),
>+  [$baseVal]: dart.finalFieldType(svg$.Length)
>+}));
>+dart.registerExtension("SVGAnimatedLength", svg$.AnimatedLength);
>+svg$.AnimatedLengthList = class AnimatedLengthList extends _interceptors.Interceptor {
>+  get [$animVal]() {
>+    return this.animVal;
>+  }
>+  get [$baseVal]() {
>+    return this.baseVal;
>+  }
>+};
>+dart.addTypeTests(svg$.AnimatedLengthList);
>+const animVal$3 = Symbol("AnimatedLengthList.animVal");
>+const baseVal$3 = Symbol("AnimatedLengthList.baseVal");
>+dart.setLibraryUri(svg$.AnimatedLengthList, "dart:svg");
>+dart.setFieldSignature(svg$.AnimatedLengthList, () => ({
>+  __proto__: dart.getFields(svg$.AnimatedLengthList.__proto__),
>+  [$animVal]: dart.finalFieldType(svg$.LengthList),
>+  [$baseVal]: dart.finalFieldType(svg$.LengthList)
>+}));
>+dart.registerExtension("SVGAnimatedLengthList", svg$.AnimatedLengthList);
>+svg$.AnimatedNumber = class AnimatedNumber extends _interceptors.Interceptor {
>+  get [$animVal]() {
>+    return this.animVal;
>+  }
>+  get [$baseVal]() {
>+    return this.baseVal;
>+  }
>+  set [$baseVal](value) {
>+    this.baseVal = value;
>+  }
>+};
>+dart.addTypeTests(svg$.AnimatedNumber);
>+const animVal$4 = Symbol("AnimatedNumber.animVal");
>+const baseVal$4 = Symbol("AnimatedNumber.baseVal");
>+dart.setLibraryUri(svg$.AnimatedNumber, "dart:svg");
>+dart.setFieldSignature(svg$.AnimatedNumber, () => ({
>+  __proto__: dart.getFields(svg$.AnimatedNumber.__proto__),
>+  [$animVal]: dart.finalFieldType(core.num),
>+  [$baseVal]: dart.fieldType(core.num)
>+}));
>+dart.registerExtension("SVGAnimatedNumber", svg$.AnimatedNumber);
>+svg$.AnimatedNumberList = class AnimatedNumberList extends _interceptors.Interceptor {
>+  get [$animVal]() {
>+    return this.animVal;
>+  }
>+  get [$baseVal]() {
>+    return this.baseVal;
>+  }
>+};
>+dart.addTypeTests(svg$.AnimatedNumberList);
>+const animVal$5 = Symbol("AnimatedNumberList.animVal");
>+const baseVal$5 = Symbol("AnimatedNumberList.baseVal");
>+dart.setLibraryUri(svg$.AnimatedNumberList, "dart:svg");
>+dart.setFieldSignature(svg$.AnimatedNumberList, () => ({
>+  __proto__: dart.getFields(svg$.AnimatedNumberList.__proto__),
>+  [$animVal]: dart.finalFieldType(svg$.NumberList),
>+  [$baseVal]: dart.finalFieldType(svg$.NumberList)
>+}));
>+dart.registerExtension("SVGAnimatedNumberList", svg$.AnimatedNumberList);
>+svg$.AnimatedPreserveAspectRatio = class AnimatedPreserveAspectRatio extends _interceptors.Interceptor {
>+  get [$animVal]() {
>+    return this.animVal;
>+  }
>+  get [$baseVal]() {
>+    return this.baseVal;
>+  }
>+};
>+dart.addTypeTests(svg$.AnimatedPreserveAspectRatio);
>+const animVal$6 = Symbol("AnimatedPreserveAspectRatio.animVal");
>+const baseVal$6 = Symbol("AnimatedPreserveAspectRatio.baseVal");
>+dart.setLibraryUri(svg$.AnimatedPreserveAspectRatio, "dart:svg");
>+dart.setFieldSignature(svg$.AnimatedPreserveAspectRatio, () => ({
>+  __proto__: dart.getFields(svg$.AnimatedPreserveAspectRatio.__proto__),
>+  [$animVal]: dart.finalFieldType(svg$.PreserveAspectRatio),
>+  [$baseVal]: dart.finalFieldType(svg$.PreserveAspectRatio)
>+}));
>+dart.registerExtension("SVGAnimatedPreserveAspectRatio", svg$.AnimatedPreserveAspectRatio);
>+svg$.AnimatedRect = class AnimatedRect extends _interceptors.Interceptor {
>+  get [$animVal]() {
>+    return this.animVal;
>+  }
>+  get [$baseVal]() {
>+    return this.baseVal;
>+  }
>+};
>+dart.addTypeTests(svg$.AnimatedRect);
>+const animVal$7 = Symbol("AnimatedRect.animVal");
>+const baseVal$7 = Symbol("AnimatedRect.baseVal");
>+dart.setLibraryUri(svg$.AnimatedRect, "dart:svg");
>+dart.setFieldSignature(svg$.AnimatedRect, () => ({
>+  __proto__: dart.getFields(svg$.AnimatedRect.__proto__),
>+  [$animVal]: dart.finalFieldType(svg$.Rect),
>+  [$baseVal]: dart.finalFieldType(svg$.Rect)
>+}));
>+dart.registerExtension("SVGAnimatedRect", svg$.AnimatedRect);
>+svg$.AnimatedString = class AnimatedString extends _interceptors.Interceptor {
>+  get [$animVal]() {
>+    return this.animVal;
>+  }
>+  get [$baseVal]() {
>+    return this.baseVal;
>+  }
>+  set [$baseVal](value) {
>+    this.baseVal = value;
>+  }
>+};
>+dart.addTypeTests(svg$.AnimatedString);
>+const animVal$8 = Symbol("AnimatedString.animVal");
>+const baseVal$8 = Symbol("AnimatedString.baseVal");
>+dart.setLibraryUri(svg$.AnimatedString, "dart:svg");
>+dart.setFieldSignature(svg$.AnimatedString, () => ({
>+  __proto__: dart.getFields(svg$.AnimatedString.__proto__),
>+  [$animVal]: dart.finalFieldType(core.String),
>+  [$baseVal]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("SVGAnimatedString", svg$.AnimatedString);
>+svg$.AnimatedTransformList = class AnimatedTransformList extends _interceptors.Interceptor {
>+  get [$animVal]() {
>+    return this.animVal;
>+  }
>+  get [$baseVal]() {
>+    return this.baseVal;
>+  }
>+};
>+dart.addTypeTests(svg$.AnimatedTransformList);
>+const animVal$9 = Symbol("AnimatedTransformList.animVal");
>+const baseVal$9 = Symbol("AnimatedTransformList.baseVal");
>+dart.setLibraryUri(svg$.AnimatedTransformList, "dart:svg");
>+dart.setFieldSignature(svg$.AnimatedTransformList, () => ({
>+  __proto__: dart.getFields(svg$.AnimatedTransformList.__proto__),
>+  [$animVal]: dart.finalFieldType(svg$.TransformList),
>+  [$baseVal]: dart.finalFieldType(svg$.TransformList)
>+}));
>+dart.registerExtension("SVGAnimatedTransformList", svg$.AnimatedTransformList);
>+svg$.GeometryElement = class GeometryElement extends svg$.GraphicsElement {
>+  get [$pathLength]() {
>+    return this.pathLength;
>+  }
>+  [$getPointAtLength](...args) {
>+    return this.getPointAtLength.apply(this, args);
>+  }
>+  [$getTotalLength](...args) {
>+    return this.getTotalLength.apply(this, args);
>+  }
>+  [$isPointInFill](...args) {
>+    return this.isPointInFill.apply(this, args);
>+  }
>+  [$isPointInStroke](...args) {
>+    return this.isPointInStroke.apply(this, args);
>+  }
>+};
>+(svg$.GeometryElement.created = function() {
>+  this[pathLength] = null;
>+  svg$.GeometryElement.__proto__.created.call(this);
>+}).prototype = svg$.GeometryElement.prototype;
>+dart.addTypeTests(svg$.GeometryElement);
>+const pathLength = Symbol("GeometryElement.pathLength");
>+dart.setMethodSignature(svg$.GeometryElement, () => ({
>+  __proto__: dart.getMethods(svg$.GeometryElement.__proto__),
>+  [$getPointAtLength]: dart.fnType(svg$.Point, [core.num]),
>+  [$getTotalLength]: dart.fnType(core.double, []),
>+  [$isPointInFill]: dart.fnType(core.bool, [svg$.Point]),
>+  [$isPointInStroke]: dart.fnType(core.bool, [svg$.Point])
>+}));
>+dart.setLibraryUri(svg$.GeometryElement, "dart:svg");
>+dart.setFieldSignature(svg$.GeometryElement, () => ({
>+  __proto__: dart.getFields(svg$.GeometryElement.__proto__),
>+  [$pathLength]: dart.finalFieldType(svg$.AnimatedNumber)
>+}));
>+dart.registerExtension("SVGGeometryElement", svg$.GeometryElement);
>+svg$.CircleElement = class CircleElement extends svg$.GeometryElement {
>+  static new() {
>+    return svg$.CircleElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("circle"));
>+  }
>+  get [$cx]() {
>+    return this.cx;
>+  }
>+  get [$cy]() {
>+    return this.cy;
>+  }
>+  get [$r]() {
>+    return this.r;
>+  }
>+};
>+(svg$.CircleElement.created = function() {
>+  this[cx] = null;
>+  this[cy] = null;
>+  this[r] = null;
>+  svg$.CircleElement.__proto__.created.call(this);
>+}).prototype = svg$.CircleElement.prototype;
>+dart.addTypeTests(svg$.CircleElement);
>+const cx = Symbol("CircleElement.cx");
>+const cy = Symbol("CircleElement.cy");
>+const r = Symbol("CircleElement.r");
>+dart.setLibraryUri(svg$.CircleElement, "dart:svg");
>+dart.setFieldSignature(svg$.CircleElement, () => ({
>+  __proto__: dart.getFields(svg$.CircleElement.__proto__),
>+  [$cx]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$cy]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$r]: dart.finalFieldType(svg$.AnimatedLength)
>+}));
>+dart.registerExtension("SVGCircleElement", svg$.CircleElement);
>+svg$.ClipPathElement = class ClipPathElement extends svg$.GraphicsElement {
>+  static new() {
>+    return svg$.ClipPathElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("clipPath"));
>+  }
>+  get [$clipPathUnits]() {
>+    return this.clipPathUnits;
>+  }
>+};
>+(svg$.ClipPathElement.created = function() {
>+  this[clipPathUnits] = null;
>+  svg$.ClipPathElement.__proto__.created.call(this);
>+}).prototype = svg$.ClipPathElement.prototype;
>+dart.addTypeTests(svg$.ClipPathElement);
>+const clipPathUnits = Symbol("ClipPathElement.clipPathUnits");
>+dart.setLibraryUri(svg$.ClipPathElement, "dart:svg");
>+dart.setFieldSignature(svg$.ClipPathElement, () => ({
>+  __proto__: dart.getFields(svg$.ClipPathElement.__proto__),
>+  [$clipPathUnits]: dart.finalFieldType(svg$.AnimatedEnumeration)
>+}));
>+dart.registerExtension("SVGClipPathElement", svg$.ClipPathElement);
>+svg$.DefsElement = class DefsElement extends svg$.GraphicsElement {
>+  static new() {
>+    return svg$.DefsElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("defs"));
>+  }
>+};
>+(svg$.DefsElement.created = function() {
>+  svg$.DefsElement.__proto__.created.call(this);
>+}).prototype = svg$.DefsElement.prototype;
>+dart.addTypeTests(svg$.DefsElement);
>+dart.setLibraryUri(svg$.DefsElement, "dart:svg");
>+dart.registerExtension("SVGDefsElement", svg$.DefsElement);
>+svg$.DescElement = class DescElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.DescElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("desc"));
>+  }
>+};
>+(svg$.DescElement.created = function() {
>+  svg$.DescElement.__proto__.created.call(this);
>+}).prototype = svg$.DescElement.prototype;
>+dart.addTypeTests(svg$.DescElement);
>+dart.setLibraryUri(svg$.DescElement, "dart:svg");
>+dart.registerExtension("SVGDescElement", svg$.DescElement);
>+svg$.DiscardElement = class DiscardElement extends svg$.SvgElement {};
>+(svg$.DiscardElement.created = function() {
>+  svg$.DiscardElement.__proto__.created.call(this);
>+}).prototype = svg$.DiscardElement.prototype;
>+dart.addTypeTests(svg$.DiscardElement);
>+dart.setLibraryUri(svg$.DiscardElement, "dart:svg");
>+dart.registerExtension("SVGDiscardElement", svg$.DiscardElement);
>+svg$.EllipseElement = class EllipseElement extends svg$.GeometryElement {
>+  static new() {
>+    return svg$.EllipseElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("ellipse"));
>+  }
>+  get [$cx]() {
>+    return this.cx;
>+  }
>+  get [$cy]() {
>+    return this.cy;
>+  }
>+  get [$rx]() {
>+    return this.rx;
>+  }
>+  get [$ry]() {
>+    return this.ry;
>+  }
>+};
>+(svg$.EllipseElement.created = function() {
>+  this[cx$] = null;
>+  this[cy$] = null;
>+  this[rx] = null;
>+  this[ry] = null;
>+  svg$.EllipseElement.__proto__.created.call(this);
>+}).prototype = svg$.EllipseElement.prototype;
>+dart.addTypeTests(svg$.EllipseElement);
>+const cx$ = Symbol("EllipseElement.cx");
>+const cy$ = Symbol("EllipseElement.cy");
>+const rx = Symbol("EllipseElement.rx");
>+const ry = Symbol("EllipseElement.ry");
>+dart.setLibraryUri(svg$.EllipseElement, "dart:svg");
>+dart.setFieldSignature(svg$.EllipseElement, () => ({
>+  __proto__: dart.getFields(svg$.EllipseElement.__proto__),
>+  [$cx]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$cy]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$rx]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$ry]: dart.finalFieldType(svg$.AnimatedLength)
>+}));
>+dart.registerExtension("SVGEllipseElement", svg$.EllipseElement);
>+svg$.FEBlendElement = class FEBlendElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.FEBlendElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("feBlend"));
>+  }
>+  static get supported() {
>+    return dart.test(svg$.SvgElement.isTagSupported("feBlend")) && svg$.FEBlendElement.is(svg$.SvgElement.tag("feBlend"));
>+  }
>+  get [$in1]() {
>+    return this.in1;
>+  }
>+  get [$in2]() {
>+    return this.in2;
>+  }
>+  get [$mode]() {
>+    return this.mode;
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$result]() {
>+    return this.result;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+};
>+(svg$.FEBlendElement.created = function() {
>+  this[in1] = null;
>+  this[in2] = null;
>+  this[mode$4] = null;
>+  this[height$14] = null;
>+  this[result] = null;
>+  this[width$16] = null;
>+  this[x$7] = null;
>+  this[y$6] = null;
>+  svg$.FEBlendElement.__proto__.created.call(this);
>+}).prototype = svg$.FEBlendElement.prototype;
>+dart.addTypeTests(svg$.FEBlendElement);
>+const in1 = Symbol("FEBlendElement.in1");
>+const in2 = Symbol("FEBlendElement.in2");
>+const mode$4 = Symbol("FEBlendElement.mode");
>+const height$14 = Symbol("FEBlendElement.height");
>+const result = Symbol("FEBlendElement.result");
>+const width$16 = Symbol("FEBlendElement.width");
>+const x$7 = Symbol("FEBlendElement.x");
>+const y$6 = Symbol("FEBlendElement.y");
>+svg$.FEBlendElement[dart.implements] = () => [svg$.FilterPrimitiveStandardAttributes];
>+dart.setLibraryUri(svg$.FEBlendElement, "dart:svg");
>+dart.setFieldSignature(svg$.FEBlendElement, () => ({
>+  __proto__: dart.getFields(svg$.FEBlendElement.__proto__),
>+  [$in1]: dart.finalFieldType(svg$.AnimatedString),
>+  [$in2]: dart.finalFieldType(svg$.AnimatedString),
>+  [$mode]: dart.finalFieldType(svg$.AnimatedEnumeration),
>+  [$height]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$result]: dart.finalFieldType(svg$.AnimatedString),
>+  [$width]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$x]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$y]: dart.finalFieldType(svg$.AnimatedLength)
>+}));
>+dart.defineLazy(svg$.FEBlendElement, {
>+  /*svg$.FEBlendElement.SVG_FEBLEND_MODE_DARKEN*/get SVG_FEBLEND_MODE_DARKEN() {
>+    return 4;
>+  },
>+  /*svg$.FEBlendElement.SVG_FEBLEND_MODE_LIGHTEN*/get SVG_FEBLEND_MODE_LIGHTEN() {
>+    return 5;
>+  },
>+  /*svg$.FEBlendElement.SVG_FEBLEND_MODE_MULTIPLY*/get SVG_FEBLEND_MODE_MULTIPLY() {
>+    return 2;
>+  },
>+  /*svg$.FEBlendElement.SVG_FEBLEND_MODE_NORMAL*/get SVG_FEBLEND_MODE_NORMAL() {
>+    return 1;
>+  },
>+  /*svg$.FEBlendElement.SVG_FEBLEND_MODE_SCREEN*/get SVG_FEBLEND_MODE_SCREEN() {
>+    return 3;
>+  },
>+  /*svg$.FEBlendElement.SVG_FEBLEND_MODE_UNKNOWN*/get SVG_FEBLEND_MODE_UNKNOWN() {
>+    return 0;
>+  }
>+});
>+dart.registerExtension("SVGFEBlendElement", svg$.FEBlendElement);
>+svg$.FEColorMatrixElement = class FEColorMatrixElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.FEColorMatrixElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("feColorMatrix"));
>+  }
>+  static get supported() {
>+    return dart.test(svg$.SvgElement.isTagSupported("feColorMatrix")) && svg$.FEColorMatrixElement.is(svg$.SvgElement.tag("feColorMatrix"));
>+  }
>+  get [$in1]() {
>+    return this.in1;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  get [$values]() {
>+    return this.values;
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$result]() {
>+    return this.result;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+};
>+(svg$.FEColorMatrixElement.created = function() {
>+  this[in1$] = null;
>+  this[type$37] = null;
>+  this[values] = null;
>+  this[height$15] = null;
>+  this[result$0] = null;
>+  this[width$17] = null;
>+  this[x$8] = null;
>+  this[y$7] = null;
>+  svg$.FEColorMatrixElement.__proto__.created.call(this);
>+}).prototype = svg$.FEColorMatrixElement.prototype;
>+dart.addTypeTests(svg$.FEColorMatrixElement);
>+const in1$ = Symbol("FEColorMatrixElement.in1");
>+const type$37 = Symbol("FEColorMatrixElement.type");
>+const values = Symbol("FEColorMatrixElement.values");
>+const height$15 = Symbol("FEColorMatrixElement.height");
>+const result$0 = Symbol("FEColorMatrixElement.result");
>+const width$17 = Symbol("FEColorMatrixElement.width");
>+const x$8 = Symbol("FEColorMatrixElement.x");
>+const y$7 = Symbol("FEColorMatrixElement.y");
>+svg$.FEColorMatrixElement[dart.implements] = () => [svg$.FilterPrimitiveStandardAttributes];
>+dart.setLibraryUri(svg$.FEColorMatrixElement, "dart:svg");
>+dart.setFieldSignature(svg$.FEColorMatrixElement, () => ({
>+  __proto__: dart.getFields(svg$.FEColorMatrixElement.__proto__),
>+  [$in1]: dart.finalFieldType(svg$.AnimatedString),
>+  [$type]: dart.finalFieldType(svg$.AnimatedEnumeration),
>+  [$values]: dart.finalFieldType(svg$.AnimatedNumberList),
>+  [$height]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$result]: dart.finalFieldType(svg$.AnimatedString),
>+  [$width]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$x]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$y]: dart.finalFieldType(svg$.AnimatedLength)
>+}));
>+dart.defineLazy(svg$.FEColorMatrixElement, {
>+  /*svg$.FEColorMatrixElement.SVG_FECOLORMATRIX_TYPE_HUEROTATE*/get SVG_FECOLORMATRIX_TYPE_HUEROTATE() {
>+    return 3;
>+  },
>+  /*svg$.FEColorMatrixElement.SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA*/get SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA() {
>+    return 4;
>+  },
>+  /*svg$.FEColorMatrixElement.SVG_FECOLORMATRIX_TYPE_MATRIX*/get SVG_FECOLORMATRIX_TYPE_MATRIX() {
>+    return 1;
>+  },
>+  /*svg$.FEColorMatrixElement.SVG_FECOLORMATRIX_TYPE_SATURATE*/get SVG_FECOLORMATRIX_TYPE_SATURATE() {
>+    return 2;
>+  },
>+  /*svg$.FEColorMatrixElement.SVG_FECOLORMATRIX_TYPE_UNKNOWN*/get SVG_FECOLORMATRIX_TYPE_UNKNOWN() {
>+    return 0;
>+  }
>+});
>+dart.registerExtension("SVGFEColorMatrixElement", svg$.FEColorMatrixElement);
>+svg$.FEComponentTransferElement = class FEComponentTransferElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.FEComponentTransferElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("feComponentTransfer"));
>+  }
>+  static get supported() {
>+    return dart.test(svg$.SvgElement.isTagSupported("feComponentTransfer")) && svg$.FEComponentTransferElement.is(svg$.SvgElement.tag("feComponentTransfer"));
>+  }
>+  get [$in1]() {
>+    return this.in1;
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$result]() {
>+    return this.result;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+};
>+(svg$.FEComponentTransferElement.created = function() {
>+  this[in1$0] = null;
>+  this[height$16] = null;
>+  this[result$1] = null;
>+  this[width$18] = null;
>+  this[x$9] = null;
>+  this[y$8] = null;
>+  svg$.FEComponentTransferElement.__proto__.created.call(this);
>+}).prototype = svg$.FEComponentTransferElement.prototype;
>+dart.addTypeTests(svg$.FEComponentTransferElement);
>+const in1$0 = Symbol("FEComponentTransferElement.in1");
>+const height$16 = Symbol("FEComponentTransferElement.height");
>+const result$1 = Symbol("FEComponentTransferElement.result");
>+const width$18 = Symbol("FEComponentTransferElement.width");
>+const x$9 = Symbol("FEComponentTransferElement.x");
>+const y$8 = Symbol("FEComponentTransferElement.y");
>+svg$.FEComponentTransferElement[dart.implements] = () => [svg$.FilterPrimitiveStandardAttributes];
>+dart.setLibraryUri(svg$.FEComponentTransferElement, "dart:svg");
>+dart.setFieldSignature(svg$.FEComponentTransferElement, () => ({
>+  __proto__: dart.getFields(svg$.FEComponentTransferElement.__proto__),
>+  [$in1]: dart.finalFieldType(svg$.AnimatedString),
>+  [$height]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$result]: dart.finalFieldType(svg$.AnimatedString),
>+  [$width]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$x]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$y]: dart.finalFieldType(svg$.AnimatedLength)
>+}));
>+dart.registerExtension("SVGFEComponentTransferElement", svg$.FEComponentTransferElement);
>+svg$.FECompositeElement = class FECompositeElement extends svg$.SvgElement {
>+  get [$in1]() {
>+    return this.in1;
>+  }
>+  get [$in2]() {
>+    return this.in2;
>+  }
>+  get [$k1]() {
>+    return this.k1;
>+  }
>+  get [$k2]() {
>+    return this.k2;
>+  }
>+  get [$k3]() {
>+    return this.k3;
>+  }
>+  get [$k4]() {
>+    return this.k4;
>+  }
>+  get [$operator]() {
>+    return this.operator;
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$result]() {
>+    return this.result;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+};
>+(svg$.FECompositeElement.created = function() {
>+  this[in1$1] = null;
>+  this[in2$] = null;
>+  this[k1] = null;
>+  this[k2] = null;
>+  this[k3] = null;
>+  this[k4] = null;
>+  this[operator] = null;
>+  this[height$17] = null;
>+  this[result$2] = null;
>+  this[width$19] = null;
>+  this[x$10] = null;
>+  this[y$9] = null;
>+  svg$.FECompositeElement.__proto__.created.call(this);
>+}).prototype = svg$.FECompositeElement.prototype;
>+dart.addTypeTests(svg$.FECompositeElement);
>+const in1$1 = Symbol("FECompositeElement.in1");
>+const in2$ = Symbol("FECompositeElement.in2");
>+const k1 = Symbol("FECompositeElement.k1");
>+const k2 = Symbol("FECompositeElement.k2");
>+const k3 = Symbol("FECompositeElement.k3");
>+const k4 = Symbol("FECompositeElement.k4");
>+const operator = Symbol("FECompositeElement.operator");
>+const height$17 = Symbol("FECompositeElement.height");
>+const result$2 = Symbol("FECompositeElement.result");
>+const width$19 = Symbol("FECompositeElement.width");
>+const x$10 = Symbol("FECompositeElement.x");
>+const y$9 = Symbol("FECompositeElement.y");
>+svg$.FECompositeElement[dart.implements] = () => [svg$.FilterPrimitiveStandardAttributes];
>+dart.setLibraryUri(svg$.FECompositeElement, "dart:svg");
>+dart.setFieldSignature(svg$.FECompositeElement, () => ({
>+  __proto__: dart.getFields(svg$.FECompositeElement.__proto__),
>+  [$in1]: dart.finalFieldType(svg$.AnimatedString),
>+  [$in2]: dart.finalFieldType(svg$.AnimatedString),
>+  [$k1]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$k2]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$k3]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$k4]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$operator]: dart.finalFieldType(svg$.AnimatedEnumeration),
>+  [$height]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$result]: dart.finalFieldType(svg$.AnimatedString),
>+  [$width]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$x]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$y]: dart.finalFieldType(svg$.AnimatedLength)
>+}));
>+dart.defineLazy(svg$.FECompositeElement, {
>+  /*svg$.FECompositeElement.SVG_FECOMPOSITE_OPERATOR_ARITHMETIC*/get SVG_FECOMPOSITE_OPERATOR_ARITHMETIC() {
>+    return 6;
>+  },
>+  /*svg$.FECompositeElement.SVG_FECOMPOSITE_OPERATOR_ATOP*/get SVG_FECOMPOSITE_OPERATOR_ATOP() {
>+    return 4;
>+  },
>+  /*svg$.FECompositeElement.SVG_FECOMPOSITE_OPERATOR_IN*/get SVG_FECOMPOSITE_OPERATOR_IN() {
>+    return 2;
>+  },
>+  /*svg$.FECompositeElement.SVG_FECOMPOSITE_OPERATOR_OUT*/get SVG_FECOMPOSITE_OPERATOR_OUT() {
>+    return 3;
>+  },
>+  /*svg$.FECompositeElement.SVG_FECOMPOSITE_OPERATOR_OVER*/get SVG_FECOMPOSITE_OPERATOR_OVER() {
>+    return 1;
>+  },
>+  /*svg$.FECompositeElement.SVG_FECOMPOSITE_OPERATOR_UNKNOWN*/get SVG_FECOMPOSITE_OPERATOR_UNKNOWN() {
>+    return 0;
>+  },
>+  /*svg$.FECompositeElement.SVG_FECOMPOSITE_OPERATOR_XOR*/get SVG_FECOMPOSITE_OPERATOR_XOR() {
>+    return 5;
>+  }
>+});
>+dart.registerExtension("SVGFECompositeElement", svg$.FECompositeElement);
>+svg$.FEConvolveMatrixElement = class FEConvolveMatrixElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.FEConvolveMatrixElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("feConvolveMatrix"));
>+  }
>+  static get supported() {
>+    return dart.test(svg$.SvgElement.isTagSupported("feConvolveMatrix")) && svg$.FEConvolveMatrixElement.is(svg$.SvgElement.tag("feConvolveMatrix"));
>+  }
>+  get [$bias]() {
>+    return this.bias;
>+  }
>+  get [$divisor]() {
>+    return this.divisor;
>+  }
>+  get [$edgeMode]() {
>+    return this.edgeMode;
>+  }
>+  get [$in1]() {
>+    return this.in1;
>+  }
>+  get [$kernelMatrix]() {
>+    return this.kernelMatrix;
>+  }
>+  get [$kernelUnitLengthX]() {
>+    return this.kernelUnitLengthX;
>+  }
>+  get [$kernelUnitLengthY]() {
>+    return this.kernelUnitLengthY;
>+  }
>+  get [$orderX]() {
>+    return this.orderX;
>+  }
>+  get [$orderY]() {
>+    return this.orderY;
>+  }
>+  get [$preserveAlpha]() {
>+    return this.preserveAlpha;
>+  }
>+  get [$targetX]() {
>+    return this.targetX;
>+  }
>+  get [$targetY]() {
>+    return this.targetY;
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$result]() {
>+    return this.result;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+};
>+(svg$.FEConvolveMatrixElement.created = function() {
>+  this[bias] = null;
>+  this[divisor] = null;
>+  this[edgeMode] = null;
>+  this[in1$2] = null;
>+  this[kernelMatrix] = null;
>+  this[kernelUnitLengthX] = null;
>+  this[kernelUnitLengthY] = null;
>+  this[orderX] = null;
>+  this[orderY] = null;
>+  this[preserveAlpha] = null;
>+  this[targetX] = null;
>+  this[targetY] = null;
>+  this[height$18] = null;
>+  this[result$3] = null;
>+  this[width$20] = null;
>+  this[x$11] = null;
>+  this[y$10] = null;
>+  svg$.FEConvolveMatrixElement.__proto__.created.call(this);
>+}).prototype = svg$.FEConvolveMatrixElement.prototype;
>+dart.addTypeTests(svg$.FEConvolveMatrixElement);
>+const bias = Symbol("FEConvolveMatrixElement.bias");
>+const divisor = Symbol("FEConvolveMatrixElement.divisor");
>+const edgeMode = Symbol("FEConvolveMatrixElement.edgeMode");
>+const in1$2 = Symbol("FEConvolveMatrixElement.in1");
>+const kernelMatrix = Symbol("FEConvolveMatrixElement.kernelMatrix");
>+const kernelUnitLengthX = Symbol("FEConvolveMatrixElement.kernelUnitLengthX");
>+const kernelUnitLengthY = Symbol("FEConvolveMatrixElement.kernelUnitLengthY");
>+const orderX = Symbol("FEConvolveMatrixElement.orderX");
>+const orderY = Symbol("FEConvolveMatrixElement.orderY");
>+const preserveAlpha = Symbol("FEConvolveMatrixElement.preserveAlpha");
>+const targetX = Symbol("FEConvolveMatrixElement.targetX");
>+const targetY = Symbol("FEConvolveMatrixElement.targetY");
>+const height$18 = Symbol("FEConvolveMatrixElement.height");
>+const result$3 = Symbol("FEConvolveMatrixElement.result");
>+const width$20 = Symbol("FEConvolveMatrixElement.width");
>+const x$11 = Symbol("FEConvolveMatrixElement.x");
>+const y$10 = Symbol("FEConvolveMatrixElement.y");
>+svg$.FEConvolveMatrixElement[dart.implements] = () => [svg$.FilterPrimitiveStandardAttributes];
>+dart.setLibraryUri(svg$.FEConvolveMatrixElement, "dart:svg");
>+dart.setFieldSignature(svg$.FEConvolveMatrixElement, () => ({
>+  __proto__: dart.getFields(svg$.FEConvolveMatrixElement.__proto__),
>+  [$bias]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$divisor]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$edgeMode]: dart.finalFieldType(svg$.AnimatedEnumeration),
>+  [$in1]: dart.finalFieldType(svg$.AnimatedString),
>+  [$kernelMatrix]: dart.finalFieldType(svg$.AnimatedNumberList),
>+  [$kernelUnitLengthX]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$kernelUnitLengthY]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$orderX]: dart.finalFieldType(svg$.AnimatedInteger),
>+  [$orderY]: dart.finalFieldType(svg$.AnimatedInteger),
>+  [$preserveAlpha]: dart.finalFieldType(svg$.AnimatedBoolean),
>+  [$targetX]: dart.finalFieldType(svg$.AnimatedInteger),
>+  [$targetY]: dart.finalFieldType(svg$.AnimatedInteger),
>+  [$height]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$result]: dart.finalFieldType(svg$.AnimatedString),
>+  [$width]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$x]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$y]: dart.finalFieldType(svg$.AnimatedLength)
>+}));
>+dart.defineLazy(svg$.FEConvolveMatrixElement, {
>+  /*svg$.FEConvolveMatrixElement.SVG_EDGEMODE_DUPLICATE*/get SVG_EDGEMODE_DUPLICATE() {
>+    return 1;
>+  },
>+  /*svg$.FEConvolveMatrixElement.SVG_EDGEMODE_NONE*/get SVG_EDGEMODE_NONE() {
>+    return 3;
>+  },
>+  /*svg$.FEConvolveMatrixElement.SVG_EDGEMODE_UNKNOWN*/get SVG_EDGEMODE_UNKNOWN() {
>+    return 0;
>+  },
>+  /*svg$.FEConvolveMatrixElement.SVG_EDGEMODE_WRAP*/get SVG_EDGEMODE_WRAP() {
>+    return 2;
>+  }
>+});
>+dart.registerExtension("SVGFEConvolveMatrixElement", svg$.FEConvolveMatrixElement);
>+svg$.FEDiffuseLightingElement = class FEDiffuseLightingElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.FEDiffuseLightingElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("feDiffuseLighting"));
>+  }
>+  static get supported() {
>+    return dart.test(svg$.SvgElement.isTagSupported("feDiffuseLighting")) && svg$.FEDiffuseLightingElement.is(svg$.SvgElement.tag("feDiffuseLighting"));
>+  }
>+  get [$diffuseConstant]() {
>+    return this.diffuseConstant;
>+  }
>+  get [$in1]() {
>+    return this.in1;
>+  }
>+  get [$kernelUnitLengthX]() {
>+    return this.kernelUnitLengthX;
>+  }
>+  get [$kernelUnitLengthY]() {
>+    return this.kernelUnitLengthY;
>+  }
>+  get [$surfaceScale]() {
>+    return this.surfaceScale;
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$result]() {
>+    return this.result;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+};
>+(svg$.FEDiffuseLightingElement.created = function() {
>+  this[diffuseConstant] = null;
>+  this[in1$3] = null;
>+  this[kernelUnitLengthX$] = null;
>+  this[kernelUnitLengthY$] = null;
>+  this[surfaceScale] = null;
>+  this[height$19] = null;
>+  this[result$4] = null;
>+  this[width$21] = null;
>+  this[x$12] = null;
>+  this[y$11] = null;
>+  svg$.FEDiffuseLightingElement.__proto__.created.call(this);
>+}).prototype = svg$.FEDiffuseLightingElement.prototype;
>+dart.addTypeTests(svg$.FEDiffuseLightingElement);
>+const diffuseConstant = Symbol("FEDiffuseLightingElement.diffuseConstant");
>+const in1$3 = Symbol("FEDiffuseLightingElement.in1");
>+const kernelUnitLengthX$ = Symbol("FEDiffuseLightingElement.kernelUnitLengthX");
>+const kernelUnitLengthY$ = Symbol("FEDiffuseLightingElement.kernelUnitLengthY");
>+const surfaceScale = Symbol("FEDiffuseLightingElement.surfaceScale");
>+const height$19 = Symbol("FEDiffuseLightingElement.height");
>+const result$4 = Symbol("FEDiffuseLightingElement.result");
>+const width$21 = Symbol("FEDiffuseLightingElement.width");
>+const x$12 = Symbol("FEDiffuseLightingElement.x");
>+const y$11 = Symbol("FEDiffuseLightingElement.y");
>+svg$.FEDiffuseLightingElement[dart.implements] = () => [svg$.FilterPrimitiveStandardAttributes];
>+dart.setLibraryUri(svg$.FEDiffuseLightingElement, "dart:svg");
>+dart.setFieldSignature(svg$.FEDiffuseLightingElement, () => ({
>+  __proto__: dart.getFields(svg$.FEDiffuseLightingElement.__proto__),
>+  [$diffuseConstant]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$in1]: dart.finalFieldType(svg$.AnimatedString),
>+  [$kernelUnitLengthX]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$kernelUnitLengthY]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$surfaceScale]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$height]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$result]: dart.finalFieldType(svg$.AnimatedString),
>+  [$width]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$x]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$y]: dart.finalFieldType(svg$.AnimatedLength)
>+}));
>+dart.registerExtension("SVGFEDiffuseLightingElement", svg$.FEDiffuseLightingElement);
>+svg$.FEDisplacementMapElement = class FEDisplacementMapElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.FEDisplacementMapElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("feDisplacementMap"));
>+  }
>+  static get supported() {
>+    return dart.test(svg$.SvgElement.isTagSupported("feDisplacementMap")) && svg$.FEDisplacementMapElement.is(svg$.SvgElement.tag("feDisplacementMap"));
>+  }
>+  get [$in1]() {
>+    return this.in1;
>+  }
>+  get [$in2]() {
>+    return this.in2;
>+  }
>+  get [$scale]() {
>+    return this.scale;
>+  }
>+  get [$xChannelSelector]() {
>+    return this.xChannelSelector;
>+  }
>+  get [$yChannelSelector]() {
>+    return this.yChannelSelector;
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$result]() {
>+    return this.result;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+};
>+(svg$.FEDisplacementMapElement.created = function() {
>+  this[in1$4] = null;
>+  this[in2$0] = null;
>+  this[scale$] = null;
>+  this[xChannelSelector] = null;
>+  this[yChannelSelector] = null;
>+  this[height$20] = null;
>+  this[result$5] = null;
>+  this[width$22] = null;
>+  this[x$13] = null;
>+  this[y$12] = null;
>+  svg$.FEDisplacementMapElement.__proto__.created.call(this);
>+}).prototype = svg$.FEDisplacementMapElement.prototype;
>+dart.addTypeTests(svg$.FEDisplacementMapElement);
>+const in1$4 = Symbol("FEDisplacementMapElement.in1");
>+const in2$0 = Symbol("FEDisplacementMapElement.in2");
>+const scale$ = Symbol("FEDisplacementMapElement.scale");
>+const xChannelSelector = Symbol("FEDisplacementMapElement.xChannelSelector");
>+const yChannelSelector = Symbol("FEDisplacementMapElement.yChannelSelector");
>+const height$20 = Symbol("FEDisplacementMapElement.height");
>+const result$5 = Symbol("FEDisplacementMapElement.result");
>+const width$22 = Symbol("FEDisplacementMapElement.width");
>+const x$13 = Symbol("FEDisplacementMapElement.x");
>+const y$12 = Symbol("FEDisplacementMapElement.y");
>+svg$.FEDisplacementMapElement[dart.implements] = () => [svg$.FilterPrimitiveStandardAttributes];
>+dart.setLibraryUri(svg$.FEDisplacementMapElement, "dart:svg");
>+dart.setFieldSignature(svg$.FEDisplacementMapElement, () => ({
>+  __proto__: dart.getFields(svg$.FEDisplacementMapElement.__proto__),
>+  [$in1]: dart.finalFieldType(svg$.AnimatedString),
>+  [$in2]: dart.finalFieldType(svg$.AnimatedString),
>+  [$scale]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$xChannelSelector]: dart.finalFieldType(svg$.AnimatedEnumeration),
>+  [$yChannelSelector]: dart.finalFieldType(svg$.AnimatedEnumeration),
>+  [$height]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$result]: dart.finalFieldType(svg$.AnimatedString),
>+  [$width]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$x]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$y]: dart.finalFieldType(svg$.AnimatedLength)
>+}));
>+dart.defineLazy(svg$.FEDisplacementMapElement, {
>+  /*svg$.FEDisplacementMapElement.SVG_CHANNEL_A*/get SVG_CHANNEL_A() {
>+    return 4;
>+  },
>+  /*svg$.FEDisplacementMapElement.SVG_CHANNEL_B*/get SVG_CHANNEL_B() {
>+    return 3;
>+  },
>+  /*svg$.FEDisplacementMapElement.SVG_CHANNEL_G*/get SVG_CHANNEL_G() {
>+    return 2;
>+  },
>+  /*svg$.FEDisplacementMapElement.SVG_CHANNEL_R*/get SVG_CHANNEL_R() {
>+    return 1;
>+  },
>+  /*svg$.FEDisplacementMapElement.SVG_CHANNEL_UNKNOWN*/get SVG_CHANNEL_UNKNOWN() {
>+    return 0;
>+  }
>+});
>+dart.registerExtension("SVGFEDisplacementMapElement", svg$.FEDisplacementMapElement);
>+svg$.FEDistantLightElement = class FEDistantLightElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.FEDistantLightElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("feDistantLight"));
>+  }
>+  static get supported() {
>+    return dart.test(svg$.SvgElement.isTagSupported("feDistantLight")) && svg$.FEDistantLightElement.is(svg$.SvgElement.tag("feDistantLight"));
>+  }
>+  get [$azimuth]() {
>+    return this.azimuth;
>+  }
>+  get [$elevation]() {
>+    return this.elevation;
>+  }
>+};
>+(svg$.FEDistantLightElement.created = function() {
>+  this[azimuth] = null;
>+  this[elevation] = null;
>+  svg$.FEDistantLightElement.__proto__.created.call(this);
>+}).prototype = svg$.FEDistantLightElement.prototype;
>+dart.addTypeTests(svg$.FEDistantLightElement);
>+const azimuth = Symbol("FEDistantLightElement.azimuth");
>+const elevation = Symbol("FEDistantLightElement.elevation");
>+dart.setLibraryUri(svg$.FEDistantLightElement, "dart:svg");
>+dart.setFieldSignature(svg$.FEDistantLightElement, () => ({
>+  __proto__: dart.getFields(svg$.FEDistantLightElement.__proto__),
>+  [$azimuth]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$elevation]: dart.finalFieldType(svg$.AnimatedNumber)
>+}));
>+dart.registerExtension("SVGFEDistantLightElement", svg$.FEDistantLightElement);
>+svg$.FEFloodElement = class FEFloodElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.FEFloodElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("feFlood"));
>+  }
>+  static get supported() {
>+    return dart.test(svg$.SvgElement.isTagSupported("feFlood")) && svg$.FEFloodElement.is(svg$.SvgElement.tag("feFlood"));
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$result]() {
>+    return this.result;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+};
>+(svg$.FEFloodElement.created = function() {
>+  this[height$21] = null;
>+  this[result$6] = null;
>+  this[width$23] = null;
>+  this[x$14] = null;
>+  this[y$13] = null;
>+  svg$.FEFloodElement.__proto__.created.call(this);
>+}).prototype = svg$.FEFloodElement.prototype;
>+dart.addTypeTests(svg$.FEFloodElement);
>+const height$21 = Symbol("FEFloodElement.height");
>+const result$6 = Symbol("FEFloodElement.result");
>+const width$23 = Symbol("FEFloodElement.width");
>+const x$14 = Symbol("FEFloodElement.x");
>+const y$13 = Symbol("FEFloodElement.y");
>+svg$.FEFloodElement[dart.implements] = () => [svg$.FilterPrimitiveStandardAttributes];
>+dart.setLibraryUri(svg$.FEFloodElement, "dart:svg");
>+dart.setFieldSignature(svg$.FEFloodElement, () => ({
>+  __proto__: dart.getFields(svg$.FEFloodElement.__proto__),
>+  [$height]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$result]: dart.finalFieldType(svg$.AnimatedString),
>+  [$width]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$x]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$y]: dart.finalFieldType(svg$.AnimatedLength)
>+}));
>+dart.registerExtension("SVGFEFloodElement", svg$.FEFloodElement);
>+svg$._SVGComponentTransferFunctionElement = class _SVGComponentTransferFunctionElement extends svg$.SvgElement {};
>+(svg$._SVGComponentTransferFunctionElement.created = function() {
>+  svg$._SVGComponentTransferFunctionElement.__proto__.created.call(this);
>+}).prototype = svg$._SVGComponentTransferFunctionElement.prototype;
>+dart.addTypeTests(svg$._SVGComponentTransferFunctionElement);
>+dart.setLibraryUri(svg$._SVGComponentTransferFunctionElement, "dart:svg");
>+dart.registerExtension("SVGComponentTransferFunctionElement", svg$._SVGComponentTransferFunctionElement);
>+svg$.FEFuncAElement = class FEFuncAElement extends svg$._SVGComponentTransferFunctionElement {
>+  static new() {
>+    return svg$.FEFuncAElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("feFuncA"));
>+  }
>+  static get supported() {
>+    return dart.test(svg$.SvgElement.isTagSupported("feFuncA")) && svg$.FEFuncAElement.is(svg$.SvgElement.tag("feFuncA"));
>+  }
>+};
>+(svg$.FEFuncAElement.created = function() {
>+  svg$.FEFuncAElement.__proto__.created.call(this);
>+}).prototype = svg$.FEFuncAElement.prototype;
>+dart.addTypeTests(svg$.FEFuncAElement);
>+dart.setLibraryUri(svg$.FEFuncAElement, "dart:svg");
>+dart.registerExtension("SVGFEFuncAElement", svg$.FEFuncAElement);
>+svg$.FEFuncBElement = class FEFuncBElement extends svg$._SVGComponentTransferFunctionElement {
>+  static new() {
>+    return svg$.FEFuncBElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("feFuncB"));
>+  }
>+  static get supported() {
>+    return dart.test(svg$.SvgElement.isTagSupported("feFuncB")) && svg$.FEFuncBElement.is(svg$.SvgElement.tag("feFuncB"));
>+  }
>+};
>+(svg$.FEFuncBElement.created = function() {
>+  svg$.FEFuncBElement.__proto__.created.call(this);
>+}).prototype = svg$.FEFuncBElement.prototype;
>+dart.addTypeTests(svg$.FEFuncBElement);
>+dart.setLibraryUri(svg$.FEFuncBElement, "dart:svg");
>+dart.registerExtension("SVGFEFuncBElement", svg$.FEFuncBElement);
>+svg$.FEFuncGElement = class FEFuncGElement extends svg$._SVGComponentTransferFunctionElement {
>+  static new() {
>+    return svg$.FEFuncGElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("feFuncG"));
>+  }
>+  static get supported() {
>+    return dart.test(svg$.SvgElement.isTagSupported("feFuncG")) && svg$.FEFuncGElement.is(svg$.SvgElement.tag("feFuncG"));
>+  }
>+};
>+(svg$.FEFuncGElement.created = function() {
>+  svg$.FEFuncGElement.__proto__.created.call(this);
>+}).prototype = svg$.FEFuncGElement.prototype;
>+dart.addTypeTests(svg$.FEFuncGElement);
>+dart.setLibraryUri(svg$.FEFuncGElement, "dart:svg");
>+dart.registerExtension("SVGFEFuncGElement", svg$.FEFuncGElement);
>+svg$.FEFuncRElement = class FEFuncRElement extends svg$._SVGComponentTransferFunctionElement {
>+  static new() {
>+    return svg$.FEFuncRElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("feFuncR"));
>+  }
>+  static get supported() {
>+    return dart.test(svg$.SvgElement.isTagSupported("feFuncR")) && svg$.FEFuncRElement.is(svg$.SvgElement.tag("feFuncR"));
>+  }
>+};
>+(svg$.FEFuncRElement.created = function() {
>+  svg$.FEFuncRElement.__proto__.created.call(this);
>+}).prototype = svg$.FEFuncRElement.prototype;
>+dart.addTypeTests(svg$.FEFuncRElement);
>+dart.setLibraryUri(svg$.FEFuncRElement, "dart:svg");
>+dart.registerExtension("SVGFEFuncRElement", svg$.FEFuncRElement);
>+svg$.FEGaussianBlurElement = class FEGaussianBlurElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.FEGaussianBlurElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("feGaussianBlur"));
>+  }
>+  static get supported() {
>+    return dart.test(svg$.SvgElement.isTagSupported("feGaussianBlur")) && svg$.FEGaussianBlurElement.is(svg$.SvgElement.tag("feGaussianBlur"));
>+  }
>+  get [$in1]() {
>+    return this.in1;
>+  }
>+  get [$stdDeviationX]() {
>+    return this.stdDeviationX;
>+  }
>+  get [$stdDeviationY]() {
>+    return this.stdDeviationY;
>+  }
>+  [$setStdDeviation](...args) {
>+    return this.setStdDeviation.apply(this, args);
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$result]() {
>+    return this.result;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+};
>+(svg$.FEGaussianBlurElement.created = function() {
>+  this[in1$5] = null;
>+  this[stdDeviationX] = null;
>+  this[stdDeviationY] = null;
>+  this[height$22] = null;
>+  this[result$7] = null;
>+  this[width$24] = null;
>+  this[x$15] = null;
>+  this[y$14] = null;
>+  svg$.FEGaussianBlurElement.__proto__.created.call(this);
>+}).prototype = svg$.FEGaussianBlurElement.prototype;
>+dart.addTypeTests(svg$.FEGaussianBlurElement);
>+const in1$5 = Symbol("FEGaussianBlurElement.in1");
>+const stdDeviationX = Symbol("FEGaussianBlurElement.stdDeviationX");
>+const stdDeviationY = Symbol("FEGaussianBlurElement.stdDeviationY");
>+const height$22 = Symbol("FEGaussianBlurElement.height");
>+const result$7 = Symbol("FEGaussianBlurElement.result");
>+const width$24 = Symbol("FEGaussianBlurElement.width");
>+const x$15 = Symbol("FEGaussianBlurElement.x");
>+const y$14 = Symbol("FEGaussianBlurElement.y");
>+svg$.FEGaussianBlurElement[dart.implements] = () => [svg$.FilterPrimitiveStandardAttributes];
>+dart.setMethodSignature(svg$.FEGaussianBlurElement, () => ({
>+  __proto__: dart.getMethods(svg$.FEGaussianBlurElement.__proto__),
>+  [$setStdDeviation]: dart.fnType(dart.void, [core.num, core.num])
>+}));
>+dart.setLibraryUri(svg$.FEGaussianBlurElement, "dart:svg");
>+dart.setFieldSignature(svg$.FEGaussianBlurElement, () => ({
>+  __proto__: dart.getFields(svg$.FEGaussianBlurElement.__proto__),
>+  [$in1]: dart.finalFieldType(svg$.AnimatedString),
>+  [$stdDeviationX]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$stdDeviationY]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$height]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$result]: dart.finalFieldType(svg$.AnimatedString),
>+  [$width]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$x]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$y]: dart.finalFieldType(svg$.AnimatedLength)
>+}));
>+dart.registerExtension("SVGFEGaussianBlurElement", svg$.FEGaussianBlurElement);
>+svg$.FEImageElement = class FEImageElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.FEImageElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("feImage"));
>+  }
>+  static get supported() {
>+    return dart.test(svg$.SvgElement.isTagSupported("feImage")) && svg$.FEImageElement.is(svg$.SvgElement.tag("feImage"));
>+  }
>+  get [$preserveAspectRatio]() {
>+    return this.preserveAspectRatio;
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$result]() {
>+    return this.result;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+  get [$href]() {
>+    return this.href;
>+  }
>+};
>+(svg$.FEImageElement.created = function() {
>+  this[preserveAspectRatio] = null;
>+  this[height$23] = null;
>+  this[result$8] = null;
>+  this[width$25] = null;
>+  this[x$16] = null;
>+  this[y$15] = null;
>+  this[href$9] = null;
>+  svg$.FEImageElement.__proto__.created.call(this);
>+}).prototype = svg$.FEImageElement.prototype;
>+dart.addTypeTests(svg$.FEImageElement);
>+const preserveAspectRatio = Symbol("FEImageElement.preserveAspectRatio");
>+const height$23 = Symbol("FEImageElement.height");
>+const result$8 = Symbol("FEImageElement.result");
>+const width$25 = Symbol("FEImageElement.width");
>+const x$16 = Symbol("FEImageElement.x");
>+const y$15 = Symbol("FEImageElement.y");
>+const href$9 = Symbol("FEImageElement.href");
>+svg$.FEImageElement[dart.implements] = () => [svg$.FilterPrimitiveStandardAttributes, svg$.UriReference];
>+dart.setLibraryUri(svg$.FEImageElement, "dart:svg");
>+dart.setFieldSignature(svg$.FEImageElement, () => ({
>+  __proto__: dart.getFields(svg$.FEImageElement.__proto__),
>+  [$preserveAspectRatio]: dart.finalFieldType(svg$.AnimatedPreserveAspectRatio),
>+  [$height]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$result]: dart.finalFieldType(svg$.AnimatedString),
>+  [$width]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$x]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$y]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$href]: dart.finalFieldType(svg$.AnimatedString)
>+}));
>+dart.registerExtension("SVGFEImageElement", svg$.FEImageElement);
>+svg$.FEMergeElement = class FEMergeElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.FEMergeElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("feMerge"));
>+  }
>+  static get supported() {
>+    return dart.test(svg$.SvgElement.isTagSupported("feMerge")) && svg$.FEMergeElement.is(svg$.SvgElement.tag("feMerge"));
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$result]() {
>+    return this.result;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+};
>+(svg$.FEMergeElement.created = function() {
>+  this[height$24] = null;
>+  this[result$9] = null;
>+  this[width$26] = null;
>+  this[x$17] = null;
>+  this[y$16] = null;
>+  svg$.FEMergeElement.__proto__.created.call(this);
>+}).prototype = svg$.FEMergeElement.prototype;
>+dart.addTypeTests(svg$.FEMergeElement);
>+const height$24 = Symbol("FEMergeElement.height");
>+const result$9 = Symbol("FEMergeElement.result");
>+const width$26 = Symbol("FEMergeElement.width");
>+const x$17 = Symbol("FEMergeElement.x");
>+const y$16 = Symbol("FEMergeElement.y");
>+svg$.FEMergeElement[dart.implements] = () => [svg$.FilterPrimitiveStandardAttributes];
>+dart.setLibraryUri(svg$.FEMergeElement, "dart:svg");
>+dart.setFieldSignature(svg$.FEMergeElement, () => ({
>+  __proto__: dart.getFields(svg$.FEMergeElement.__proto__),
>+  [$height]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$result]: dart.finalFieldType(svg$.AnimatedString),
>+  [$width]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$x]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$y]: dart.finalFieldType(svg$.AnimatedLength)
>+}));
>+dart.registerExtension("SVGFEMergeElement", svg$.FEMergeElement);
>+svg$.FEMergeNodeElement = class FEMergeNodeElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.FEMergeNodeElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("feMergeNode"));
>+  }
>+  static get supported() {
>+    return dart.test(svg$.SvgElement.isTagSupported("feMergeNode")) && svg$.FEMergeNodeElement.is(svg$.SvgElement.tag("feMergeNode"));
>+  }
>+  get [$in1]() {
>+    return this.in1;
>+  }
>+};
>+(svg$.FEMergeNodeElement.created = function() {
>+  this[in1$6] = null;
>+  svg$.FEMergeNodeElement.__proto__.created.call(this);
>+}).prototype = svg$.FEMergeNodeElement.prototype;
>+dart.addTypeTests(svg$.FEMergeNodeElement);
>+const in1$6 = Symbol("FEMergeNodeElement.in1");
>+dart.setLibraryUri(svg$.FEMergeNodeElement, "dart:svg");
>+dart.setFieldSignature(svg$.FEMergeNodeElement, () => ({
>+  __proto__: dart.getFields(svg$.FEMergeNodeElement.__proto__),
>+  [$in1]: dart.finalFieldType(svg$.AnimatedString)
>+}));
>+dart.registerExtension("SVGFEMergeNodeElement", svg$.FEMergeNodeElement);
>+svg$.FEMorphologyElement = class FEMorphologyElement extends svg$.SvgElement {
>+  get [$in1]() {
>+    return this.in1;
>+  }
>+  get [$operator]() {
>+    return this.operator;
>+  }
>+  get [$radiusX]() {
>+    return this.radiusX;
>+  }
>+  get [$radiusY]() {
>+    return this.radiusY;
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$result]() {
>+    return this.result;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+};
>+(svg$.FEMorphologyElement.created = function() {
>+  this[in1$7] = null;
>+  this[operator$] = null;
>+  this[radiusX] = null;
>+  this[radiusY] = null;
>+  this[height$25] = null;
>+  this[result$10] = null;
>+  this[width$27] = null;
>+  this[x$18] = null;
>+  this[y$17] = null;
>+  svg$.FEMorphologyElement.__proto__.created.call(this);
>+}).prototype = svg$.FEMorphologyElement.prototype;
>+dart.addTypeTests(svg$.FEMorphologyElement);
>+const in1$7 = Symbol("FEMorphologyElement.in1");
>+const operator$ = Symbol("FEMorphologyElement.operator");
>+const radiusX = Symbol("FEMorphologyElement.radiusX");
>+const radiusY = Symbol("FEMorphologyElement.radiusY");
>+const height$25 = Symbol("FEMorphologyElement.height");
>+const result$10 = Symbol("FEMorphologyElement.result");
>+const width$27 = Symbol("FEMorphologyElement.width");
>+const x$18 = Symbol("FEMorphologyElement.x");
>+const y$17 = Symbol("FEMorphologyElement.y");
>+svg$.FEMorphologyElement[dart.implements] = () => [svg$.FilterPrimitiveStandardAttributes];
>+dart.setLibraryUri(svg$.FEMorphologyElement, "dart:svg");
>+dart.setFieldSignature(svg$.FEMorphologyElement, () => ({
>+  __proto__: dart.getFields(svg$.FEMorphologyElement.__proto__),
>+  [$in1]: dart.finalFieldType(svg$.AnimatedString),
>+  [$operator]: dart.finalFieldType(svg$.AnimatedEnumeration),
>+  [$radiusX]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$radiusY]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$height]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$result]: dart.finalFieldType(svg$.AnimatedString),
>+  [$width]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$x]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$y]: dart.finalFieldType(svg$.AnimatedLength)
>+}));
>+dart.defineLazy(svg$.FEMorphologyElement, {
>+  /*svg$.FEMorphologyElement.SVG_MORPHOLOGY_OPERATOR_DILATE*/get SVG_MORPHOLOGY_OPERATOR_DILATE() {
>+    return 2;
>+  },
>+  /*svg$.FEMorphologyElement.SVG_MORPHOLOGY_OPERATOR_ERODE*/get SVG_MORPHOLOGY_OPERATOR_ERODE() {
>+    return 1;
>+  },
>+  /*svg$.FEMorphologyElement.SVG_MORPHOLOGY_OPERATOR_UNKNOWN*/get SVG_MORPHOLOGY_OPERATOR_UNKNOWN() {
>+    return 0;
>+  }
>+});
>+dart.registerExtension("SVGFEMorphologyElement", svg$.FEMorphologyElement);
>+svg$.FEOffsetElement = class FEOffsetElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.FEOffsetElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("feOffset"));
>+  }
>+  static get supported() {
>+    return dart.test(svg$.SvgElement.isTagSupported("feOffset")) && svg$.FEOffsetElement.is(svg$.SvgElement.tag("feOffset"));
>+  }
>+  get [$dx]() {
>+    return this.dx;
>+  }
>+  get [$dy]() {
>+    return this.dy;
>+  }
>+  get [$in1]() {
>+    return this.in1;
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$result]() {
>+    return this.result;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+};
>+(svg$.FEOffsetElement.created = function() {
>+  this[dx] = null;
>+  this[dy] = null;
>+  this[in1$8] = null;
>+  this[height$26] = null;
>+  this[result$11] = null;
>+  this[width$28] = null;
>+  this[x$19] = null;
>+  this[y$18] = null;
>+  svg$.FEOffsetElement.__proto__.created.call(this);
>+}).prototype = svg$.FEOffsetElement.prototype;
>+dart.addTypeTests(svg$.FEOffsetElement);
>+const dx = Symbol("FEOffsetElement.dx");
>+const dy = Symbol("FEOffsetElement.dy");
>+const in1$8 = Symbol("FEOffsetElement.in1");
>+const height$26 = Symbol("FEOffsetElement.height");
>+const result$11 = Symbol("FEOffsetElement.result");
>+const width$28 = Symbol("FEOffsetElement.width");
>+const x$19 = Symbol("FEOffsetElement.x");
>+const y$18 = Symbol("FEOffsetElement.y");
>+svg$.FEOffsetElement[dart.implements] = () => [svg$.FilterPrimitiveStandardAttributes];
>+dart.setLibraryUri(svg$.FEOffsetElement, "dart:svg");
>+dart.setFieldSignature(svg$.FEOffsetElement, () => ({
>+  __proto__: dart.getFields(svg$.FEOffsetElement.__proto__),
>+  [$dx]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$dy]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$in1]: dart.finalFieldType(svg$.AnimatedString),
>+  [$height]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$result]: dart.finalFieldType(svg$.AnimatedString),
>+  [$width]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$x]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$y]: dart.finalFieldType(svg$.AnimatedLength)
>+}));
>+dart.registerExtension("SVGFEOffsetElement", svg$.FEOffsetElement);
>+svg$.FEPointLightElement = class FEPointLightElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.FEPointLightElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("fePointLight"));
>+  }
>+  static get supported() {
>+    return dart.test(svg$.SvgElement.isTagSupported("fePointLight")) && svg$.FEPointLightElement.is(svg$.SvgElement.tag("fePointLight"));
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+  get [$z]() {
>+    return this.z;
>+  }
>+};
>+(svg$.FEPointLightElement.created = function() {
>+  this[x$20] = null;
>+  this[y$19] = null;
>+  this[z$6] = null;
>+  svg$.FEPointLightElement.__proto__.created.call(this);
>+}).prototype = svg$.FEPointLightElement.prototype;
>+dart.addTypeTests(svg$.FEPointLightElement);
>+const x$20 = Symbol("FEPointLightElement.x");
>+const y$19 = Symbol("FEPointLightElement.y");
>+const z$6 = Symbol("FEPointLightElement.z");
>+dart.setLibraryUri(svg$.FEPointLightElement, "dart:svg");
>+dart.setFieldSignature(svg$.FEPointLightElement, () => ({
>+  __proto__: dart.getFields(svg$.FEPointLightElement.__proto__),
>+  [$x]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$y]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$z]: dart.finalFieldType(svg$.AnimatedNumber)
>+}));
>+dart.registerExtension("SVGFEPointLightElement", svg$.FEPointLightElement);
>+svg$.FESpecularLightingElement = class FESpecularLightingElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.FESpecularLightingElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("feSpecularLighting"));
>+  }
>+  static get supported() {
>+    return dart.test(svg$.SvgElement.isTagSupported("feSpecularLighting")) && svg$.FESpecularLightingElement.is(svg$.SvgElement.tag("feSpecularLighting"));
>+  }
>+  get [$in1]() {
>+    return this.in1;
>+  }
>+  get [$kernelUnitLengthX]() {
>+    return this.kernelUnitLengthX;
>+  }
>+  get [$kernelUnitLengthY]() {
>+    return this.kernelUnitLengthY;
>+  }
>+  get [$specularConstant]() {
>+    return this.specularConstant;
>+  }
>+  get [$specularExponent]() {
>+    return this.specularExponent;
>+  }
>+  get [$surfaceScale]() {
>+    return this.surfaceScale;
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$result]() {
>+    return this.result;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+};
>+(svg$.FESpecularLightingElement.created = function() {
>+  this[in1$9] = null;
>+  this[kernelUnitLengthX$0] = null;
>+  this[kernelUnitLengthY$0] = null;
>+  this[specularConstant] = null;
>+  this[specularExponent] = null;
>+  this[surfaceScale$] = null;
>+  this[height$27] = null;
>+  this[result$12] = null;
>+  this[width$29] = null;
>+  this[x$21] = null;
>+  this[y$20] = null;
>+  svg$.FESpecularLightingElement.__proto__.created.call(this);
>+}).prototype = svg$.FESpecularLightingElement.prototype;
>+dart.addTypeTests(svg$.FESpecularLightingElement);
>+const in1$9 = Symbol("FESpecularLightingElement.in1");
>+const kernelUnitLengthX$0 = Symbol("FESpecularLightingElement.kernelUnitLengthX");
>+const kernelUnitLengthY$0 = Symbol("FESpecularLightingElement.kernelUnitLengthY");
>+const specularConstant = Symbol("FESpecularLightingElement.specularConstant");
>+const specularExponent = Symbol("FESpecularLightingElement.specularExponent");
>+const surfaceScale$ = Symbol("FESpecularLightingElement.surfaceScale");
>+const height$27 = Symbol("FESpecularLightingElement.height");
>+const result$12 = Symbol("FESpecularLightingElement.result");
>+const width$29 = Symbol("FESpecularLightingElement.width");
>+const x$21 = Symbol("FESpecularLightingElement.x");
>+const y$20 = Symbol("FESpecularLightingElement.y");
>+svg$.FESpecularLightingElement[dart.implements] = () => [svg$.FilterPrimitiveStandardAttributes];
>+dart.setLibraryUri(svg$.FESpecularLightingElement, "dart:svg");
>+dart.setFieldSignature(svg$.FESpecularLightingElement, () => ({
>+  __proto__: dart.getFields(svg$.FESpecularLightingElement.__proto__),
>+  [$in1]: dart.finalFieldType(svg$.AnimatedString),
>+  [$kernelUnitLengthX]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$kernelUnitLengthY]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$specularConstant]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$specularExponent]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$surfaceScale]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$height]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$result]: dart.finalFieldType(svg$.AnimatedString),
>+  [$width]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$x]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$y]: dart.finalFieldType(svg$.AnimatedLength)
>+}));
>+dart.registerExtension("SVGFESpecularLightingElement", svg$.FESpecularLightingElement);
>+svg$.FESpotLightElement = class FESpotLightElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.FESpotLightElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("feSpotLight"));
>+  }
>+  static get supported() {
>+    return dart.test(svg$.SvgElement.isTagSupported("feSpotLight")) && svg$.FESpotLightElement.is(svg$.SvgElement.tag("feSpotLight"));
>+  }
>+  get [$limitingConeAngle]() {
>+    return this.limitingConeAngle;
>+  }
>+  get [$pointsAtX]() {
>+    return this.pointsAtX;
>+  }
>+  get [$pointsAtY]() {
>+    return this.pointsAtY;
>+  }
>+  get [$pointsAtZ]() {
>+    return this.pointsAtZ;
>+  }
>+  get [$specularExponent]() {
>+    return this.specularExponent;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+  get [$z]() {
>+    return this.z;
>+  }
>+};
>+(svg$.FESpotLightElement.created = function() {
>+  this[limitingConeAngle] = null;
>+  this[pointsAtX] = null;
>+  this[pointsAtY] = null;
>+  this[pointsAtZ] = null;
>+  this[specularExponent$] = null;
>+  this[x$22] = null;
>+  this[y$21] = null;
>+  this[z$7] = null;
>+  svg$.FESpotLightElement.__proto__.created.call(this);
>+}).prototype = svg$.FESpotLightElement.prototype;
>+dart.addTypeTests(svg$.FESpotLightElement);
>+const limitingConeAngle = Symbol("FESpotLightElement.limitingConeAngle");
>+const pointsAtX = Symbol("FESpotLightElement.pointsAtX");
>+const pointsAtY = Symbol("FESpotLightElement.pointsAtY");
>+const pointsAtZ = Symbol("FESpotLightElement.pointsAtZ");
>+const specularExponent$ = Symbol("FESpotLightElement.specularExponent");
>+const x$22 = Symbol("FESpotLightElement.x");
>+const y$21 = Symbol("FESpotLightElement.y");
>+const z$7 = Symbol("FESpotLightElement.z");
>+dart.setLibraryUri(svg$.FESpotLightElement, "dart:svg");
>+dart.setFieldSignature(svg$.FESpotLightElement, () => ({
>+  __proto__: dart.getFields(svg$.FESpotLightElement.__proto__),
>+  [$limitingConeAngle]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$pointsAtX]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$pointsAtY]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$pointsAtZ]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$specularExponent]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$x]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$y]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$z]: dart.finalFieldType(svg$.AnimatedNumber)
>+}));
>+dart.registerExtension("SVGFESpotLightElement", svg$.FESpotLightElement);
>+svg$.FETileElement = class FETileElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.FETileElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("feTile"));
>+  }
>+  static get supported() {
>+    return dart.test(svg$.SvgElement.isTagSupported("feTile")) && svg$.FETileElement.is(svg$.SvgElement.tag("feTile"));
>+  }
>+  get [$in1]() {
>+    return this.in1;
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$result]() {
>+    return this.result;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+};
>+(svg$.FETileElement.created = function() {
>+  this[in1$10] = null;
>+  this[height$28] = null;
>+  this[result$13] = null;
>+  this[width$30] = null;
>+  this[x$23] = null;
>+  this[y$22] = null;
>+  svg$.FETileElement.__proto__.created.call(this);
>+}).prototype = svg$.FETileElement.prototype;
>+dart.addTypeTests(svg$.FETileElement);
>+const in1$10 = Symbol("FETileElement.in1");
>+const height$28 = Symbol("FETileElement.height");
>+const result$13 = Symbol("FETileElement.result");
>+const width$30 = Symbol("FETileElement.width");
>+const x$23 = Symbol("FETileElement.x");
>+const y$22 = Symbol("FETileElement.y");
>+svg$.FETileElement[dart.implements] = () => [svg$.FilterPrimitiveStandardAttributes];
>+dart.setLibraryUri(svg$.FETileElement, "dart:svg");
>+dart.setFieldSignature(svg$.FETileElement, () => ({
>+  __proto__: dart.getFields(svg$.FETileElement.__proto__),
>+  [$in1]: dart.finalFieldType(svg$.AnimatedString),
>+  [$height]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$result]: dart.finalFieldType(svg$.AnimatedString),
>+  [$width]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$x]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$y]: dart.finalFieldType(svg$.AnimatedLength)
>+}));
>+dart.registerExtension("SVGFETileElement", svg$.FETileElement);
>+svg$.FETurbulenceElement = class FETurbulenceElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.FETurbulenceElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("feTurbulence"));
>+  }
>+  static get supported() {
>+    return dart.test(svg$.SvgElement.isTagSupported("feTurbulence")) && svg$.FETurbulenceElement.is(svg$.SvgElement.tag("feTurbulence"));
>+  }
>+  get [$baseFrequencyX]() {
>+    return this.baseFrequencyX;
>+  }
>+  get [$baseFrequencyY]() {
>+    return this.baseFrequencyY;
>+  }
>+  get [$numOctaves]() {
>+    return this.numOctaves;
>+  }
>+  get [$seed]() {
>+    return this.seed;
>+  }
>+  get [$stitchTiles]() {
>+    return this.stitchTiles;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$result]() {
>+    return this.result;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+};
>+(svg$.FETurbulenceElement.created = function() {
>+  this[baseFrequencyX] = null;
>+  this[baseFrequencyY] = null;
>+  this[numOctaves] = null;
>+  this[seed] = null;
>+  this[stitchTiles] = null;
>+  this[type$38] = null;
>+  this[height$29] = null;
>+  this[result$14] = null;
>+  this[width$31] = null;
>+  this[x$24] = null;
>+  this[y$23] = null;
>+  svg$.FETurbulenceElement.__proto__.created.call(this);
>+}).prototype = svg$.FETurbulenceElement.prototype;
>+dart.addTypeTests(svg$.FETurbulenceElement);
>+const baseFrequencyX = Symbol("FETurbulenceElement.baseFrequencyX");
>+const baseFrequencyY = Symbol("FETurbulenceElement.baseFrequencyY");
>+const numOctaves = Symbol("FETurbulenceElement.numOctaves");
>+const seed = Symbol("FETurbulenceElement.seed");
>+const stitchTiles = Symbol("FETurbulenceElement.stitchTiles");
>+const type$38 = Symbol("FETurbulenceElement.type");
>+const height$29 = Symbol("FETurbulenceElement.height");
>+const result$14 = Symbol("FETurbulenceElement.result");
>+const width$31 = Symbol("FETurbulenceElement.width");
>+const x$24 = Symbol("FETurbulenceElement.x");
>+const y$23 = Symbol("FETurbulenceElement.y");
>+svg$.FETurbulenceElement[dart.implements] = () => [svg$.FilterPrimitiveStandardAttributes];
>+dart.setLibraryUri(svg$.FETurbulenceElement, "dart:svg");
>+dart.setFieldSignature(svg$.FETurbulenceElement, () => ({
>+  __proto__: dart.getFields(svg$.FETurbulenceElement.__proto__),
>+  [$baseFrequencyX]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$baseFrequencyY]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$numOctaves]: dart.finalFieldType(svg$.AnimatedInteger),
>+  [$seed]: dart.finalFieldType(svg$.AnimatedNumber),
>+  [$stitchTiles]: dart.finalFieldType(svg$.AnimatedEnumeration),
>+  [$type]: dart.finalFieldType(svg$.AnimatedEnumeration),
>+  [$height]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$result]: dart.finalFieldType(svg$.AnimatedString),
>+  [$width]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$x]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$y]: dart.finalFieldType(svg$.AnimatedLength)
>+}));
>+dart.defineLazy(svg$.FETurbulenceElement, {
>+  /*svg$.FETurbulenceElement.SVG_STITCHTYPE_NOSTITCH*/get SVG_STITCHTYPE_NOSTITCH() {
>+    return 2;
>+  },
>+  /*svg$.FETurbulenceElement.SVG_STITCHTYPE_STITCH*/get SVG_STITCHTYPE_STITCH() {
>+    return 1;
>+  },
>+  /*svg$.FETurbulenceElement.SVG_STITCHTYPE_UNKNOWN*/get SVG_STITCHTYPE_UNKNOWN() {
>+    return 0;
>+  },
>+  /*svg$.FETurbulenceElement.SVG_TURBULENCE_TYPE_FRACTALNOISE*/get SVG_TURBULENCE_TYPE_FRACTALNOISE() {
>+    return 1;
>+  },
>+  /*svg$.FETurbulenceElement.SVG_TURBULENCE_TYPE_TURBULENCE*/get SVG_TURBULENCE_TYPE_TURBULENCE() {
>+    return 2;
>+  },
>+  /*svg$.FETurbulenceElement.SVG_TURBULENCE_TYPE_UNKNOWN*/get SVG_TURBULENCE_TYPE_UNKNOWN() {
>+    return 0;
>+  }
>+});
>+dart.registerExtension("SVGFETurbulenceElement", svg$.FETurbulenceElement);
>+svg$.FilterElement = class FilterElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.FilterElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("filter"));
>+  }
>+  static get supported() {
>+    return dart.test(svg$.SvgElement.isTagSupported("filter")) && svg$.FilterElement.is(svg$.SvgElement.tag("filter"));
>+  }
>+  get [$filterUnits]() {
>+    return this.filterUnits;
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$primitiveUnits]() {
>+    return this.primitiveUnits;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+  get [$href]() {
>+    return this.href;
>+  }
>+};
>+(svg$.FilterElement.created = function() {
>+  this[filterUnits] = null;
>+  this[height$30] = null;
>+  this[primitiveUnits] = null;
>+  this[width$32] = null;
>+  this[x$25] = null;
>+  this[y$24] = null;
>+  this[href$10] = null;
>+  svg$.FilterElement.__proto__.created.call(this);
>+}).prototype = svg$.FilterElement.prototype;
>+dart.addTypeTests(svg$.FilterElement);
>+const filterUnits = Symbol("FilterElement.filterUnits");
>+const height$30 = Symbol("FilterElement.height");
>+const primitiveUnits = Symbol("FilterElement.primitiveUnits");
>+const width$32 = Symbol("FilterElement.width");
>+const x$25 = Symbol("FilterElement.x");
>+const y$24 = Symbol("FilterElement.y");
>+const href$10 = Symbol("FilterElement.href");
>+svg$.FilterElement[dart.implements] = () => [svg$.UriReference];
>+dart.setLibraryUri(svg$.FilterElement, "dart:svg");
>+dart.setFieldSignature(svg$.FilterElement, () => ({
>+  __proto__: dart.getFields(svg$.FilterElement.__proto__),
>+  [$filterUnits]: dart.finalFieldType(svg$.AnimatedEnumeration),
>+  [$height]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$primitiveUnits]: dart.finalFieldType(svg$.AnimatedEnumeration),
>+  [$width]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$x]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$y]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$href]: dart.finalFieldType(svg$.AnimatedString)
>+}));
>+dart.registerExtension("SVGFilterElement", svg$.FilterElement);
>+svg$.FilterPrimitiveStandardAttributes = class FilterPrimitiveStandardAttributes extends _interceptors.Interceptor {
>+  get height() {
>+    return this[height$31];
>+  }
>+  set height(value) {
>+    super.height = value;
>+  }
>+  get result() {
>+    return this[result$15];
>+  }
>+  set result(value) {
>+    super.result = value;
>+  }
>+  get width() {
>+    return this[width$33];
>+  }
>+  set width(value) {
>+    super.width = value;
>+  }
>+  get x() {
>+    return this[x$26];
>+  }
>+  set x(value) {
>+    super.x = value;
>+  }
>+  get y() {
>+    return this[y$25];
>+  }
>+  set y(value) {
>+    super.y = value;
>+  }
>+};
>+dart.addTypeTests(svg$.FilterPrimitiveStandardAttributes);
>+const height$31 = Symbol("FilterPrimitiveStandardAttributes.height");
>+const result$15 = Symbol("FilterPrimitiveStandardAttributes.result");
>+const width$33 = Symbol("FilterPrimitiveStandardAttributes.width");
>+const x$26 = Symbol("FilterPrimitiveStandardAttributes.x");
>+const y$25 = Symbol("FilterPrimitiveStandardAttributes.y");
>+dart.setLibraryUri(svg$.FilterPrimitiveStandardAttributes, "dart:svg");
>+dart.setFieldSignature(svg$.FilterPrimitiveStandardAttributes, () => ({
>+  __proto__: dart.getFields(svg$.FilterPrimitiveStandardAttributes.__proto__),
>+  height: dart.finalFieldType(svg$.AnimatedLength),
>+  result: dart.finalFieldType(svg$.AnimatedString),
>+  width: dart.finalFieldType(svg$.AnimatedLength),
>+  x: dart.finalFieldType(svg$.AnimatedLength),
>+  y: dart.finalFieldType(svg$.AnimatedLength)
>+}));
>+dart.defineExtensionAccessors(svg$.FilterPrimitiveStandardAttributes, [
>+  'height',
>+  'result',
>+  'width',
>+  'x',
>+  'y'
>+]);
>+svg$.FitToViewBox = class FitToViewBox extends _interceptors.Interceptor {
>+  get preserveAspectRatio() {
>+    return this[preserveAspectRatio$];
>+  }
>+  set preserveAspectRatio(value) {
>+    super.preserveAspectRatio = value;
>+  }
>+  get viewBox() {
>+    return this[viewBox];
>+  }
>+  set viewBox(value) {
>+    super.viewBox = value;
>+  }
>+};
>+dart.addTypeTests(svg$.FitToViewBox);
>+const preserveAspectRatio$ = Symbol("FitToViewBox.preserveAspectRatio");
>+const viewBox = Symbol("FitToViewBox.viewBox");
>+dart.setLibraryUri(svg$.FitToViewBox, "dart:svg");
>+dart.setFieldSignature(svg$.FitToViewBox, () => ({
>+  __proto__: dart.getFields(svg$.FitToViewBox.__proto__),
>+  preserveAspectRatio: dart.finalFieldType(svg$.AnimatedPreserveAspectRatio),
>+  viewBox: dart.finalFieldType(svg$.AnimatedRect)
>+}));
>+dart.defineExtensionAccessors(svg$.FitToViewBox, ['preserveAspectRatio', 'viewBox']);
>+svg$.ForeignObjectElement = class ForeignObjectElement extends svg$.GraphicsElement {
>+  static new() {
>+    return svg$.ForeignObjectElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("foreignObject"));
>+  }
>+  static get supported() {
>+    return dart.test(svg$.SvgElement.isTagSupported("foreignObject")) && svg$.ForeignObjectElement.is(svg$.SvgElement.tag("foreignObject"));
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+};
>+(svg$.ForeignObjectElement.created = function() {
>+  this[height$32] = null;
>+  this[width$34] = null;
>+  this[x$27] = null;
>+  this[y$26] = null;
>+  svg$.ForeignObjectElement.__proto__.created.call(this);
>+}).prototype = svg$.ForeignObjectElement.prototype;
>+dart.addTypeTests(svg$.ForeignObjectElement);
>+const height$32 = Symbol("ForeignObjectElement.height");
>+const width$34 = Symbol("ForeignObjectElement.width");
>+const x$27 = Symbol("ForeignObjectElement.x");
>+const y$26 = Symbol("ForeignObjectElement.y");
>+dart.setLibraryUri(svg$.ForeignObjectElement, "dart:svg");
>+dart.setFieldSignature(svg$.ForeignObjectElement, () => ({
>+  __proto__: dart.getFields(svg$.ForeignObjectElement.__proto__),
>+  [$height]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$width]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$x]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$y]: dart.finalFieldType(svg$.AnimatedLength)
>+}));
>+dart.registerExtension("SVGForeignObjectElement", svg$.ForeignObjectElement);
>+svg$.GElement = class GElement extends svg$.GraphicsElement {
>+  static new() {
>+    return svg$.GElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("g"));
>+  }
>+};
>+(svg$.GElement.created = function() {
>+  svg$.GElement.__proto__.created.call(this);
>+}).prototype = svg$.GElement.prototype;
>+dart.addTypeTests(svg$.GElement);
>+dart.setLibraryUri(svg$.GElement, "dart:svg");
>+dart.registerExtension("SVGGElement", svg$.GElement);
>+svg$.ImageElement = class ImageElement extends svg$.GraphicsElement {
>+  static new() {
>+    return svg$.ImageElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("image"));
>+  }
>+  get [$async]() {
>+    return this.async;
>+  }
>+  set [$async](value) {
>+    this.async = value;
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$preserveAspectRatio]() {
>+    return this.preserveAspectRatio;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+  [$decode]() {
>+    return html$.promiseToFuture(dart.dynamic, this.decode());
>+  }
>+  get [$href]() {
>+    return this.href;
>+  }
>+};
>+(svg$.ImageElement.created = function() {
>+  this[async$1] = null;
>+  this[height$33] = null;
>+  this[preserveAspectRatio$0] = null;
>+  this[width$35] = null;
>+  this[x$28] = null;
>+  this[y$27] = null;
>+  this[href$11] = null;
>+  svg$.ImageElement.__proto__.created.call(this);
>+}).prototype = svg$.ImageElement.prototype;
>+dart.addTypeTests(svg$.ImageElement);
>+const async$1 = Symbol("ImageElement.async");
>+const height$33 = Symbol("ImageElement.height");
>+const preserveAspectRatio$0 = Symbol("ImageElement.preserveAspectRatio");
>+const width$35 = Symbol("ImageElement.width");
>+const x$28 = Symbol("ImageElement.x");
>+const y$27 = Symbol("ImageElement.y");
>+const href$11 = Symbol("ImageElement.href");
>+svg$.ImageElement[dart.implements] = () => [svg$.UriReference];
>+dart.setMethodSignature(svg$.ImageElement, () => ({
>+  __proto__: dart.getMethods(svg$.ImageElement.__proto__),
>+  [$decode]: dart.fnType(async.Future, [])
>+}));
>+dart.setLibraryUri(svg$.ImageElement, "dart:svg");
>+dart.setFieldSignature(svg$.ImageElement, () => ({
>+  __proto__: dart.getFields(svg$.ImageElement.__proto__),
>+  [$async]: dart.fieldType(core.String),
>+  [$height]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$preserveAspectRatio]: dart.finalFieldType(svg$.AnimatedPreserveAspectRatio),
>+  [$width]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$x]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$y]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$href]: dart.finalFieldType(svg$.AnimatedString)
>+}));
>+dart.registerExtension("SVGImageElement", svg$.ImageElement);
>+svg$.Length = class Length extends _interceptors.Interceptor {
>+  get [$unitType]() {
>+    return this.unitType;
>+  }
>+  get [$value]() {
>+    return this.value;
>+  }
>+  set [$value](value) {
>+    this.value = value;
>+  }
>+  get [$valueAsString]() {
>+    return this.valueAsString;
>+  }
>+  set [$valueAsString](value) {
>+    this.valueAsString = value;
>+  }
>+  get [$valueInSpecifiedUnits]() {
>+    return this.valueInSpecifiedUnits;
>+  }
>+  set [$valueInSpecifiedUnits](value) {
>+    this.valueInSpecifiedUnits = value;
>+  }
>+  [$convertToSpecifiedUnits](...args) {
>+    return this.convertToSpecifiedUnits.apply(this, args);
>+  }
>+  [$newValueSpecifiedUnits](...args) {
>+    return this.newValueSpecifiedUnits.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(svg$.Length);
>+const unitType$ = Symbol("Length.unitType");
>+const value$19 = Symbol("Length.value");
>+const valueAsString$ = Symbol("Length.valueAsString");
>+const valueInSpecifiedUnits$ = Symbol("Length.valueInSpecifiedUnits");
>+dart.setMethodSignature(svg$.Length, () => ({
>+  __proto__: dart.getMethods(svg$.Length.__proto__),
>+  [$convertToSpecifiedUnits]: dart.fnType(dart.void, [core.int]),
>+  [$newValueSpecifiedUnits]: dart.fnType(dart.void, [core.int, core.num])
>+}));
>+dart.setLibraryUri(svg$.Length, "dart:svg");
>+dart.setFieldSignature(svg$.Length, () => ({
>+  __proto__: dart.getFields(svg$.Length.__proto__),
>+  [$unitType]: dart.finalFieldType(core.int),
>+  [$value]: dart.fieldType(core.num),
>+  [$valueAsString]: dart.fieldType(core.String),
>+  [$valueInSpecifiedUnits]: dart.fieldType(core.num)
>+}));
>+dart.defineLazy(svg$.Length, {
>+  /*svg$.Length.SVG_LENGTHTYPE_CM*/get SVG_LENGTHTYPE_CM() {
>+    return 6;
>+  },
>+  /*svg$.Length.SVG_LENGTHTYPE_EMS*/get SVG_LENGTHTYPE_EMS() {
>+    return 3;
>+  },
>+  /*svg$.Length.SVG_LENGTHTYPE_EXS*/get SVG_LENGTHTYPE_EXS() {
>+    return 4;
>+  },
>+  /*svg$.Length.SVG_LENGTHTYPE_IN*/get SVG_LENGTHTYPE_IN() {
>+    return 8;
>+  },
>+  /*svg$.Length.SVG_LENGTHTYPE_MM*/get SVG_LENGTHTYPE_MM() {
>+    return 7;
>+  },
>+  /*svg$.Length.SVG_LENGTHTYPE_NUMBER*/get SVG_LENGTHTYPE_NUMBER() {
>+    return 1;
>+  },
>+  /*svg$.Length.SVG_LENGTHTYPE_PC*/get SVG_LENGTHTYPE_PC() {
>+    return 10;
>+  },
>+  /*svg$.Length.SVG_LENGTHTYPE_PERCENTAGE*/get SVG_LENGTHTYPE_PERCENTAGE() {
>+    return 2;
>+  },
>+  /*svg$.Length.SVG_LENGTHTYPE_PT*/get SVG_LENGTHTYPE_PT() {
>+    return 9;
>+  },
>+  /*svg$.Length.SVG_LENGTHTYPE_PX*/get SVG_LENGTHTYPE_PX() {
>+    return 5;
>+  },
>+  /*svg$.Length.SVG_LENGTHTYPE_UNKNOWN*/get SVG_LENGTHTYPE_UNKNOWN() {
>+    return 0;
>+  }
>+});
>+dart.registerExtension("SVGLength", svg$.Length);
>+const __setter__$ = dart.privateName(svg$, "__setter__");
>+const Interceptor_ListMixin$$13 = class Interceptor_ListMixin extends _interceptors.Interceptor {};
>+(Interceptor_ListMixin$$13.new = function() {
>+  Interceptor_ListMixin$$13.__proto__.new.call(this);
>+}).prototype = Interceptor_ListMixin$$13.prototype;
>+dart.applyMixin(Interceptor_ListMixin$$13, collection.ListMixin$(svg$.Length));
>+const Interceptor_ImmutableListMixin$$13 = class Interceptor_ImmutableListMixin extends Interceptor_ListMixin$$13 {};
>+(Interceptor_ImmutableListMixin$$13.new = function() {
>+  Interceptor_ImmutableListMixin$$13.__proto__.new.call(this);
>+}).prototype = Interceptor_ImmutableListMixin$$13.prototype;
>+dart.applyMixin(Interceptor_ImmutableListMixin$$13, html$.ImmutableListMixin$(svg$.Length));
>+svg$.LengthList = class LengthList extends Interceptor_ImmutableListMixin$$13 {
>+  get [$length]() {
>+    return this.length;
>+  }
>+  get [$numberOfItems]() {
>+    return this.numberOfItems;
>+  }
>+  [$_get](index) {
>+    if (index >>> 0 !== index || index >= this[$length]) dart.throw(core.RangeError.index(index, this));
>+    return this.getItem(index);
>+  }
>+  [$_set](index, value) {
>+    svg$.Length._check(value);
>+    dart.throw(new core.UnsupportedError.new("Cannot assign element of immutable List."));
>+    return value;
>+  }
>+  set [$length](value) {
>+    dart.throw(new core.UnsupportedError.new("Cannot resize immutable List."));
>+  }
>+  get [$first]() {
>+    if (dart.notNull(this[$length]) > 0) {
>+      return this[0];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$first](value) {
>+    super[$first] = value;
>+  }
>+  get [$last]() {
>+    let len = this[$length];
>+    if (dart.notNull(len) > 0) {
>+      return this[dart.notNull(len) - 1];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$last](value) {
>+    super[$last] = value;
>+  }
>+  get [$single]() {
>+    let len = this[$length];
>+    if (len === 1) {
>+      return this[0];
>+    }
>+    if (len === 0) dart.throw(new core.StateError.new("No elements"));
>+    dart.throw(new core.StateError.new("More than one element"));
>+  }
>+  [$elementAt](index) {
>+    return this[$_get](index);
>+  }
>+  [__setter__$](...args) {
>+    return this.__setter__.apply(this, args);
>+  }
>+  [$appendItem](...args) {
>+    return this.appendItem.apply(this, args);
>+  }
>+  [$clear](...args) {
>+    return this.clear.apply(this, args);
>+  }
>+  [$getItem](...args) {
>+    return this.getItem.apply(this, args);
>+  }
>+  [$initialize](...args) {
>+    return this.initialize.apply(this, args);
>+  }
>+  [$insertItemBefore](...args) {
>+    return this.insertItemBefore.apply(this, args);
>+  }
>+  [$removeItem](...args) {
>+    return this.removeItem.apply(this, args);
>+  }
>+  [$replaceItem](...args) {
>+    return this.replaceItem.apply(this, args);
>+  }
>+};
>+svg$.LengthList.prototype[dart.isList] = true;
>+dart.addTypeTests(svg$.LengthList);
>+const numberOfItems = Symbol("LengthList.numberOfItems");
>+svg$.LengthList[dart.implements] = () => [ListOfLength()];
>+dart.setMethodSignature(svg$.LengthList, () => ({
>+  __proto__: dart.getMethods(svg$.LengthList.__proto__),
>+  [$_get]: dart.fnType(svg$.Length, [core.int]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$elementAt]: dart.fnType(svg$.Length, [core.int]),
>+  [__setter__$]: dart.fnType(dart.void, [core.int, svg$.Length]),
>+  [$appendItem]: dart.fnType(svg$.Length, [svg$.Length]),
>+  [$clear]: dart.fnType(dart.void, []),
>+  [$getItem]: dart.fnType(svg$.Length, [core.int]),
>+  [$initialize]: dart.fnType(svg$.Length, [svg$.Length]),
>+  [$insertItemBefore]: dart.fnType(svg$.Length, [svg$.Length, core.int]),
>+  [$removeItem]: dart.fnType(svg$.Length, [core.int]),
>+  [$replaceItem]: dart.fnType(svg$.Length, [svg$.Length, core.int])
>+}));
>+dart.setGetterSignature(svg$.LengthList, () => ({
>+  __proto__: dart.getGetters(svg$.LengthList.__proto__),
>+  [$length]: core.int,
>+  [$first]: svg$.Length,
>+  [$last]: svg$.Length,
>+  [$single]: svg$.Length
>+}));
>+dart.setSetterSignature(svg$.LengthList, () => ({
>+  __proto__: dart.getSetters(svg$.LengthList.__proto__),
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(svg$.LengthList, "dart:svg");
>+dart.setFieldSignature(svg$.LengthList, () => ({
>+  __proto__: dart.getFields(svg$.LengthList.__proto__),
>+  [$numberOfItems]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("SVGLengthList", svg$.LengthList);
>+svg$.LineElement = class LineElement extends svg$.GeometryElement {
>+  static new() {
>+    return svg$.LineElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("line"));
>+  }
>+  get [$x1]() {
>+    return this.x1;
>+  }
>+  get [$x2]() {
>+    return this.x2;
>+  }
>+  get [$y1]() {
>+    return this.y1;
>+  }
>+  get [$y2]() {
>+    return this.y2;
>+  }
>+};
>+(svg$.LineElement.created = function() {
>+  this[x1] = null;
>+  this[x2] = null;
>+  this[y1] = null;
>+  this[y2] = null;
>+  svg$.LineElement.__proto__.created.call(this);
>+}).prototype = svg$.LineElement.prototype;
>+dart.addTypeTests(svg$.LineElement);
>+const x1 = Symbol("LineElement.x1");
>+const x2 = Symbol("LineElement.x2");
>+const y1 = Symbol("LineElement.y1");
>+const y2 = Symbol("LineElement.y2");
>+dart.setLibraryUri(svg$.LineElement, "dart:svg");
>+dart.setFieldSignature(svg$.LineElement, () => ({
>+  __proto__: dart.getFields(svg$.LineElement.__proto__),
>+  [$x1]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$x2]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$y1]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$y2]: dart.finalFieldType(svg$.AnimatedLength)
>+}));
>+dart.registerExtension("SVGLineElement", svg$.LineElement);
>+svg$._GradientElement = class _GradientElement extends svg$.SvgElement {
>+  get [$gradientTransform]() {
>+    return this.gradientTransform;
>+  }
>+  get [$gradientUnits]() {
>+    return this.gradientUnits;
>+  }
>+  get [$spreadMethod]() {
>+    return this.spreadMethod;
>+  }
>+  get [$href]() {
>+    return this.href;
>+  }
>+};
>+(svg$._GradientElement.created = function() {
>+  this[gradientTransform] = null;
>+  this[gradientUnits] = null;
>+  this[spreadMethod] = null;
>+  this[href$12] = null;
>+  svg$._GradientElement.__proto__.created.call(this);
>+}).prototype = svg$._GradientElement.prototype;
>+dart.addTypeTests(svg$._GradientElement);
>+const gradientTransform = Symbol("_GradientElement.gradientTransform");
>+const gradientUnits = Symbol("_GradientElement.gradientUnits");
>+const spreadMethod = Symbol("_GradientElement.spreadMethod");
>+const href$12 = Symbol("_GradientElement.href");
>+svg$._GradientElement[dart.implements] = () => [svg$.UriReference];
>+dart.setLibraryUri(svg$._GradientElement, "dart:svg");
>+dart.setFieldSignature(svg$._GradientElement, () => ({
>+  __proto__: dart.getFields(svg$._GradientElement.__proto__),
>+  [$gradientTransform]: dart.finalFieldType(svg$.AnimatedTransformList),
>+  [$gradientUnits]: dart.finalFieldType(svg$.AnimatedEnumeration),
>+  [$spreadMethod]: dart.finalFieldType(svg$.AnimatedEnumeration),
>+  [$href]: dart.finalFieldType(svg$.AnimatedString)
>+}));
>+dart.defineLazy(svg$._GradientElement, {
>+  /*svg$._GradientElement.SVG_SPREADMETHOD_PAD*/get SVG_SPREADMETHOD_PAD() {
>+    return 1;
>+  },
>+  /*svg$._GradientElement.SVG_SPREADMETHOD_REFLECT*/get SVG_SPREADMETHOD_REFLECT() {
>+    return 2;
>+  },
>+  /*svg$._GradientElement.SVG_SPREADMETHOD_REPEAT*/get SVG_SPREADMETHOD_REPEAT() {
>+    return 3;
>+  },
>+  /*svg$._GradientElement.SVG_SPREADMETHOD_UNKNOWN*/get SVG_SPREADMETHOD_UNKNOWN() {
>+    return 0;
>+  }
>+});
>+dart.registerExtension("SVGGradientElement", svg$._GradientElement);
>+svg$.LinearGradientElement = class LinearGradientElement extends svg$._GradientElement {
>+  static new() {
>+    return svg$.LinearGradientElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("linearGradient"));
>+  }
>+  get [$x1]() {
>+    return this.x1;
>+  }
>+  get [$x2]() {
>+    return this.x2;
>+  }
>+  get [$y1]() {
>+    return this.y1;
>+  }
>+  get [$y2]() {
>+    return this.y2;
>+  }
>+};
>+(svg$.LinearGradientElement.created = function() {
>+  this[x1$] = null;
>+  this[x2$] = null;
>+  this[y1$] = null;
>+  this[y2$] = null;
>+  svg$.LinearGradientElement.__proto__.created.call(this);
>+}).prototype = svg$.LinearGradientElement.prototype;
>+dart.addTypeTests(svg$.LinearGradientElement);
>+const x1$ = Symbol("LinearGradientElement.x1");
>+const x2$ = Symbol("LinearGradientElement.x2");
>+const y1$ = Symbol("LinearGradientElement.y1");
>+const y2$ = Symbol("LinearGradientElement.y2");
>+dart.setLibraryUri(svg$.LinearGradientElement, "dart:svg");
>+dart.setFieldSignature(svg$.LinearGradientElement, () => ({
>+  __proto__: dart.getFields(svg$.LinearGradientElement.__proto__),
>+  [$x1]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$x2]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$y1]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$y2]: dart.finalFieldType(svg$.AnimatedLength)
>+}));
>+dart.registerExtension("SVGLinearGradientElement", svg$.LinearGradientElement);
>+svg$.MarkerElement = class MarkerElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.MarkerElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("marker"));
>+  }
>+  get [$markerHeight]() {
>+    return this.markerHeight;
>+  }
>+  get [$markerUnits]() {
>+    return this.markerUnits;
>+  }
>+  get [$markerWidth]() {
>+    return this.markerWidth;
>+  }
>+  get [$orientAngle]() {
>+    return this.orientAngle;
>+  }
>+  get [$orientType]() {
>+    return this.orientType;
>+  }
>+  get [$refX]() {
>+    return this.refX;
>+  }
>+  get [$refY]() {
>+    return this.refY;
>+  }
>+  [$setOrientToAngle](...args) {
>+    return this.setOrientToAngle.apply(this, args);
>+  }
>+  [$setOrientToAuto](...args) {
>+    return this.setOrientToAuto.apply(this, args);
>+  }
>+  get [$preserveAspectRatio]() {
>+    return this.preserveAspectRatio;
>+  }
>+  get [$viewBox]() {
>+    return this.viewBox;
>+  }
>+};
>+(svg$.MarkerElement.created = function() {
>+  this[markerHeight] = null;
>+  this[markerUnits] = null;
>+  this[markerWidth] = null;
>+  this[orientAngle] = null;
>+  this[orientType] = null;
>+  this[refX] = null;
>+  this[refY] = null;
>+  this[preserveAspectRatio$1] = null;
>+  this[viewBox$] = null;
>+  svg$.MarkerElement.__proto__.created.call(this);
>+}).prototype = svg$.MarkerElement.prototype;
>+dart.addTypeTests(svg$.MarkerElement);
>+const markerHeight = Symbol("MarkerElement.markerHeight");
>+const markerUnits = Symbol("MarkerElement.markerUnits");
>+const markerWidth = Symbol("MarkerElement.markerWidth");
>+const orientAngle = Symbol("MarkerElement.orientAngle");
>+const orientType = Symbol("MarkerElement.orientType");
>+const refX = Symbol("MarkerElement.refX");
>+const refY = Symbol("MarkerElement.refY");
>+const preserveAspectRatio$1 = Symbol("MarkerElement.preserveAspectRatio");
>+const viewBox$ = Symbol("MarkerElement.viewBox");
>+svg$.MarkerElement[dart.implements] = () => [svg$.FitToViewBox];
>+dart.setMethodSignature(svg$.MarkerElement, () => ({
>+  __proto__: dart.getMethods(svg$.MarkerElement.__proto__),
>+  [$setOrientToAngle]: dart.fnType(dart.void, [svg$.Angle]),
>+  [$setOrientToAuto]: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(svg$.MarkerElement, "dart:svg");
>+dart.setFieldSignature(svg$.MarkerElement, () => ({
>+  __proto__: dart.getFields(svg$.MarkerElement.__proto__),
>+  [$markerHeight]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$markerUnits]: dart.finalFieldType(svg$.AnimatedEnumeration),
>+  [$markerWidth]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$orientAngle]: dart.finalFieldType(svg$.AnimatedAngle),
>+  [$orientType]: dart.finalFieldType(svg$.AnimatedEnumeration),
>+  [$refX]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$refY]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$preserveAspectRatio]: dart.finalFieldType(svg$.AnimatedPreserveAspectRatio),
>+  [$viewBox]: dart.finalFieldType(svg$.AnimatedRect)
>+}));
>+dart.defineLazy(svg$.MarkerElement, {
>+  /*svg$.MarkerElement.SVG_MARKERUNITS_STROKEWIDTH*/get SVG_MARKERUNITS_STROKEWIDTH() {
>+    return 2;
>+  },
>+  /*svg$.MarkerElement.SVG_MARKERUNITS_UNKNOWN*/get SVG_MARKERUNITS_UNKNOWN() {
>+    return 0;
>+  },
>+  /*svg$.MarkerElement.SVG_MARKERUNITS_USERSPACEONUSE*/get SVG_MARKERUNITS_USERSPACEONUSE() {
>+    return 1;
>+  },
>+  /*svg$.MarkerElement.SVG_MARKER_ORIENT_ANGLE*/get SVG_MARKER_ORIENT_ANGLE() {
>+    return 2;
>+  },
>+  /*svg$.MarkerElement.SVG_MARKER_ORIENT_AUTO*/get SVG_MARKER_ORIENT_AUTO() {
>+    return 1;
>+  },
>+  /*svg$.MarkerElement.SVG_MARKER_ORIENT_UNKNOWN*/get SVG_MARKER_ORIENT_UNKNOWN() {
>+    return 0;
>+  }
>+});
>+dart.registerExtension("SVGMarkerElement", svg$.MarkerElement);
>+svg$.MaskElement = class MaskElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.MaskElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("mask"));
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$maskContentUnits]() {
>+    return this.maskContentUnits;
>+  }
>+  get [$maskUnits]() {
>+    return this.maskUnits;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+  get [$requiredExtensions]() {
>+    return this.requiredExtensions;
>+  }
>+  get [$systemLanguage]() {
>+    return this.systemLanguage;
>+  }
>+};
>+(svg$.MaskElement.created = function() {
>+  this[height$34] = null;
>+  this[maskContentUnits] = null;
>+  this[maskUnits] = null;
>+  this[width$36] = null;
>+  this[x$29] = null;
>+  this[y$28] = null;
>+  this[requiredExtensions$0] = null;
>+  this[systemLanguage$0] = null;
>+  svg$.MaskElement.__proto__.created.call(this);
>+}).prototype = svg$.MaskElement.prototype;
>+dart.addTypeTests(svg$.MaskElement);
>+const height$34 = Symbol("MaskElement.height");
>+const maskContentUnits = Symbol("MaskElement.maskContentUnits");
>+const maskUnits = Symbol("MaskElement.maskUnits");
>+const width$36 = Symbol("MaskElement.width");
>+const x$29 = Symbol("MaskElement.x");
>+const y$28 = Symbol("MaskElement.y");
>+const requiredExtensions$0 = Symbol("MaskElement.requiredExtensions");
>+const systemLanguage$0 = Symbol("MaskElement.systemLanguage");
>+svg$.MaskElement[dart.implements] = () => [svg$.Tests];
>+dart.setLibraryUri(svg$.MaskElement, "dart:svg");
>+dart.setFieldSignature(svg$.MaskElement, () => ({
>+  __proto__: dart.getFields(svg$.MaskElement.__proto__),
>+  [$height]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$maskContentUnits]: dart.finalFieldType(svg$.AnimatedEnumeration),
>+  [$maskUnits]: dart.finalFieldType(svg$.AnimatedEnumeration),
>+  [$width]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$x]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$y]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$requiredExtensions]: dart.finalFieldType(svg$.StringList),
>+  [$systemLanguage]: dart.finalFieldType(svg$.StringList)
>+}));
>+dart.registerExtension("SVGMaskElement", svg$.MaskElement);
>+svg$.Matrix = class Matrix extends _interceptors.Interceptor {
>+  get [$a]() {
>+    return this.a;
>+  }
>+  set [$a](value) {
>+    this.a = value;
>+  }
>+  get [$b]() {
>+    return this.b;
>+  }
>+  set [$b](value) {
>+    this.b = value;
>+  }
>+  get [$c]() {
>+    return this.c;
>+  }
>+  set [$c](value) {
>+    this.c = value;
>+  }
>+  get [$d]() {
>+    return this.d;
>+  }
>+  set [$d](value) {
>+    this.d = value;
>+  }
>+  get [$e]() {
>+    return this.e;
>+  }
>+  set [$e](value) {
>+    this.e = value;
>+  }
>+  get [$f]() {
>+    return this.f;
>+  }
>+  set [$f](value) {
>+    this.f = value;
>+  }
>+  [$flipX](...args) {
>+    return this.flipX.apply(this, args);
>+  }
>+  [$flipY](...args) {
>+    return this.flipY.apply(this, args);
>+  }
>+  [$inverse](...args) {
>+    return this.inverse.apply(this, args);
>+  }
>+  [$multiply](...args) {
>+    return this.multiply.apply(this, args);
>+  }
>+  [$rotate](...args) {
>+    return this.rotate.apply(this, args);
>+  }
>+  [$rotateFromVector](...args) {
>+    return this.rotateFromVector.apply(this, args);
>+  }
>+  [$scale](...args) {
>+    return this.scale.apply(this, args);
>+  }
>+  [$scaleNonUniform](...args) {
>+    return this.scaleNonUniform.apply(this, args);
>+  }
>+  [$skewX](...args) {
>+    return this.skewX.apply(this, args);
>+  }
>+  [$skewY](...args) {
>+    return this.skewY.apply(this, args);
>+  }
>+  [$translate](...args) {
>+    return this.translate.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(svg$.Matrix);
>+const a = Symbol("Matrix.a");
>+const b = Symbol("Matrix.b");
>+const c = Symbol("Matrix.c");
>+const d = Symbol("Matrix.d");
>+const e = Symbol("Matrix.e");
>+const f = Symbol("Matrix.f");
>+dart.setMethodSignature(svg$.Matrix, () => ({
>+  __proto__: dart.getMethods(svg$.Matrix.__proto__),
>+  [$flipX]: dart.fnType(svg$.Matrix, []),
>+  [$flipY]: dart.fnType(svg$.Matrix, []),
>+  [$inverse]: dart.fnType(svg$.Matrix, []),
>+  [$multiply]: dart.fnType(svg$.Matrix, [svg$.Matrix]),
>+  [$rotate]: dart.fnType(svg$.Matrix, [core.num]),
>+  [$rotateFromVector]: dart.fnType(svg$.Matrix, [core.num, core.num]),
>+  [$scale]: dart.fnType(svg$.Matrix, [core.num]),
>+  [$scaleNonUniform]: dart.fnType(svg$.Matrix, [core.num, core.num]),
>+  [$skewX]: dart.fnType(svg$.Matrix, [core.num]),
>+  [$skewY]: dart.fnType(svg$.Matrix, [core.num]),
>+  [$translate]: dart.fnType(svg$.Matrix, [core.num, core.num])
>+}));
>+dart.setLibraryUri(svg$.Matrix, "dart:svg");
>+dart.setFieldSignature(svg$.Matrix, () => ({
>+  __proto__: dart.getFields(svg$.Matrix.__proto__),
>+  [$a]: dart.fieldType(core.num),
>+  [$b]: dart.fieldType(core.num),
>+  [$c]: dart.fieldType(core.num),
>+  [$d]: dart.fieldType(core.num),
>+  [$e]: dart.fieldType(core.num),
>+  [$f]: dart.fieldType(core.num)
>+}));
>+dart.registerExtension("SVGMatrix", svg$.Matrix);
>+svg$.MetadataElement = class MetadataElement extends svg$.SvgElement {};
>+(svg$.MetadataElement.created = function() {
>+  svg$.MetadataElement.__proto__.created.call(this);
>+}).prototype = svg$.MetadataElement.prototype;
>+dart.addTypeTests(svg$.MetadataElement);
>+dart.setLibraryUri(svg$.MetadataElement, "dart:svg");
>+dart.registerExtension("SVGMetadataElement", svg$.MetadataElement);
>+svg$.Number = class Number extends _interceptors.Interceptor {
>+  get [$value]() {
>+    return this.value;
>+  }
>+  set [$value](value) {
>+    this.value = value;
>+  }
>+};
>+dart.addTypeTests(svg$.Number);
>+const value$20 = Symbol("Number.value");
>+dart.setLibraryUri(svg$.Number, "dart:svg");
>+dart.setFieldSignature(svg$.Number, () => ({
>+  __proto__: dart.getFields(svg$.Number.__proto__),
>+  [$value]: dart.fieldType(core.num)
>+}));
>+dart.registerExtension("SVGNumber", svg$.Number);
>+const Interceptor_ListMixin$$14 = class Interceptor_ListMixin extends _interceptors.Interceptor {};
>+(Interceptor_ListMixin$$14.new = function() {
>+  Interceptor_ListMixin$$14.__proto__.new.call(this);
>+}).prototype = Interceptor_ListMixin$$14.prototype;
>+dart.applyMixin(Interceptor_ListMixin$$14, collection.ListMixin$(svg$.Number));
>+const Interceptor_ImmutableListMixin$$14 = class Interceptor_ImmutableListMixin extends Interceptor_ListMixin$$14 {};
>+(Interceptor_ImmutableListMixin$$14.new = function() {
>+  Interceptor_ImmutableListMixin$$14.__proto__.new.call(this);
>+}).prototype = Interceptor_ImmutableListMixin$$14.prototype;
>+dart.applyMixin(Interceptor_ImmutableListMixin$$14, html$.ImmutableListMixin$(svg$.Number));
>+svg$.NumberList = class NumberList extends Interceptor_ImmutableListMixin$$14 {
>+  get [$length]() {
>+    return this.length;
>+  }
>+  get [$numberOfItems]() {
>+    return this.numberOfItems;
>+  }
>+  [$_get](index) {
>+    if (index >>> 0 !== index || index >= this[$length]) dart.throw(core.RangeError.index(index, this));
>+    return this.getItem(index);
>+  }
>+  [$_set](index, value) {
>+    svg$.Number._check(value);
>+    dart.throw(new core.UnsupportedError.new("Cannot assign element of immutable List."));
>+    return value;
>+  }
>+  set [$length](value) {
>+    dart.throw(new core.UnsupportedError.new("Cannot resize immutable List."));
>+  }
>+  get [$first]() {
>+    if (dart.notNull(this[$length]) > 0) {
>+      return this[0];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$first](value) {
>+    super[$first] = value;
>+  }
>+  get [$last]() {
>+    let len = this[$length];
>+    if (dart.notNull(len) > 0) {
>+      return this[dart.notNull(len) - 1];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$last](value) {
>+    super[$last] = value;
>+  }
>+  get [$single]() {
>+    let len = this[$length];
>+    if (len === 1) {
>+      return this[0];
>+    }
>+    if (len === 0) dart.throw(new core.StateError.new("No elements"));
>+    dart.throw(new core.StateError.new("More than one element"));
>+  }
>+  [$elementAt](index) {
>+    return this[$_get](index);
>+  }
>+  [__setter__$](...args) {
>+    return this.__setter__.apply(this, args);
>+  }
>+  [$appendItem](...args) {
>+    return this.appendItem.apply(this, args);
>+  }
>+  [$clear](...args) {
>+    return this.clear.apply(this, args);
>+  }
>+  [$getItem](...args) {
>+    return this.getItem.apply(this, args);
>+  }
>+  [$initialize](...args) {
>+    return this.initialize.apply(this, args);
>+  }
>+  [$insertItemBefore](...args) {
>+    return this.insertItemBefore.apply(this, args);
>+  }
>+  [$removeItem](...args) {
>+    return this.removeItem.apply(this, args);
>+  }
>+  [$replaceItem](...args) {
>+    return this.replaceItem.apply(this, args);
>+  }
>+};
>+svg$.NumberList.prototype[dart.isList] = true;
>+dart.addTypeTests(svg$.NumberList);
>+const numberOfItems$ = Symbol("NumberList.numberOfItems");
>+svg$.NumberList[dart.implements] = () => [ListOfNumber()];
>+dart.setMethodSignature(svg$.NumberList, () => ({
>+  __proto__: dart.getMethods(svg$.NumberList.__proto__),
>+  [$_get]: dart.fnType(svg$.Number, [core.int]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$elementAt]: dart.fnType(svg$.Number, [core.int]),
>+  [__setter__$]: dart.fnType(dart.void, [core.int, svg$.Number]),
>+  [$appendItem]: dart.fnType(svg$.Number, [svg$.Number]),
>+  [$clear]: dart.fnType(dart.void, []),
>+  [$getItem]: dart.fnType(svg$.Number, [core.int]),
>+  [$initialize]: dart.fnType(svg$.Number, [svg$.Number]),
>+  [$insertItemBefore]: dart.fnType(svg$.Number, [svg$.Number, core.int]),
>+  [$removeItem]: dart.fnType(svg$.Number, [core.int]),
>+  [$replaceItem]: dart.fnType(svg$.Number, [svg$.Number, core.int])
>+}));
>+dart.setGetterSignature(svg$.NumberList, () => ({
>+  __proto__: dart.getGetters(svg$.NumberList.__proto__),
>+  [$length]: core.int,
>+  [$first]: svg$.Number,
>+  [$last]: svg$.Number,
>+  [$single]: svg$.Number
>+}));
>+dart.setSetterSignature(svg$.NumberList, () => ({
>+  __proto__: dart.getSetters(svg$.NumberList.__proto__),
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(svg$.NumberList, "dart:svg");
>+dart.setFieldSignature(svg$.NumberList, () => ({
>+  __proto__: dart.getFields(svg$.NumberList.__proto__),
>+  [$numberOfItems]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("SVGNumberList", svg$.NumberList);
>+svg$.PathElement = class PathElement extends svg$.GeometryElement {
>+  static new() {
>+    return svg$.PathElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("path"));
>+  }
>+};
>+(svg$.PathElement.created = function() {
>+  svg$.PathElement.__proto__.created.call(this);
>+}).prototype = svg$.PathElement.prototype;
>+dart.addTypeTests(svg$.PathElement);
>+dart.setLibraryUri(svg$.PathElement, "dart:svg");
>+dart.registerExtension("SVGPathElement", svg$.PathElement);
>+svg$.PatternElement = class PatternElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.PatternElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("pattern"));
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$patternContentUnits]() {
>+    return this.patternContentUnits;
>+  }
>+  get [$patternTransform]() {
>+    return this.patternTransform;
>+  }
>+  get [$patternUnits]() {
>+    return this.patternUnits;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+  get [$preserveAspectRatio]() {
>+    return this.preserveAspectRatio;
>+  }
>+  get [$viewBox]() {
>+    return this.viewBox;
>+  }
>+  get [$requiredExtensions]() {
>+    return this.requiredExtensions;
>+  }
>+  get [$systemLanguage]() {
>+    return this.systemLanguage;
>+  }
>+  get [$href]() {
>+    return this.href;
>+  }
>+};
>+(svg$.PatternElement.created = function() {
>+  this[height$35] = null;
>+  this[patternContentUnits] = null;
>+  this[patternTransform] = null;
>+  this[patternUnits] = null;
>+  this[width$37] = null;
>+  this[x$30] = null;
>+  this[y$29] = null;
>+  this[preserveAspectRatio$2] = null;
>+  this[viewBox$0] = null;
>+  this[requiredExtensions$1] = null;
>+  this[systemLanguage$1] = null;
>+  this[href$13] = null;
>+  svg$.PatternElement.__proto__.created.call(this);
>+}).prototype = svg$.PatternElement.prototype;
>+dart.addTypeTests(svg$.PatternElement);
>+const height$35 = Symbol("PatternElement.height");
>+const patternContentUnits = Symbol("PatternElement.patternContentUnits");
>+const patternTransform = Symbol("PatternElement.patternTransform");
>+const patternUnits = Symbol("PatternElement.patternUnits");
>+const width$37 = Symbol("PatternElement.width");
>+const x$30 = Symbol("PatternElement.x");
>+const y$29 = Symbol("PatternElement.y");
>+const preserveAspectRatio$2 = Symbol("PatternElement.preserveAspectRatio");
>+const viewBox$0 = Symbol("PatternElement.viewBox");
>+const requiredExtensions$1 = Symbol("PatternElement.requiredExtensions");
>+const systemLanguage$1 = Symbol("PatternElement.systemLanguage");
>+const href$13 = Symbol("PatternElement.href");
>+svg$.PatternElement[dart.implements] = () => [svg$.FitToViewBox, svg$.UriReference, svg$.Tests];
>+dart.setLibraryUri(svg$.PatternElement, "dart:svg");
>+dart.setFieldSignature(svg$.PatternElement, () => ({
>+  __proto__: dart.getFields(svg$.PatternElement.__proto__),
>+  [$height]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$patternContentUnits]: dart.finalFieldType(svg$.AnimatedEnumeration),
>+  [$patternTransform]: dart.finalFieldType(svg$.AnimatedTransformList),
>+  [$patternUnits]: dart.finalFieldType(svg$.AnimatedEnumeration),
>+  [$width]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$x]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$y]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$preserveAspectRatio]: dart.finalFieldType(svg$.AnimatedPreserveAspectRatio),
>+  [$viewBox]: dart.finalFieldType(svg$.AnimatedRect),
>+  [$requiredExtensions]: dart.finalFieldType(svg$.StringList),
>+  [$systemLanguage]: dart.finalFieldType(svg$.StringList),
>+  [$href]: dart.finalFieldType(svg$.AnimatedString)
>+}));
>+dart.registerExtension("SVGPatternElement", svg$.PatternElement);
>+svg$.Point = class Point extends _interceptors.Interceptor {
>+  get [$x]() {
>+    return this.x;
>+  }
>+  set [$x](value) {
>+    this.x = value;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+  set [$y](value) {
>+    this.y = value;
>+  }
>+  [$matrixTransform](...args) {
>+    return this.matrixTransform.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(svg$.Point);
>+const x$31 = Symbol("Point.x");
>+const y$30 = Symbol("Point.y");
>+dart.setMethodSignature(svg$.Point, () => ({
>+  __proto__: dart.getMethods(svg$.Point.__proto__),
>+  [$matrixTransform]: dart.fnType(svg$.Point, [svg$.Matrix])
>+}));
>+dart.setLibraryUri(svg$.Point, "dart:svg");
>+dart.setFieldSignature(svg$.Point, () => ({
>+  __proto__: dart.getFields(svg$.Point.__proto__),
>+  [$x]: dart.fieldType(core.num),
>+  [$y]: dart.fieldType(core.num)
>+}));
>+dart.registerExtension("SVGPoint", svg$.Point);
>+svg$.PointList = class PointList extends _interceptors.Interceptor {
>+  get [$length]() {
>+    return this.length;
>+  }
>+  get [$numberOfItems]() {
>+    return this.numberOfItems;
>+  }
>+  [__setter__$](...args) {
>+    return this.__setter__.apply(this, args);
>+  }
>+  [$appendItem](...args) {
>+    return this.appendItem.apply(this, args);
>+  }
>+  [$clear](...args) {
>+    return this.clear.apply(this, args);
>+  }
>+  [$getItem](...args) {
>+    return this.getItem.apply(this, args);
>+  }
>+  [$initialize](...args) {
>+    return this.initialize.apply(this, args);
>+  }
>+  [$insertItemBefore](...args) {
>+    return this.insertItemBefore.apply(this, args);
>+  }
>+  [$removeItem](...args) {
>+    return this.removeItem.apply(this, args);
>+  }
>+  [$replaceItem](...args) {
>+    return this.replaceItem.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(svg$.PointList);
>+const length$17 = Symbol("PointList.length");
>+const numberOfItems$0 = Symbol("PointList.numberOfItems");
>+dart.setMethodSignature(svg$.PointList, () => ({
>+  __proto__: dart.getMethods(svg$.PointList.__proto__),
>+  [__setter__$]: dart.fnType(dart.void, [core.int, svg$.Point]),
>+  [$appendItem]: dart.fnType(svg$.Point, [svg$.Point]),
>+  [$clear]: dart.fnType(dart.void, []),
>+  [$getItem]: dart.fnType(svg$.Point, [core.int]),
>+  [$initialize]: dart.fnType(svg$.Point, [svg$.Point]),
>+  [$insertItemBefore]: dart.fnType(svg$.Point, [svg$.Point, core.int]),
>+  [$removeItem]: dart.fnType(svg$.Point, [core.int]),
>+  [$replaceItem]: dart.fnType(svg$.Point, [svg$.Point, core.int])
>+}));
>+dart.setLibraryUri(svg$.PointList, "dart:svg");
>+dart.setFieldSignature(svg$.PointList, () => ({
>+  __proto__: dart.getFields(svg$.PointList.__proto__),
>+  [$length]: dart.finalFieldType(core.int),
>+  [$numberOfItems]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("SVGPointList", svg$.PointList);
>+svg$.PolygonElement = class PolygonElement extends svg$.GeometryElement {
>+  static new() {
>+    return svg$.PolygonElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("polygon"));
>+  }
>+  get [$animatedPoints]() {
>+    return this.animatedPoints;
>+  }
>+  get [$points]() {
>+    return this.points;
>+  }
>+};
>+(svg$.PolygonElement.created = function() {
>+  this[animatedPoints] = null;
>+  this[points] = null;
>+  svg$.PolygonElement.__proto__.created.call(this);
>+}).prototype = svg$.PolygonElement.prototype;
>+dart.addTypeTests(svg$.PolygonElement);
>+const animatedPoints = Symbol("PolygonElement.animatedPoints");
>+const points = Symbol("PolygonElement.points");
>+dart.setLibraryUri(svg$.PolygonElement, "dart:svg");
>+dart.setFieldSignature(svg$.PolygonElement, () => ({
>+  __proto__: dart.getFields(svg$.PolygonElement.__proto__),
>+  [$animatedPoints]: dart.finalFieldType(svg$.PointList),
>+  [$points]: dart.finalFieldType(svg$.PointList)
>+}));
>+dart.registerExtension("SVGPolygonElement", svg$.PolygonElement);
>+svg$.PolylineElement = class PolylineElement extends svg$.GeometryElement {
>+  static new() {
>+    return svg$.PolylineElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("polyline"));
>+  }
>+  get [$animatedPoints]() {
>+    return this.animatedPoints;
>+  }
>+  get [$points]() {
>+    return this.points;
>+  }
>+};
>+(svg$.PolylineElement.created = function() {
>+  this[animatedPoints$] = null;
>+  this[points$] = null;
>+  svg$.PolylineElement.__proto__.created.call(this);
>+}).prototype = svg$.PolylineElement.prototype;
>+dart.addTypeTests(svg$.PolylineElement);
>+const animatedPoints$ = Symbol("PolylineElement.animatedPoints");
>+const points$ = Symbol("PolylineElement.points");
>+dart.setLibraryUri(svg$.PolylineElement, "dart:svg");
>+dart.setFieldSignature(svg$.PolylineElement, () => ({
>+  __proto__: dart.getFields(svg$.PolylineElement.__proto__),
>+  [$animatedPoints]: dart.finalFieldType(svg$.PointList),
>+  [$points]: dart.finalFieldType(svg$.PointList)
>+}));
>+dart.registerExtension("SVGPolylineElement", svg$.PolylineElement);
>+svg$.PreserveAspectRatio = class PreserveAspectRatio extends _interceptors.Interceptor {
>+  get [$align]() {
>+    return this.align;
>+  }
>+  set [$align](value) {
>+    this.align = value;
>+  }
>+  get [$meetOrSlice]() {
>+    return this.meetOrSlice;
>+  }
>+  set [$meetOrSlice](value) {
>+    this.meetOrSlice = value;
>+  }
>+};
>+dart.addTypeTests(svg$.PreserveAspectRatio);
>+const align$ = Symbol("PreserveAspectRatio.align");
>+const meetOrSlice = Symbol("PreserveAspectRatio.meetOrSlice");
>+dart.setLibraryUri(svg$.PreserveAspectRatio, "dart:svg");
>+dart.setFieldSignature(svg$.PreserveAspectRatio, () => ({
>+  __proto__: dart.getFields(svg$.PreserveAspectRatio.__proto__),
>+  [$align]: dart.fieldType(core.int),
>+  [$meetOrSlice]: dart.fieldType(core.int)
>+}));
>+dart.defineLazy(svg$.PreserveAspectRatio, {
>+  /*svg$.PreserveAspectRatio.SVG_MEETORSLICE_MEET*/get SVG_MEETORSLICE_MEET() {
>+    return 1;
>+  },
>+  /*svg$.PreserveAspectRatio.SVG_MEETORSLICE_SLICE*/get SVG_MEETORSLICE_SLICE() {
>+    return 2;
>+  },
>+  /*svg$.PreserveAspectRatio.SVG_MEETORSLICE_UNKNOWN*/get SVG_MEETORSLICE_UNKNOWN() {
>+    return 0;
>+  },
>+  /*svg$.PreserveAspectRatio.SVG_PRESERVEASPECTRATIO_NONE*/get SVG_PRESERVEASPECTRATIO_NONE() {
>+    return 1;
>+  },
>+  /*svg$.PreserveAspectRatio.SVG_PRESERVEASPECTRATIO_UNKNOWN*/get SVG_PRESERVEASPECTRATIO_UNKNOWN() {
>+    return 0;
>+  },
>+  /*svg$.PreserveAspectRatio.SVG_PRESERVEASPECTRATIO_XMAXYMAX*/get SVG_PRESERVEASPECTRATIO_XMAXYMAX() {
>+    return 10;
>+  },
>+  /*svg$.PreserveAspectRatio.SVG_PRESERVEASPECTRATIO_XMAXYMID*/get SVG_PRESERVEASPECTRATIO_XMAXYMID() {
>+    return 7;
>+  },
>+  /*svg$.PreserveAspectRatio.SVG_PRESERVEASPECTRATIO_XMAXYMIN*/get SVG_PRESERVEASPECTRATIO_XMAXYMIN() {
>+    return 4;
>+  },
>+  /*svg$.PreserveAspectRatio.SVG_PRESERVEASPECTRATIO_XMIDYMAX*/get SVG_PRESERVEASPECTRATIO_XMIDYMAX() {
>+    return 9;
>+  },
>+  /*svg$.PreserveAspectRatio.SVG_PRESERVEASPECTRATIO_XMIDYMID*/get SVG_PRESERVEASPECTRATIO_XMIDYMID() {
>+    return 6;
>+  },
>+  /*svg$.PreserveAspectRatio.SVG_PRESERVEASPECTRATIO_XMIDYMIN*/get SVG_PRESERVEASPECTRATIO_XMIDYMIN() {
>+    return 3;
>+  },
>+  /*svg$.PreserveAspectRatio.SVG_PRESERVEASPECTRATIO_XMINYMAX*/get SVG_PRESERVEASPECTRATIO_XMINYMAX() {
>+    return 8;
>+  },
>+  /*svg$.PreserveAspectRatio.SVG_PRESERVEASPECTRATIO_XMINYMID*/get SVG_PRESERVEASPECTRATIO_XMINYMID() {
>+    return 5;
>+  },
>+  /*svg$.PreserveAspectRatio.SVG_PRESERVEASPECTRATIO_XMINYMIN*/get SVG_PRESERVEASPECTRATIO_XMINYMIN() {
>+    return 2;
>+  }
>+});
>+dart.registerExtension("SVGPreserveAspectRatio", svg$.PreserveAspectRatio);
>+svg$.RadialGradientElement = class RadialGradientElement extends svg$._GradientElement {
>+  static new() {
>+    return svg$.RadialGradientElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("radialGradient"));
>+  }
>+  get [$cx]() {
>+    return this.cx;
>+  }
>+  get [$cy]() {
>+    return this.cy;
>+  }
>+  get [$fr]() {
>+    return this.fr;
>+  }
>+  get [$fx]() {
>+    return this.fx;
>+  }
>+  get [$fy]() {
>+    return this.fy;
>+  }
>+  get [$r]() {
>+    return this.r;
>+  }
>+};
>+(svg$.RadialGradientElement.created = function() {
>+  this[cx$0] = null;
>+  this[cy$0] = null;
>+  this[fr] = null;
>+  this[fx] = null;
>+  this[fy] = null;
>+  this[r$] = null;
>+  svg$.RadialGradientElement.__proto__.created.call(this);
>+}).prototype = svg$.RadialGradientElement.prototype;
>+dart.addTypeTests(svg$.RadialGradientElement);
>+const cx$0 = Symbol("RadialGradientElement.cx");
>+const cy$0 = Symbol("RadialGradientElement.cy");
>+const fr = Symbol("RadialGradientElement.fr");
>+const fx = Symbol("RadialGradientElement.fx");
>+const fy = Symbol("RadialGradientElement.fy");
>+const r$ = Symbol("RadialGradientElement.r");
>+dart.setLibraryUri(svg$.RadialGradientElement, "dart:svg");
>+dart.setFieldSignature(svg$.RadialGradientElement, () => ({
>+  __proto__: dart.getFields(svg$.RadialGradientElement.__proto__),
>+  [$cx]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$cy]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$fr]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$fx]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$fy]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$r]: dart.finalFieldType(svg$.AnimatedLength)
>+}));
>+dart.registerExtension("SVGRadialGradientElement", svg$.RadialGradientElement);
>+svg$.Rect = class Rect extends _interceptors.Interceptor {
>+  get [$height]() {
>+    return this.height;
>+  }
>+  set [$height](value) {
>+    this.height = value;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  set [$width](value) {
>+    this.width = value;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  set [$x](value) {
>+    this.x = value;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+  set [$y](value) {
>+    this.y = value;
>+  }
>+};
>+dart.addTypeTests(svg$.Rect);
>+const height$36 = Symbol("Rect.height");
>+const width$38 = Symbol("Rect.width");
>+const x$32 = Symbol("Rect.x");
>+const y$31 = Symbol("Rect.y");
>+dart.setLibraryUri(svg$.Rect, "dart:svg");
>+dart.setFieldSignature(svg$.Rect, () => ({
>+  __proto__: dart.getFields(svg$.Rect.__proto__),
>+  [$height]: dart.fieldType(core.num),
>+  [$width]: dart.fieldType(core.num),
>+  [$x]: dart.fieldType(core.num),
>+  [$y]: dart.fieldType(core.num)
>+}));
>+dart.registerExtension("SVGRect", svg$.Rect);
>+svg$.RectElement = class RectElement extends svg$.GeometryElement {
>+  static new() {
>+    return svg$.RectElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("rect"));
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$rx]() {
>+    return this.rx;
>+  }
>+  get [$ry]() {
>+    return this.ry;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+};
>+(svg$.RectElement.created = function() {
>+  this[height$37] = null;
>+  this[rx$] = null;
>+  this[ry$] = null;
>+  this[width$39] = null;
>+  this[x$33] = null;
>+  this[y$32] = null;
>+  svg$.RectElement.__proto__.created.call(this);
>+}).prototype = svg$.RectElement.prototype;
>+dart.addTypeTests(svg$.RectElement);
>+const height$37 = Symbol("RectElement.height");
>+const rx$ = Symbol("RectElement.rx");
>+const ry$ = Symbol("RectElement.ry");
>+const width$39 = Symbol("RectElement.width");
>+const x$33 = Symbol("RectElement.x");
>+const y$32 = Symbol("RectElement.y");
>+dart.setLibraryUri(svg$.RectElement, "dart:svg");
>+dart.setFieldSignature(svg$.RectElement, () => ({
>+  __proto__: dart.getFields(svg$.RectElement.__proto__),
>+  [$height]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$rx]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$ry]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$width]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$x]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$y]: dart.finalFieldType(svg$.AnimatedLength)
>+}));
>+dart.registerExtension("SVGRectElement", svg$.RectElement);
>+svg$.ScriptElement = class ScriptElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.ScriptElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("script"));
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  set [$type](value) {
>+    this.type = value;
>+  }
>+  get [$href]() {
>+    return this.href;
>+  }
>+};
>+(svg$.ScriptElement.created = function() {
>+  this[type$39] = null;
>+  this[href$14] = null;
>+  svg$.ScriptElement.__proto__.created.call(this);
>+}).prototype = svg$.ScriptElement.prototype;
>+dart.addTypeTests(svg$.ScriptElement);
>+const type$39 = Symbol("ScriptElement.type");
>+const href$14 = Symbol("ScriptElement.href");
>+svg$.ScriptElement[dart.implements] = () => [svg$.UriReference];
>+dart.setLibraryUri(svg$.ScriptElement, "dart:svg");
>+dart.setFieldSignature(svg$.ScriptElement, () => ({
>+  __proto__: dart.getFields(svg$.ScriptElement.__proto__),
>+  [$type]: dart.fieldType(core.String),
>+  [$href]: dart.finalFieldType(svg$.AnimatedString)
>+}));
>+dart.registerExtension("SVGScriptElement", svg$.ScriptElement);
>+svg$.SetElement = class SetElement extends svg$.AnimationElement {
>+  static new() {
>+    return svg$.SetElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("set"));
>+  }
>+  static get supported() {
>+    return dart.test(svg$.SvgElement.isTagSupported("set")) && svg$.SetElement.is(svg$.SvgElement.tag("set"));
>+  }
>+};
>+(svg$.SetElement.created = function() {
>+  svg$.SetElement.__proto__.created.call(this);
>+}).prototype = svg$.SetElement.prototype;
>+dart.addTypeTests(svg$.SetElement);
>+dart.setLibraryUri(svg$.SetElement, "dart:svg");
>+dart.registerExtension("SVGSetElement", svg$.SetElement);
>+svg$.StopElement = class StopElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.StopElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("stop"));
>+  }
>+  get [$gradientOffset]() {
>+    return this.offset;
>+  }
>+};
>+(svg$.StopElement.created = function() {
>+  this[gradientOffset] = null;
>+  svg$.StopElement.__proto__.created.call(this);
>+}).prototype = svg$.StopElement.prototype;
>+dart.addTypeTests(svg$.StopElement);
>+const gradientOffset = Symbol("StopElement.gradientOffset");
>+dart.setLibraryUri(svg$.StopElement, "dart:svg");
>+dart.setFieldSignature(svg$.StopElement, () => ({
>+  __proto__: dart.getFields(svg$.StopElement.__proto__),
>+  [$gradientOffset]: dart.finalFieldType(svg$.AnimatedNumber)
>+}));
>+dart.registerExtension("SVGStopElement", svg$.StopElement);
>+const Interceptor_ListMixin$$15 = class Interceptor_ListMixin extends _interceptors.Interceptor {};
>+(Interceptor_ListMixin$$15.new = function() {
>+  Interceptor_ListMixin$$15.__proto__.new.call(this);
>+}).prototype = Interceptor_ListMixin$$15.prototype;
>+dart.applyMixin(Interceptor_ListMixin$$15, collection.ListMixin$(core.String));
>+const Interceptor_ImmutableListMixin$$15 = class Interceptor_ImmutableListMixin extends Interceptor_ListMixin$$15 {};
>+(Interceptor_ImmutableListMixin$$15.new = function() {
>+  Interceptor_ImmutableListMixin$$15.__proto__.new.call(this);
>+}).prototype = Interceptor_ImmutableListMixin$$15.prototype;
>+dart.applyMixin(Interceptor_ImmutableListMixin$$15, html$.ImmutableListMixin$(core.String));
>+svg$.StringList = class StringList extends Interceptor_ImmutableListMixin$$15 {
>+  get [$length]() {
>+    return this.length;
>+  }
>+  get [$numberOfItems]() {
>+    return this.numberOfItems;
>+  }
>+  [$_get](index) {
>+    if (index >>> 0 !== index || index >= this[$length]) dart.throw(core.RangeError.index(index, this));
>+    return this.getItem(index);
>+  }
>+  [$_set](index, value) {
>+    core.String._check(value);
>+    dart.throw(new core.UnsupportedError.new("Cannot assign element of immutable List."));
>+    return value;
>+  }
>+  set [$length](value) {
>+    dart.throw(new core.UnsupportedError.new("Cannot resize immutable List."));
>+  }
>+  get [$first]() {
>+    if (dart.notNull(this[$length]) > 0) {
>+      return this[0];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$first](value) {
>+    super[$first] = value;
>+  }
>+  get [$last]() {
>+    let len = this[$length];
>+    if (dart.notNull(len) > 0) {
>+      return this[dart.notNull(len) - 1];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$last](value) {
>+    super[$last] = value;
>+  }
>+  get [$single]() {
>+    let len = this[$length];
>+    if (len === 1) {
>+      return this[0];
>+    }
>+    if (len === 0) dart.throw(new core.StateError.new("No elements"));
>+    dart.throw(new core.StateError.new("More than one element"));
>+  }
>+  [$elementAt](index) {
>+    return this[$_get](index);
>+  }
>+  [__setter__$](...args) {
>+    return this.__setter__.apply(this, args);
>+  }
>+  [$appendItem](...args) {
>+    return this.appendItem.apply(this, args);
>+  }
>+  [$clear](...args) {
>+    return this.clear.apply(this, args);
>+  }
>+  [$getItem](...args) {
>+    return this.getItem.apply(this, args);
>+  }
>+  [$initialize](...args) {
>+    return this.initialize.apply(this, args);
>+  }
>+  [$insertItemBefore](...args) {
>+    return this.insertItemBefore.apply(this, args);
>+  }
>+  [$removeItem](...args) {
>+    return this.removeItem.apply(this, args);
>+  }
>+  [$replaceItem](...args) {
>+    return this.replaceItem.apply(this, args);
>+  }
>+};
>+svg$.StringList.prototype[dart.isList] = true;
>+dart.addTypeTests(svg$.StringList);
>+const numberOfItems$1 = Symbol("StringList.numberOfItems");
>+svg$.StringList[dart.implements] = () => [ListOfString()];
>+dart.setMethodSignature(svg$.StringList, () => ({
>+  __proto__: dart.getMethods(svg$.StringList.__proto__),
>+  [$_get]: dart.fnType(core.String, [core.int]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$elementAt]: dart.fnType(core.String, [core.int]),
>+  [__setter__$]: dart.fnType(dart.void, [core.int, core.String]),
>+  [$appendItem]: dart.fnType(core.String, [core.String]),
>+  [$clear]: dart.fnType(dart.void, []),
>+  [$getItem]: dart.fnType(core.String, [core.int]),
>+  [$initialize]: dart.fnType(core.String, [core.String]),
>+  [$insertItemBefore]: dart.fnType(core.String, [core.String, core.int]),
>+  [$removeItem]: dart.fnType(core.String, [core.int]),
>+  [$replaceItem]: dart.fnType(core.String, [core.String, core.int])
>+}));
>+dart.setGetterSignature(svg$.StringList, () => ({
>+  __proto__: dart.getGetters(svg$.StringList.__proto__),
>+  [$length]: core.int,
>+  [$first]: core.String,
>+  [$last]: core.String,
>+  [$single]: core.String
>+}));
>+dart.setSetterSignature(svg$.StringList, () => ({
>+  __proto__: dart.getSetters(svg$.StringList.__proto__),
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(svg$.StringList, "dart:svg");
>+dart.setFieldSignature(svg$.StringList, () => ({
>+  __proto__: dart.getFields(svg$.StringList.__proto__),
>+  [$numberOfItems]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("SVGStringList", svg$.StringList);
>+svg$.StyleElement = class StyleElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.StyleElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("style"));
>+  }
>+  get [$disabled]() {
>+    return this.disabled;
>+  }
>+  set [$disabled](value) {
>+    this.disabled = value;
>+  }
>+  get [$media]() {
>+    return this.media;
>+  }
>+  set [$media](value) {
>+    this.media = value;
>+  }
>+  get [$sheet]() {
>+    return this.sheet;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  set [$type](value) {
>+    this.type = value;
>+  }
>+};
>+(svg$.StyleElement.created = function() {
>+  this[disabled$10] = null;
>+  this[media$6] = null;
>+  this[sheet$1] = null;
>+  this[type$40] = null;
>+  svg$.StyleElement.__proto__.created.call(this);
>+}).prototype = svg$.StyleElement.prototype;
>+dart.addTypeTests(svg$.StyleElement);
>+const disabled$10 = Symbol("StyleElement.disabled");
>+const media$6 = Symbol("StyleElement.media");
>+const sheet$1 = Symbol("StyleElement.sheet");
>+const type$40 = Symbol("StyleElement.type");
>+dart.setLibraryUri(svg$.StyleElement, "dart:svg");
>+dart.setFieldSignature(svg$.StyleElement, () => ({
>+  __proto__: dart.getFields(svg$.StyleElement.__proto__),
>+  [$disabled]: dart.fieldType(core.bool),
>+  [$media]: dart.fieldType(core.String),
>+  [$sheet]: dart.finalFieldType(html$.StyleSheet),
>+  [$type]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("SVGStyleElement", svg$.StyleElement);
>+const _element$0 = dart.privateName(svg$, "_element");
>+svg$.AttributeClassSet = class AttributeClassSet extends html_common.CssClassSetImpl {
>+  readClasses() {
>+    let classname = this[_element$0][$attributes][$_get]("class");
>+    if (svg$.AnimatedString.is(classname)) {
>+      classname = svg$.AnimatedString.as(classname).baseVal;
>+    }
>+    let s = new (_IdentityHashSetOfString()).new();
>+    if (classname == null) {
>+      return s;
>+    }
>+    for (let name of classname[$split](" ")) {
>+      let trimmed = name[$trim]();
>+      if (!trimmed[$isEmpty]) {
>+        s.add(trimmed);
>+      }
>+    }
>+    return s;
>+  }
>+  writeClasses(s) {
>+    this[_element$0][$setAttribute]("class", s.join(" "));
>+  }
>+};
>+(svg$.AttributeClassSet.new = function(element) {
>+  this[_element$0] = element;
>+}).prototype = svg$.AttributeClassSet.prototype;
>+dart.addTypeTests(svg$.AttributeClassSet);
>+dart.setMethodSignature(svg$.AttributeClassSet, () => ({
>+  __proto__: dart.getMethods(svg$.AttributeClassSet.__proto__),
>+  readClasses: dart.fnType(core.Set$(core.String), []),
>+  writeClasses: dart.fnType(dart.void, [core.Set])
>+}));
>+dart.setLibraryUri(svg$.AttributeClassSet, "dart:svg");
>+dart.setFieldSignature(svg$.AttributeClassSet, () => ({
>+  __proto__: dart.getFields(svg$.AttributeClassSet.__proto__),
>+  [_element$0]: dart.finalFieldType(html$.Element)
>+}));
>+svg$.SvgSvgElement = class SvgSvgElement extends svg$.GraphicsElement {
>+  static new() {
>+    let el = svg$.SvgElement.tag("svg");
>+    el[$attributes][$_set]("version", "1.1");
>+    return svg$.SvgSvgElement._check(el);
>+  }
>+  get [$currentScale]() {
>+    return this.currentScale;
>+  }
>+  set [$currentScale](value) {
>+    this.currentScale = value;
>+  }
>+  get [$currentTranslate]() {
>+    return this.currentTranslate;
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+  [$animationsPaused](...args) {
>+    return this.animationsPaused.apply(this, args);
>+  }
>+  [$checkEnclosure](...args) {
>+    return this.checkEnclosure.apply(this, args);
>+  }
>+  [$checkIntersection](...args) {
>+    return this.checkIntersection.apply(this, args);
>+  }
>+  [$createSvgAngle](...args) {
>+    return this.createSVGAngle.apply(this, args);
>+  }
>+  [$createSvgLength](...args) {
>+    return this.createSVGLength.apply(this, args);
>+  }
>+  [$createSvgMatrix](...args) {
>+    return this.createSVGMatrix.apply(this, args);
>+  }
>+  [$createSvgNumber](...args) {
>+    return this.createSVGNumber.apply(this, args);
>+  }
>+  [$createSvgPoint](...args) {
>+    return this.createSVGPoint.apply(this, args);
>+  }
>+  [$createSvgRect](...args) {
>+    return this.createSVGRect.apply(this, args);
>+  }
>+  [$createSvgTransform](...args) {
>+    return this.createSVGTransform.apply(this, args);
>+  }
>+  [$createSvgTransformFromMatrix](...args) {
>+    return this.createSVGTransformFromMatrix.apply(this, args);
>+  }
>+  [$deselectAll](...args) {
>+    return this.deselectAll.apply(this, args);
>+  }
>+  [$forceRedraw](...args) {
>+    return this.forceRedraw.apply(this, args);
>+  }
>+  [$getCurrentTime](...args) {
>+    return this.getCurrentTime.apply(this, args);
>+  }
>+  [$getElementById](...args) {
>+    return this.getElementById.apply(this, args);
>+  }
>+  [$getEnclosureList](...args) {
>+    return this.getEnclosureList.apply(this, args);
>+  }
>+  [$getIntersectionList](...args) {
>+    return this.getIntersectionList.apply(this, args);
>+  }
>+  [$pauseAnimations](...args) {
>+    return this.pauseAnimations.apply(this, args);
>+  }
>+  [$setCurrentTime](...args) {
>+    return this.setCurrentTime.apply(this, args);
>+  }
>+  [$suspendRedraw](...args) {
>+    return this.suspendRedraw.apply(this, args);
>+  }
>+  [$unpauseAnimations](...args) {
>+    return this.unpauseAnimations.apply(this, args);
>+  }
>+  [$unsuspendRedraw](...args) {
>+    return this.unsuspendRedraw.apply(this, args);
>+  }
>+  [$unsuspendRedrawAll](...args) {
>+    return this.unsuspendRedrawAll.apply(this, args);
>+  }
>+  get [$preserveAspectRatio]() {
>+    return this.preserveAspectRatio;
>+  }
>+  get [$viewBox]() {
>+    return this.viewBox;
>+  }
>+  get [$zoomAndPan]() {
>+    return this.zoomAndPan;
>+  }
>+  set [$zoomAndPan](value) {
>+    this.zoomAndPan = value;
>+  }
>+};
>+(svg$.SvgSvgElement.created = function() {
>+  this[currentScale] = null;
>+  this[currentTranslate] = null;
>+  this[height$38] = null;
>+  this[width$40] = null;
>+  this[x$34] = null;
>+  this[y$33] = null;
>+  this[preserveAspectRatio$3] = null;
>+  this[viewBox$1] = null;
>+  this[zoomAndPan] = null;
>+  svg$.SvgSvgElement.__proto__.created.call(this);
>+}).prototype = svg$.SvgSvgElement.prototype;
>+dart.addTypeTests(svg$.SvgSvgElement);
>+const currentScale = Symbol("SvgSvgElement.currentScale");
>+const currentTranslate = Symbol("SvgSvgElement.currentTranslate");
>+const height$38 = Symbol("SvgSvgElement.height");
>+const width$40 = Symbol("SvgSvgElement.width");
>+const x$34 = Symbol("SvgSvgElement.x");
>+const y$33 = Symbol("SvgSvgElement.y");
>+const preserveAspectRatio$3 = Symbol("SvgSvgElement.preserveAspectRatio");
>+const viewBox$1 = Symbol("SvgSvgElement.viewBox");
>+const zoomAndPan = Symbol("SvgSvgElement.zoomAndPan");
>+svg$.SvgSvgElement[dart.implements] = () => [svg$.FitToViewBox, svg$.ZoomAndPan];
>+dart.setMethodSignature(svg$.SvgSvgElement, () => ({
>+  __proto__: dart.getMethods(svg$.SvgSvgElement.__proto__),
>+  [$animationsPaused]: dart.fnType(core.bool, []),
>+  [$checkEnclosure]: dart.fnType(core.bool, [svg$.SvgElement, svg$.Rect]),
>+  [$checkIntersection]: dart.fnType(core.bool, [svg$.SvgElement, svg$.Rect]),
>+  [$createSvgAngle]: dart.fnType(svg$.Angle, []),
>+  [$createSvgLength]: dart.fnType(svg$.Length, []),
>+  [$createSvgMatrix]: dart.fnType(svg$.Matrix, []),
>+  [$createSvgNumber]: dart.fnType(svg$.Number, []),
>+  [$createSvgPoint]: dart.fnType(svg$.Point, []),
>+  [$createSvgRect]: dart.fnType(svg$.Rect, []),
>+  [$createSvgTransform]: dart.fnType(svg$.Transform, []),
>+  [$createSvgTransformFromMatrix]: dart.fnType(svg$.Transform, [svg$.Matrix]),
>+  [$deselectAll]: dart.fnType(dart.void, []),
>+  [$forceRedraw]: dart.fnType(dart.void, []),
>+  [$getCurrentTime]: dart.fnType(core.double, []),
>+  [$getElementById]: dart.fnType(html$.Element, [core.String]),
>+  [$getEnclosureList]: dart.fnType(core.List$(html$.Node), [svg$.Rect, svg$.SvgElement]),
>+  [$getIntersectionList]: dart.fnType(core.List$(html$.Node), [svg$.Rect, svg$.SvgElement]),
>+  [$pauseAnimations]: dart.fnType(dart.void, []),
>+  [$setCurrentTime]: dart.fnType(dart.void, [core.num]),
>+  [$suspendRedraw]: dart.fnType(core.int, [core.int]),
>+  [$unpauseAnimations]: dart.fnType(dart.void, []),
>+  [$unsuspendRedraw]: dart.fnType(dart.void, [core.int]),
>+  [$unsuspendRedrawAll]: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(svg$.SvgSvgElement, "dart:svg");
>+dart.setFieldSignature(svg$.SvgSvgElement, () => ({
>+  __proto__: dart.getFields(svg$.SvgSvgElement.__proto__),
>+  [$currentScale]: dart.fieldType(core.num),
>+  [$currentTranslate]: dart.finalFieldType(svg$.Point),
>+  [$height]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$width]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$x]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$y]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$preserveAspectRatio]: dart.finalFieldType(svg$.AnimatedPreserveAspectRatio),
>+  [$viewBox]: dart.finalFieldType(svg$.AnimatedRect),
>+  [$zoomAndPan]: dart.fieldType(core.int)
>+}));
>+dart.registerExtension("SVGSVGElement", svg$.SvgSvgElement);
>+svg$.SwitchElement = class SwitchElement extends svg$.GraphicsElement {
>+  static new() {
>+    return svg$.SwitchElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("switch"));
>+  }
>+};
>+(svg$.SwitchElement.created = function() {
>+  svg$.SwitchElement.__proto__.created.call(this);
>+}).prototype = svg$.SwitchElement.prototype;
>+dart.addTypeTests(svg$.SwitchElement);
>+dart.setLibraryUri(svg$.SwitchElement, "dart:svg");
>+dart.registerExtension("SVGSwitchElement", svg$.SwitchElement);
>+svg$.SymbolElement = class SymbolElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.SymbolElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("symbol"));
>+  }
>+  get [$preserveAspectRatio]() {
>+    return this.preserveAspectRatio;
>+  }
>+  get [$viewBox]() {
>+    return this.viewBox;
>+  }
>+};
>+(svg$.SymbolElement.created = function() {
>+  this[preserveAspectRatio$4] = null;
>+  this[viewBox$2] = null;
>+  svg$.SymbolElement.__proto__.created.call(this);
>+}).prototype = svg$.SymbolElement.prototype;
>+dart.addTypeTests(svg$.SymbolElement);
>+const preserveAspectRatio$4 = Symbol("SymbolElement.preserveAspectRatio");
>+const viewBox$2 = Symbol("SymbolElement.viewBox");
>+svg$.SymbolElement[dart.implements] = () => [svg$.FitToViewBox];
>+dart.setLibraryUri(svg$.SymbolElement, "dart:svg");
>+dart.setFieldSignature(svg$.SymbolElement, () => ({
>+  __proto__: dart.getFields(svg$.SymbolElement.__proto__),
>+  [$preserveAspectRatio]: dart.finalFieldType(svg$.AnimatedPreserveAspectRatio),
>+  [$viewBox]: dart.finalFieldType(svg$.AnimatedRect)
>+}));
>+dart.registerExtension("SVGSymbolElement", svg$.SymbolElement);
>+svg$.TextContentElement = class TextContentElement extends svg$.GraphicsElement {
>+  get [$lengthAdjust]() {
>+    return this.lengthAdjust;
>+  }
>+  get [$textLength]() {
>+    return this.textLength;
>+  }
>+  [$getCharNumAtPosition](...args) {
>+    return this.getCharNumAtPosition.apply(this, args);
>+  }
>+  [$getComputedTextLength](...args) {
>+    return this.getComputedTextLength.apply(this, args);
>+  }
>+  [$getEndPositionOfChar](...args) {
>+    return this.getEndPositionOfChar.apply(this, args);
>+  }
>+  [$getExtentOfChar](...args) {
>+    return this.getExtentOfChar.apply(this, args);
>+  }
>+  [$getNumberOfChars](...args) {
>+    return this.getNumberOfChars.apply(this, args);
>+  }
>+  [$getRotationOfChar](...args) {
>+    return this.getRotationOfChar.apply(this, args);
>+  }
>+  [$getStartPositionOfChar](...args) {
>+    return this.getStartPositionOfChar.apply(this, args);
>+  }
>+  [$getSubStringLength](...args) {
>+    return this.getSubStringLength.apply(this, args);
>+  }
>+  [$selectSubString](...args) {
>+    return this.selectSubString.apply(this, args);
>+  }
>+};
>+(svg$.TextContentElement.created = function() {
>+  this[lengthAdjust] = null;
>+  this[textLength$] = null;
>+  svg$.TextContentElement.__proto__.created.call(this);
>+}).prototype = svg$.TextContentElement.prototype;
>+dart.addTypeTests(svg$.TextContentElement);
>+const lengthAdjust = Symbol("TextContentElement.lengthAdjust");
>+const textLength$ = Symbol("TextContentElement.textLength");
>+dart.setMethodSignature(svg$.TextContentElement, () => ({
>+  __proto__: dart.getMethods(svg$.TextContentElement.__proto__),
>+  [$getCharNumAtPosition]: dart.fnType(core.int, [svg$.Point]),
>+  [$getComputedTextLength]: dart.fnType(core.double, []),
>+  [$getEndPositionOfChar]: dart.fnType(svg$.Point, [core.int]),
>+  [$getExtentOfChar]: dart.fnType(svg$.Rect, [core.int]),
>+  [$getNumberOfChars]: dart.fnType(core.int, []),
>+  [$getRotationOfChar]: dart.fnType(core.double, [core.int]),
>+  [$getStartPositionOfChar]: dart.fnType(svg$.Point, [core.int]),
>+  [$getSubStringLength]: dart.fnType(core.double, [core.int, core.int]),
>+  [$selectSubString]: dart.fnType(dart.void, [core.int, core.int])
>+}));
>+dart.setLibraryUri(svg$.TextContentElement, "dart:svg");
>+dart.setFieldSignature(svg$.TextContentElement, () => ({
>+  __proto__: dart.getFields(svg$.TextContentElement.__proto__),
>+  [$lengthAdjust]: dart.finalFieldType(svg$.AnimatedEnumeration),
>+  [$textLength]: dart.finalFieldType(svg$.AnimatedLength)
>+}));
>+dart.defineLazy(svg$.TextContentElement, {
>+  /*svg$.TextContentElement.LENGTHADJUST_SPACING*/get LENGTHADJUST_SPACING() {
>+    return 1;
>+  },
>+  /*svg$.TextContentElement.LENGTHADJUST_SPACINGANDGLYPHS*/get LENGTHADJUST_SPACINGANDGLYPHS() {
>+    return 2;
>+  },
>+  /*svg$.TextContentElement.LENGTHADJUST_UNKNOWN*/get LENGTHADJUST_UNKNOWN() {
>+    return 0;
>+  }
>+});
>+dart.registerExtension("SVGTextContentElement", svg$.TextContentElement);
>+svg$.TextPositioningElement = class TextPositioningElement extends svg$.TextContentElement {
>+  get [$dx]() {
>+    return this.dx;
>+  }
>+  get [$dy]() {
>+    return this.dy;
>+  }
>+  get [$rotate]() {
>+    return this.rotate;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+};
>+(svg$.TextPositioningElement.created = function() {
>+  this[dx$] = null;
>+  this[dy$] = null;
>+  this[rotate] = null;
>+  this[x$35] = null;
>+  this[y$34] = null;
>+  svg$.TextPositioningElement.__proto__.created.call(this);
>+}).prototype = svg$.TextPositioningElement.prototype;
>+dart.addTypeTests(svg$.TextPositioningElement);
>+const dx$ = Symbol("TextPositioningElement.dx");
>+const dy$ = Symbol("TextPositioningElement.dy");
>+const rotate = Symbol("TextPositioningElement.rotate");
>+const x$35 = Symbol("TextPositioningElement.x");
>+const y$34 = Symbol("TextPositioningElement.y");
>+dart.setLibraryUri(svg$.TextPositioningElement, "dart:svg");
>+dart.setFieldSignature(svg$.TextPositioningElement, () => ({
>+  __proto__: dart.getFields(svg$.TextPositioningElement.__proto__),
>+  [$dx]: dart.finalFieldType(svg$.AnimatedLengthList),
>+  [$dy]: dart.finalFieldType(svg$.AnimatedLengthList),
>+  [$rotate]: dart.finalFieldType(svg$.AnimatedNumberList),
>+  [$x]: dart.finalFieldType(svg$.AnimatedLengthList),
>+  [$y]: dart.finalFieldType(svg$.AnimatedLengthList)
>+}));
>+dart.registerExtension("SVGTextPositioningElement", svg$.TextPositioningElement);
>+svg$.TSpanElement = class TSpanElement extends svg$.TextPositioningElement {
>+  static new() {
>+    return svg$.TSpanElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("tspan"));
>+  }
>+};
>+(svg$.TSpanElement.created = function() {
>+  svg$.TSpanElement.__proto__.created.call(this);
>+}).prototype = svg$.TSpanElement.prototype;
>+dart.addTypeTests(svg$.TSpanElement);
>+dart.setLibraryUri(svg$.TSpanElement, "dart:svg");
>+dart.registerExtension("SVGTSpanElement", svg$.TSpanElement);
>+svg$.Tests = class Tests extends _interceptors.Interceptor {
>+  get requiredExtensions() {
>+    return this[requiredExtensions$2];
>+  }
>+  set requiredExtensions(value) {
>+    super.requiredExtensions = value;
>+  }
>+  get systemLanguage() {
>+    return this[systemLanguage$2];
>+  }
>+  set systemLanguage(value) {
>+    super.systemLanguage = value;
>+  }
>+};
>+dart.addTypeTests(svg$.Tests);
>+const requiredExtensions$2 = Symbol("Tests.requiredExtensions");
>+const systemLanguage$2 = Symbol("Tests.systemLanguage");
>+dart.setLibraryUri(svg$.Tests, "dart:svg");
>+dart.setFieldSignature(svg$.Tests, () => ({
>+  __proto__: dart.getFields(svg$.Tests.__proto__),
>+  requiredExtensions: dart.finalFieldType(svg$.StringList),
>+  systemLanguage: dart.finalFieldType(svg$.StringList)
>+}));
>+dart.defineExtensionAccessors(svg$.Tests, ['requiredExtensions', 'systemLanguage']);
>+svg$.TextElement = class TextElement extends svg$.TextPositioningElement {
>+  static new() {
>+    return svg$.TextElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("text"));
>+  }
>+};
>+(svg$.TextElement.created = function() {
>+  svg$.TextElement.__proto__.created.call(this);
>+}).prototype = svg$.TextElement.prototype;
>+dart.addTypeTests(svg$.TextElement);
>+dart.setLibraryUri(svg$.TextElement, "dart:svg");
>+dart.registerExtension("SVGTextElement", svg$.TextElement);
>+svg$.TextPathElement = class TextPathElement extends svg$.TextContentElement {
>+  get [$method]() {
>+    return this.method;
>+  }
>+  get [$spacing]() {
>+    return this.spacing;
>+  }
>+  get [$startOffset]() {
>+    return this.startOffset;
>+  }
>+  get [$href]() {
>+    return this.href;
>+  }
>+};
>+(svg$.TextPathElement.created = function() {
>+  this[method$] = null;
>+  this[spacing] = null;
>+  this[startOffset$0] = null;
>+  this[href$15] = null;
>+  svg$.TextPathElement.__proto__.created.call(this);
>+}).prototype = svg$.TextPathElement.prototype;
>+dart.addTypeTests(svg$.TextPathElement);
>+const method$ = Symbol("TextPathElement.method");
>+const spacing = Symbol("TextPathElement.spacing");
>+const startOffset$0 = Symbol("TextPathElement.startOffset");
>+const href$15 = Symbol("TextPathElement.href");
>+svg$.TextPathElement[dart.implements] = () => [svg$.UriReference];
>+dart.setLibraryUri(svg$.TextPathElement, "dart:svg");
>+dart.setFieldSignature(svg$.TextPathElement, () => ({
>+  __proto__: dart.getFields(svg$.TextPathElement.__proto__),
>+  [$method]: dart.finalFieldType(svg$.AnimatedEnumeration),
>+  [$spacing]: dart.finalFieldType(svg$.AnimatedEnumeration),
>+  [$startOffset]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$href]: dart.finalFieldType(svg$.AnimatedString)
>+}));
>+dart.defineLazy(svg$.TextPathElement, {
>+  /*svg$.TextPathElement.TEXTPATH_METHODTYPE_ALIGN*/get TEXTPATH_METHODTYPE_ALIGN() {
>+    return 1;
>+  },
>+  /*svg$.TextPathElement.TEXTPATH_METHODTYPE_STRETCH*/get TEXTPATH_METHODTYPE_STRETCH() {
>+    return 2;
>+  },
>+  /*svg$.TextPathElement.TEXTPATH_METHODTYPE_UNKNOWN*/get TEXTPATH_METHODTYPE_UNKNOWN() {
>+    return 0;
>+  },
>+  /*svg$.TextPathElement.TEXTPATH_SPACINGTYPE_AUTO*/get TEXTPATH_SPACINGTYPE_AUTO() {
>+    return 1;
>+  },
>+  /*svg$.TextPathElement.TEXTPATH_SPACINGTYPE_EXACT*/get TEXTPATH_SPACINGTYPE_EXACT() {
>+    return 2;
>+  },
>+  /*svg$.TextPathElement.TEXTPATH_SPACINGTYPE_UNKNOWN*/get TEXTPATH_SPACINGTYPE_UNKNOWN() {
>+    return 0;
>+  }
>+});
>+dart.registerExtension("SVGTextPathElement", svg$.TextPathElement);
>+svg$.TitleElement = class TitleElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.TitleElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("title"));
>+  }
>+};
>+(svg$.TitleElement.created = function() {
>+  svg$.TitleElement.__proto__.created.call(this);
>+}).prototype = svg$.TitleElement.prototype;
>+dart.addTypeTests(svg$.TitleElement);
>+dart.setLibraryUri(svg$.TitleElement, "dart:svg");
>+dart.registerExtension("SVGTitleElement", svg$.TitleElement);
>+svg$.Transform = class Transform extends _interceptors.Interceptor {
>+  get [$angle]() {
>+    return this.angle;
>+  }
>+  get [$matrix]() {
>+    return this.matrix;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  [$setMatrix](...args) {
>+    return this.setMatrix.apply(this, args);
>+  }
>+  [$setRotate](...args) {
>+    return this.setRotate.apply(this, args);
>+  }
>+  [$setScale](...args) {
>+    return this.setScale.apply(this, args);
>+  }
>+  [$setSkewX](...args) {
>+    return this.setSkewX.apply(this, args);
>+  }
>+  [$setSkewY](...args) {
>+    return this.setSkewY.apply(this, args);
>+  }
>+  [$setTranslate](...args) {
>+    return this.setTranslate.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(svg$.Transform);
>+const angle$0 = Symbol("Transform.angle");
>+const matrix$ = Symbol("Transform.matrix");
>+const type$41 = Symbol("Transform.type");
>+dart.setMethodSignature(svg$.Transform, () => ({
>+  __proto__: dart.getMethods(svg$.Transform.__proto__),
>+  [$setMatrix]: dart.fnType(dart.void, [svg$.Matrix]),
>+  [$setRotate]: dart.fnType(dart.void, [core.num, core.num, core.num]),
>+  [$setScale]: dart.fnType(dart.void, [core.num, core.num]),
>+  [$setSkewX]: dart.fnType(dart.void, [core.num]),
>+  [$setSkewY]: dart.fnType(dart.void, [core.num]),
>+  [$setTranslate]: dart.fnType(dart.void, [core.num, core.num])
>+}));
>+dart.setLibraryUri(svg$.Transform, "dart:svg");
>+dart.setFieldSignature(svg$.Transform, () => ({
>+  __proto__: dart.getFields(svg$.Transform.__proto__),
>+  [$angle]: dart.finalFieldType(core.num),
>+  [$matrix]: dart.finalFieldType(svg$.Matrix),
>+  [$type]: dart.finalFieldType(core.int)
>+}));
>+dart.defineLazy(svg$.Transform, {
>+  /*svg$.Transform.SVG_TRANSFORM_MATRIX*/get SVG_TRANSFORM_MATRIX() {
>+    return 1;
>+  },
>+  /*svg$.Transform.SVG_TRANSFORM_ROTATE*/get SVG_TRANSFORM_ROTATE() {
>+    return 4;
>+  },
>+  /*svg$.Transform.SVG_TRANSFORM_SCALE*/get SVG_TRANSFORM_SCALE() {
>+    return 3;
>+  },
>+  /*svg$.Transform.SVG_TRANSFORM_SKEWX*/get SVG_TRANSFORM_SKEWX() {
>+    return 5;
>+  },
>+  /*svg$.Transform.SVG_TRANSFORM_SKEWY*/get SVG_TRANSFORM_SKEWY() {
>+    return 6;
>+  },
>+  /*svg$.Transform.SVG_TRANSFORM_TRANSLATE*/get SVG_TRANSFORM_TRANSLATE() {
>+    return 2;
>+  },
>+  /*svg$.Transform.SVG_TRANSFORM_UNKNOWN*/get SVG_TRANSFORM_UNKNOWN() {
>+    return 0;
>+  }
>+});
>+dart.registerExtension("SVGTransform", svg$.Transform);
>+const Interceptor_ListMixin$$16 = class Interceptor_ListMixin extends _interceptors.Interceptor {};
>+(Interceptor_ListMixin$$16.new = function() {
>+  Interceptor_ListMixin$$16.__proto__.new.call(this);
>+}).prototype = Interceptor_ListMixin$$16.prototype;
>+dart.applyMixin(Interceptor_ListMixin$$16, collection.ListMixin$(svg$.Transform));
>+const Interceptor_ImmutableListMixin$$16 = class Interceptor_ImmutableListMixin extends Interceptor_ListMixin$$16 {};
>+(Interceptor_ImmutableListMixin$$16.new = function() {
>+  Interceptor_ImmutableListMixin$$16.__proto__.new.call(this);
>+}).prototype = Interceptor_ImmutableListMixin$$16.prototype;
>+dart.applyMixin(Interceptor_ImmutableListMixin$$16, html$.ImmutableListMixin$(svg$.Transform));
>+svg$.TransformList = class TransformList extends Interceptor_ImmutableListMixin$$16 {
>+  get [$length]() {
>+    return this.length;
>+  }
>+  get [$numberOfItems]() {
>+    return this.numberOfItems;
>+  }
>+  [$_get](index) {
>+    if (index >>> 0 !== index || index >= this[$length]) dart.throw(core.RangeError.index(index, this));
>+    return this.getItem(index);
>+  }
>+  [$_set](index, value) {
>+    svg$.Transform._check(value);
>+    dart.throw(new core.UnsupportedError.new("Cannot assign element of immutable List."));
>+    return value;
>+  }
>+  set [$length](value) {
>+    dart.throw(new core.UnsupportedError.new("Cannot resize immutable List."));
>+  }
>+  get [$first]() {
>+    if (dart.notNull(this[$length]) > 0) {
>+      return this[0];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$first](value) {
>+    super[$first] = value;
>+  }
>+  get [$last]() {
>+    let len = this[$length];
>+    if (dart.notNull(len) > 0) {
>+      return this[dart.notNull(len) - 1];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$last](value) {
>+    super[$last] = value;
>+  }
>+  get [$single]() {
>+    let len = this[$length];
>+    if (len === 1) {
>+      return this[0];
>+    }
>+    if (len === 0) dart.throw(new core.StateError.new("No elements"));
>+    dart.throw(new core.StateError.new("More than one element"));
>+  }
>+  [$elementAt](index) {
>+    return this[$_get](index);
>+  }
>+  [__setter__$](...args) {
>+    return this.__setter__.apply(this, args);
>+  }
>+  [$appendItem](...args) {
>+    return this.appendItem.apply(this, args);
>+  }
>+  [$clear](...args) {
>+    return this.clear.apply(this, args);
>+  }
>+  [$consolidate](...args) {
>+    return this.consolidate.apply(this, args);
>+  }
>+  [$createSvgTransformFromMatrix](...args) {
>+    return this.createSVGTransformFromMatrix.apply(this, args);
>+  }
>+  [$getItem](...args) {
>+    return this.getItem.apply(this, args);
>+  }
>+  [$initialize](...args) {
>+    return this.initialize.apply(this, args);
>+  }
>+  [$insertItemBefore](...args) {
>+    return this.insertItemBefore.apply(this, args);
>+  }
>+  [$removeItem](...args) {
>+    return this.removeItem.apply(this, args);
>+  }
>+  [$replaceItem](...args) {
>+    return this.replaceItem.apply(this, args);
>+  }
>+};
>+svg$.TransformList.prototype[dart.isList] = true;
>+dart.addTypeTests(svg$.TransformList);
>+const numberOfItems$2 = Symbol("TransformList.numberOfItems");
>+svg$.TransformList[dart.implements] = () => [ListOfTransform()];
>+dart.setMethodSignature(svg$.TransformList, () => ({
>+  __proto__: dart.getMethods(svg$.TransformList.__proto__),
>+  [$_get]: dart.fnType(svg$.Transform, [core.int]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$elementAt]: dart.fnType(svg$.Transform, [core.int]),
>+  [__setter__$]: dart.fnType(dart.void, [core.int, svg$.Transform]),
>+  [$appendItem]: dart.fnType(svg$.Transform, [svg$.Transform]),
>+  [$clear]: dart.fnType(dart.void, []),
>+  [$consolidate]: dart.fnType(svg$.Transform, []),
>+  [$createSvgTransformFromMatrix]: dart.fnType(svg$.Transform, [svg$.Matrix]),
>+  [$getItem]: dart.fnType(svg$.Transform, [core.int]),
>+  [$initialize]: dart.fnType(svg$.Transform, [svg$.Transform]),
>+  [$insertItemBefore]: dart.fnType(svg$.Transform, [svg$.Transform, core.int]),
>+  [$removeItem]: dart.fnType(svg$.Transform, [core.int]),
>+  [$replaceItem]: dart.fnType(svg$.Transform, [svg$.Transform, core.int])
>+}));
>+dart.setGetterSignature(svg$.TransformList, () => ({
>+  __proto__: dart.getGetters(svg$.TransformList.__proto__),
>+  [$length]: core.int,
>+  [$first]: svg$.Transform,
>+  [$last]: svg$.Transform,
>+  [$single]: svg$.Transform
>+}));
>+dart.setSetterSignature(svg$.TransformList, () => ({
>+  __proto__: dart.getSetters(svg$.TransformList.__proto__),
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(svg$.TransformList, "dart:svg");
>+dart.setFieldSignature(svg$.TransformList, () => ({
>+  __proto__: dart.getFields(svg$.TransformList.__proto__),
>+  [$numberOfItems]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("SVGTransformList", svg$.TransformList);
>+svg$.UnitTypes = class UnitTypes extends _interceptors.Interceptor {};
>+dart.addTypeTests(svg$.UnitTypes);
>+dart.setLibraryUri(svg$.UnitTypes, "dart:svg");
>+dart.defineLazy(svg$.UnitTypes, {
>+  /*svg$.UnitTypes.SVG_UNIT_TYPE_OBJECTBOUNDINGBOX*/get SVG_UNIT_TYPE_OBJECTBOUNDINGBOX() {
>+    return 2;
>+  },
>+  /*svg$.UnitTypes.SVG_UNIT_TYPE_UNKNOWN*/get SVG_UNIT_TYPE_UNKNOWN() {
>+    return 0;
>+  },
>+  /*svg$.UnitTypes.SVG_UNIT_TYPE_USERSPACEONUSE*/get SVG_UNIT_TYPE_USERSPACEONUSE() {
>+    return 1;
>+  }
>+});
>+dart.registerExtension("SVGUnitTypes", svg$.UnitTypes);
>+svg$.UriReference = class UriReference extends _interceptors.Interceptor {
>+  get href() {
>+    return this[href$16];
>+  }
>+  set href(value) {
>+    super.href = value;
>+  }
>+};
>+dart.addTypeTests(svg$.UriReference);
>+const href$16 = Symbol("UriReference.href");
>+dart.setLibraryUri(svg$.UriReference, "dart:svg");
>+dart.setFieldSignature(svg$.UriReference, () => ({
>+  __proto__: dart.getFields(svg$.UriReference.__proto__),
>+  href: dart.finalFieldType(svg$.AnimatedString)
>+}));
>+dart.defineExtensionAccessors(svg$.UriReference, ['href']);
>+svg$.UseElement = class UseElement extends svg$.GraphicsElement {
>+  static new() {
>+    return svg$.UseElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("use"));
>+  }
>+  get [$height]() {
>+    return this.height;
>+  }
>+  get [$width]() {
>+    return this.width;
>+  }
>+  get [$x]() {
>+    return this.x;
>+  }
>+  get [$y]() {
>+    return this.y;
>+  }
>+  get [$href]() {
>+    return this.href;
>+  }
>+};
>+(svg$.UseElement.created = function() {
>+  this[height$39] = null;
>+  this[width$41] = null;
>+  this[x$36] = null;
>+  this[y$35] = null;
>+  this[href$17] = null;
>+  svg$.UseElement.__proto__.created.call(this);
>+}).prototype = svg$.UseElement.prototype;
>+dart.addTypeTests(svg$.UseElement);
>+const height$39 = Symbol("UseElement.height");
>+const width$41 = Symbol("UseElement.width");
>+const x$36 = Symbol("UseElement.x");
>+const y$35 = Symbol("UseElement.y");
>+const href$17 = Symbol("UseElement.href");
>+svg$.UseElement[dart.implements] = () => [svg$.UriReference];
>+dart.setLibraryUri(svg$.UseElement, "dart:svg");
>+dart.setFieldSignature(svg$.UseElement, () => ({
>+  __proto__: dart.getFields(svg$.UseElement.__proto__),
>+  [$height]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$width]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$x]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$y]: dart.finalFieldType(svg$.AnimatedLength),
>+  [$href]: dart.finalFieldType(svg$.AnimatedString)
>+}));
>+dart.registerExtension("SVGUseElement", svg$.UseElement);
>+svg$.ViewElement = class ViewElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$.ViewElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("view"));
>+  }
>+  get [$preserveAspectRatio]() {
>+    return this.preserveAspectRatio;
>+  }
>+  get [$viewBox]() {
>+    return this.viewBox;
>+  }
>+  get [$zoomAndPan]() {
>+    return this.zoomAndPan;
>+  }
>+  set [$zoomAndPan](value) {
>+    this.zoomAndPan = value;
>+  }
>+};
>+(svg$.ViewElement.created = function() {
>+  this[preserveAspectRatio$5] = null;
>+  this[viewBox$3] = null;
>+  this[zoomAndPan$] = null;
>+  svg$.ViewElement.__proto__.created.call(this);
>+}).prototype = svg$.ViewElement.prototype;
>+dart.addTypeTests(svg$.ViewElement);
>+const preserveAspectRatio$5 = Symbol("ViewElement.preserveAspectRatio");
>+const viewBox$3 = Symbol("ViewElement.viewBox");
>+const zoomAndPan$ = Symbol("ViewElement.zoomAndPan");
>+svg$.ViewElement[dart.implements] = () => [svg$.FitToViewBox, svg$.ZoomAndPan];
>+dart.setLibraryUri(svg$.ViewElement, "dart:svg");
>+dart.setFieldSignature(svg$.ViewElement, () => ({
>+  __proto__: dart.getFields(svg$.ViewElement.__proto__),
>+  [$preserveAspectRatio]: dart.finalFieldType(svg$.AnimatedPreserveAspectRatio),
>+  [$viewBox]: dart.finalFieldType(svg$.AnimatedRect),
>+  [$zoomAndPan]: dart.fieldType(core.int)
>+}));
>+dart.registerExtension("SVGViewElement", svg$.ViewElement);
>+svg$.ZoomAndPan = class ZoomAndPan extends _interceptors.Interceptor {
>+  get zoomAndPan() {
>+    return this[zoomAndPan$0];
>+  }
>+  set zoomAndPan(value) {
>+    this[zoomAndPan$0] = value;
>+  }
>+};
>+dart.addTypeTests(svg$.ZoomAndPan);
>+const zoomAndPan$0 = Symbol("ZoomAndPan.zoomAndPan");
>+dart.setLibraryUri(svg$.ZoomAndPan, "dart:svg");
>+dart.setFieldSignature(svg$.ZoomAndPan, () => ({
>+  __proto__: dart.getFields(svg$.ZoomAndPan.__proto__),
>+  zoomAndPan: dart.fieldType(core.int)
>+}));
>+dart.defineExtensionAccessors(svg$.ZoomAndPan, ['zoomAndPan']);
>+dart.defineLazy(svg$.ZoomAndPan, {
>+  /*svg$.ZoomAndPan.SVG_ZOOMANDPAN_DISABLE*/get SVG_ZOOMANDPAN_DISABLE() {
>+    return 1;
>+  },
>+  /*svg$.ZoomAndPan.SVG_ZOOMANDPAN_MAGNIFY*/get SVG_ZOOMANDPAN_MAGNIFY() {
>+    return 2;
>+  },
>+  /*svg$.ZoomAndPan.SVG_ZOOMANDPAN_UNKNOWN*/get SVG_ZOOMANDPAN_UNKNOWN() {
>+    return 0;
>+  }
>+});
>+svg$._SVGFEDropShadowElement = class _SVGFEDropShadowElement extends svg$.SvgElement {};
>+(svg$._SVGFEDropShadowElement.created = function() {
>+  svg$._SVGFEDropShadowElement.__proto__.created.call(this);
>+}).prototype = svg$._SVGFEDropShadowElement.prototype;
>+dart.addTypeTests(svg$._SVGFEDropShadowElement);
>+svg$._SVGFEDropShadowElement[dart.implements] = () => [svg$.FilterPrimitiveStandardAttributes];
>+dart.setLibraryUri(svg$._SVGFEDropShadowElement, "dart:svg");
>+dart.registerExtension("SVGFEDropShadowElement", svg$._SVGFEDropShadowElement);
>+svg$._SVGMPathElement = class _SVGMPathElement extends svg$.SvgElement {
>+  static new() {
>+    return svg$._SVGMPathElement._check(svg$._SvgElementFactoryProvider.createSvgElement_tag("mpath"));
>+  }
>+};
>+(svg$._SVGMPathElement.created = function() {
>+  svg$._SVGMPathElement.__proto__.created.call(this);
>+}).prototype = svg$._SVGMPathElement.prototype;
>+dart.addTypeTests(svg$._SVGMPathElement);
>+svg$._SVGMPathElement[dart.implements] = () => [svg$.UriReference];
>+dart.setLibraryUri(svg$._SVGMPathElement, "dart:svg");
>+dart.registerExtension("SVGMPathElement", svg$._SVGMPathElement);
>+const _connect = dart.privateName(web_audio, "_connect");
>+web_audio.AudioNode = class AudioNode extends html$.EventTarget {
>+  get [$channelCount]() {
>+    return this.channelCount;
>+  }
>+  set [$channelCount](value) {
>+    this.channelCount = value;
>+  }
>+  get [$channelCountMode]() {
>+    return this.channelCountMode;
>+  }
>+  set [$channelCountMode](value) {
>+    this.channelCountMode = value;
>+  }
>+  get [$channelInterpretation]() {
>+    return this.channelInterpretation;
>+  }
>+  set [$channelInterpretation](value) {
>+    this.channelInterpretation = value;
>+  }
>+  get [$context]() {
>+    return this.context;
>+  }
>+  get [$numberOfInputs]() {
>+    return this.numberOfInputs;
>+  }
>+  get [$numberOfOutputs]() {
>+    return this.numberOfOutputs;
>+  }
>+  [_connect](...args) {
>+    return this.connect.apply(this, args);
>+  }
>+  [$disconnect](...args) {
>+    return this.disconnect.apply(this, args);
>+  }
>+  [$connectNode](destination, output, input) {
>+    if (output === void 0) output = 0;
>+    if (input === void 0) input = 0;
>+    this[_connect](destination, output, input);
>+  }
>+  [$connectParam](destination, output) {
>+    if (output === void 0) output = 0;
>+    this[_connect](destination, output);
>+  }
>+};
>+dart.addTypeTests(web_audio.AudioNode);
>+const channelCount = Symbol("AudioNode.channelCount");
>+const channelCountMode = Symbol("AudioNode.channelCountMode");
>+const channelInterpretation = Symbol("AudioNode.channelInterpretation");
>+const context = Symbol("AudioNode.context");
>+const numberOfInputs = Symbol("AudioNode.numberOfInputs");
>+const numberOfOutputs = Symbol("AudioNode.numberOfOutputs");
>+dart.setMethodSignature(web_audio.AudioNode, () => ({
>+  __proto__: dart.getMethods(web_audio.AudioNode.__proto__),
>+  [_connect]: dart.fnType(web_audio.AudioNode, [dart.dynamic], [core.int, core.int]),
>+  [$disconnect]: dart.fnType(dart.void, [], [dart.dynamic, core.int, core.int]),
>+  [$connectNode]: dart.fnType(dart.void, [web_audio.AudioNode], [core.int, core.int]),
>+  [$connectParam]: dart.fnType(dart.void, [web_audio.AudioParam], [core.int])
>+}));
>+dart.setLibraryUri(web_audio.AudioNode, "dart:web_audio");
>+dart.setFieldSignature(web_audio.AudioNode, () => ({
>+  __proto__: dart.getFields(web_audio.AudioNode.__proto__),
>+  [$channelCount]: dart.fieldType(core.int),
>+  [$channelCountMode]: dart.fieldType(core.String),
>+  [$channelInterpretation]: dart.fieldType(core.String),
>+  [$context]: dart.finalFieldType(web_audio.BaseAudioContext),
>+  [$numberOfInputs]: dart.finalFieldType(core.int),
>+  [$numberOfOutputs]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("AudioNode", web_audio.AudioNode);
>+web_audio.AnalyserNode = class AnalyserNode$ extends web_audio.AudioNode {
>+  static new(context, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      return web_audio.AnalyserNode._create_1(context, options_1);
>+    }
>+    return web_audio.AnalyserNode._create_2(context);
>+  }
>+  static _create_1(context, options) {
>+    return new AnalyserNode(context, options);
>+  }
>+  static _create_2(context) {
>+    return new AnalyserNode(context);
>+  }
>+  get [$fftSize]() {
>+    return this.fftSize;
>+  }
>+  set [$fftSize](value) {
>+    this.fftSize = value;
>+  }
>+  get [$frequencyBinCount]() {
>+    return this.frequencyBinCount;
>+  }
>+  get [$maxDecibels]() {
>+    return this.maxDecibels;
>+  }
>+  set [$maxDecibels](value) {
>+    this.maxDecibels = value;
>+  }
>+  get [$minDecibels]() {
>+    return this.minDecibels;
>+  }
>+  set [$minDecibels](value) {
>+    this.minDecibels = value;
>+  }
>+  get [$smoothingTimeConstant]() {
>+    return this.smoothingTimeConstant;
>+  }
>+  set [$smoothingTimeConstant](value) {
>+    this.smoothingTimeConstant = value;
>+  }
>+  [$getByteFrequencyData](...args) {
>+    return this.getByteFrequencyData.apply(this, args);
>+  }
>+  [$getByteTimeDomainData](...args) {
>+    return this.getByteTimeDomainData.apply(this, args);
>+  }
>+  [$getFloatFrequencyData](...args) {
>+    return this.getFloatFrequencyData.apply(this, args);
>+  }
>+  [$getFloatTimeDomainData](...args) {
>+    return this.getFloatTimeDomainData.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(web_audio.AnalyserNode);
>+const fftSize = Symbol("AnalyserNode.fftSize");
>+const frequencyBinCount = Symbol("AnalyserNode.frequencyBinCount");
>+const maxDecibels = Symbol("AnalyserNode.maxDecibels");
>+const minDecibels = Symbol("AnalyserNode.minDecibels");
>+const smoothingTimeConstant = Symbol("AnalyserNode.smoothingTimeConstant");
>+dart.setMethodSignature(web_audio.AnalyserNode, () => ({
>+  __proto__: dart.getMethods(web_audio.AnalyserNode.__proto__),
>+  [$getByteFrequencyData]: dart.fnType(dart.void, [typed_data.Uint8List]),
>+  [$getByteTimeDomainData]: dart.fnType(dart.void, [typed_data.Uint8List]),
>+  [$getFloatFrequencyData]: dart.fnType(dart.void, [typed_data.Float32List]),
>+  [$getFloatTimeDomainData]: dart.fnType(dart.void, [typed_data.Float32List])
>+}));
>+dart.setLibraryUri(web_audio.AnalyserNode, "dart:web_audio");
>+dart.setFieldSignature(web_audio.AnalyserNode, () => ({
>+  __proto__: dart.getFields(web_audio.AnalyserNode.__proto__),
>+  [$fftSize]: dart.fieldType(core.int),
>+  [$frequencyBinCount]: dart.finalFieldType(core.int),
>+  [$maxDecibels]: dart.fieldType(core.num),
>+  [$minDecibels]: dart.fieldType(core.num),
>+  [$smoothingTimeConstant]: dart.fieldType(core.num)
>+}));
>+dart.registerExtension("AnalyserNode", web_audio.AnalyserNode);
>+dart.registerExtension("RealtimeAnalyserNode", web_audio.AnalyserNode);
>+web_audio.AudioBuffer = class AudioBuffer$ extends _interceptors.Interceptor {
>+  static new(options) {
>+    let options_1 = html_common.convertDartToNative_Dictionary(options);
>+    return web_audio.AudioBuffer._create_1(options_1);
>+  }
>+  static _create_1(options) {
>+    return new AudioBuffer(options);
>+  }
>+  get [$duration]() {
>+    return this.duration;
>+  }
>+  get [$length]() {
>+    return this.length;
>+  }
>+  get [$numberOfChannels]() {
>+    return this.numberOfChannels;
>+  }
>+  get [$sampleRate]() {
>+    return this.sampleRate;
>+  }
>+  [$copyFromChannel](...args) {
>+    return this.copyFromChannel.apply(this, args);
>+  }
>+  [$copyToChannel](...args) {
>+    return this.copyToChannel.apply(this, args);
>+  }
>+  [$getChannelData](...args) {
>+    return this.getChannelData.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(web_audio.AudioBuffer);
>+const duration$5 = Symbol("AudioBuffer.duration");
>+const length$18 = Symbol("AudioBuffer.length");
>+const numberOfChannels = Symbol("AudioBuffer.numberOfChannels");
>+const sampleRate = Symbol("AudioBuffer.sampleRate");
>+dart.setMethodSignature(web_audio.AudioBuffer, () => ({
>+  __proto__: dart.getMethods(web_audio.AudioBuffer.__proto__),
>+  [$copyFromChannel]: dart.fnType(dart.void, [typed_data.Float32List, core.int], [core.int]),
>+  [$copyToChannel]: dart.fnType(dart.void, [typed_data.Float32List, core.int], [core.int]),
>+  [$getChannelData]: dart.fnType(typed_data.Float32List, [core.int])
>+}));
>+dart.setLibraryUri(web_audio.AudioBuffer, "dart:web_audio");
>+dart.setFieldSignature(web_audio.AudioBuffer, () => ({
>+  __proto__: dart.getFields(web_audio.AudioBuffer.__proto__),
>+  [$duration]: dart.finalFieldType(core.num),
>+  [$length]: dart.finalFieldType(core.int),
>+  [$numberOfChannels]: dart.finalFieldType(core.int),
>+  [$sampleRate]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("AudioBuffer", web_audio.AudioBuffer);
>+web_audio.AudioScheduledSourceNode = class AudioScheduledSourceNode extends web_audio.AudioNode {
>+  [$start2](...args) {
>+    return this.start.apply(this, args);
>+  }
>+  [$stop](...args) {
>+    return this.stop.apply(this, args);
>+  }
>+  get [$onEnded]() {
>+    return web_audio.AudioScheduledSourceNode.endedEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(web_audio.AudioScheduledSourceNode);
>+dart.setMethodSignature(web_audio.AudioScheduledSourceNode, () => ({
>+  __proto__: dart.getMethods(web_audio.AudioScheduledSourceNode.__proto__),
>+  [$start2]: dart.fnType(dart.void, [], [core.num]),
>+  [$stop]: dart.fnType(dart.void, [], [core.num])
>+}));
>+dart.setGetterSignature(web_audio.AudioScheduledSourceNode, () => ({
>+  __proto__: dart.getGetters(web_audio.AudioScheduledSourceNode.__proto__),
>+  [$onEnded]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(web_audio.AudioScheduledSourceNode, "dart:web_audio");
>+dart.defineLazy(web_audio.AudioScheduledSourceNode, {
>+  /*web_audio.AudioScheduledSourceNode.endedEvent*/get endedEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("ended"));
>+  }
>+});
>+dart.registerExtension("AudioScheduledSourceNode", web_audio.AudioScheduledSourceNode);
>+web_audio.AudioBufferSourceNode = class AudioBufferSourceNode$ extends web_audio.AudioScheduledSourceNode {
>+  static new(context, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      return web_audio.AudioBufferSourceNode._create_1(context, options_1);
>+    }
>+    return web_audio.AudioBufferSourceNode._create_2(context);
>+  }
>+  static _create_1(context, options) {
>+    return new AudioBufferSourceNode(context, options);
>+  }
>+  static _create_2(context) {
>+    return new AudioBufferSourceNode(context);
>+  }
>+  get [$buffer]() {
>+    return this.buffer;
>+  }
>+  set [$buffer](value) {
>+    this.buffer = value;
>+  }
>+  get [$detune]() {
>+    return this.detune;
>+  }
>+  get [$loop]() {
>+    return this.loop;
>+  }
>+  set [$loop](value) {
>+    this.loop = value;
>+  }
>+  get [$loopEnd]() {
>+    return this.loopEnd;
>+  }
>+  set [$loopEnd](value) {
>+    this.loopEnd = value;
>+  }
>+  get [$loopStart]() {
>+    return this.loopStart;
>+  }
>+  set [$loopStart](value) {
>+    this.loopStart = value;
>+  }
>+  get [$playbackRate]() {
>+    return this.playbackRate;
>+  }
>+  [$start](...args) {
>+    return this.start.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(web_audio.AudioBufferSourceNode);
>+const buffer = Symbol("AudioBufferSourceNode.buffer");
>+const detune = Symbol("AudioBufferSourceNode.detune");
>+const loop$ = Symbol("AudioBufferSourceNode.loop");
>+const loopEnd = Symbol("AudioBufferSourceNode.loopEnd");
>+const loopStart = Symbol("AudioBufferSourceNode.loopStart");
>+const playbackRate$0 = Symbol("AudioBufferSourceNode.playbackRate");
>+dart.setMethodSignature(web_audio.AudioBufferSourceNode, () => ({
>+  __proto__: dart.getMethods(web_audio.AudioBufferSourceNode.__proto__),
>+  [$start]: dart.fnType(dart.void, [], [core.num, core.num, core.num])
>+}));
>+dart.setLibraryUri(web_audio.AudioBufferSourceNode, "dart:web_audio");
>+dart.setFieldSignature(web_audio.AudioBufferSourceNode, () => ({
>+  __proto__: dart.getFields(web_audio.AudioBufferSourceNode.__proto__),
>+  [$buffer]: dart.fieldType(web_audio.AudioBuffer),
>+  [$detune]: dart.finalFieldType(web_audio.AudioParam),
>+  [$loop]: dart.fieldType(core.bool),
>+  [$loopEnd]: dart.fieldType(core.num),
>+  [$loopStart]: dart.fieldType(core.num),
>+  [$playbackRate]: dart.finalFieldType(web_audio.AudioParam)
>+}));
>+dart.registerExtension("AudioBufferSourceNode", web_audio.AudioBufferSourceNode);
>+const _getOutputTimestamp_1 = dart.privateName(web_audio, "_getOutputTimestamp_1");
>+const _decodeAudioData = dart.privateName(web_audio, "_decodeAudioData");
>+const _createPeriodicWave_1 = dart.privateName(web_audio, "_createPeriodicWave_1");
>+const _createPeriodicWave_2 = dart.privateName(web_audio, "_createPeriodicWave_2");
>+web_audio.BaseAudioContext = class BaseAudioContext extends html$.EventTarget {
>+  get [$currentTime]() {
>+    return this.currentTime;
>+  }
>+  get [$destination]() {
>+    return this.destination;
>+  }
>+  get [$listener]() {
>+    return this.listener;
>+  }
>+  get [$sampleRate]() {
>+    return this.sampleRate;
>+  }
>+  get [$state]() {
>+    return this.state;
>+  }
>+  [$createAnalyser](...args) {
>+    return this.createAnalyser.apply(this, args);
>+  }
>+  [$createBiquadFilter](...args) {
>+    return this.createBiquadFilter.apply(this, args);
>+  }
>+  [$createBuffer](...args) {
>+    return this.createBuffer.apply(this, args);
>+  }
>+  [$createBufferSource](...args) {
>+    return this.createBufferSource.apply(this, args);
>+  }
>+  [$createChannelMerger](...args) {
>+    return this.createChannelMerger.apply(this, args);
>+  }
>+  [$createChannelSplitter](...args) {
>+    return this.createChannelSplitter.apply(this, args);
>+  }
>+  [$createConstantSource](...args) {
>+    return this.createConstantSource.apply(this, args);
>+  }
>+  [$createConvolver](...args) {
>+    return this.createConvolver.apply(this, args);
>+  }
>+  [$createDelay](...args) {
>+    return this.createDelay.apply(this, args);
>+  }
>+  [$createDynamicsCompressor](...args) {
>+    return this.createDynamicsCompressor.apply(this, args);
>+  }
>+  [$createGain](...args) {
>+    return this.createGain.apply(this, args);
>+  }
>+  [$createIirFilter](...args) {
>+    return this.createIIRFilter.apply(this, args);
>+  }
>+  [$createMediaElementSource](...args) {
>+    return this.createMediaElementSource.apply(this, args);
>+  }
>+  [$createMediaStreamDestination](...args) {
>+    return this.createMediaStreamDestination.apply(this, args);
>+  }
>+  [$createMediaStreamSource](...args) {
>+    return this.createMediaStreamSource.apply(this, args);
>+  }
>+  [$createOscillator](...args) {
>+    return this.createOscillator.apply(this, args);
>+  }
>+  [$createPanner](...args) {
>+    return this.createPanner.apply(this, args);
>+  }
>+  [$createPeriodicWave](real, imag, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      return this[_createPeriodicWave_1](real, imag, options_1);
>+    }
>+    return this[_createPeriodicWave_2](real, imag);
>+  }
>+  [_createPeriodicWave_1](...args) {
>+    return this.createPeriodicWave.apply(this, args);
>+  }
>+  [_createPeriodicWave_2](...args) {
>+    return this.createPeriodicWave.apply(this, args);
>+  }
>+  [$createScriptProcessor](...args) {
>+    return this.createScriptProcessor.apply(this, args);
>+  }
>+  [$createStereoPanner](...args) {
>+    return this.createStereoPanner.apply(this, args);
>+  }
>+  [$createWaveShaper](...args) {
>+    return this.createWaveShaper.apply(this, args);
>+  }
>+  [$decodeAudioData](audioData, successCallback, errorCallback) {
>+    if (successCallback === void 0) successCallback = null;
>+    if (errorCallback === void 0) errorCallback = null;
>+    return html$.promiseToFuture(web_audio.AudioBuffer, this.decodeAudioData(audioData, successCallback, errorCallback));
>+  }
>+  [$resume]() {
>+    return html$.promiseToFuture(dart.dynamic, this.resume());
>+  }
>+};
>+dart.addTypeTests(web_audio.BaseAudioContext);
>+const currentTime$2 = Symbol("BaseAudioContext.currentTime");
>+const destination = Symbol("BaseAudioContext.destination");
>+const listener = Symbol("BaseAudioContext.listener");
>+const sampleRate$ = Symbol("BaseAudioContext.sampleRate");
>+const state$6 = Symbol("BaseAudioContext.state");
>+dart.setMethodSignature(web_audio.BaseAudioContext, () => ({
>+  __proto__: dart.getMethods(web_audio.BaseAudioContext.__proto__),
>+  [$createAnalyser]: dart.fnType(web_audio.AnalyserNode, []),
>+  [$createBiquadFilter]: dart.fnType(web_audio.BiquadFilterNode, []),
>+  [$createBuffer]: dart.fnType(web_audio.AudioBuffer, [core.int, core.int, core.num]),
>+  [$createBufferSource]: dart.fnType(web_audio.AudioBufferSourceNode, []),
>+  [$createChannelMerger]: dart.fnType(web_audio.ChannelMergerNode, [], [core.int]),
>+  [$createChannelSplitter]: dart.fnType(web_audio.ChannelSplitterNode, [], [core.int]),
>+  [$createConstantSource]: dart.fnType(web_audio.ConstantSourceNode, []),
>+  [$createConvolver]: dart.fnType(web_audio.ConvolverNode, []),
>+  [$createDelay]: dart.fnType(web_audio.DelayNode, [], [core.num]),
>+  [$createDynamicsCompressor]: dart.fnType(web_audio.DynamicsCompressorNode, []),
>+  [$createGain]: dart.fnType(web_audio.GainNode, []),
>+  [$createIirFilter]: dart.fnType(web_audio.IirFilterNode, [core.List$(core.num), core.List$(core.num)]),
>+  [$createMediaElementSource]: dart.fnType(web_audio.MediaElementAudioSourceNode, [html$.MediaElement]),
>+  [$createMediaStreamDestination]: dart.fnType(web_audio.MediaStreamAudioDestinationNode, []),
>+  [$createMediaStreamSource]: dart.fnType(web_audio.MediaStreamAudioSourceNode, [html$.MediaStream]),
>+  [$createOscillator]: dart.fnType(web_audio.OscillatorNode, []),
>+  [$createPanner]: dart.fnType(web_audio.PannerNode, []),
>+  [$createPeriodicWave]: dart.fnType(web_audio.PeriodicWave, [core.List$(core.num), core.List$(core.num)], [core.Map]),
>+  [_createPeriodicWave_1]: dart.fnType(web_audio.PeriodicWave, [core.List$(core.num), core.List$(core.num), dart.dynamic]),
>+  [_createPeriodicWave_2]: dart.fnType(web_audio.PeriodicWave, [core.List$(core.num), core.List$(core.num)]),
>+  [$createScriptProcessor]: dart.fnType(web_audio.ScriptProcessorNode, [], [core.int, core.int, core.int]),
>+  [$createStereoPanner]: dart.fnType(web_audio.StereoPannerNode, []),
>+  [$createWaveShaper]: dart.fnType(web_audio.WaveShaperNode, []),
>+  [$decodeAudioData]: dart.fnType(async.Future$(web_audio.AudioBuffer), [typed_data.ByteBuffer], [dart.fnType(dart.void, [web_audio.AudioBuffer]), dart.fnType(dart.void, [html$.DomException])]),
>+  [$resume]: dart.fnType(async.Future, [])
>+}));
>+dart.setLibraryUri(web_audio.BaseAudioContext, "dart:web_audio");
>+dart.setFieldSignature(web_audio.BaseAudioContext, () => ({
>+  __proto__: dart.getFields(web_audio.BaseAudioContext.__proto__),
>+  [$currentTime]: dart.finalFieldType(core.num),
>+  [$destination]: dart.finalFieldType(web_audio.AudioDestinationNode),
>+  [$listener]: dart.finalFieldType(web_audio.AudioListener),
>+  [$sampleRate]: dart.finalFieldType(core.num),
>+  [$state]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("BaseAudioContext", web_audio.BaseAudioContext);
>+web_audio.AudioContext = class AudioContext extends web_audio.BaseAudioContext {
>+  static get supported() {
>+    return !!(window.AudioContext || window.webkitAudioContext);
>+  }
>+  get [$baseLatency]() {
>+    return this.baseLatency;
>+  }
>+  [$close]() {
>+    return html$.promiseToFuture(dart.dynamic, this.close());
>+  }
>+  [$getOutputTimestamp]() {
>+    return html_common.convertNativeToDart_Dictionary(this[_getOutputTimestamp_1]());
>+  }
>+  [_getOutputTimestamp_1](...args) {
>+    return this.getOutputTimestamp.apply(this, args);
>+  }
>+  [$suspend]() {
>+    return html$.promiseToFuture(dart.dynamic, this.suspend());
>+  }
>+  static new() {
>+    return new (window.AudioContext || window.webkitAudioContext)();
>+  }
>+  [$createGain]() {
>+    if (this.createGain !== undefined) {
>+      return this.createGain();
>+    } else {
>+      return this.createGainNode();
>+    }
>+  }
>+  [$createScriptProcessor](bufferSize, numberOfInputChannels, numberOfOutputChannels) {
>+    if (bufferSize === void 0) bufferSize = null;
>+    if (numberOfInputChannels === void 0) numberOfInputChannels = null;
>+    if (numberOfOutputChannels === void 0) numberOfOutputChannels = null;
>+    let func = this.createScriptProcessor || this.createJavaScriptNode;
>+    if (numberOfOutputChannels != null) {
>+      return func.call(this, bufferSize, numberOfInputChannels, numberOfOutputChannels);
>+    } else if (numberOfInputChannels != null) {
>+      return func.call(this, bufferSize, numberOfInputChannels);
>+    } else if (bufferSize != null) {
>+      return func.call(this, bufferSize);
>+    } else {
>+      return func.call(this);
>+    }
>+  }
>+  [_decodeAudioData](...args) {
>+    return this.decodeAudioData.apply(this, args);
>+  }
>+  [$decodeAudioData](audioData, successCallback, errorCallback) {
>+    if (successCallback === void 0) successCallback = null;
>+    if (errorCallback === void 0) errorCallback = null;
>+    if (successCallback != null && errorCallback != null) {
>+      return FutureOfAudioBuffer()._check(this[_decodeAudioData](audioData, successCallback, errorCallback));
>+    }
>+    let completer = CompleterOfAudioBuffer().new();
>+    this[_decodeAudioData](audioData, dart.fn(value => {
>+      completer.complete(value);
>+    }, AudioBufferToNull()), dart.fn(error => {
>+      if (error == null) {
>+        completer.completeError("");
>+      } else {
>+        completer.completeError(error);
>+      }
>+    }, DomExceptionToNull()));
>+    return completer.future;
>+  }
>+};
>+dart.addTypeTests(web_audio.AudioContext);
>+const baseLatency = Symbol("AudioContext.baseLatency");
>+dart.setMethodSignature(web_audio.AudioContext, () => ({
>+  __proto__: dart.getMethods(web_audio.AudioContext.__proto__),
>+  [$close]: dart.fnType(async.Future, []),
>+  [$getOutputTimestamp]: dart.fnType(core.Map, []),
>+  [_getOutputTimestamp_1]: dart.fnType(dart.dynamic, []),
>+  [$suspend]: dart.fnType(async.Future, []),
>+  [_decodeAudioData]: dart.fnType(async.Future, [typed_data.ByteBuffer], [dart.fnType(dart.void, [web_audio.AudioBuffer]), dart.fnType(dart.void, [html$.DomException])])
>+}));
>+dart.setLibraryUri(web_audio.AudioContext, "dart:web_audio");
>+dart.setFieldSignature(web_audio.AudioContext, () => ({
>+  __proto__: dart.getFields(web_audio.AudioContext.__proto__),
>+  [$baseLatency]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("AudioContext", web_audio.AudioContext);
>+dart.registerExtension("webkitAudioContext", web_audio.AudioContext);
>+web_audio.AudioDestinationNode = class AudioDestinationNode extends web_audio.AudioNode {
>+  get [$maxChannelCount]() {
>+    return this.maxChannelCount;
>+  }
>+};
>+dart.addTypeTests(web_audio.AudioDestinationNode);
>+const maxChannelCount = Symbol("AudioDestinationNode.maxChannelCount");
>+dart.setLibraryUri(web_audio.AudioDestinationNode, "dart:web_audio");
>+dart.setFieldSignature(web_audio.AudioDestinationNode, () => ({
>+  __proto__: dart.getFields(web_audio.AudioDestinationNode.__proto__),
>+  [$maxChannelCount]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("AudioDestinationNode", web_audio.AudioDestinationNode);
>+web_audio.AudioListener = class AudioListener extends _interceptors.Interceptor {
>+  get [$forwardX]() {
>+    return this.forwardX;
>+  }
>+  get [$forwardY]() {
>+    return this.forwardY;
>+  }
>+  get [$forwardZ]() {
>+    return this.forwardZ;
>+  }
>+  get [$positionX]() {
>+    return this.positionX;
>+  }
>+  get [$positionY]() {
>+    return this.positionY;
>+  }
>+  get [$positionZ]() {
>+    return this.positionZ;
>+  }
>+  get [$upX]() {
>+    return this.upX;
>+  }
>+  get [$upY]() {
>+    return this.upY;
>+  }
>+  get [$upZ]() {
>+    return this.upZ;
>+  }
>+  [$setOrientation](...args) {
>+    return this.setOrientation.apply(this, args);
>+  }
>+  [$setPosition](...args) {
>+    return this.setPosition.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(web_audio.AudioListener);
>+const forwardX = Symbol("AudioListener.forwardX");
>+const forwardY = Symbol("AudioListener.forwardY");
>+const forwardZ = Symbol("AudioListener.forwardZ");
>+const positionX$ = Symbol("AudioListener.positionX");
>+const positionY$ = Symbol("AudioListener.positionY");
>+const positionZ = Symbol("AudioListener.positionZ");
>+const upX = Symbol("AudioListener.upX");
>+const upY = Symbol("AudioListener.upY");
>+const upZ = Symbol("AudioListener.upZ");
>+dart.setMethodSignature(web_audio.AudioListener, () => ({
>+  __proto__: dart.getMethods(web_audio.AudioListener.__proto__),
>+  [$setOrientation]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num, core.num, core.num]),
>+  [$setPosition]: dart.fnType(dart.void, [core.num, core.num, core.num])
>+}));
>+dart.setLibraryUri(web_audio.AudioListener, "dart:web_audio");
>+dart.setFieldSignature(web_audio.AudioListener, () => ({
>+  __proto__: dart.getFields(web_audio.AudioListener.__proto__),
>+  [$forwardX]: dart.finalFieldType(web_audio.AudioParam),
>+  [$forwardY]: dart.finalFieldType(web_audio.AudioParam),
>+  [$forwardZ]: dart.finalFieldType(web_audio.AudioParam),
>+  [$positionX]: dart.finalFieldType(web_audio.AudioParam),
>+  [$positionY]: dart.finalFieldType(web_audio.AudioParam),
>+  [$positionZ]: dart.finalFieldType(web_audio.AudioParam),
>+  [$upX]: dart.finalFieldType(web_audio.AudioParam),
>+  [$upY]: dart.finalFieldType(web_audio.AudioParam),
>+  [$upZ]: dart.finalFieldType(web_audio.AudioParam)
>+}));
>+dart.registerExtension("AudioListener", web_audio.AudioListener);
>+web_audio.AudioParam = class AudioParam extends _interceptors.Interceptor {
>+  get [$defaultValue]() {
>+    return this.defaultValue;
>+  }
>+  get [$maxValue]() {
>+    return this.maxValue;
>+  }
>+  get [$minValue]() {
>+    return this.minValue;
>+  }
>+  get [$value]() {
>+    return this.value;
>+  }
>+  set [$value](value) {
>+    this.value = value;
>+  }
>+  [$cancelAndHoldAtTime](...args) {
>+    return this.cancelAndHoldAtTime.apply(this, args);
>+  }
>+  [$cancelScheduledValues](...args) {
>+    return this.cancelScheduledValues.apply(this, args);
>+  }
>+  [$exponentialRampToValueAtTime](...args) {
>+    return this.exponentialRampToValueAtTime.apply(this, args);
>+  }
>+  [$linearRampToValueAtTime](...args) {
>+    return this.linearRampToValueAtTime.apply(this, args);
>+  }
>+  [$setTargetAtTime](...args) {
>+    return this.setTargetAtTime.apply(this, args);
>+  }
>+  [$setValueAtTime](...args) {
>+    return this.setValueAtTime.apply(this, args);
>+  }
>+  [$setValueCurveAtTime](...args) {
>+    return this.setValueCurveAtTime.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(web_audio.AudioParam);
>+const defaultValue$3 = Symbol("AudioParam.defaultValue");
>+const maxValue = Symbol("AudioParam.maxValue");
>+const minValue = Symbol("AudioParam.minValue");
>+const value$21 = Symbol("AudioParam.value");
>+dart.setMethodSignature(web_audio.AudioParam, () => ({
>+  __proto__: dart.getMethods(web_audio.AudioParam.__proto__),
>+  [$cancelAndHoldAtTime]: dart.fnType(web_audio.AudioParam, [core.num]),
>+  [$cancelScheduledValues]: dart.fnType(web_audio.AudioParam, [core.num]),
>+  [$exponentialRampToValueAtTime]: dart.fnType(web_audio.AudioParam, [core.num, core.num]),
>+  [$linearRampToValueAtTime]: dart.fnType(web_audio.AudioParam, [core.num, core.num]),
>+  [$setTargetAtTime]: dart.fnType(web_audio.AudioParam, [core.num, core.num, core.num]),
>+  [$setValueAtTime]: dart.fnType(web_audio.AudioParam, [core.num, core.num]),
>+  [$setValueCurveAtTime]: dart.fnType(web_audio.AudioParam, [core.List$(core.num), core.num, core.num])
>+}));
>+dart.setLibraryUri(web_audio.AudioParam, "dart:web_audio");
>+dart.setFieldSignature(web_audio.AudioParam, () => ({
>+  __proto__: dart.getFields(web_audio.AudioParam.__proto__),
>+  [$defaultValue]: dart.finalFieldType(core.num),
>+  [$maxValue]: dart.finalFieldType(core.num),
>+  [$minValue]: dart.finalFieldType(core.num),
>+  [$value]: dart.fieldType(core.num)
>+}));
>+dart.registerExtension("AudioParam", web_audio.AudioParam);
>+const _getItem$ = dart.privateName(web_audio, "_getItem");
>+const Interceptor_MapMixin$$2 = class Interceptor_MapMixin extends _interceptors.Interceptor {};
>+(Interceptor_MapMixin$$2.new = function() {
>+  Interceptor_MapMixin$$2.__proto__.new.call(this);
>+}).prototype = Interceptor_MapMixin$$2.prototype;
>+dart.applyMixin(Interceptor_MapMixin$$2, collection.MapMixin$(core.String, dart.dynamic));
>+web_audio.AudioParamMap = class AudioParamMap extends Interceptor_MapMixin$$2 {
>+  [_getItem$](key) {
>+    return html_common.convertNativeToDart_Dictionary(this.get(key));
>+  }
>+  [$addAll](other) {
>+    MapOfString$dynamic()._check(other);
>+    dart.throw(new core.UnsupportedError.new("Not supported"));
>+  }
>+  [$containsValue](value) {
>+    return this[$values][$any](dart.fn(e => dart.equals(e, value), MapTobool()));
>+  }
>+  [$containsKey](key) {
>+    return this[_getItem$](core.String._check(key)) != null;
>+  }
>+  [$_get](key) {
>+    return this[_getItem$](core.String._check(key));
>+  }
>+  [$forEach](f) {
>+    let entries = this.entries();
>+    while (true) {
>+      let entry = entries.next();
>+      if (entry.done) return;
>+      f(entry.value[0], html_common.convertNativeToDart_Dictionary(entry.value[1]));
>+    }
>+  }
>+  get [$keys]() {
>+    let keys = JSArrayOfString().of([]);
>+    this[$forEach](dart.fn((k, v) => keys[$add](k), StringAnddynamicTovoid()));
>+    return keys;
>+  }
>+  get [$values]() {
>+    let values = JSArrayOfMap().of([]);
>+    this[$forEach](dart.fn((k, v) => values[$add](core.Map._check(v)), StringAnddynamicTovoid()));
>+    return values;
>+  }
>+  get [$length]() {
>+    return this.size;
>+  }
>+  get [$isEmpty]() {
>+    return this[$length] === 0;
>+  }
>+  get [$isNotEmpty]() {
>+    return !dart.test(this[$isEmpty]);
>+  }
>+  [$_set](key, value) {
>+    core.String._check(key);
>+    dart.throw(new core.UnsupportedError.new("Not supported"));
>+    return value;
>+  }
>+  [$putIfAbsent](key, ifAbsent) {
>+    core.String._check(key);
>+    dart.throw(new core.UnsupportedError.new("Not supported"));
>+  }
>+  [$remove](key) {
>+    dart.throw(new core.UnsupportedError.new("Not supported"));
>+  }
>+  [$clear]() {
>+    dart.throw(new core.UnsupportedError.new("Not supported"));
>+  }
>+};
>+dart.addTypeTests(web_audio.AudioParamMap);
>+dart.setMethodSignature(web_audio.AudioParamMap, () => ({
>+  __proto__: dart.getMethods(web_audio.AudioParamMap.__proto__),
>+  [_getItem$]: dart.fnType(core.Map, [core.String]),
>+  [$addAll]: dart.fnType(dart.void, [core.Object]),
>+  [$containsValue]: dart.fnType(core.bool, [dart.dynamic]),
>+  [$containsKey]: dart.fnType(core.bool, [dart.dynamic]),
>+  [$_get]: dart.fnType(core.Map, [dart.dynamic]),
>+  [$forEach]: dart.fnType(dart.void, [dart.fnType(dart.void, [core.String, dart.dynamic])]),
>+  [$_set]: dart.fnType(dart.void, [core.Object, dart.dynamic]),
>+  [$putIfAbsent]: dart.fnType(dart.dynamic, [core.Object, dart.fnType(dart.dynamic, [])]),
>+  [$remove]: dart.fnType(core.String, [dart.dynamic]),
>+  [$clear]: dart.fnType(dart.void, [])
>+}));
>+dart.setGetterSignature(web_audio.AudioParamMap, () => ({
>+  __proto__: dart.getGetters(web_audio.AudioParamMap.__proto__),
>+  [$keys]: core.Iterable$(core.String),
>+  [$values]: core.Iterable$(core.Map),
>+  [$length]: core.int,
>+  [$isEmpty]: core.bool,
>+  [$isNotEmpty]: core.bool
>+}));
>+dart.setLibraryUri(web_audio.AudioParamMap, "dart:web_audio");
>+dart.registerExtension("AudioParamMap", web_audio.AudioParamMap);
>+web_audio.AudioProcessingEvent = class AudioProcessingEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+    return web_audio.AudioProcessingEvent._create_1(type, eventInitDict_1);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new AudioProcessingEvent(type, eventInitDict);
>+  }
>+  get [$inputBuffer]() {
>+    return this.inputBuffer;
>+  }
>+  get [$outputBuffer]() {
>+    return this.outputBuffer;
>+  }
>+  get [$playbackTime]() {
>+    return this.playbackTime;
>+  }
>+};
>+dart.addTypeTests(web_audio.AudioProcessingEvent);
>+const inputBuffer = Symbol("AudioProcessingEvent.inputBuffer");
>+const outputBuffer = Symbol("AudioProcessingEvent.outputBuffer");
>+const playbackTime = Symbol("AudioProcessingEvent.playbackTime");
>+dart.setLibraryUri(web_audio.AudioProcessingEvent, "dart:web_audio");
>+dart.setFieldSignature(web_audio.AudioProcessingEvent, () => ({
>+  __proto__: dart.getFields(web_audio.AudioProcessingEvent.__proto__),
>+  [$inputBuffer]: dart.finalFieldType(web_audio.AudioBuffer),
>+  [$outputBuffer]: dart.finalFieldType(web_audio.AudioBuffer),
>+  [$playbackTime]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("AudioProcessingEvent", web_audio.AudioProcessingEvent);
>+web_audio.AudioTrack = class AudioTrack extends _interceptors.Interceptor {
>+  get [$enabled]() {
>+    return this.enabled;
>+  }
>+  set [$enabled](value) {
>+    this.enabled = value;
>+  }
>+  get [$id]() {
>+    return this.id;
>+  }
>+  get [$kind]() {
>+    return this.kind;
>+  }
>+  get [$label]() {
>+    return this.label;
>+  }
>+  get [$language]() {
>+    return this.language;
>+  }
>+  get [$sourceBuffer]() {
>+    return this.sourceBuffer;
>+  }
>+};
>+dart.addTypeTests(web_audio.AudioTrack);
>+const enabled$ = Symbol("AudioTrack.enabled");
>+const id$18 = Symbol("AudioTrack.id");
>+const kind$4 = Symbol("AudioTrack.kind");
>+const label$8 = Symbol("AudioTrack.label");
>+const language$2 = Symbol("AudioTrack.language");
>+const sourceBuffer$ = Symbol("AudioTrack.sourceBuffer");
>+dart.setLibraryUri(web_audio.AudioTrack, "dart:web_audio");
>+dart.setFieldSignature(web_audio.AudioTrack, () => ({
>+  __proto__: dart.getFields(web_audio.AudioTrack.__proto__),
>+  [$enabled]: dart.fieldType(core.bool),
>+  [$id]: dart.finalFieldType(core.String),
>+  [$kind]: dart.finalFieldType(core.String),
>+  [$label]: dart.finalFieldType(core.String),
>+  [$language]: dart.finalFieldType(core.String),
>+  [$sourceBuffer]: dart.finalFieldType(html$.SourceBuffer)
>+}));
>+dart.registerExtension("AudioTrack", web_audio.AudioTrack);
>+const __getter__$ = dart.privateName(web_audio, "__getter__");
>+web_audio.AudioTrackList = class AudioTrackList extends html$.EventTarget {
>+  get [$length]() {
>+    return this.length;
>+  }
>+  [__getter__$](...args) {
>+    return this.__getter__.apply(this, args);
>+  }
>+  [$getTrackById](...args) {
>+    return this.getTrackById.apply(this, args);
>+  }
>+  get [$onChange]() {
>+    return web_audio.AudioTrackList.changeEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(web_audio.AudioTrackList);
>+const length$19 = Symbol("AudioTrackList.length");
>+dart.setMethodSignature(web_audio.AudioTrackList, () => ({
>+  __proto__: dart.getMethods(web_audio.AudioTrackList.__proto__),
>+  [__getter__$]: dart.fnType(web_audio.AudioTrack, [core.int]),
>+  [$getTrackById]: dart.fnType(web_audio.AudioTrack, [core.String])
>+}));
>+dart.setGetterSignature(web_audio.AudioTrackList, () => ({
>+  __proto__: dart.getGetters(web_audio.AudioTrackList.__proto__),
>+  [$onChange]: async.Stream$(html$.Event)
>+}));
>+dart.setLibraryUri(web_audio.AudioTrackList, "dart:web_audio");
>+dart.setFieldSignature(web_audio.AudioTrackList, () => ({
>+  __proto__: dart.getFields(web_audio.AudioTrackList.__proto__),
>+  [$length]: dart.finalFieldType(core.int)
>+}));
>+dart.defineLazy(web_audio.AudioTrackList, {
>+  /*web_audio.AudioTrackList.changeEvent*/get changeEvent() {
>+    return dart.const(new (EventStreamProviderOfEvent()).new("change"));
>+  }
>+});
>+dart.registerExtension("AudioTrackList", web_audio.AudioTrackList);
>+web_audio.AudioWorkletGlobalScope = class AudioWorkletGlobalScope extends html$.WorkletGlobalScope {
>+  get [$currentTime]() {
>+    return this.currentTime;
>+  }
>+  get [$sampleRate]() {
>+    return this.sampleRate;
>+  }
>+  [$registerProcessor](...args) {
>+    return this.registerProcessor.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(web_audio.AudioWorkletGlobalScope);
>+const currentTime$3 = Symbol("AudioWorkletGlobalScope.currentTime");
>+const sampleRate$0 = Symbol("AudioWorkletGlobalScope.sampleRate");
>+dart.setMethodSignature(web_audio.AudioWorkletGlobalScope, () => ({
>+  __proto__: dart.getMethods(web_audio.AudioWorkletGlobalScope.__proto__),
>+  [$registerProcessor]: dart.fnType(dart.void, [core.String, core.Object])
>+}));
>+dart.setLibraryUri(web_audio.AudioWorkletGlobalScope, "dart:web_audio");
>+dart.setFieldSignature(web_audio.AudioWorkletGlobalScope, () => ({
>+  __proto__: dart.getFields(web_audio.AudioWorkletGlobalScope.__proto__),
>+  [$currentTime]: dart.finalFieldType(core.num),
>+  [$sampleRate]: dart.finalFieldType(core.num)
>+}));
>+dart.registerExtension("AudioWorkletGlobalScope", web_audio.AudioWorkletGlobalScope);
>+web_audio.AudioWorkletNode = class AudioWorkletNode$ extends web_audio.AudioNode {
>+  static new(context, name, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      return web_audio.AudioWorkletNode._create_1(context, name, options_1);
>+    }
>+    return web_audio.AudioWorkletNode._create_2(context, name);
>+  }
>+  static _create_1(context, name, options) {
>+    return new AudioWorkletNode(context, name, options);
>+  }
>+  static _create_2(context, name) {
>+    return new AudioWorkletNode(context, name);
>+  }
>+  get [$parameters]() {
>+    return this.parameters;
>+  }
>+};
>+dart.addTypeTests(web_audio.AudioWorkletNode);
>+const parameters = Symbol("AudioWorkletNode.parameters");
>+dart.setLibraryUri(web_audio.AudioWorkletNode, "dart:web_audio");
>+dart.setFieldSignature(web_audio.AudioWorkletNode, () => ({
>+  __proto__: dart.getFields(web_audio.AudioWorkletNode.__proto__),
>+  [$parameters]: dart.finalFieldType(web_audio.AudioParamMap)
>+}));
>+dart.registerExtension("AudioWorkletNode", web_audio.AudioWorkletNode);
>+web_audio.AudioWorkletProcessor = class AudioWorkletProcessor extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_audio.AudioWorkletProcessor);
>+dart.setLibraryUri(web_audio.AudioWorkletProcessor, "dart:web_audio");
>+dart.registerExtension("AudioWorkletProcessor", web_audio.AudioWorkletProcessor);
>+web_audio.BiquadFilterNode = class BiquadFilterNode$ extends web_audio.AudioNode {
>+  static new(context, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      return web_audio.BiquadFilterNode._create_1(context, options_1);
>+    }
>+    return web_audio.BiquadFilterNode._create_2(context);
>+  }
>+  static _create_1(context, options) {
>+    return new BiquadFilterNode(context, options);
>+  }
>+  static _create_2(context) {
>+    return new BiquadFilterNode(context);
>+  }
>+  get [$Q]() {
>+    return this.Q;
>+  }
>+  get [$detune]() {
>+    return this.detune;
>+  }
>+  get [$frequency]() {
>+    return this.frequency;
>+  }
>+  get [$gain]() {
>+    return this.gain;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  set [$type](value) {
>+    this.type = value;
>+  }
>+  [$getFrequencyResponse](...args) {
>+    return this.getFrequencyResponse.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(web_audio.BiquadFilterNode);
>+const Q = Symbol("BiquadFilterNode.Q");
>+const detune$ = Symbol("BiquadFilterNode.detune");
>+const frequency = Symbol("BiquadFilterNode.frequency");
>+const gain = Symbol("BiquadFilterNode.gain");
>+const type$42 = Symbol("BiquadFilterNode.type");
>+dart.setMethodSignature(web_audio.BiquadFilterNode, () => ({
>+  __proto__: dart.getMethods(web_audio.BiquadFilterNode.__proto__),
>+  [$getFrequencyResponse]: dart.fnType(dart.void, [typed_data.Float32List, typed_data.Float32List, typed_data.Float32List])
>+}));
>+dart.setLibraryUri(web_audio.BiquadFilterNode, "dart:web_audio");
>+dart.setFieldSignature(web_audio.BiquadFilterNode, () => ({
>+  __proto__: dart.getFields(web_audio.BiquadFilterNode.__proto__),
>+  [$Q]: dart.finalFieldType(web_audio.AudioParam),
>+  [$detune]: dart.finalFieldType(web_audio.AudioParam),
>+  [$frequency]: dart.finalFieldType(web_audio.AudioParam),
>+  [$gain]: dart.finalFieldType(web_audio.AudioParam),
>+  [$type]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("BiquadFilterNode", web_audio.BiquadFilterNode);
>+web_audio.ChannelMergerNode = class ChannelMergerNode$ extends web_audio.AudioNode {
>+  static new(context, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      return web_audio.ChannelMergerNode._create_1(context, options_1);
>+    }
>+    return web_audio.ChannelMergerNode._create_2(context);
>+  }
>+  static _create_1(context, options) {
>+    return new ChannelMergerNode(context, options);
>+  }
>+  static _create_2(context) {
>+    return new ChannelMergerNode(context);
>+  }
>+};
>+dart.addTypeTests(web_audio.ChannelMergerNode);
>+dart.setLibraryUri(web_audio.ChannelMergerNode, "dart:web_audio");
>+dart.registerExtension("ChannelMergerNode", web_audio.ChannelMergerNode);
>+dart.registerExtension("AudioChannelMerger", web_audio.ChannelMergerNode);
>+web_audio.ChannelSplitterNode = class ChannelSplitterNode$ extends web_audio.AudioNode {
>+  static new(context, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      return web_audio.ChannelSplitterNode._create_1(context, options_1);
>+    }
>+    return web_audio.ChannelSplitterNode._create_2(context);
>+  }
>+  static _create_1(context, options) {
>+    return new ChannelSplitterNode(context, options);
>+  }
>+  static _create_2(context) {
>+    return new ChannelSplitterNode(context);
>+  }
>+};
>+dart.addTypeTests(web_audio.ChannelSplitterNode);
>+dart.setLibraryUri(web_audio.ChannelSplitterNode, "dart:web_audio");
>+dart.registerExtension("ChannelSplitterNode", web_audio.ChannelSplitterNode);
>+dart.registerExtension("AudioChannelSplitter", web_audio.ChannelSplitterNode);
>+web_audio.ConstantSourceNode = class ConstantSourceNode$ extends web_audio.AudioScheduledSourceNode {
>+  static new(context, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      return web_audio.ConstantSourceNode._create_1(context, options_1);
>+    }
>+    return web_audio.ConstantSourceNode._create_2(context);
>+  }
>+  static _create_1(context, options) {
>+    return new ConstantSourceNode(context, options);
>+  }
>+  static _create_2(context) {
>+    return new ConstantSourceNode(context);
>+  }
>+  get [$offset]() {
>+    return this.offset;
>+  }
>+};
>+dart.addTypeTests(web_audio.ConstantSourceNode);
>+const offset$0 = Symbol("ConstantSourceNode.offset");
>+dart.setLibraryUri(web_audio.ConstantSourceNode, "dart:web_audio");
>+dart.setFieldSignature(web_audio.ConstantSourceNode, () => ({
>+  __proto__: dart.getFields(web_audio.ConstantSourceNode.__proto__),
>+  [$offset]: dart.finalFieldType(web_audio.AudioParam)
>+}));
>+dart.registerExtension("ConstantSourceNode", web_audio.ConstantSourceNode);
>+web_audio.ConvolverNode = class ConvolverNode$ extends web_audio.AudioNode {
>+  static new(context, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      return web_audio.ConvolverNode._create_1(context, options_1);
>+    }
>+    return web_audio.ConvolverNode._create_2(context);
>+  }
>+  static _create_1(context, options) {
>+    return new ConvolverNode(context, options);
>+  }
>+  static _create_2(context) {
>+    return new ConvolverNode(context);
>+  }
>+  get [$buffer]() {
>+    return this.buffer;
>+  }
>+  set [$buffer](value) {
>+    this.buffer = value;
>+  }
>+  get [$normalize]() {
>+    return this.normalize;
>+  }
>+  set [$normalize](value) {
>+    this.normalize = value;
>+  }
>+};
>+dart.addTypeTests(web_audio.ConvolverNode);
>+const buffer$ = Symbol("ConvolverNode.buffer");
>+const normalize = Symbol("ConvolverNode.normalize");
>+dart.setLibraryUri(web_audio.ConvolverNode, "dart:web_audio");
>+dart.setFieldSignature(web_audio.ConvolverNode, () => ({
>+  __proto__: dart.getFields(web_audio.ConvolverNode.__proto__),
>+  [$buffer]: dart.fieldType(web_audio.AudioBuffer),
>+  [$normalize]: dart.fieldType(core.bool)
>+}));
>+dart.registerExtension("ConvolverNode", web_audio.ConvolverNode);
>+web_audio.DelayNode = class DelayNode$ extends web_audio.AudioNode {
>+  static new(context, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      return web_audio.DelayNode._create_1(context, options_1);
>+    }
>+    return web_audio.DelayNode._create_2(context);
>+  }
>+  static _create_1(context, options) {
>+    return new DelayNode(context, options);
>+  }
>+  static _create_2(context) {
>+    return new DelayNode(context);
>+  }
>+  get [$delayTime]() {
>+    return this.delayTime;
>+  }
>+};
>+dart.addTypeTests(web_audio.DelayNode);
>+const delayTime = Symbol("DelayNode.delayTime");
>+dart.setLibraryUri(web_audio.DelayNode, "dart:web_audio");
>+dart.setFieldSignature(web_audio.DelayNode, () => ({
>+  __proto__: dart.getFields(web_audio.DelayNode.__proto__),
>+  [$delayTime]: dart.finalFieldType(web_audio.AudioParam)
>+}));
>+dart.registerExtension("DelayNode", web_audio.DelayNode);
>+web_audio.DynamicsCompressorNode = class DynamicsCompressorNode$ extends web_audio.AudioNode {
>+  static new(context, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      return web_audio.DynamicsCompressorNode._create_1(context, options_1);
>+    }
>+    return web_audio.DynamicsCompressorNode._create_2(context);
>+  }
>+  static _create_1(context, options) {
>+    return new DynamicsCompressorNode(context, options);
>+  }
>+  static _create_2(context) {
>+    return new DynamicsCompressorNode(context);
>+  }
>+  get [$attack]() {
>+    return this.attack;
>+  }
>+  get [$knee]() {
>+    return this.knee;
>+  }
>+  get [$ratio]() {
>+    return this.ratio;
>+  }
>+  get [$reduction]() {
>+    return this.reduction;
>+  }
>+  get [$release]() {
>+    return this.release;
>+  }
>+  get [$threshold]() {
>+    return this.threshold;
>+  }
>+};
>+dart.addTypeTests(web_audio.DynamicsCompressorNode);
>+const attack = Symbol("DynamicsCompressorNode.attack");
>+const knee = Symbol("DynamicsCompressorNode.knee");
>+const ratio = Symbol("DynamicsCompressorNode.ratio");
>+const reduction = Symbol("DynamicsCompressorNode.reduction");
>+const release = Symbol("DynamicsCompressorNode.release");
>+const threshold = Symbol("DynamicsCompressorNode.threshold");
>+dart.setLibraryUri(web_audio.DynamicsCompressorNode, "dart:web_audio");
>+dart.setFieldSignature(web_audio.DynamicsCompressorNode, () => ({
>+  __proto__: dart.getFields(web_audio.DynamicsCompressorNode.__proto__),
>+  [$attack]: dart.finalFieldType(web_audio.AudioParam),
>+  [$knee]: dart.finalFieldType(web_audio.AudioParam),
>+  [$ratio]: dart.finalFieldType(web_audio.AudioParam),
>+  [$reduction]: dart.finalFieldType(core.num),
>+  [$release]: dart.finalFieldType(web_audio.AudioParam),
>+  [$threshold]: dart.finalFieldType(web_audio.AudioParam)
>+}));
>+dart.registerExtension("DynamicsCompressorNode", web_audio.DynamicsCompressorNode);
>+web_audio.GainNode = class GainNode$ extends web_audio.AudioNode {
>+  static new(context, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      return web_audio.GainNode._create_1(context, options_1);
>+    }
>+    return web_audio.GainNode._create_2(context);
>+  }
>+  static _create_1(context, options) {
>+    return new GainNode(context, options);
>+  }
>+  static _create_2(context) {
>+    return new GainNode(context);
>+  }
>+  get [$gain]() {
>+    return this.gain;
>+  }
>+};
>+dart.addTypeTests(web_audio.GainNode);
>+const gain$ = Symbol("GainNode.gain");
>+dart.setLibraryUri(web_audio.GainNode, "dart:web_audio");
>+dart.setFieldSignature(web_audio.GainNode, () => ({
>+  __proto__: dart.getFields(web_audio.GainNode.__proto__),
>+  [$gain]: dart.finalFieldType(web_audio.AudioParam)
>+}));
>+dart.registerExtension("GainNode", web_audio.GainNode);
>+dart.registerExtension("AudioGainNode", web_audio.GainNode);
>+web_audio.IirFilterNode = class IirFilterNode extends web_audio.AudioNode {
>+  static new(context, options) {
>+    let options_1 = html_common.convertDartToNative_Dictionary(options);
>+    return web_audio.IirFilterNode._create_1(context, options_1);
>+  }
>+  static _create_1(context, options) {
>+    return new IIRFilterNode(context, options);
>+  }
>+  [$getFrequencyResponse](...args) {
>+    return this.getFrequencyResponse.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(web_audio.IirFilterNode);
>+dart.setMethodSignature(web_audio.IirFilterNode, () => ({
>+  __proto__: dart.getMethods(web_audio.IirFilterNode.__proto__),
>+  [$getFrequencyResponse]: dart.fnType(dart.void, [typed_data.Float32List, typed_data.Float32List, typed_data.Float32List])
>+}));
>+dart.setLibraryUri(web_audio.IirFilterNode, "dart:web_audio");
>+dart.registerExtension("IIRFilterNode", web_audio.IirFilterNode);
>+web_audio.MediaElementAudioSourceNode = class MediaElementAudioSourceNode$ extends web_audio.AudioNode {
>+  static new(context, options) {
>+    let options_1 = html_common.convertDartToNative_Dictionary(options);
>+    return web_audio.MediaElementAudioSourceNode._create_1(context, options_1);
>+  }
>+  static _create_1(context, options) {
>+    return new MediaElementAudioSourceNode(context, options);
>+  }
>+  get [$mediaElement]() {
>+    return this.mediaElement;
>+  }
>+};
>+dart.addTypeTests(web_audio.MediaElementAudioSourceNode);
>+const mediaElement = Symbol("MediaElementAudioSourceNode.mediaElement");
>+dart.setLibraryUri(web_audio.MediaElementAudioSourceNode, "dart:web_audio");
>+dart.setFieldSignature(web_audio.MediaElementAudioSourceNode, () => ({
>+  __proto__: dart.getFields(web_audio.MediaElementAudioSourceNode.__proto__),
>+  [$mediaElement]: dart.finalFieldType(html$.MediaElement)
>+}));
>+dart.registerExtension("MediaElementAudioSourceNode", web_audio.MediaElementAudioSourceNode);
>+web_audio.MediaStreamAudioDestinationNode = class MediaStreamAudioDestinationNode$ extends web_audio.AudioNode {
>+  static new(context, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      return web_audio.MediaStreamAudioDestinationNode._create_1(context, options_1);
>+    }
>+    return web_audio.MediaStreamAudioDestinationNode._create_2(context);
>+  }
>+  static _create_1(context, options) {
>+    return new MediaStreamAudioDestinationNode(context, options);
>+  }
>+  static _create_2(context) {
>+    return new MediaStreamAudioDestinationNode(context);
>+  }
>+  get [$stream]() {
>+    return this.stream;
>+  }
>+};
>+dart.addTypeTests(web_audio.MediaStreamAudioDestinationNode);
>+const stream$0 = Symbol("MediaStreamAudioDestinationNode.stream");
>+dart.setLibraryUri(web_audio.MediaStreamAudioDestinationNode, "dart:web_audio");
>+dart.setFieldSignature(web_audio.MediaStreamAudioDestinationNode, () => ({
>+  __proto__: dart.getFields(web_audio.MediaStreamAudioDestinationNode.__proto__),
>+  [$stream]: dart.finalFieldType(html$.MediaStream)
>+}));
>+dart.registerExtension("MediaStreamAudioDestinationNode", web_audio.MediaStreamAudioDestinationNode);
>+web_audio.MediaStreamAudioSourceNode = class MediaStreamAudioSourceNode$ extends web_audio.AudioNode {
>+  static new(context, options) {
>+    let options_1 = html_common.convertDartToNative_Dictionary(options);
>+    return web_audio.MediaStreamAudioSourceNode._create_1(context, options_1);
>+  }
>+  static _create_1(context, options) {
>+    return new MediaStreamAudioSourceNode(context, options);
>+  }
>+  get [$mediaStream]() {
>+    return this.mediaStream;
>+  }
>+};
>+dart.addTypeTests(web_audio.MediaStreamAudioSourceNode);
>+const mediaStream = Symbol("MediaStreamAudioSourceNode.mediaStream");
>+dart.setLibraryUri(web_audio.MediaStreamAudioSourceNode, "dart:web_audio");
>+dart.setFieldSignature(web_audio.MediaStreamAudioSourceNode, () => ({
>+  __proto__: dart.getFields(web_audio.MediaStreamAudioSourceNode.__proto__),
>+  [$mediaStream]: dart.finalFieldType(html$.MediaStream)
>+}));
>+dart.registerExtension("MediaStreamAudioSourceNode", web_audio.MediaStreamAudioSourceNode);
>+web_audio.OfflineAudioCompletionEvent = class OfflineAudioCompletionEvent$ extends html$.Event {
>+  static new(type, eventInitDict) {
>+    let eventInitDict_1 = html_common.convertDartToNative_Dictionary(eventInitDict);
>+    return web_audio.OfflineAudioCompletionEvent._create_1(type, eventInitDict_1);
>+  }
>+  static _create_1(type, eventInitDict) {
>+    return new OfflineAudioCompletionEvent(type, eventInitDict);
>+  }
>+  get [$renderedBuffer]() {
>+    return this.renderedBuffer;
>+  }
>+};
>+dart.addTypeTests(web_audio.OfflineAudioCompletionEvent);
>+const renderedBuffer = Symbol("OfflineAudioCompletionEvent.renderedBuffer");
>+dart.setLibraryUri(web_audio.OfflineAudioCompletionEvent, "dart:web_audio");
>+dart.setFieldSignature(web_audio.OfflineAudioCompletionEvent, () => ({
>+  __proto__: dart.getFields(web_audio.OfflineAudioCompletionEvent.__proto__),
>+  [$renderedBuffer]: dart.finalFieldType(web_audio.AudioBuffer)
>+}));
>+dart.registerExtension("OfflineAudioCompletionEvent", web_audio.OfflineAudioCompletionEvent);
>+web_audio.OfflineAudioContext = class OfflineAudioContext$ extends web_audio.BaseAudioContext {
>+  static new(numberOfChannels_OR_options, numberOfFrames, sampleRate) {
>+    if (numberOfFrames === void 0) numberOfFrames = null;
>+    if (sampleRate === void 0) sampleRate = null;
>+    if (typeof sampleRate == 'number' && core.int.is(numberOfFrames) && core.int.is(numberOfChannels_OR_options)) {
>+      return web_audio.OfflineAudioContext._create_1(numberOfChannels_OR_options, numberOfFrames, sampleRate);
>+    }
>+    if (core.Map.is(numberOfChannels_OR_options) && numberOfFrames == null && sampleRate == null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(numberOfChannels_OR_options);
>+      return web_audio.OfflineAudioContext._create_2(options_1);
>+    }
>+    dart.throw(new core.ArgumentError.new("Incorrect number or type of arguments"));
>+  }
>+  static _create_1(numberOfChannels_OR_options, numberOfFrames, sampleRate) {
>+    return new OfflineAudioContext(numberOfChannels_OR_options, numberOfFrames, sampleRate);
>+  }
>+  static _create_2(numberOfChannels_OR_options) {
>+    return new OfflineAudioContext(numberOfChannels_OR_options);
>+  }
>+  get [$length]() {
>+    return this.length;
>+  }
>+  [$startRendering]() {
>+    return html$.promiseToFuture(web_audio.AudioBuffer, this.startRendering());
>+  }
>+  [$suspendFor](suspendTime) {
>+    return html$.promiseToFuture(dart.dynamic, this.suspendFor(suspendTime));
>+  }
>+};
>+dart.addTypeTests(web_audio.OfflineAudioContext);
>+const length$20 = Symbol("OfflineAudioContext.length");
>+dart.setMethodSignature(web_audio.OfflineAudioContext, () => ({
>+  __proto__: dart.getMethods(web_audio.OfflineAudioContext.__proto__),
>+  [$startRendering]: dart.fnType(async.Future$(web_audio.AudioBuffer), []),
>+  [$suspendFor]: dart.fnType(async.Future, [core.num])
>+}));
>+dart.setLibraryUri(web_audio.OfflineAudioContext, "dart:web_audio");
>+dart.setFieldSignature(web_audio.OfflineAudioContext, () => ({
>+  __proto__: dart.getFields(web_audio.OfflineAudioContext.__proto__),
>+  [$length]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("OfflineAudioContext", web_audio.OfflineAudioContext);
>+web_audio.OscillatorNode = class OscillatorNode$ extends web_audio.AudioScheduledSourceNode {
>+  static new(context, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      return web_audio.OscillatorNode._create_1(context, options_1);
>+    }
>+    return web_audio.OscillatorNode._create_2(context);
>+  }
>+  static _create_1(context, options) {
>+    return new OscillatorNode(context, options);
>+  }
>+  static _create_2(context) {
>+    return new OscillatorNode(context);
>+  }
>+  get [$detune]() {
>+    return this.detune;
>+  }
>+  get [$frequency]() {
>+    return this.frequency;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+  set [$type](value) {
>+    this.type = value;
>+  }
>+  [$setPeriodicWave](...args) {
>+    return this.setPeriodicWave.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(web_audio.OscillatorNode);
>+const detune$0 = Symbol("OscillatorNode.detune");
>+const frequency$ = Symbol("OscillatorNode.frequency");
>+const type$43 = Symbol("OscillatorNode.type");
>+dart.setMethodSignature(web_audio.OscillatorNode, () => ({
>+  __proto__: dart.getMethods(web_audio.OscillatorNode.__proto__),
>+  [$setPeriodicWave]: dart.fnType(dart.void, [web_audio.PeriodicWave])
>+}));
>+dart.setLibraryUri(web_audio.OscillatorNode, "dart:web_audio");
>+dart.setFieldSignature(web_audio.OscillatorNode, () => ({
>+  __proto__: dart.getFields(web_audio.OscillatorNode.__proto__),
>+  [$detune]: dart.finalFieldType(web_audio.AudioParam),
>+  [$frequency]: dart.finalFieldType(web_audio.AudioParam),
>+  [$type]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("OscillatorNode", web_audio.OscillatorNode);
>+dart.registerExtension("Oscillator", web_audio.OscillatorNode);
>+web_audio.PannerNode = class PannerNode$ extends web_audio.AudioNode {
>+  static new(context, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      return web_audio.PannerNode._create_1(context, options_1);
>+    }
>+    return web_audio.PannerNode._create_2(context);
>+  }
>+  static _create_1(context, options) {
>+    return new PannerNode(context, options);
>+  }
>+  static _create_2(context) {
>+    return new PannerNode(context);
>+  }
>+  get [$coneInnerAngle]() {
>+    return this.coneInnerAngle;
>+  }
>+  set [$coneInnerAngle](value) {
>+    this.coneInnerAngle = value;
>+  }
>+  get [$coneOuterAngle]() {
>+    return this.coneOuterAngle;
>+  }
>+  set [$coneOuterAngle](value) {
>+    this.coneOuterAngle = value;
>+  }
>+  get [$coneOuterGain]() {
>+    return this.coneOuterGain;
>+  }
>+  set [$coneOuterGain](value) {
>+    this.coneOuterGain = value;
>+  }
>+  get [$distanceModel]() {
>+    return this.distanceModel;
>+  }
>+  set [$distanceModel](value) {
>+    this.distanceModel = value;
>+  }
>+  get [$maxDistance]() {
>+    return this.maxDistance;
>+  }
>+  set [$maxDistance](value) {
>+    this.maxDistance = value;
>+  }
>+  get [$orientationX]() {
>+    return this.orientationX;
>+  }
>+  get [$orientationY]() {
>+    return this.orientationY;
>+  }
>+  get [$orientationZ]() {
>+    return this.orientationZ;
>+  }
>+  get [$panningModel]() {
>+    return this.panningModel;
>+  }
>+  set [$panningModel](value) {
>+    this.panningModel = value;
>+  }
>+  get [$positionX]() {
>+    return this.positionX;
>+  }
>+  get [$positionY]() {
>+    return this.positionY;
>+  }
>+  get [$positionZ]() {
>+    return this.positionZ;
>+  }
>+  get [$refDistance]() {
>+    return this.refDistance;
>+  }
>+  set [$refDistance](value) {
>+    this.refDistance = value;
>+  }
>+  get [$rolloffFactor]() {
>+    return this.rolloffFactor;
>+  }
>+  set [$rolloffFactor](value) {
>+    this.rolloffFactor = value;
>+  }
>+  [$setOrientation](...args) {
>+    return this.setOrientation.apply(this, args);
>+  }
>+  [$setPosition](...args) {
>+    return this.setPosition.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(web_audio.PannerNode);
>+const coneInnerAngle = Symbol("PannerNode.coneInnerAngle");
>+const coneOuterAngle = Symbol("PannerNode.coneOuterAngle");
>+const coneOuterGain = Symbol("PannerNode.coneOuterGain");
>+const distanceModel = Symbol("PannerNode.distanceModel");
>+const maxDistance = Symbol("PannerNode.maxDistance");
>+const orientationX = Symbol("PannerNode.orientationX");
>+const orientationY = Symbol("PannerNode.orientationY");
>+const orientationZ = Symbol("PannerNode.orientationZ");
>+const panningModel = Symbol("PannerNode.panningModel");
>+const positionX$0 = Symbol("PannerNode.positionX");
>+const positionY$0 = Symbol("PannerNode.positionY");
>+const positionZ$ = Symbol("PannerNode.positionZ");
>+const refDistance = Symbol("PannerNode.refDistance");
>+const rolloffFactor = Symbol("PannerNode.rolloffFactor");
>+dart.setMethodSignature(web_audio.PannerNode, () => ({
>+  __proto__: dart.getMethods(web_audio.PannerNode.__proto__),
>+  [$setOrientation]: dart.fnType(dart.void, [core.num, core.num, core.num]),
>+  [$setPosition]: dart.fnType(dart.void, [core.num, core.num, core.num])
>+}));
>+dart.setLibraryUri(web_audio.PannerNode, "dart:web_audio");
>+dart.setFieldSignature(web_audio.PannerNode, () => ({
>+  __proto__: dart.getFields(web_audio.PannerNode.__proto__),
>+  [$coneInnerAngle]: dart.fieldType(core.num),
>+  [$coneOuterAngle]: dart.fieldType(core.num),
>+  [$coneOuterGain]: dart.fieldType(core.num),
>+  [$distanceModel]: dart.fieldType(core.String),
>+  [$maxDistance]: dart.fieldType(core.num),
>+  [$orientationX]: dart.finalFieldType(web_audio.AudioParam),
>+  [$orientationY]: dart.finalFieldType(web_audio.AudioParam),
>+  [$orientationZ]: dart.finalFieldType(web_audio.AudioParam),
>+  [$panningModel]: dart.fieldType(core.String),
>+  [$positionX]: dart.finalFieldType(web_audio.AudioParam),
>+  [$positionY]: dart.finalFieldType(web_audio.AudioParam),
>+  [$positionZ]: dart.finalFieldType(web_audio.AudioParam),
>+  [$refDistance]: dart.fieldType(core.num),
>+  [$rolloffFactor]: dart.fieldType(core.num)
>+}));
>+dart.registerExtension("PannerNode", web_audio.PannerNode);
>+dart.registerExtension("AudioPannerNode", web_audio.PannerNode);
>+dart.registerExtension("webkitAudioPannerNode", web_audio.PannerNode);
>+web_audio.PeriodicWave = class PeriodicWave$ extends _interceptors.Interceptor {
>+  static new(context, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      return web_audio.PeriodicWave._create_1(context, options_1);
>+    }
>+    return web_audio.PeriodicWave._create_2(context);
>+  }
>+  static _create_1(context, options) {
>+    return new PeriodicWave(context, options);
>+  }
>+  static _create_2(context) {
>+    return new PeriodicWave(context);
>+  }
>+};
>+dart.addTypeTests(web_audio.PeriodicWave);
>+dart.setLibraryUri(web_audio.PeriodicWave, "dart:web_audio");
>+dart.registerExtension("PeriodicWave", web_audio.PeriodicWave);
>+web_audio.ScriptProcessorNode = class ScriptProcessorNode extends web_audio.AudioNode {
>+  get [$bufferSize]() {
>+    return this.bufferSize;
>+  }
>+  [$setEventListener](...args) {
>+    return this.setEventListener.apply(this, args);
>+  }
>+  get [$onAudioProcess]() {
>+    return web_audio.ScriptProcessorNode.audioProcessEvent.forTarget(this);
>+  }
>+};
>+dart.addTypeTests(web_audio.ScriptProcessorNode);
>+const bufferSize = Symbol("ScriptProcessorNode.bufferSize");
>+dart.setMethodSignature(web_audio.ScriptProcessorNode, () => ({
>+  __proto__: dart.getMethods(web_audio.ScriptProcessorNode.__proto__),
>+  [$setEventListener]: dart.fnType(dart.void, [dart.fnType(dart.dynamic, [html$.Event])])
>+}));
>+dart.setGetterSignature(web_audio.ScriptProcessorNode, () => ({
>+  __proto__: dart.getGetters(web_audio.ScriptProcessorNode.__proto__),
>+  [$onAudioProcess]: async.Stream$(web_audio.AudioProcessingEvent)
>+}));
>+dart.setLibraryUri(web_audio.ScriptProcessorNode, "dart:web_audio");
>+dart.setFieldSignature(web_audio.ScriptProcessorNode, () => ({
>+  __proto__: dart.getFields(web_audio.ScriptProcessorNode.__proto__),
>+  [$bufferSize]: dart.finalFieldType(core.int)
>+}));
>+dart.defineLazy(web_audio.ScriptProcessorNode, {
>+  /*web_audio.ScriptProcessorNode.audioProcessEvent*/get audioProcessEvent() {
>+    return dart.const(new (EventStreamProviderOfAudioProcessingEvent()).new("audioprocess"));
>+  }
>+});
>+dart.registerExtension("ScriptProcessorNode", web_audio.ScriptProcessorNode);
>+dart.registerExtension("JavaScriptAudioNode", web_audio.ScriptProcessorNode);
>+web_audio.StereoPannerNode = class StereoPannerNode$ extends web_audio.AudioNode {
>+  static new(context, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      return web_audio.StereoPannerNode._create_1(context, options_1);
>+    }
>+    return web_audio.StereoPannerNode._create_2(context);
>+  }
>+  static _create_1(context, options) {
>+    return new StereoPannerNode(context, options);
>+  }
>+  static _create_2(context) {
>+    return new StereoPannerNode(context);
>+  }
>+  get [$pan]() {
>+    return this.pan;
>+  }
>+};
>+dart.addTypeTests(web_audio.StereoPannerNode);
>+const pan = Symbol("StereoPannerNode.pan");
>+dart.setLibraryUri(web_audio.StereoPannerNode, "dart:web_audio");
>+dart.setFieldSignature(web_audio.StereoPannerNode, () => ({
>+  __proto__: dart.getFields(web_audio.StereoPannerNode.__proto__),
>+  [$pan]: dart.finalFieldType(web_audio.AudioParam)
>+}));
>+dart.registerExtension("StereoPannerNode", web_audio.StereoPannerNode);
>+web_audio.WaveShaperNode = class WaveShaperNode$ extends web_audio.AudioNode {
>+  static new(context, options) {
>+    if (options === void 0) options = null;
>+    if (options != null) {
>+      let options_1 = html_common.convertDartToNative_Dictionary(options);
>+      return web_audio.WaveShaperNode._create_1(context, options_1);
>+    }
>+    return web_audio.WaveShaperNode._create_2(context);
>+  }
>+  static _create_1(context, options) {
>+    return new WaveShaperNode(context, options);
>+  }
>+  static _create_2(context) {
>+    return new WaveShaperNode(context);
>+  }
>+  get [$curve]() {
>+    return this.curve;
>+  }
>+  set [$curve](value) {
>+    this.curve = value;
>+  }
>+  get [$oversample]() {
>+    return this.oversample;
>+  }
>+  set [$oversample](value) {
>+    this.oversample = value;
>+  }
>+};
>+dart.addTypeTests(web_audio.WaveShaperNode);
>+const curve = Symbol("WaveShaperNode.curve");
>+const oversample = Symbol("WaveShaperNode.oversample");
>+dart.setLibraryUri(web_audio.WaveShaperNode, "dart:web_audio");
>+dart.setFieldSignature(web_audio.WaveShaperNode, () => ({
>+  __proto__: dart.getFields(web_audio.WaveShaperNode.__proto__),
>+  [$curve]: dart.fieldType(typed_data.Float32List),
>+  [$oversample]: dart.fieldType(core.String)
>+}));
>+dart.registerExtension("WaveShaperNode", web_audio.WaveShaperNode);
>+web_gl.ActiveInfo = class ActiveInfo extends _interceptors.Interceptor {
>+  get [$name]() {
>+    return this.name;
>+  }
>+  get [$size]() {
>+    return this.size;
>+  }
>+  get [$type]() {
>+    return this.type;
>+  }
>+};
>+dart.addTypeTests(web_gl.ActiveInfo);
>+const name$40 = Symbol("ActiveInfo.name");
>+const size$7 = Symbol("ActiveInfo.size");
>+const type$44 = Symbol("ActiveInfo.type");
>+dart.setLibraryUri(web_gl.ActiveInfo, "dart:web_gl");
>+dart.setFieldSignature(web_gl.ActiveInfo, () => ({
>+  __proto__: dart.getFields(web_gl.ActiveInfo.__proto__),
>+  [$name]: dart.finalFieldType(core.String),
>+  [$size]: dart.finalFieldType(core.int),
>+  [$type]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("WebGLActiveInfo", web_gl.ActiveInfo);
>+web_gl.AngleInstancedArrays = class AngleInstancedArrays extends _interceptors.Interceptor {
>+  [$drawArraysInstancedAngle](...args) {
>+    return this.drawArraysInstancedANGLE.apply(this, args);
>+  }
>+  [$drawElementsInstancedAngle](...args) {
>+    return this.drawElementsInstancedANGLE.apply(this, args);
>+  }
>+  [$vertexAttribDivisorAngle](...args) {
>+    return this.vertexAttribDivisorANGLE.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(web_gl.AngleInstancedArrays);
>+dart.setMethodSignature(web_gl.AngleInstancedArrays, () => ({
>+  __proto__: dart.getMethods(web_gl.AngleInstancedArrays.__proto__),
>+  [$drawArraysInstancedAngle]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int]),
>+  [$drawElementsInstancedAngle]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int]),
>+  [$vertexAttribDivisorAngle]: dart.fnType(dart.void, [core.int, core.int])
>+}));
>+dart.setLibraryUri(web_gl.AngleInstancedArrays, "dart:web_gl");
>+dart.defineLazy(web_gl.AngleInstancedArrays, {
>+  /*web_gl.AngleInstancedArrays.VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE*/get VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE() {
>+    return 35070;
>+  }
>+});
>+dart.registerExtension("ANGLEInstancedArrays", web_gl.AngleInstancedArrays);
>+dart.registerExtension("ANGLE_instanced_arrays", web_gl.AngleInstancedArrays);
>+web_gl.Buffer = class Buffer extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.Buffer);
>+dart.setLibraryUri(web_gl.Buffer, "dart:web_gl");
>+dart.registerExtension("WebGLBuffer", web_gl.Buffer);
>+web_gl.Canvas = class Canvas extends _interceptors.Interceptor {
>+  get [$canvas]() {
>+    return this.canvas;
>+  }
>+  get [$offscreenCanvas]() {
>+    return this.canvas;
>+  }
>+};
>+dart.addTypeTests(web_gl.Canvas);
>+const canvas$2 = Symbol("Canvas.canvas");
>+const offscreenCanvas = Symbol("Canvas.offscreenCanvas");
>+dart.setLibraryUri(web_gl.Canvas, "dart:web_gl");
>+dart.setFieldSignature(web_gl.Canvas, () => ({
>+  __proto__: dart.getFields(web_gl.Canvas.__proto__),
>+  [$canvas]: dart.finalFieldType(html$.CanvasElement),
>+  [$offscreenCanvas]: dart.finalFieldType(html$.OffscreenCanvas)
>+}));
>+dart.registerExtension("WebGLCanvas", web_gl.Canvas);
>+web_gl.ColorBufferFloat = class ColorBufferFloat extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.ColorBufferFloat);
>+dart.setLibraryUri(web_gl.ColorBufferFloat, "dart:web_gl");
>+dart.registerExtension("WebGLColorBufferFloat", web_gl.ColorBufferFloat);
>+web_gl.CompressedTextureAstc = class CompressedTextureAstc extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.CompressedTextureAstc);
>+dart.setLibraryUri(web_gl.CompressedTextureAstc, "dart:web_gl");
>+dart.defineLazy(web_gl.CompressedTextureAstc, {
>+  /*web_gl.CompressedTextureAstc.COMPRESSED_RGBA_ASTC_10x10_KHR*/get COMPRESSED_RGBA_ASTC_10x10_KHR() {
>+    return 37819;
>+  },
>+  /*web_gl.CompressedTextureAstc.COMPRESSED_RGBA_ASTC_10x5_KHR*/get COMPRESSED_RGBA_ASTC_10x5_KHR() {
>+    return 37816;
>+  },
>+  /*web_gl.CompressedTextureAstc.COMPRESSED_RGBA_ASTC_10x6_KHR*/get COMPRESSED_RGBA_ASTC_10x6_KHR() {
>+    return 37817;
>+  },
>+  /*web_gl.CompressedTextureAstc.COMPRESSED_RGBA_ASTC_10x8_KHR*/get COMPRESSED_RGBA_ASTC_10x8_KHR() {
>+    return 37818;
>+  },
>+  /*web_gl.CompressedTextureAstc.COMPRESSED_RGBA_ASTC_12x10_KHR*/get COMPRESSED_RGBA_ASTC_12x10_KHR() {
>+    return 37820;
>+  },
>+  /*web_gl.CompressedTextureAstc.COMPRESSED_RGBA_ASTC_12x12_KHR*/get COMPRESSED_RGBA_ASTC_12x12_KHR() {
>+    return 37821;
>+  },
>+  /*web_gl.CompressedTextureAstc.COMPRESSED_RGBA_ASTC_4x4_KHR*/get COMPRESSED_RGBA_ASTC_4x4_KHR() {
>+    return 37808;
>+  },
>+  /*web_gl.CompressedTextureAstc.COMPRESSED_RGBA_ASTC_5x4_KHR*/get COMPRESSED_RGBA_ASTC_5x4_KHR() {
>+    return 37809;
>+  },
>+  /*web_gl.CompressedTextureAstc.COMPRESSED_RGBA_ASTC_5x5_KHR*/get COMPRESSED_RGBA_ASTC_5x5_KHR() {
>+    return 37810;
>+  },
>+  /*web_gl.CompressedTextureAstc.COMPRESSED_RGBA_ASTC_6x5_KHR*/get COMPRESSED_RGBA_ASTC_6x5_KHR() {
>+    return 37811;
>+  },
>+  /*web_gl.CompressedTextureAstc.COMPRESSED_RGBA_ASTC_6x6_KHR*/get COMPRESSED_RGBA_ASTC_6x6_KHR() {
>+    return 37812;
>+  },
>+  /*web_gl.CompressedTextureAstc.COMPRESSED_RGBA_ASTC_8x5_KHR*/get COMPRESSED_RGBA_ASTC_8x5_KHR() {
>+    return 37813;
>+  },
>+  /*web_gl.CompressedTextureAstc.COMPRESSED_RGBA_ASTC_8x6_KHR*/get COMPRESSED_RGBA_ASTC_8x6_KHR() {
>+    return 37814;
>+  },
>+  /*web_gl.CompressedTextureAstc.COMPRESSED_RGBA_ASTC_8x8_KHR*/get COMPRESSED_RGBA_ASTC_8x8_KHR() {
>+    return 37815;
>+  },
>+  /*web_gl.CompressedTextureAstc.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR*/get COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR() {
>+    return 37851;
>+  },
>+  /*web_gl.CompressedTextureAstc.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR*/get COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR() {
>+    return 37848;
>+  },
>+  /*web_gl.CompressedTextureAstc.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR*/get COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR() {
>+    return 37849;
>+  },
>+  /*web_gl.CompressedTextureAstc.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR*/get COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR() {
>+    return 37850;
>+  },
>+  /*web_gl.CompressedTextureAstc.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR*/get COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR() {
>+    return 37852;
>+  },
>+  /*web_gl.CompressedTextureAstc.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR*/get COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR() {
>+    return 37853;
>+  },
>+  /*web_gl.CompressedTextureAstc.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR*/get COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR() {
>+    return 37840;
>+  },
>+  /*web_gl.CompressedTextureAstc.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR*/get COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR() {
>+    return 37841;
>+  },
>+  /*web_gl.CompressedTextureAstc.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR*/get COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR() {
>+    return 37842;
>+  },
>+  /*web_gl.CompressedTextureAstc.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR*/get COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR() {
>+    return 37843;
>+  },
>+  /*web_gl.CompressedTextureAstc.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR*/get COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR() {
>+    return 37844;
>+  },
>+  /*web_gl.CompressedTextureAstc.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR*/get COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR() {
>+    return 37845;
>+  },
>+  /*web_gl.CompressedTextureAstc.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR*/get COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR() {
>+    return 37846;
>+  },
>+  /*web_gl.CompressedTextureAstc.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR*/get COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR() {
>+    return 37847;
>+  }
>+});
>+dart.registerExtension("WebGLCompressedTextureASTC", web_gl.CompressedTextureAstc);
>+web_gl.CompressedTextureAtc = class CompressedTextureAtc extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.CompressedTextureAtc);
>+dart.setLibraryUri(web_gl.CompressedTextureAtc, "dart:web_gl");
>+dart.defineLazy(web_gl.CompressedTextureAtc, {
>+  /*web_gl.CompressedTextureAtc.COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL*/get COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL() {
>+    return 35987;
>+  },
>+  /*web_gl.CompressedTextureAtc.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL*/get COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL() {
>+    return 34798;
>+  },
>+  /*web_gl.CompressedTextureAtc.COMPRESSED_RGB_ATC_WEBGL*/get COMPRESSED_RGB_ATC_WEBGL() {
>+    return 35986;
>+  }
>+});
>+dart.registerExtension("WebGLCompressedTextureATC", web_gl.CompressedTextureAtc);
>+dart.registerExtension("WEBGL_compressed_texture_atc", web_gl.CompressedTextureAtc);
>+web_gl.CompressedTextureETC1 = class CompressedTextureETC1 extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.CompressedTextureETC1);
>+dart.setLibraryUri(web_gl.CompressedTextureETC1, "dart:web_gl");
>+dart.defineLazy(web_gl.CompressedTextureETC1, {
>+  /*web_gl.CompressedTextureETC1.COMPRESSED_RGB_ETC1_WEBGL*/get COMPRESSED_RGB_ETC1_WEBGL() {
>+    return 36196;
>+  }
>+});
>+dart.registerExtension("WebGLCompressedTextureETC1", web_gl.CompressedTextureETC1);
>+dart.registerExtension("WEBGL_compressed_texture_etc1", web_gl.CompressedTextureETC1);
>+web_gl.CompressedTextureEtc = class CompressedTextureEtc extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.CompressedTextureEtc);
>+dart.setLibraryUri(web_gl.CompressedTextureEtc, "dart:web_gl");
>+dart.defineLazy(web_gl.CompressedTextureEtc, {
>+  /*web_gl.CompressedTextureEtc.COMPRESSED_R11_EAC*/get COMPRESSED_R11_EAC() {
>+    return 37488;
>+  },
>+  /*web_gl.CompressedTextureEtc.COMPRESSED_RG11_EAC*/get COMPRESSED_RG11_EAC() {
>+    return 37490;
>+  },
>+  /*web_gl.CompressedTextureEtc.COMPRESSED_RGB8_ETC2*/get COMPRESSED_RGB8_ETC2() {
>+    return 37492;
>+  },
>+  /*web_gl.CompressedTextureEtc.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2*/get COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2() {
>+    return 37494;
>+  },
>+  /*web_gl.CompressedTextureEtc.COMPRESSED_RGBA8_ETC2_EAC*/get COMPRESSED_RGBA8_ETC2_EAC() {
>+    return 37496;
>+  },
>+  /*web_gl.CompressedTextureEtc.COMPRESSED_SIGNED_R11_EAC*/get COMPRESSED_SIGNED_R11_EAC() {
>+    return 37489;
>+  },
>+  /*web_gl.CompressedTextureEtc.COMPRESSED_SIGNED_RG11_EAC*/get COMPRESSED_SIGNED_RG11_EAC() {
>+    return 37491;
>+  },
>+  /*web_gl.CompressedTextureEtc.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC*/get COMPRESSED_SRGB8_ALPHA8_ETC2_EAC() {
>+    return 37497;
>+  },
>+  /*web_gl.CompressedTextureEtc.COMPRESSED_SRGB8_ETC2*/get COMPRESSED_SRGB8_ETC2() {
>+    return 37493;
>+  },
>+  /*web_gl.CompressedTextureEtc.COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2*/get COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2() {
>+    return 37495;
>+  }
>+});
>+dart.registerExtension("WebGLCompressedTextureETC", web_gl.CompressedTextureEtc);
>+web_gl.CompressedTexturePvrtc = class CompressedTexturePvrtc extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.CompressedTexturePvrtc);
>+dart.setLibraryUri(web_gl.CompressedTexturePvrtc, "dart:web_gl");
>+dart.defineLazy(web_gl.CompressedTexturePvrtc, {
>+  /*web_gl.CompressedTexturePvrtc.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG*/get COMPRESSED_RGBA_PVRTC_2BPPV1_IMG() {
>+    return 35843;
>+  },
>+  /*web_gl.CompressedTexturePvrtc.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG*/get COMPRESSED_RGBA_PVRTC_4BPPV1_IMG() {
>+    return 35842;
>+  },
>+  /*web_gl.CompressedTexturePvrtc.COMPRESSED_RGB_PVRTC_2BPPV1_IMG*/get COMPRESSED_RGB_PVRTC_2BPPV1_IMG() {
>+    return 35841;
>+  },
>+  /*web_gl.CompressedTexturePvrtc.COMPRESSED_RGB_PVRTC_4BPPV1_IMG*/get COMPRESSED_RGB_PVRTC_4BPPV1_IMG() {
>+    return 35840;
>+  }
>+});
>+dart.registerExtension("WebGLCompressedTexturePVRTC", web_gl.CompressedTexturePvrtc);
>+dart.registerExtension("WEBGL_compressed_texture_pvrtc", web_gl.CompressedTexturePvrtc);
>+web_gl.CompressedTextureS3TC = class CompressedTextureS3TC extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.CompressedTextureS3TC);
>+dart.setLibraryUri(web_gl.CompressedTextureS3TC, "dart:web_gl");
>+dart.defineLazy(web_gl.CompressedTextureS3TC, {
>+  /*web_gl.CompressedTextureS3TC.COMPRESSED_RGBA_S3TC_DXT1_EXT*/get COMPRESSED_RGBA_S3TC_DXT1_EXT() {
>+    return 33777;
>+  },
>+  /*web_gl.CompressedTextureS3TC.COMPRESSED_RGBA_S3TC_DXT3_EXT*/get COMPRESSED_RGBA_S3TC_DXT3_EXT() {
>+    return 33778;
>+  },
>+  /*web_gl.CompressedTextureS3TC.COMPRESSED_RGBA_S3TC_DXT5_EXT*/get COMPRESSED_RGBA_S3TC_DXT5_EXT() {
>+    return 33779;
>+  },
>+  /*web_gl.CompressedTextureS3TC.COMPRESSED_RGB_S3TC_DXT1_EXT*/get COMPRESSED_RGB_S3TC_DXT1_EXT() {
>+    return 33776;
>+  }
>+});
>+dart.registerExtension("WebGLCompressedTextureS3TC", web_gl.CompressedTextureS3TC);
>+dart.registerExtension("WEBGL_compressed_texture_s3tc", web_gl.CompressedTextureS3TC);
>+web_gl.CompressedTextureS3TCsRgb = class CompressedTextureS3TCsRgb extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.CompressedTextureS3TCsRgb);
>+dart.setLibraryUri(web_gl.CompressedTextureS3TCsRgb, "dart:web_gl");
>+dart.defineLazy(web_gl.CompressedTextureS3TCsRgb, {
>+  /*web_gl.CompressedTextureS3TCsRgb.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT*/get COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT() {
>+    return 35917;
>+  },
>+  /*web_gl.CompressedTextureS3TCsRgb.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT*/get COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT() {
>+    return 35918;
>+  },
>+  /*web_gl.CompressedTextureS3TCsRgb.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT*/get COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT() {
>+    return 35919;
>+  },
>+  /*web_gl.CompressedTextureS3TCsRgb.COMPRESSED_SRGB_S3TC_DXT1_EXT*/get COMPRESSED_SRGB_S3TC_DXT1_EXT() {
>+    return 35916;
>+  }
>+});
>+dart.registerExtension("WebGLCompressedTextureS3TCsRGB", web_gl.CompressedTextureS3TCsRgb);
>+web_gl.ContextEvent = class ContextEvent extends html$.Event {
>+  static new(type, eventInit) {
>+    if (eventInit === void 0) eventInit = null;
>+    if (eventInit != null) {
>+      let eventInit_1 = html_common.convertDartToNative_Dictionary(eventInit);
>+      return web_gl.ContextEvent._create_1(type, eventInit_1);
>+    }
>+    return web_gl.ContextEvent._create_2(type);
>+  }
>+  static _create_1(type, eventInit) {
>+    return new WebGLContextEvent(type, eventInit);
>+  }
>+  static _create_2(type) {
>+    return new WebGLContextEvent(type);
>+  }
>+  get [$statusMessage]() {
>+    return this.statusMessage;
>+  }
>+};
>+dart.addTypeTests(web_gl.ContextEvent);
>+const statusMessage = Symbol("ContextEvent.statusMessage");
>+dart.setLibraryUri(web_gl.ContextEvent, "dart:web_gl");
>+dart.setFieldSignature(web_gl.ContextEvent, () => ({
>+  __proto__: dart.getFields(web_gl.ContextEvent.__proto__),
>+  [$statusMessage]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("WebGLContextEvent", web_gl.ContextEvent);
>+web_gl.DebugRendererInfo = class DebugRendererInfo extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.DebugRendererInfo);
>+dart.setLibraryUri(web_gl.DebugRendererInfo, "dart:web_gl");
>+dart.defineLazy(web_gl.DebugRendererInfo, {
>+  /*web_gl.DebugRendererInfo.UNMASKED_RENDERER_WEBGL*/get UNMASKED_RENDERER_WEBGL() {
>+    return 37446;
>+  },
>+  /*web_gl.DebugRendererInfo.UNMASKED_VENDOR_WEBGL*/get UNMASKED_VENDOR_WEBGL() {
>+    return 37445;
>+  }
>+});
>+dart.registerExtension("WebGLDebugRendererInfo", web_gl.DebugRendererInfo);
>+dart.registerExtension("WEBGL_debug_renderer_info", web_gl.DebugRendererInfo);
>+web_gl.DebugShaders = class DebugShaders extends _interceptors.Interceptor {
>+  [$getTranslatedShaderSource](...args) {
>+    return this.getTranslatedShaderSource.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(web_gl.DebugShaders);
>+dart.setMethodSignature(web_gl.DebugShaders, () => ({
>+  __proto__: dart.getMethods(web_gl.DebugShaders.__proto__),
>+  [$getTranslatedShaderSource]: dart.fnType(core.String, [web_gl.Shader])
>+}));
>+dart.setLibraryUri(web_gl.DebugShaders, "dart:web_gl");
>+dart.registerExtension("WebGLDebugShaders", web_gl.DebugShaders);
>+dart.registerExtension("WEBGL_debug_shaders", web_gl.DebugShaders);
>+web_gl.DepthTexture = class DepthTexture extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.DepthTexture);
>+dart.setLibraryUri(web_gl.DepthTexture, "dart:web_gl");
>+dart.defineLazy(web_gl.DepthTexture, {
>+  /*web_gl.DepthTexture.UNSIGNED_INT_24_8_WEBGL*/get UNSIGNED_INT_24_8_WEBGL() {
>+    return 34042;
>+  }
>+});
>+dart.registerExtension("WebGLDepthTexture", web_gl.DepthTexture);
>+dart.registerExtension("WEBGL_depth_texture", web_gl.DepthTexture);
>+web_gl.DrawBuffers = class DrawBuffers extends _interceptors.Interceptor {
>+  [$drawBuffersWebgl](...args) {
>+    return this.drawBuffersWEBGL.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(web_gl.DrawBuffers);
>+dart.setMethodSignature(web_gl.DrawBuffers, () => ({
>+  __proto__: dart.getMethods(web_gl.DrawBuffers.__proto__),
>+  [$drawBuffersWebgl]: dart.fnType(dart.void, [core.List$(core.int)])
>+}));
>+dart.setLibraryUri(web_gl.DrawBuffers, "dart:web_gl");
>+dart.registerExtension("WebGLDrawBuffers", web_gl.DrawBuffers);
>+dart.registerExtension("WEBGL_draw_buffers", web_gl.DrawBuffers);
>+web_gl.EXTsRgb = class EXTsRgb extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.EXTsRgb);
>+dart.setLibraryUri(web_gl.EXTsRgb, "dart:web_gl");
>+dart.defineLazy(web_gl.EXTsRgb, {
>+  /*web_gl.EXTsRgb.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT*/get FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT() {
>+    return 33296;
>+  },
>+  /*web_gl.EXTsRgb.SRGB8_ALPHA8_EXT*/get SRGB8_ALPHA8_EXT() {
>+    return 35907;
>+  },
>+  /*web_gl.EXTsRgb.SRGB_ALPHA_EXT*/get SRGB_ALPHA_EXT() {
>+    return 35906;
>+  },
>+  /*web_gl.EXTsRgb.SRGB_EXT*/get SRGB_EXT() {
>+    return 35904;
>+  }
>+});
>+dart.registerExtension("EXTsRGB", web_gl.EXTsRgb);
>+dart.registerExtension("EXT_sRGB", web_gl.EXTsRgb);
>+web_gl.ExtBlendMinMax = class ExtBlendMinMax extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.ExtBlendMinMax);
>+dart.setLibraryUri(web_gl.ExtBlendMinMax, "dart:web_gl");
>+dart.defineLazy(web_gl.ExtBlendMinMax, {
>+  /*web_gl.ExtBlendMinMax.MAX_EXT*/get MAX_EXT() {
>+    return 32776;
>+  },
>+  /*web_gl.ExtBlendMinMax.MIN_EXT*/get MIN_EXT() {
>+    return 32775;
>+  }
>+});
>+dart.registerExtension("EXTBlendMinMax", web_gl.ExtBlendMinMax);
>+dart.registerExtension("EXT_blend_minmax", web_gl.ExtBlendMinMax);
>+web_gl.ExtColorBufferFloat = class ExtColorBufferFloat extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.ExtColorBufferFloat);
>+dart.setLibraryUri(web_gl.ExtColorBufferFloat, "dart:web_gl");
>+dart.registerExtension("EXTColorBufferFloat", web_gl.ExtColorBufferFloat);
>+web_gl.ExtColorBufferHalfFloat = class ExtColorBufferHalfFloat extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.ExtColorBufferHalfFloat);
>+dart.setLibraryUri(web_gl.ExtColorBufferHalfFloat, "dart:web_gl");
>+dart.registerExtension("EXTColorBufferHalfFloat", web_gl.ExtColorBufferHalfFloat);
>+web_gl.ExtDisjointTimerQuery = class ExtDisjointTimerQuery extends _interceptors.Interceptor {
>+  [$beginQueryExt](...args) {
>+    return this.beginQueryEXT.apply(this, args);
>+  }
>+  [$createQueryExt](...args) {
>+    return this.createQueryEXT.apply(this, args);
>+  }
>+  [$deleteQueryExt](...args) {
>+    return this.deleteQueryEXT.apply(this, args);
>+  }
>+  [$endQueryExt](...args) {
>+    return this.endQueryEXT.apply(this, args);
>+  }
>+  [$getQueryExt](...args) {
>+    return this.getQueryEXT.apply(this, args);
>+  }
>+  [$getQueryObjectExt](...args) {
>+    return this.getQueryObjectEXT.apply(this, args);
>+  }
>+  [$isQueryExt](...args) {
>+    return this.isQueryEXT.apply(this, args);
>+  }
>+  [$queryCounterExt](...args) {
>+    return this.queryCounterEXT.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(web_gl.ExtDisjointTimerQuery);
>+dart.setMethodSignature(web_gl.ExtDisjointTimerQuery, () => ({
>+  __proto__: dart.getMethods(web_gl.ExtDisjointTimerQuery.__proto__),
>+  [$beginQueryExt]: dart.fnType(dart.void, [core.int, web_gl.TimerQueryExt]),
>+  [$createQueryExt]: dart.fnType(web_gl.TimerQueryExt, []),
>+  [$deleteQueryExt]: dart.fnType(dart.void, [web_gl.TimerQueryExt]),
>+  [$endQueryExt]: dart.fnType(dart.void, [core.int]),
>+  [$getQueryExt]: dart.fnType(core.Object, [core.int, core.int]),
>+  [$getQueryObjectExt]: dart.fnType(core.Object, [web_gl.TimerQueryExt, core.int]),
>+  [$isQueryExt]: dart.fnType(core.bool, [web_gl.TimerQueryExt]),
>+  [$queryCounterExt]: dart.fnType(dart.void, [web_gl.TimerQueryExt, core.int])
>+}));
>+dart.setLibraryUri(web_gl.ExtDisjointTimerQuery, "dart:web_gl");
>+dart.defineLazy(web_gl.ExtDisjointTimerQuery, {
>+  /*web_gl.ExtDisjointTimerQuery.CURRENT_QUERY_EXT*/get CURRENT_QUERY_EXT() {
>+    return 34917;
>+  },
>+  /*web_gl.ExtDisjointTimerQuery.GPU_DISJOINT_EXT*/get GPU_DISJOINT_EXT() {
>+    return 36795;
>+  },
>+  /*web_gl.ExtDisjointTimerQuery.QUERY_COUNTER_BITS_EXT*/get QUERY_COUNTER_BITS_EXT() {
>+    return 34916;
>+  },
>+  /*web_gl.ExtDisjointTimerQuery.QUERY_RESULT_AVAILABLE_EXT*/get QUERY_RESULT_AVAILABLE_EXT() {
>+    return 34919;
>+  },
>+  /*web_gl.ExtDisjointTimerQuery.QUERY_RESULT_EXT*/get QUERY_RESULT_EXT() {
>+    return 34918;
>+  },
>+  /*web_gl.ExtDisjointTimerQuery.TIMESTAMP_EXT*/get TIMESTAMP_EXT() {
>+    return 36392;
>+  },
>+  /*web_gl.ExtDisjointTimerQuery.TIME_ELAPSED_EXT*/get TIME_ELAPSED_EXT() {
>+    return 35007;
>+  }
>+});
>+dart.registerExtension("EXTDisjointTimerQuery", web_gl.ExtDisjointTimerQuery);
>+web_gl.ExtDisjointTimerQueryWebGL2 = class ExtDisjointTimerQueryWebGL2 extends _interceptors.Interceptor {
>+  [$queryCounterExt](...args) {
>+    return this.queryCounterEXT.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(web_gl.ExtDisjointTimerQueryWebGL2);
>+dart.setMethodSignature(web_gl.ExtDisjointTimerQueryWebGL2, () => ({
>+  __proto__: dart.getMethods(web_gl.ExtDisjointTimerQueryWebGL2.__proto__),
>+  [$queryCounterExt]: dart.fnType(dart.void, [web_gl.Query, core.int])
>+}));
>+dart.setLibraryUri(web_gl.ExtDisjointTimerQueryWebGL2, "dart:web_gl");
>+dart.defineLazy(web_gl.ExtDisjointTimerQueryWebGL2, {
>+  /*web_gl.ExtDisjointTimerQueryWebGL2.GPU_DISJOINT_EXT*/get GPU_DISJOINT_EXT() {
>+    return 36795;
>+  },
>+  /*web_gl.ExtDisjointTimerQueryWebGL2.QUERY_COUNTER_BITS_EXT*/get QUERY_COUNTER_BITS_EXT() {
>+    return 34916;
>+  },
>+  /*web_gl.ExtDisjointTimerQueryWebGL2.TIMESTAMP_EXT*/get TIMESTAMP_EXT() {
>+    return 36392;
>+  },
>+  /*web_gl.ExtDisjointTimerQueryWebGL2.TIME_ELAPSED_EXT*/get TIME_ELAPSED_EXT() {
>+    return 35007;
>+  }
>+});
>+dart.registerExtension("EXTDisjointTimerQueryWebGL2", web_gl.ExtDisjointTimerQueryWebGL2);
>+web_gl.ExtFragDepth = class ExtFragDepth extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.ExtFragDepth);
>+dart.setLibraryUri(web_gl.ExtFragDepth, "dart:web_gl");
>+dart.registerExtension("EXTFragDepth", web_gl.ExtFragDepth);
>+dart.registerExtension("EXT_frag_depth", web_gl.ExtFragDepth);
>+web_gl.ExtShaderTextureLod = class ExtShaderTextureLod extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.ExtShaderTextureLod);
>+dart.setLibraryUri(web_gl.ExtShaderTextureLod, "dart:web_gl");
>+dart.registerExtension("EXTShaderTextureLOD", web_gl.ExtShaderTextureLod);
>+dart.registerExtension("EXT_shader_texture_lod", web_gl.ExtShaderTextureLod);
>+web_gl.ExtTextureFilterAnisotropic = class ExtTextureFilterAnisotropic extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.ExtTextureFilterAnisotropic);
>+dart.setLibraryUri(web_gl.ExtTextureFilterAnisotropic, "dart:web_gl");
>+dart.defineLazy(web_gl.ExtTextureFilterAnisotropic, {
>+  /*web_gl.ExtTextureFilterAnisotropic.MAX_TEXTURE_MAX_ANISOTROPY_EXT*/get MAX_TEXTURE_MAX_ANISOTROPY_EXT() {
>+    return 34047;
>+  },
>+  /*web_gl.ExtTextureFilterAnisotropic.TEXTURE_MAX_ANISOTROPY_EXT*/get TEXTURE_MAX_ANISOTROPY_EXT() {
>+    return 34046;
>+  }
>+});
>+dart.registerExtension("EXTTextureFilterAnisotropic", web_gl.ExtTextureFilterAnisotropic);
>+dart.registerExtension("EXT_texture_filter_anisotropic", web_gl.ExtTextureFilterAnisotropic);
>+web_gl.Framebuffer = class Framebuffer extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.Framebuffer);
>+dart.setLibraryUri(web_gl.Framebuffer, "dart:web_gl");
>+dart.registerExtension("WebGLFramebuffer", web_gl.Framebuffer);
>+web_gl.GetBufferSubDataAsync = class GetBufferSubDataAsync extends _interceptors.Interceptor {
>+  [$getBufferSubDataAsync](target, srcByteOffset, dstData, dstOffset, length) {
>+    if (dstOffset === void 0) dstOffset = null;
>+    if (length === void 0) length = null;
>+    return html$.promiseToFuture(dart.dynamic, this.getBufferSubDataAsync(target, srcByteOffset, dstData, dstOffset, length));
>+  }
>+};
>+dart.addTypeTests(web_gl.GetBufferSubDataAsync);
>+dart.setMethodSignature(web_gl.GetBufferSubDataAsync, () => ({
>+  __proto__: dart.getMethods(web_gl.GetBufferSubDataAsync.__proto__),
>+  [$getBufferSubDataAsync]: dart.fnType(async.Future, [core.int, core.int, typed_data.TypedData], [core.int, core.int])
>+}));
>+dart.setLibraryUri(web_gl.GetBufferSubDataAsync, "dart:web_gl");
>+dart.registerExtension("WebGLGetBufferSubDataAsync", web_gl.GetBufferSubDataAsync);
>+web_gl.LoseContext = class LoseContext extends _interceptors.Interceptor {
>+  [$loseContext](...args) {
>+    return this.loseContext.apply(this, args);
>+  }
>+  [$restoreContext](...args) {
>+    return this.restoreContext.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(web_gl.LoseContext);
>+dart.setMethodSignature(web_gl.LoseContext, () => ({
>+  __proto__: dart.getMethods(web_gl.LoseContext.__proto__),
>+  [$loseContext]: dart.fnType(dart.void, []),
>+  [$restoreContext]: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(web_gl.LoseContext, "dart:web_gl");
>+dart.registerExtension("WebGLLoseContext", web_gl.LoseContext);
>+dart.registerExtension("WebGLExtensionLoseContext", web_gl.LoseContext);
>+dart.registerExtension("WEBGL_lose_context", web_gl.LoseContext);
>+web_gl.OesElementIndexUint = class OesElementIndexUint extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.OesElementIndexUint);
>+dart.setLibraryUri(web_gl.OesElementIndexUint, "dart:web_gl");
>+dart.registerExtension("OESElementIndexUint", web_gl.OesElementIndexUint);
>+dart.registerExtension("OES_element_index_uint", web_gl.OesElementIndexUint);
>+web_gl.OesStandardDerivatives = class OesStandardDerivatives extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.OesStandardDerivatives);
>+dart.setLibraryUri(web_gl.OesStandardDerivatives, "dart:web_gl");
>+dart.defineLazy(web_gl.OesStandardDerivatives, {
>+  /*web_gl.OesStandardDerivatives.FRAGMENT_SHADER_DERIVATIVE_HINT_OES*/get FRAGMENT_SHADER_DERIVATIVE_HINT_OES() {
>+    return 35723;
>+  }
>+});
>+dart.registerExtension("OESStandardDerivatives", web_gl.OesStandardDerivatives);
>+dart.registerExtension("OES_standard_derivatives", web_gl.OesStandardDerivatives);
>+web_gl.OesTextureFloat = class OesTextureFloat extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.OesTextureFloat);
>+dart.setLibraryUri(web_gl.OesTextureFloat, "dart:web_gl");
>+dart.registerExtension("OESTextureFloat", web_gl.OesTextureFloat);
>+dart.registerExtension("OES_texture_float", web_gl.OesTextureFloat);
>+web_gl.OesTextureFloatLinear = class OesTextureFloatLinear extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.OesTextureFloatLinear);
>+dart.setLibraryUri(web_gl.OesTextureFloatLinear, "dart:web_gl");
>+dart.registerExtension("OESTextureFloatLinear", web_gl.OesTextureFloatLinear);
>+dart.registerExtension("OES_texture_float_linear", web_gl.OesTextureFloatLinear);
>+web_gl.OesTextureHalfFloat = class OesTextureHalfFloat extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.OesTextureHalfFloat);
>+dart.setLibraryUri(web_gl.OesTextureHalfFloat, "dart:web_gl");
>+dart.defineLazy(web_gl.OesTextureHalfFloat, {
>+  /*web_gl.OesTextureHalfFloat.HALF_FLOAT_OES*/get HALF_FLOAT_OES() {
>+    return 36193;
>+  }
>+});
>+dart.registerExtension("OESTextureHalfFloat", web_gl.OesTextureHalfFloat);
>+dart.registerExtension("OES_texture_half_float", web_gl.OesTextureHalfFloat);
>+web_gl.OesTextureHalfFloatLinear = class OesTextureHalfFloatLinear extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.OesTextureHalfFloatLinear);
>+dart.setLibraryUri(web_gl.OesTextureHalfFloatLinear, "dart:web_gl");
>+dart.registerExtension("OESTextureHalfFloatLinear", web_gl.OesTextureHalfFloatLinear);
>+dart.registerExtension("OES_texture_half_float_linear", web_gl.OesTextureHalfFloatLinear);
>+web_gl.OesVertexArrayObject = class OesVertexArrayObject extends _interceptors.Interceptor {
>+  [$bindVertexArray](...args) {
>+    return this.bindVertexArrayOES.apply(this, args);
>+  }
>+  [$createVertexArray](...args) {
>+    return this.createVertexArrayOES.apply(this, args);
>+  }
>+  [$deleteVertexArray](...args) {
>+    return this.deleteVertexArrayOES.apply(this, args);
>+  }
>+  [$isVertexArray](...args) {
>+    return this.isVertexArrayOES.apply(this, args);
>+  }
>+};
>+dart.addTypeTests(web_gl.OesVertexArrayObject);
>+dart.setMethodSignature(web_gl.OesVertexArrayObject, () => ({
>+  __proto__: dart.getMethods(web_gl.OesVertexArrayObject.__proto__),
>+  [$bindVertexArray]: dart.fnType(dart.void, [web_gl.VertexArrayObjectOes]),
>+  [$createVertexArray]: dart.fnType(web_gl.VertexArrayObjectOes, []),
>+  [$deleteVertexArray]: dart.fnType(dart.void, [web_gl.VertexArrayObjectOes]),
>+  [$isVertexArray]: dart.fnType(core.bool, [web_gl.VertexArrayObjectOes])
>+}));
>+dart.setLibraryUri(web_gl.OesVertexArrayObject, "dart:web_gl");
>+dart.defineLazy(web_gl.OesVertexArrayObject, {
>+  /*web_gl.OesVertexArrayObject.VERTEX_ARRAY_BINDING_OES*/get VERTEX_ARRAY_BINDING_OES() {
>+    return 34229;
>+  }
>+});
>+dart.registerExtension("OESVertexArrayObject", web_gl.OesVertexArrayObject);
>+dart.registerExtension("OES_vertex_array_object", web_gl.OesVertexArrayObject);
>+web_gl.Program = class Program extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.Program);
>+dart.setLibraryUri(web_gl.Program, "dart:web_gl");
>+dart.registerExtension("WebGLProgram", web_gl.Program);
>+web_gl.Query = class Query extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.Query);
>+dart.setLibraryUri(web_gl.Query, "dart:web_gl");
>+dart.registerExtension("WebGLQuery", web_gl.Query);
>+web_gl.Renderbuffer = class Renderbuffer extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.Renderbuffer);
>+dart.setLibraryUri(web_gl.Renderbuffer, "dart:web_gl");
>+dart.registerExtension("WebGLRenderbuffer", web_gl.Renderbuffer);
>+const _getContextAttributes_1$ = dart.privateName(web_gl, "_getContextAttributes_1");
>+const _readPixels = dart.privateName(web_gl, "_readPixels");
>+const _texImage2D_1 = dart.privateName(web_gl, "_texImage2D_1");
>+const _texImage2D_2 = dart.privateName(web_gl, "_texImage2D_2");
>+const _texImage2D_3 = dart.privateName(web_gl, "_texImage2D_3");
>+const _texImage2D_4 = dart.privateName(web_gl, "_texImage2D_4");
>+const _texImage2D_5 = dart.privateName(web_gl, "_texImage2D_5");
>+const _texImage2D_6 = dart.privateName(web_gl, "_texImage2D_6");
>+const _texSubImage2D_1 = dart.privateName(web_gl, "_texSubImage2D_1");
>+const _texSubImage2D_2 = dart.privateName(web_gl, "_texSubImage2D_2");
>+const _texSubImage2D_3 = dart.privateName(web_gl, "_texSubImage2D_3");
>+const _texSubImage2D_4 = dart.privateName(web_gl, "_texSubImage2D_4");
>+const _texSubImage2D_5 = dart.privateName(web_gl, "_texSubImage2D_5");
>+const _texSubImage2D_6 = dart.privateName(web_gl, "_texSubImage2D_6");
>+web_gl.RenderingContext = class RenderingContext extends _interceptors.Interceptor {
>+  static get supported() {
>+    return !!window.WebGLRenderingContext;
>+  }
>+  get [$canvas]() {
>+    return this.canvas;
>+  }
>+  get [$drawingBufferHeight]() {
>+    return this.drawingBufferHeight;
>+  }
>+  get [$drawingBufferWidth]() {
>+    return this.drawingBufferWidth;
>+  }
>+  [$activeTexture](...args) {
>+    return this.activeTexture.apply(this, args);
>+  }
>+  [$attachShader](...args) {
>+    return this.attachShader.apply(this, args);
>+  }
>+  [$bindAttribLocation](...args) {
>+    return this.bindAttribLocation.apply(this, args);
>+  }
>+  [$bindBuffer](...args) {
>+    return this.bindBuffer.apply(this, args);
>+  }
>+  [$bindFramebuffer](...args) {
>+    return this.bindFramebuffer.apply(this, args);
>+  }
>+  [$bindRenderbuffer](...args) {
>+    return this.bindRenderbuffer.apply(this, args);
>+  }
>+  [$bindTexture](...args) {
>+    return this.bindTexture.apply(this, args);
>+  }
>+  [$blendColor](...args) {
>+    return this.blendColor.apply(this, args);
>+  }
>+  [$blendEquation](...args) {
>+    return this.blendEquation.apply(this, args);
>+  }
>+  [$blendEquationSeparate](...args) {
>+    return this.blendEquationSeparate.apply(this, args);
>+  }
>+  [$blendFunc](...args) {
>+    return this.blendFunc.apply(this, args);
>+  }
>+  [$blendFuncSeparate](...args) {
>+    return this.blendFuncSeparate.apply(this, args);
>+  }
>+  [$bufferData](...args) {
>+    return this.bufferData.apply(this, args);
>+  }
>+  [$bufferSubData](...args) {
>+    return this.bufferSubData.apply(this, args);
>+  }
>+  [$checkFramebufferStatus](...args) {
>+    return this.checkFramebufferStatus.apply(this, args);
>+  }
>+  [$clear](...args) {
>+    return this.clear.apply(this, args);
>+  }
>+  [$clearColor](...args) {
>+    return this.clearColor.apply(this, args);
>+  }
>+  [$clearDepth](...args) {
>+    return this.clearDepth.apply(this, args);
>+  }
>+  [$clearStencil](...args) {
>+    return this.clearStencil.apply(this, args);
>+  }
>+  [$colorMask](...args) {
>+    return this.colorMask.apply(this, args);
>+  }
>+  [$commit]() {
>+    return html$.promiseToFuture(dart.dynamic, this.commit());
>+  }
>+  [$compileShader](...args) {
>+    return this.compileShader.apply(this, args);
>+  }
>+  [$compressedTexImage2D](...args) {
>+    return this.compressedTexImage2D.apply(this, args);
>+  }
>+  [$compressedTexSubImage2D](...args) {
>+    return this.compressedTexSubImage2D.apply(this, args);
>+  }
>+  [$copyTexImage2D](...args) {
>+    return this.copyTexImage2D.apply(this, args);
>+  }
>+  [$copyTexSubImage2D](...args) {
>+    return this.copyTexSubImage2D.apply(this, args);
>+  }
>+  [$createBuffer](...args) {
>+    return this.createBuffer.apply(this, args);
>+  }
>+  [$createFramebuffer](...args) {
>+    return this.createFramebuffer.apply(this, args);
>+  }
>+  [$createProgram](...args) {
>+    return this.createProgram.apply(this, args);
>+  }
>+  [$createRenderbuffer](...args) {
>+    return this.createRenderbuffer.apply(this, args);
>+  }
>+  [$createShader](...args) {
>+    return this.createShader.apply(this, args);
>+  }
>+  [$createTexture](...args) {
>+    return this.createTexture.apply(this, args);
>+  }
>+  [$cullFace](...args) {
>+    return this.cullFace.apply(this, args);
>+  }
>+  [$deleteBuffer](...args) {
>+    return this.deleteBuffer.apply(this, args);
>+  }
>+  [$deleteFramebuffer](...args) {
>+    return this.deleteFramebuffer.apply(this, args);
>+  }
>+  [$deleteProgram](...args) {
>+    return this.deleteProgram.apply(this, args);
>+  }
>+  [$deleteRenderbuffer](...args) {
>+    return this.deleteRenderbuffer.apply(this, args);
>+  }
>+  [$deleteShader](...args) {
>+    return this.deleteShader.apply(this, args);
>+  }
>+  [$deleteTexture](...args) {
>+    return this.deleteTexture.apply(this, args);
>+  }
>+  [$depthFunc](...args) {
>+    return this.depthFunc.apply(this, args);
>+  }
>+  [$depthMask](...args) {
>+    return this.depthMask.apply(this, args);
>+  }
>+  [$depthRange](...args) {
>+    return this.depthRange.apply(this, args);
>+  }
>+  [$detachShader](...args) {
>+    return this.detachShader.apply(this, args);
>+  }
>+  [$disable](...args) {
>+    return this.disable.apply(this, args);
>+  }
>+  [$disableVertexAttribArray](...args) {
>+    return this.disableVertexAttribArray.apply(this, args);
>+  }
>+  [$drawArrays](...args) {
>+    return this.drawArrays.apply(this, args);
>+  }
>+  [$drawElements](...args) {
>+    return this.drawElements.apply(this, args);
>+  }
>+  [$enable](...args) {
>+    return this.enable.apply(this, args);
>+  }
>+  [$enableVertexAttribArray](...args) {
>+    return this.enableVertexAttribArray.apply(this, args);
>+  }
>+  [$finish](...args) {
>+    return this.finish.apply(this, args);
>+  }
>+  [$flush](...args) {
>+    return this.flush.apply(this, args);
>+  }
>+  [$framebufferRenderbuffer](...args) {
>+    return this.framebufferRenderbuffer.apply(this, args);
>+  }
>+  [$framebufferTexture2D](...args) {
>+    return this.framebufferTexture2D.apply(this, args);
>+  }
>+  [$frontFace](...args) {
>+    return this.frontFace.apply(this, args);
>+  }
>+  [$generateMipmap](...args) {
>+    return this.generateMipmap.apply(this, args);
>+  }
>+  [$getActiveAttrib](...args) {
>+    return this.getActiveAttrib.apply(this, args);
>+  }
>+  [$getActiveUniform](...args) {
>+    return this.getActiveUniform.apply(this, args);
>+  }
>+  [$getAttachedShaders](...args) {
>+    return this.getAttachedShaders.apply(this, args);
>+  }
>+  [$getAttribLocation](...args) {
>+    return this.getAttribLocation.apply(this, args);
>+  }
>+  [$getBufferParameter](...args) {
>+    return this.getBufferParameter.apply(this, args);
>+  }
>+  [$getContextAttributes]() {
>+    return html_common.convertNativeToDart_Dictionary(this[_getContextAttributes_1$]());
>+  }
>+  [_getContextAttributes_1$](...args) {
>+    return this.getContextAttributes.apply(this, args);
>+  }
>+  [$getError](...args) {
>+    return this.getError.apply(this, args);
>+  }
>+  [$getExtension](...args) {
>+    return this.getExtension.apply(this, args);
>+  }
>+  [$getFramebufferAttachmentParameter](...args) {
>+    return this.getFramebufferAttachmentParameter.apply(this, args);
>+  }
>+  [$getParameter](...args) {
>+    return this.getParameter.apply(this, args);
>+  }
>+  [$getProgramInfoLog](...args) {
>+    return this.getProgramInfoLog.apply(this, args);
>+  }
>+  [$getProgramParameter](...args) {
>+    return this.getProgramParameter.apply(this, args);
>+  }
>+  [$getRenderbufferParameter](...args) {
>+    return this.getRenderbufferParameter.apply(this, args);
>+  }
>+  [$getShaderInfoLog](...args) {
>+    return this.getShaderInfoLog.apply(this, args);
>+  }
>+  [$getShaderParameter](...args) {
>+    return this.getShaderParameter.apply(this, args);
>+  }
>+  [$getShaderPrecisionFormat](...args) {
>+    return this.getShaderPrecisionFormat.apply(this, args);
>+  }
>+  [$getShaderSource](...args) {
>+    return this.getShaderSource.apply(this, args);
>+  }
>+  [$getSupportedExtensions](...args) {
>+    return this.getSupportedExtensions.apply(this, args);
>+  }
>+  [$getTexParameter](...args) {
>+    return this.getTexParameter.apply(this, args);
>+  }
>+  [$getUniform](...args) {
>+    return this.getUniform.apply(this, args);
>+  }
>+  [$getUniformLocation](...args) {
>+    return this.getUniformLocation.apply(this, args);
>+  }
>+  [$getVertexAttrib](...args) {
>+    return this.getVertexAttrib.apply(this, args);
>+  }
>+  [$getVertexAttribOffset](...args) {
>+    return this.getVertexAttribOffset.apply(this, args);
>+  }
>+  [$hint](...args) {
>+    return this.hint.apply(this, args);
>+  }
>+  [$isBuffer](...args) {
>+    return this.isBuffer.apply(this, args);
>+  }
>+  [$isContextLost](...args) {
>+    return this.isContextLost.apply(this, args);
>+  }
>+  [$isEnabled](...args) {
>+    return this.isEnabled.apply(this, args);
>+  }
>+  [$isFramebuffer](...args) {
>+    return this.isFramebuffer.apply(this, args);
>+  }
>+  [$isProgram](...args) {
>+    return this.isProgram.apply(this, args);
>+  }
>+  [$isRenderbuffer](...args) {
>+    return this.isRenderbuffer.apply(this, args);
>+  }
>+  [$isShader](...args) {
>+    return this.isShader.apply(this, args);
>+  }
>+  [$isTexture](...args) {
>+    return this.isTexture.apply(this, args);
>+  }
>+  [$lineWidth](...args) {
>+    return this.lineWidth.apply(this, args);
>+  }
>+  [$linkProgram](...args) {
>+    return this.linkProgram.apply(this, args);
>+  }
>+  [$pixelStorei](...args) {
>+    return this.pixelStorei.apply(this, args);
>+  }
>+  [$polygonOffset](...args) {
>+    return this.polygonOffset.apply(this, args);
>+  }
>+  [_readPixels](...args) {
>+    return this.readPixels.apply(this, args);
>+  }
>+  [$renderbufferStorage](...args) {
>+    return this.renderbufferStorage.apply(this, args);
>+  }
>+  [$sampleCoverage](...args) {
>+    return this.sampleCoverage.apply(this, args);
>+  }
>+  [$scissor](...args) {
>+    return this.scissor.apply(this, args);
>+  }
>+  [$shaderSource](...args) {
>+    return this.shaderSource.apply(this, args);
>+  }
>+  [$stencilFunc](...args) {
>+    return this.stencilFunc.apply(this, args);
>+  }
>+  [$stencilFuncSeparate](...args) {
>+    return this.stencilFuncSeparate.apply(this, args);
>+  }
>+  [$stencilMask](...args) {
>+    return this.stencilMask.apply(this, args);
>+  }
>+  [$stencilMaskSeparate](...args) {
>+    return this.stencilMaskSeparate.apply(this, args);
>+  }
>+  [$stencilOp](...args) {
>+    return this.stencilOp.apply(this, args);
>+  }
>+  [$stencilOpSeparate](...args) {
>+    return this.stencilOpSeparate.apply(this, args);
>+  }
>+  [$texImage2D](target, level, internalformat, format_OR_width, height_OR_type, bitmap_OR_border_OR_canvas_OR_image_OR_pixels_OR_video, format, type, pixels) {
>+    if (format === void 0) format = null;
>+    if (type === void 0) type = null;
>+    if (pixels === void 0) pixels = null;
>+    if (type != null && format != null && core.int.is(bitmap_OR_border_OR_canvas_OR_image_OR_pixels_OR_video)) {
>+      this[_texImage2D_1](target, level, internalformat, format_OR_width, height_OR_type, bitmap_OR_border_OR_canvas_OR_image_OR_pixels_OR_video, format, type, pixels);
>+      return;
>+    }
>+    if (html$.ImageData.is(bitmap_OR_border_OR_canvas_OR_image_OR_pixels_OR_video) && format == null && type == null && pixels == null) {
>+      let pixels_1 = html_common.convertDartToNative_ImageData(bitmap_OR_border_OR_canvas_OR_image_OR_pixels_OR_video);
>+      this[_texImage2D_2](target, level, internalformat, format_OR_width, height_OR_type, pixels_1);
>+      return;
>+    }
>+    if (html$.ImageElement.is(bitmap_OR_border_OR_canvas_OR_image_OR_pixels_OR_video) && format == null && type == null && pixels == null) {
>+      this[_texImage2D_3](target, level, internalformat, format_OR_width, height_OR_type, bitmap_OR_border_OR_canvas_OR_image_OR_pixels_OR_video);
>+      return;
>+    }
>+    if (html$.CanvasElement.is(bitmap_OR_border_OR_canvas_OR_image_OR_pixels_OR_video) && format == null && type == null && pixels == null) {
>+      this[_texImage2D_4](target, level, internalformat, format_OR_width, height_OR_type, bitmap_OR_border_OR_canvas_OR_image_OR_pixels_OR_video);
>+      return;
>+    }
>+    if (html$.VideoElement.is(bitmap_OR_border_OR_canvas_OR_image_OR_pixels_OR_video) && format == null && type == null && pixels == null) {
>+      this[_texImage2D_5](target, level, internalformat, format_OR_width, height_OR_type, bitmap_OR_border_OR_canvas_OR_image_OR_pixels_OR_video);
>+      return;
>+    }
>+    if (html$.ImageBitmap.is(bitmap_OR_border_OR_canvas_OR_image_OR_pixels_OR_video) && format == null && type == null && pixels == null) {
>+      this[_texImage2D_6](target, level, internalformat, format_OR_width, height_OR_type, bitmap_OR_border_OR_canvas_OR_image_OR_pixels_OR_video);
>+      return;
>+    }
>+    dart.throw(new core.ArgumentError.new("Incorrect number or type of arguments"));
>+  }
>+  [_texImage2D_1](...args) {
>+    return this.texImage2D.apply(this, args);
>+  }
>+  [_texImage2D_2](...args) {
>+    return this.texImage2D.apply(this, args);
>+  }
>+  [_texImage2D_3](...args) {
>+    return this.texImage2D.apply(this, args);
>+  }
>+  [_texImage2D_4](...args) {
>+    return this.texImage2D.apply(this, args);
>+  }
>+  [_texImage2D_5](...args) {
>+    return this.texImage2D.apply(this, args);
>+  }
>+  [_texImage2D_6](...args) {
>+    return this.texImage2D.apply(this, args);
>+  }
>+  [$texParameterf](...args) {
>+    return this.texParameterf.apply(this, args);
>+  }
>+  [$texParameteri](...args) {
>+    return this.texParameteri.apply(this, args);
>+  }
>+  [$texSubImage2D](target, level, xoffset, yoffset, format_OR_width, height_OR_type, bitmap_OR_canvas_OR_format_OR_image_OR_pixels_OR_video, type, pixels) {
>+    if (type === void 0) type = null;
>+    if (pixels === void 0) pixels = null;
>+    if (type != null && core.int.is(bitmap_OR_canvas_OR_format_OR_image_OR_pixels_OR_video)) {
>+      this[_texSubImage2D_1](target, level, xoffset, yoffset, format_OR_width, height_OR_type, bitmap_OR_canvas_OR_format_OR_image_OR_pixels_OR_video, type, pixels);
>+      return;
>+    }
>+    if (html$.ImageData.is(bitmap_OR_canvas_OR_format_OR_image_OR_pixels_OR_video) && type == null && pixels == null) {
>+      let pixels_1 = html_common.convertDartToNative_ImageData(bitmap_OR_canvas_OR_format_OR_image_OR_pixels_OR_video);
>+      this[_texSubImage2D_2](target, level, xoffset, yoffset, format_OR_width, height_OR_type, pixels_1);
>+      return;
>+    }
>+    if (html$.ImageElement.is(bitmap_OR_canvas_OR_format_OR_image_OR_pixels_OR_video) && type == null && pixels == null) {
>+      this[_texSubImage2D_3](target, level, xoffset, yoffset, format_OR_width, height_OR_type, bitmap_OR_canvas_OR_format_OR_image_OR_pixels_OR_video);
>+      return;
>+    }
>+    if (html$.CanvasElement.is(bitmap_OR_canvas_OR_format_OR_image_OR_pixels_OR_video) && type == null && pixels == null) {
>+      this[_texSubImage2D_4](target, level, xoffset, yoffset, format_OR_width, height_OR_type, bitmap_OR_canvas_OR_format_OR_image_OR_pixels_OR_video);
>+      return;
>+    }
>+    if (html$.VideoElement.is(bitmap_OR_canvas_OR_format_OR_image_OR_pixels_OR_video) && type == null && pixels == null) {
>+      this[_texSubImage2D_5](target, level, xoffset, yoffset, format_OR_width, height_OR_type, bitmap_OR_canvas_OR_format_OR_image_OR_pixels_OR_video);
>+      return;
>+    }
>+    if (html$.ImageBitmap.is(bitmap_OR_canvas_OR_format_OR_image_OR_pixels_OR_video) && type == null && pixels == null) {
>+      this[_texSubImage2D_6](target, level, xoffset, yoffset, format_OR_width, height_OR_type, bitmap_OR_canvas_OR_format_OR_image_OR_pixels_OR_video);
>+      return;
>+    }
>+    dart.throw(new core.ArgumentError.new("Incorrect number or type of arguments"));
>+  }
>+  [_texSubImage2D_1](...args) {
>+    return this.texSubImage2D.apply(this, args);
>+  }
>+  [_texSubImage2D_2](...args) {
>+    return this.texSubImage2D.apply(this, args);
>+  }
>+  [_texSubImage2D_3](...args) {
>+    return this.texSubImage2D.apply(this, args);
>+  }
>+  [_texSubImage2D_4](...args) {
>+    return this.texSubImage2D.apply(this, args);
>+  }
>+  [_texSubImage2D_5](...args) {
>+    return this.texSubImage2D.apply(this, args);
>+  }
>+  [_texSubImage2D_6](...args) {
>+    return this.texSubImage2D.apply(this, args);
>+  }
>+  [$uniform1f](...args) {
>+    return this.uniform1f.apply(this, args);
>+  }
>+  [$uniform1fv](...args) {
>+    return this.uniform1fv.apply(this, args);
>+  }
>+  [$uniform1i](...args) {
>+    return this.uniform1i.apply(this, args);
>+  }
>+  [$uniform1iv](...args) {
>+    return this.uniform1iv.apply(this, args);
>+  }
>+  [$uniform2f](...args) {
>+    return this.uniform2f.apply(this, args);
>+  }
>+  [$uniform2fv](...args) {
>+    return this.uniform2fv.apply(this, args);
>+  }
>+  [$uniform2i](...args) {
>+    return this.uniform2i.apply(this, args);
>+  }
>+  [$uniform2iv](...args) {
>+    return this.uniform2iv.apply(this, args);
>+  }
>+  [$uniform3f](...args) {
>+    return this.uniform3f.apply(this, args);
>+  }
>+  [$uniform3fv](...args) {
>+    return this.uniform3fv.apply(this, args);
>+  }
>+  [$uniform3i](...args) {
>+    return this.uniform3i.apply(this, args);
>+  }
>+  [$uniform3iv](...args) {
>+    return this.uniform3iv.apply(this, args);
>+  }
>+  [$uniform4f](...args) {
>+    return this.uniform4f.apply(this, args);
>+  }
>+  [$uniform4fv](...args) {
>+    return this.uniform4fv.apply(this, args);
>+  }
>+  [$uniform4i](...args) {
>+    return this.uniform4i.apply(this, args);
>+  }
>+  [$uniform4iv](...args) {
>+    return this.uniform4iv.apply(this, args);
>+  }
>+  [$uniformMatrix2fv](...args) {
>+    return this.uniformMatrix2fv.apply(this, args);
>+  }
>+  [$uniformMatrix3fv](...args) {
>+    return this.uniformMatrix3fv.apply(this, args);
>+  }
>+  [$uniformMatrix4fv](...args) {
>+    return this.uniformMatrix4fv.apply(this, args);
>+  }
>+  [$useProgram](...args) {
>+    return this.useProgram.apply(this, args);
>+  }
>+  [$validateProgram](...args) {
>+    return this.validateProgram.apply(this, args);
>+  }
>+  [$vertexAttrib1f](...args) {
>+    return this.vertexAttrib1f.apply(this, args);
>+  }
>+  [$vertexAttrib1fv](...args) {
>+    return this.vertexAttrib1fv.apply(this, args);
>+  }
>+  [$vertexAttrib2f](...args) {
>+    return this.vertexAttrib2f.apply(this, args);
>+  }
>+  [$vertexAttrib2fv](...args) {
>+    return this.vertexAttrib2fv.apply(this, args);
>+  }
>+  [$vertexAttrib3f](...args) {
>+    return this.vertexAttrib3f.apply(this, args);
>+  }
>+  [$vertexAttrib3fv](...args) {
>+    return this.vertexAttrib3fv.apply(this, args);
>+  }
>+  [$vertexAttrib4f](...args) {
>+    return this.vertexAttrib4f.apply(this, args);
>+  }
>+  [$vertexAttrib4fv](...args) {
>+    return this.vertexAttrib4fv.apply(this, args);
>+  }
>+  [$vertexAttribPointer](...args) {
>+    return this.vertexAttribPointer.apply(this, args);
>+  }
>+  [$viewport](...args) {
>+    return this.viewport.apply(this, args);
>+  }
>+  [$readPixels](x, y, width, height, format, type, pixels) {
>+    this[_readPixels](x, y, width, height, format, type, pixels);
>+  }
>+  [$texImage2DUntyped](targetTexture, levelOfDetail, internalFormat, format, type, data) {
>+    this[$texImage2D](targetTexture, levelOfDetail, internalFormat, format, type, data);
>+  }
>+  [$texImage2DTyped](targetTexture, levelOfDetail, internalFormat, width, height, border, format, type, data) {
>+    this[$texImage2D](targetTexture, levelOfDetail, internalFormat, width, height, border, format, type, data);
>+  }
>+  [$texSubImage2DUntyped](targetTexture, levelOfDetail, xOffset, yOffset, format, type, data) {
>+    this[$texSubImage2D](targetTexture, levelOfDetail, xOffset, yOffset, format, type, data);
>+  }
>+  [$texSubImage2DTyped](targetTexture, levelOfDetail, xOffset, yOffset, width, height, border, format, type, data) {
>+    this[$texSubImage2D](targetTexture, levelOfDetail, xOffset, yOffset, width, height, format, type, data);
>+  }
>+  [$bufferDataTyped](target, data, usage) {
>+    this.bufferData(target, data, usage);
>+  }
>+  [$bufferSubDataTyped](target, offset, data) {
>+    this.bufferSubData(target, offset, data);
>+  }
>+};
>+dart.addTypeTests(web_gl.RenderingContext);
>+const canvas$3 = Symbol("RenderingContext.canvas");
>+const drawingBufferHeight = Symbol("RenderingContext.drawingBufferHeight");
>+const drawingBufferWidth = Symbol("RenderingContext.drawingBufferWidth");
>+web_gl.RenderingContext[dart.implements] = () => [html$.CanvasRenderingContext];
>+dart.setMethodSignature(web_gl.RenderingContext, () => ({
>+  __proto__: dart.getMethods(web_gl.RenderingContext.__proto__),
>+  [$activeTexture]: dart.fnType(dart.void, [core.int]),
>+  [$attachShader]: dart.fnType(dart.void, [web_gl.Program, web_gl.Shader]),
>+  [$bindAttribLocation]: dart.fnType(dart.void, [web_gl.Program, core.int, core.String]),
>+  [$bindBuffer]: dart.fnType(dart.void, [core.int, web_gl.Buffer]),
>+  [$bindFramebuffer]: dart.fnType(dart.void, [core.int, web_gl.Framebuffer]),
>+  [$bindRenderbuffer]: dart.fnType(dart.void, [core.int, web_gl.Renderbuffer]),
>+  [$bindTexture]: dart.fnType(dart.void, [core.int, web_gl.Texture]),
>+  [$blendColor]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num]),
>+  [$blendEquation]: dart.fnType(dart.void, [core.int]),
>+  [$blendEquationSeparate]: dart.fnType(dart.void, [core.int, core.int]),
>+  [$blendFunc]: dart.fnType(dart.void, [core.int, core.int]),
>+  [$blendFuncSeparate]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int]),
>+  [$bufferData]: dart.fnType(dart.void, [core.int, dart.dynamic, core.int]),
>+  [$bufferSubData]: dart.fnType(dart.void, [core.int, core.int, dart.dynamic]),
>+  [$checkFramebufferStatus]: dart.fnType(core.int, [core.int]),
>+  [$clear]: dart.fnType(dart.void, [core.int]),
>+  [$clearColor]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num]),
>+  [$clearDepth]: dart.fnType(dart.void, [core.num]),
>+  [$clearStencil]: dart.fnType(dart.void, [core.int]),
>+  [$colorMask]: dart.fnType(dart.void, [core.bool, core.bool, core.bool, core.bool]),
>+  [$commit]: dart.fnType(async.Future, []),
>+  [$compileShader]: dart.fnType(dart.void, [web_gl.Shader]),
>+  [$compressedTexImage2D]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, typed_data.TypedData]),
>+  [$compressedTexSubImage2D]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, core.int, typed_data.TypedData]),
>+  [$copyTexImage2D]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int]),
>+  [$copyTexSubImage2D]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int]),
>+  [$createBuffer]: dart.fnType(web_gl.Buffer, []),
>+  [$createFramebuffer]: dart.fnType(web_gl.Framebuffer, []),
>+  [$createProgram]: dart.fnType(web_gl.Program, []),
>+  [$createRenderbuffer]: dart.fnType(web_gl.Renderbuffer, []),
>+  [$createShader]: dart.fnType(web_gl.Shader, [core.int]),
>+  [$createTexture]: dart.fnType(web_gl.Texture, []),
>+  [$cullFace]: dart.fnType(dart.void, [core.int]),
>+  [$deleteBuffer]: dart.fnType(dart.void, [web_gl.Buffer]),
>+  [$deleteFramebuffer]: dart.fnType(dart.void, [web_gl.Framebuffer]),
>+  [$deleteProgram]: dart.fnType(dart.void, [web_gl.Program]),
>+  [$deleteRenderbuffer]: dart.fnType(dart.void, [web_gl.Renderbuffer]),
>+  [$deleteShader]: dart.fnType(dart.void, [web_gl.Shader]),
>+  [$deleteTexture]: dart.fnType(dart.void, [web_gl.Texture]),
>+  [$depthFunc]: dart.fnType(dart.void, [core.int]),
>+  [$depthMask]: dart.fnType(dart.void, [core.bool]),
>+  [$depthRange]: dart.fnType(dart.void, [core.num, core.num]),
>+  [$detachShader]: dart.fnType(dart.void, [web_gl.Program, web_gl.Shader]),
>+  [$disable]: dart.fnType(dart.void, [core.int]),
>+  [$disableVertexAttribArray]: dart.fnType(dart.void, [core.int]),
>+  [$drawArrays]: dart.fnType(dart.void, [core.int, core.int, core.int]),
>+  [$drawElements]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int]),
>+  [$enable]: dart.fnType(dart.void, [core.int]),
>+  [$enableVertexAttribArray]: dart.fnType(dart.void, [core.int]),
>+  [$finish]: dart.fnType(dart.void, []),
>+  [$flush]: dart.fnType(dart.void, []),
>+  [$framebufferRenderbuffer]: dart.fnType(dart.void, [core.int, core.int, core.int, web_gl.Renderbuffer]),
>+  [$framebufferTexture2D]: dart.fnType(dart.void, [core.int, core.int, core.int, web_gl.Texture, core.int]),
>+  [$frontFace]: dart.fnType(dart.void, [core.int]),
>+  [$generateMipmap]: dart.fnType(dart.void, [core.int]),
>+  [$getActiveAttrib]: dart.fnType(web_gl.ActiveInfo, [web_gl.Program, core.int]),
>+  [$getActiveUniform]: dart.fnType(web_gl.ActiveInfo, [web_gl.Program, core.int]),
>+  [$getAttachedShaders]: dart.fnType(core.List$(web_gl.Shader), [web_gl.Program]),
>+  [$getAttribLocation]: dart.fnType(core.int, [web_gl.Program, core.String]),
>+  [$getBufferParameter]: dart.fnType(core.Object, [core.int, core.int]),
>+  [$getContextAttributes]: dart.fnType(core.Map, []),
>+  [_getContextAttributes_1$]: dart.fnType(dart.dynamic, []),
>+  [$getError]: dart.fnType(core.int, []),
>+  [$getExtension]: dart.fnType(core.Object, [core.String]),
>+  [$getFramebufferAttachmentParameter]: dart.fnType(core.Object, [core.int, core.int, core.int]),
>+  [$getParameter]: dart.fnType(core.Object, [core.int]),
>+  [$getProgramInfoLog]: dart.fnType(core.String, [web_gl.Program]),
>+  [$getProgramParameter]: dart.fnType(core.Object, [web_gl.Program, core.int]),
>+  [$getRenderbufferParameter]: dart.fnType(core.Object, [core.int, core.int]),
>+  [$getShaderInfoLog]: dart.fnType(core.String, [web_gl.Shader]),
>+  [$getShaderParameter]: dart.fnType(core.Object, [web_gl.Shader, core.int]),
>+  [$getShaderPrecisionFormat]: dart.fnType(web_gl.ShaderPrecisionFormat, [core.int, core.int]),
>+  [$getShaderSource]: dart.fnType(core.String, [web_gl.Shader]),
>+  [$getSupportedExtensions]: dart.fnType(core.List$(core.String), []),
>+  [$getTexParameter]: dart.fnType(core.Object, [core.int, core.int]),
>+  [$getUniform]: dart.fnType(core.Object, [web_gl.Program, web_gl.UniformLocation]),
>+  [$getUniformLocation]: dart.fnType(web_gl.UniformLocation, [web_gl.Program, core.String]),
>+  [$getVertexAttrib]: dart.fnType(core.Object, [core.int, core.int]),
>+  [$getVertexAttribOffset]: dart.fnType(core.int, [core.int, core.int]),
>+  [$hint]: dart.fnType(dart.void, [core.int, core.int]),
>+  [$isBuffer]: dart.fnType(core.bool, [web_gl.Buffer]),
>+  [$isContextLost]: dart.fnType(core.bool, []),
>+  [$isEnabled]: dart.fnType(core.bool, [core.int]),
>+  [$isFramebuffer]: dart.fnType(core.bool, [web_gl.Framebuffer]),
>+  [$isProgram]: dart.fnType(core.bool, [web_gl.Program]),
>+  [$isRenderbuffer]: dart.fnType(core.bool, [web_gl.Renderbuffer]),
>+  [$isShader]: dart.fnType(core.bool, [web_gl.Shader]),
>+  [$isTexture]: dart.fnType(core.bool, [web_gl.Texture]),
>+  [$lineWidth]: dart.fnType(dart.void, [core.num]),
>+  [$linkProgram]: dart.fnType(dart.void, [web_gl.Program]),
>+  [$pixelStorei]: dart.fnType(dart.void, [core.int, core.int]),
>+  [$polygonOffset]: dart.fnType(dart.void, [core.num, core.num]),
>+  [_readPixels]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, typed_data.TypedData]),
>+  [$renderbufferStorage]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int]),
>+  [$sampleCoverage]: dart.fnType(dart.void, [core.num, core.bool]),
>+  [$scissor]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int]),
>+  [$shaderSource]: dart.fnType(dart.void, [web_gl.Shader, core.String]),
>+  [$stencilFunc]: dart.fnType(dart.void, [core.int, core.int, core.int]),
>+  [$stencilFuncSeparate]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int]),
>+  [$stencilMask]: dart.fnType(dart.void, [core.int]),
>+  [$stencilMaskSeparate]: dart.fnType(dart.void, [core.int, core.int]),
>+  [$stencilOp]: dart.fnType(dart.void, [core.int, core.int, core.int]),
>+  [$stencilOpSeparate]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int]),
>+  [$texImage2D]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, dart.dynamic], [core.int, core.int, typed_data.TypedData]),
>+  [_texImage2D_1]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, core.int, dart.dynamic, dart.dynamic, typed_data.TypedData]),
>+  [_texImage2D_2]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic]),
>+  [_texImage2D_3]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.ImageElement]),
>+  [_texImage2D_4]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.CanvasElement]),
>+  [_texImage2D_5]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.VideoElement]),
>+  [_texImage2D_6]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.ImageBitmap]),
>+  [$texParameterf]: dart.fnType(dart.void, [core.int, core.int, core.num]),
>+  [$texParameteri]: dart.fnType(dart.void, [core.int, core.int, core.int]),
>+  [$texSubImage2D]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, dart.dynamic], [core.int, typed_data.TypedData]),
>+  [_texSubImage2D_1]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, core.int, dart.dynamic, typed_data.TypedData]),
>+  [_texSubImage2D_2]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic]),
>+  [_texSubImage2D_3]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.ImageElement]),
>+  [_texSubImage2D_4]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.CanvasElement]),
>+  [_texSubImage2D_5]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.VideoElement]),
>+  [_texSubImage2D_6]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.ImageBitmap]),
>+  [$uniform1f]: dart.fnType(dart.void, [web_gl.UniformLocation, core.num]),
>+  [$uniform1fv]: dart.fnType(dart.void, [web_gl.UniformLocation, dart.dynamic]),
>+  [$uniform1i]: dart.fnType(dart.void, [web_gl.UniformLocation, core.int]),
>+  [$uniform1iv]: dart.fnType(dart.void, [web_gl.UniformLocation, dart.dynamic]),
>+  [$uniform2f]: dart.fnType(dart.void, [web_gl.UniformLocation, core.num, core.num]),
>+  [$uniform2fv]: dart.fnType(dart.void, [web_gl.UniformLocation, dart.dynamic]),
>+  [$uniform2i]: dart.fnType(dart.void, [web_gl.UniformLocation, core.int, core.int]),
>+  [$uniform2iv]: dart.fnType(dart.void, [web_gl.UniformLocation, dart.dynamic]),
>+  [$uniform3f]: dart.fnType(dart.void, [web_gl.UniformLocation, core.num, core.num, core.num]),
>+  [$uniform3fv]: dart.fnType(dart.void, [web_gl.UniformLocation, dart.dynamic]),
>+  [$uniform3i]: dart.fnType(dart.void, [web_gl.UniformLocation, core.int, core.int, core.int]),
>+  [$uniform3iv]: dart.fnType(dart.void, [web_gl.UniformLocation, dart.dynamic]),
>+  [$uniform4f]: dart.fnType(dart.void, [web_gl.UniformLocation, core.num, core.num, core.num, core.num]),
>+  [$uniform4fv]: dart.fnType(dart.void, [web_gl.UniformLocation, dart.dynamic]),
>+  [$uniform4i]: dart.fnType(dart.void, [web_gl.UniformLocation, core.int, core.int, core.int, core.int]),
>+  [$uniform4iv]: dart.fnType(dart.void, [web_gl.UniformLocation, dart.dynamic]),
>+  [$uniformMatrix2fv]: dart.fnType(dart.void, [web_gl.UniformLocation, core.bool, dart.dynamic]),
>+  [$uniformMatrix3fv]: dart.fnType(dart.void, [web_gl.UniformLocation, core.bool, dart.dynamic]),
>+  [$uniformMatrix4fv]: dart.fnType(dart.void, [web_gl.UniformLocation, core.bool, dart.dynamic]),
>+  [$useProgram]: dart.fnType(dart.void, [web_gl.Program]),
>+  [$validateProgram]: dart.fnType(dart.void, [web_gl.Program]),
>+  [$vertexAttrib1f]: dart.fnType(dart.void, [core.int, core.num]),
>+  [$vertexAttrib1fv]: dart.fnType(dart.void, [core.int, dart.dynamic]),
>+  [$vertexAttrib2f]: dart.fnType(dart.void, [core.int, core.num, core.num]),
>+  [$vertexAttrib2fv]: dart.fnType(dart.void, [core.int, dart.dynamic]),
>+  [$vertexAttrib3f]: dart.fnType(dart.void, [core.int, core.num, core.num, core.num]),
>+  [$vertexAttrib3fv]: dart.fnType(dart.void, [core.int, dart.dynamic]),
>+  [$vertexAttrib4f]: dart.fnType(dart.void, [core.int, core.num, core.num, core.num, core.num]),
>+  [$vertexAttrib4fv]: dart.fnType(dart.void, [core.int, dart.dynamic]),
>+  [$vertexAttribPointer]: dart.fnType(dart.void, [core.int, core.int, core.int, core.bool, core.int, core.int]),
>+  [$viewport]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int]),
>+  [$readPixels]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, typed_data.TypedData]),
>+  [$texImage2DUntyped]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, dart.dynamic]),
>+  [$texImage2DTyped]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int, typed_data.TypedData]),
>+  [$texSubImage2DUntyped]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, dart.dynamic]),
>+  [$texSubImage2DTyped]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int, typed_data.TypedData]),
>+  [$bufferDataTyped]: dart.fnType(dart.void, [core.int, typed_data.TypedData, core.int]),
>+  [$bufferSubDataTyped]: dart.fnType(dart.void, [core.int, core.int, typed_data.TypedData])
>+}));
>+dart.setLibraryUri(web_gl.RenderingContext, "dart:web_gl");
>+dart.setFieldSignature(web_gl.RenderingContext, () => ({
>+  __proto__: dart.getFields(web_gl.RenderingContext.__proto__),
>+  [$canvas]: dart.finalFieldType(html$.CanvasElement),
>+  [$drawingBufferHeight]: dart.finalFieldType(core.int),
>+  [$drawingBufferWidth]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("WebGLRenderingContext", web_gl.RenderingContext);
>+const _getUniformIndices_1 = dart.privateName(web_gl, "_getUniformIndices_1");
>+const _texImage2D2_1 = dart.privateName(web_gl, "_texImage2D2_1");
>+const _texImage2D2_2 = dart.privateName(web_gl, "_texImage2D2_2");
>+const _texImage2D2_3 = dart.privateName(web_gl, "_texImage2D2_3");
>+const _texImage2D2_4 = dart.privateName(web_gl, "_texImage2D2_4");
>+const _texImage2D2_5 = dart.privateName(web_gl, "_texImage2D2_5");
>+const _texImage2D2_6 = dart.privateName(web_gl, "_texImage2D2_6");
>+const _texImage2D2_7 = dart.privateName(web_gl, "_texImage2D2_7");
>+const _texImage3D_1 = dart.privateName(web_gl, "_texImage3D_1");
>+const _texImage3D_2 = dart.privateName(web_gl, "_texImage3D_2");
>+const _texImage3D_3 = dart.privateName(web_gl, "_texImage3D_3");
>+const _texImage3D_4 = dart.privateName(web_gl, "_texImage3D_4");
>+const _texImage3D_5 = dart.privateName(web_gl, "_texImage3D_5");
>+const _texImage3D_6 = dart.privateName(web_gl, "_texImage3D_6");
>+const _texImage3D_7 = dart.privateName(web_gl, "_texImage3D_7");
>+const _texImage3D_8 = dart.privateName(web_gl, "_texImage3D_8");
>+const _texSubImage2D2_1 = dart.privateName(web_gl, "_texSubImage2D2_1");
>+const _texSubImage2D2_2 = dart.privateName(web_gl, "_texSubImage2D2_2");
>+const _texSubImage2D2_3 = dart.privateName(web_gl, "_texSubImage2D2_3");
>+const _texSubImage2D2_4 = dart.privateName(web_gl, "_texSubImage2D2_4");
>+const _texSubImage2D2_5 = dart.privateName(web_gl, "_texSubImage2D2_5");
>+const _texSubImage2D2_6 = dart.privateName(web_gl, "_texSubImage2D2_6");
>+const _texSubImage2D2_7 = dart.privateName(web_gl, "_texSubImage2D2_7");
>+const _texSubImage3D_1 = dart.privateName(web_gl, "_texSubImage3D_1");
>+const _texSubImage3D_2 = dart.privateName(web_gl, "_texSubImage3D_2");
>+const _texSubImage3D_3 = dart.privateName(web_gl, "_texSubImage3D_3");
>+const _texSubImage3D_4 = dart.privateName(web_gl, "_texSubImage3D_4");
>+const _texSubImage3D_5 = dart.privateName(web_gl, "_texSubImage3D_5");
>+const _texSubImage3D_6 = dart.privateName(web_gl, "_texSubImage3D_6");
>+const _texSubImage3D_7 = dart.privateName(web_gl, "_texSubImage3D_7");
>+const _texSubImage3D_8 = dart.privateName(web_gl, "_texSubImage3D_8");
>+const _transformFeedbackVaryings_1 = dart.privateName(web_gl, "_transformFeedbackVaryings_1");
>+web_gl.RenderingContext2 = class RenderingContext2 extends _interceptors.Interceptor {
>+  get [$canvas]() {
>+    return this.canvas;
>+  }
>+  [$beginQuery](...args) {
>+    return this.beginQuery.apply(this, args);
>+  }
>+  [$beginTransformFeedback](...args) {
>+    return this.beginTransformFeedback.apply(this, args);
>+  }
>+  [$bindBufferBase](...args) {
>+    return this.bindBufferBase.apply(this, args);
>+  }
>+  [$bindBufferRange](...args) {
>+    return this.bindBufferRange.apply(this, args);
>+  }
>+  [$bindSampler](...args) {
>+    return this.bindSampler.apply(this, args);
>+  }
>+  [$bindTransformFeedback](...args) {
>+    return this.bindTransformFeedback.apply(this, args);
>+  }
>+  [$bindVertexArray](...args) {
>+    return this.bindVertexArray.apply(this, args);
>+  }
>+  [$blitFramebuffer](...args) {
>+    return this.blitFramebuffer.apply(this, args);
>+  }
>+  [$bufferData2](...args) {
>+    return this.bufferData.apply(this, args);
>+  }
>+  [$bufferSubData2](...args) {
>+    return this.bufferSubData.apply(this, args);
>+  }
>+  [$clearBufferfi](...args) {
>+    return this.clearBufferfi.apply(this, args);
>+  }
>+  [$clearBufferfv](...args) {
>+    return this.clearBufferfv.apply(this, args);
>+  }
>+  [$clearBufferiv](...args) {
>+    return this.clearBufferiv.apply(this, args);
>+  }
>+  [$clearBufferuiv](...args) {
>+    return this.clearBufferuiv.apply(this, args);
>+  }
>+  [$clientWaitSync](...args) {
>+    return this.clientWaitSync.apply(this, args);
>+  }
>+  [$compressedTexImage2D2](...args) {
>+    return this.compressedTexImage2D.apply(this, args);
>+  }
>+  [$compressedTexImage2D3](...args) {
>+    return this.compressedTexImage2D.apply(this, args);
>+  }
>+  [$compressedTexImage3D](...args) {
>+    return this.compressedTexImage3D.apply(this, args);
>+  }
>+  [$compressedTexImage3D2](...args) {
>+    return this.compressedTexImage3D.apply(this, args);
>+  }
>+  [$compressedTexSubImage2D2](...args) {
>+    return this.compressedTexSubImage2D.apply(this, args);
>+  }
>+  [$compressedTexSubImage2D3](...args) {
>+    return this.compressedTexSubImage2D.apply(this, args);
>+  }
>+  [$compressedTexSubImage3D](...args) {
>+    return this.compressedTexSubImage3D.apply(this, args);
>+  }
>+  [$compressedTexSubImage3D2](...args) {
>+    return this.compressedTexSubImage3D.apply(this, args);
>+  }
>+  [$copyBufferSubData](...args) {
>+    return this.copyBufferSubData.apply(this, args);
>+  }
>+  [$copyTexSubImage3D](...args) {
>+    return this.copyTexSubImage3D.apply(this, args);
>+  }
>+  [$createQuery](...args) {
>+    return this.createQuery.apply(this, args);
>+  }
>+  [$createSampler](...args) {
>+    return this.createSampler.apply(this, args);
>+  }
>+  [$createTransformFeedback](...args) {
>+    return this.createTransformFeedback.apply(this, args);
>+  }
>+  [$createVertexArray](...args) {
>+    return this.createVertexArray.apply(this, args);
>+  }
>+  [$deleteQuery](...args) {
>+    return this.deleteQuery.apply(this, args);
>+  }
>+  [$deleteSampler](...args) {
>+    return this.deleteSampler.apply(this, args);
>+  }
>+  [$deleteSync](...args) {
>+    return this.deleteSync.apply(this, args);
>+  }
>+  [$deleteTransformFeedback](...args) {
>+    return this.deleteTransformFeedback.apply(this, args);
>+  }
>+  [$deleteVertexArray](...args) {
>+    return this.deleteVertexArray.apply(this, args);
>+  }
>+  [$drawArraysInstanced](...args) {
>+    return this.drawArraysInstanced.apply(this, args);
>+  }
>+  [$drawBuffers](...args) {
>+    return this.drawBuffers.apply(this, args);
>+  }
>+  [$drawElementsInstanced](...args) {
>+    return this.drawElementsInstanced.apply(this, args);
>+  }
>+  [$drawRangeElements](...args) {
>+    return this.drawRangeElements.apply(this, args);
>+  }
>+  [$endQuery](...args) {
>+    return this.endQuery.apply(this, args);
>+  }
>+  [$endTransformFeedback](...args) {
>+    return this.endTransformFeedback.apply(this, args);
>+  }
>+  [$fenceSync](...args) {
>+    return this.fenceSync.apply(this, args);
>+  }
>+  [$framebufferTextureLayer](...args) {
>+    return this.framebufferTextureLayer.apply(this, args);
>+  }
>+  [$getActiveUniformBlockName](...args) {
>+    return this.getActiveUniformBlockName.apply(this, args);
>+  }
>+  [$getActiveUniformBlockParameter](...args) {
>+    return this.getActiveUniformBlockParameter.apply(this, args);
>+  }
>+  [$getActiveUniforms](...args) {
>+    return this.getActiveUniforms.apply(this, args);
>+  }
>+  [$getBufferSubData](...args) {
>+    return this.getBufferSubData.apply(this, args);
>+  }
>+  [$getFragDataLocation](...args) {
>+    return this.getFragDataLocation.apply(this, args);
>+  }
>+  [$getIndexedParameter](...args) {
>+    return this.getIndexedParameter.apply(this, args);
>+  }
>+  [$getInternalformatParameter](...args) {
>+    return this.getInternalformatParameter.apply(this, args);
>+  }
>+  [$getQuery](...args) {
>+    return this.getQuery.apply(this, args);
>+  }
>+  [$getQueryParameter](...args) {
>+    return this.getQueryParameter.apply(this, args);
>+  }
>+  [$getSamplerParameter](...args) {
>+    return this.getSamplerParameter.apply(this, args);
>+  }
>+  [$getSyncParameter](...args) {
>+    return this.getSyncParameter.apply(this, args);
>+  }
>+  [$getTransformFeedbackVarying](...args) {
>+    return this.getTransformFeedbackVarying.apply(this, args);
>+  }
>+  [$getUniformBlockIndex](...args) {
>+    return this.getUniformBlockIndex.apply(this, args);
>+  }
>+  [$getUniformIndices](program, uniformNames) {
>+    let uniformNames_1 = html_common.convertDartToNative_StringArray(uniformNames);
>+    return this[_getUniformIndices_1](program, uniformNames_1);
>+  }
>+  [_getUniformIndices_1](...args) {
>+    return this.getUniformIndices.apply(this, args);
>+  }
>+  [$invalidateFramebuffer](...args) {
>+    return this.invalidateFramebuffer.apply(this, args);
>+  }
>+  [$invalidateSubFramebuffer](...args) {
>+    return this.invalidateSubFramebuffer.apply(this, args);
>+  }
>+  [$isQuery](...args) {
>+    return this.isQuery.apply(this, args);
>+  }
>+  [$isSampler](...args) {
>+    return this.isSampler.apply(this, args);
>+  }
>+  [$isSync](...args) {
>+    return this.isSync.apply(this, args);
>+  }
>+  [$isTransformFeedback](...args) {
>+    return this.isTransformFeedback.apply(this, args);
>+  }
>+  [$isVertexArray](...args) {
>+    return this.isVertexArray.apply(this, args);
>+  }
>+  [$pauseTransformFeedback](...args) {
>+    return this.pauseTransformFeedback.apply(this, args);
>+  }
>+  [$readBuffer](...args) {
>+    return this.readBuffer.apply(this, args);
>+  }
>+  [$readPixels2](...args) {
>+    return this.readPixels.apply(this, args);
>+  }
>+  [$renderbufferStorageMultisample](...args) {
>+    return this.renderbufferStorageMultisample.apply(this, args);
>+  }
>+  [$resumeTransformFeedback](...args) {
>+    return this.resumeTransformFeedback.apply(this, args);
>+  }
>+  [$samplerParameterf](...args) {
>+    return this.samplerParameterf.apply(this, args);
>+  }
>+  [$samplerParameteri](...args) {
>+    return this.samplerParameteri.apply(this, args);
>+  }
>+  [$texImage2D2](target, level, internalformat, width, height, border, format, type, bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video, srcOffset) {
>+    if (srcOffset === void 0) srcOffset = null;
>+    if (core.int.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video) && srcOffset == null) {
>+      this[_texImage2D2_1](target, level, internalformat, width, height, border, format, type, bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video);
>+      return;
>+    }
>+    if (html$.ImageData.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video) && srcOffset == null) {
>+      let data_1 = html_common.convertDartToNative_ImageData(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video);
>+      this[_texImage2D2_2](target, level, internalformat, width, height, border, format, type, data_1);
>+      return;
>+    }
>+    if (html$.ImageElement.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video) && srcOffset == null) {
>+      this[_texImage2D2_3](target, level, internalformat, width, height, border, format, type, bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video);
>+      return;
>+    }
>+    if (html$.CanvasElement.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video) && srcOffset == null) {
>+      this[_texImage2D2_4](target, level, internalformat, width, height, border, format, type, bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video);
>+      return;
>+    }
>+    if (html$.VideoElement.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video) && srcOffset == null) {
>+      this[_texImage2D2_5](target, level, internalformat, width, height, border, format, type, bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video);
>+      return;
>+    }
>+    if (html$.ImageBitmap.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video) && srcOffset == null) {
>+      this[_texImage2D2_6](target, level, internalformat, width, height, border, format, type, bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video);
>+      return;
>+    }
>+    if (srcOffset != null && typed_data.TypedData.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video)) {
>+      this[_texImage2D2_7](target, level, internalformat, width, height, border, format, type, bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video, srcOffset);
>+      return;
>+    }
>+    dart.throw(new core.ArgumentError.new("Incorrect number or type of arguments"));
>+  }
>+  [_texImage2D2_1](...args) {
>+    return this.texImage2D.apply(this, args);
>+  }
>+  [_texImage2D2_2](...args) {
>+    return this.texImage2D.apply(this, args);
>+  }
>+  [_texImage2D2_3](...args) {
>+    return this.texImage2D.apply(this, args);
>+  }
>+  [_texImage2D2_4](...args) {
>+    return this.texImage2D.apply(this, args);
>+  }
>+  [_texImage2D2_5](...args) {
>+    return this.texImage2D.apply(this, args);
>+  }
>+  [_texImage2D2_6](...args) {
>+    return this.texImage2D.apply(this, args);
>+  }
>+  [_texImage2D2_7](...args) {
>+    return this.texImage2D.apply(this, args);
>+  }
>+  [$texImage3D](target, level, internalformat, width, height, depth, border, format, type, bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video, srcOffset) {
>+    if (srcOffset === void 0) srcOffset = null;
>+    if (core.int.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video) && srcOffset == null) {
>+      this[_texImage3D_1](target, level, internalformat, width, height, depth, border, format, type, bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video);
>+      return;
>+    }
>+    if (html$.ImageData.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video) && srcOffset == null) {
>+      let data_1 = html_common.convertDartToNative_ImageData(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video);
>+      this[_texImage3D_2](target, level, internalformat, width, height, depth, border, format, type, data_1);
>+      return;
>+    }
>+    if (html$.ImageElement.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video) && srcOffset == null) {
>+      this[_texImage3D_3](target, level, internalformat, width, height, depth, border, format, type, bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video);
>+      return;
>+    }
>+    if (html$.CanvasElement.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video) && srcOffset == null) {
>+      this[_texImage3D_4](target, level, internalformat, width, height, depth, border, format, type, bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video);
>+      return;
>+    }
>+    if (html$.VideoElement.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video) && srcOffset == null) {
>+      this[_texImage3D_5](target, level, internalformat, width, height, depth, border, format, type, bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video);
>+      return;
>+    }
>+    if (html$.ImageBitmap.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video) && srcOffset == null) {
>+      this[_texImage3D_6](target, level, internalformat, width, height, depth, border, format, type, bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video);
>+      return;
>+    }
>+    if ((typed_data.TypedData.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video) || bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video == null) && srcOffset == null) {
>+      this[_texImage3D_7](target, level, internalformat, width, height, depth, border, format, type, typed_data.TypedData._check(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video));
>+      return;
>+    }
>+    if (srcOffset != null && typed_data.TypedData.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video)) {
>+      this[_texImage3D_8](target, level, internalformat, width, height, depth, border, format, type, bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video, srcOffset);
>+      return;
>+    }
>+    dart.throw(new core.ArgumentError.new("Incorrect number or type of arguments"));
>+  }
>+  [_texImage3D_1](...args) {
>+    return this.texImage3D.apply(this, args);
>+  }
>+  [_texImage3D_2](...args) {
>+    return this.texImage3D.apply(this, args);
>+  }
>+  [_texImage3D_3](...args) {
>+    return this.texImage3D.apply(this, args);
>+  }
>+  [_texImage3D_4](...args) {
>+    return this.texImage3D.apply(this, args);
>+  }
>+  [_texImage3D_5](...args) {
>+    return this.texImage3D.apply(this, args);
>+  }
>+  [_texImage3D_6](...args) {
>+    return this.texImage3D.apply(this, args);
>+  }
>+  [_texImage3D_7](...args) {
>+    return this.texImage3D.apply(this, args);
>+  }
>+  [_texImage3D_8](...args) {
>+    return this.texImage3D.apply(this, args);
>+  }
>+  [$texStorage2D](...args) {
>+    return this.texStorage2D.apply(this, args);
>+  }
>+  [$texStorage3D](...args) {
>+    return this.texStorage3D.apply(this, args);
>+  }
>+  [$texSubImage2D2](target, level, xoffset, yoffset, width, height, format, type, bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video, srcOffset) {
>+    if (srcOffset === void 0) srcOffset = null;
>+    if (core.int.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video) && srcOffset == null) {
>+      this[_texSubImage2D2_1](target, level, xoffset, yoffset, width, height, format, type, bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video);
>+      return;
>+    }
>+    if (html$.ImageData.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video) && srcOffset == null) {
>+      let data_1 = html_common.convertDartToNative_ImageData(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video);
>+      this[_texSubImage2D2_2](target, level, xoffset, yoffset, width, height, format, type, data_1);
>+      return;
>+    }
>+    if (html$.ImageElement.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video) && srcOffset == null) {
>+      this[_texSubImage2D2_3](target, level, xoffset, yoffset, width, height, format, type, bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video);
>+      return;
>+    }
>+    if (html$.CanvasElement.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video) && srcOffset == null) {
>+      this[_texSubImage2D2_4](target, level, xoffset, yoffset, width, height, format, type, bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video);
>+      return;
>+    }
>+    if (html$.VideoElement.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video) && srcOffset == null) {
>+      this[_texSubImage2D2_5](target, level, xoffset, yoffset, width, height, format, type, bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video);
>+      return;
>+    }
>+    if (html$.ImageBitmap.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video) && srcOffset == null) {
>+      this[_texSubImage2D2_6](target, level, xoffset, yoffset, width, height, format, type, bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video);
>+      return;
>+    }
>+    if (srcOffset != null && typed_data.TypedData.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video)) {
>+      this[_texSubImage2D2_7](target, level, xoffset, yoffset, width, height, format, type, bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_srcData_OR_video, srcOffset);
>+      return;
>+    }
>+    dart.throw(new core.ArgumentError.new("Incorrect number or type of arguments"));
>+  }
>+  [_texSubImage2D2_1](...args) {
>+    return this.texSubImage2D.apply(this, args);
>+  }
>+  [_texSubImage2D2_2](...args) {
>+    return this.texSubImage2D.apply(this, args);
>+  }
>+  [_texSubImage2D2_3](...args) {
>+    return this.texSubImage2D.apply(this, args);
>+  }
>+  [_texSubImage2D2_4](...args) {
>+    return this.texSubImage2D.apply(this, args);
>+  }
>+  [_texSubImage2D2_5](...args) {
>+    return this.texSubImage2D.apply(this, args);
>+  }
>+  [_texSubImage2D2_6](...args) {
>+    return this.texSubImage2D.apply(this, args);
>+  }
>+  [_texSubImage2D2_7](...args) {
>+    return this.texSubImage2D.apply(this, args);
>+  }
>+  [$texSubImage3D](target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video, srcOffset) {
>+    if (srcOffset === void 0) srcOffset = null;
>+    if (core.int.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video) && srcOffset == null) {
>+      this[_texSubImage3D_1](target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video);
>+      return;
>+    }
>+    if (html$.ImageData.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video) && srcOffset == null) {
>+      let data_1 = html_common.convertDartToNative_ImageData(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video);
>+      this[_texSubImage3D_2](target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data_1);
>+      return;
>+    }
>+    if (html$.ImageElement.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video) && srcOffset == null) {
>+      this[_texSubImage3D_3](target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video);
>+      return;
>+    }
>+    if (html$.CanvasElement.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video) && srcOffset == null) {
>+      this[_texSubImage3D_4](target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video);
>+      return;
>+    }
>+    if (html$.VideoElement.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video) && srcOffset == null) {
>+      this[_texSubImage3D_5](target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video);
>+      return;
>+    }
>+    if (html$.ImageBitmap.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video) && srcOffset == null) {
>+      this[_texSubImage3D_6](target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video);
>+      return;
>+    }
>+    if (typed_data.TypedData.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video) && srcOffset == null) {
>+      this[_texSubImage3D_7](target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video);
>+      return;
>+    }
>+    if (srcOffset != null && typed_data.TypedData.is(bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video)) {
>+      this[_texSubImage3D_8](target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bitmap_OR_canvas_OR_data_OR_image_OR_offset_OR_pixels_OR_video, srcOffset);
>+      return;
>+    }
>+    dart.throw(new core.ArgumentError.new("Incorrect number or type of arguments"));
>+  }
>+  [_texSubImage3D_1](...args) {
>+    return this.texSubImage3D.apply(this, args);
>+  }
>+  [_texSubImage3D_2](...args) {
>+    return this.texSubImage3D.apply(this, args);
>+  }
>+  [_texSubImage3D_3](...args) {
>+    return this.texSubImage3D.apply(this, args);
>+  }
>+  [_texSubImage3D_4](...args) {
>+    return this.texSubImage3D.apply(this, args);
>+  }
>+  [_texSubImage3D_5](...args) {
>+    return this.texSubImage3D.apply(this, args);
>+  }
>+  [_texSubImage3D_6](...args) {
>+    return this.texSubImage3D.apply(this, args);
>+  }
>+  [_texSubImage3D_7](...args) {
>+    return this.texSubImage3D.apply(this, args);
>+  }
>+  [_texSubImage3D_8](...args) {
>+    return this.texSubImage3D.apply(this, args);
>+  }
>+  [$transformFeedbackVaryings](program, varyings, bufferMode) {
>+    let varyings_1 = html_common.convertDartToNative_StringArray(varyings);
>+    this[_transformFeedbackVaryings_1](program, varyings_1, bufferMode);
>+    return;
>+  }
>+  [_transformFeedbackVaryings_1](...args) {
>+    return this.transformFeedbackVaryings.apply(this, args);
>+  }
>+  [$uniform1fv2](...args) {
>+    return this.uniform1fv.apply(this, args);
>+  }
>+  [$uniform1iv2](...args) {
>+    return this.uniform1iv.apply(this, args);
>+  }
>+  [$uniform1ui](...args) {
>+    return this.uniform1ui.apply(this, args);
>+  }
>+  [$uniform1uiv](...args) {
>+    return this.uniform1uiv.apply(this, args);
>+  }
>+  [$uniform2fv2](...args) {
>+    return this.uniform2fv.apply(this, args);
>+  }
>+  [$uniform2iv2](...args) {
>+    return this.uniform2iv.apply(this, args);
>+  }
>+  [$uniform2ui](...args) {
>+    return this.uniform2ui.apply(this, args);
>+  }
>+  [$uniform2uiv](...args) {
>+    return this.uniform2uiv.apply(this, args);
>+  }
>+  [$uniform3fv2](...args) {
>+    return this.uniform3fv.apply(this, args);
>+  }
>+  [$uniform3iv2](...args) {
>+    return this.uniform3iv.apply(this, args);
>+  }
>+  [$uniform3ui](...args) {
>+    return this.uniform3ui.apply(this, args);
>+  }
>+  [$uniform3uiv](...args) {
>+    return this.uniform3uiv.apply(this, args);
>+  }
>+  [$uniform4fv2](...args) {
>+    return this.uniform4fv.apply(this, args);
>+  }
>+  [$uniform4iv2](...args) {
>+    return this.uniform4iv.apply(this, args);
>+  }
>+  [$uniform4ui](...args) {
>+    return this.uniform4ui.apply(this, args);
>+  }
>+  [$uniform4uiv](...args) {
>+    return this.uniform4uiv.apply(this, args);
>+  }
>+  [$uniformBlockBinding](...args) {
>+    return this.uniformBlockBinding.apply(this, args);
>+  }
>+  [$uniformMatrix2fv2](...args) {
>+    return this.uniformMatrix2fv.apply(this, args);
>+  }
>+  [$uniformMatrix2x3fv](...args) {
>+    return this.uniformMatrix2x3fv.apply(this, args);
>+  }
>+  [$uniformMatrix2x4fv](...args) {
>+    return this.uniformMatrix2x4fv.apply(this, args);
>+  }
>+  [$uniformMatrix3fv2](...args) {
>+    return this.uniformMatrix3fv.apply(this, args);
>+  }
>+  [$uniformMatrix3x2fv](...args) {
>+    return this.uniformMatrix3x2fv.apply(this, args);
>+  }
>+  [$uniformMatrix3x4fv](...args) {
>+    return this.uniformMatrix3x4fv.apply(this, args);
>+  }
>+  [$uniformMatrix4fv2](...args) {
>+    return this.uniformMatrix4fv.apply(this, args);
>+  }
>+  [$uniformMatrix4x2fv](...args) {
>+    return this.uniformMatrix4x2fv.apply(this, args);
>+  }
>+  [$uniformMatrix4x3fv](...args) {
>+    return this.uniformMatrix4x3fv.apply(this, args);
>+  }
>+  [$vertexAttribDivisor](...args) {
>+    return this.vertexAttribDivisor.apply(this, args);
>+  }
>+  [$vertexAttribI4i](...args) {
>+    return this.vertexAttribI4i.apply(this, args);
>+  }
>+  [$vertexAttribI4iv](...args) {
>+    return this.vertexAttribI4iv.apply(this, args);
>+  }
>+  [$vertexAttribI4ui](...args) {
>+    return this.vertexAttribI4ui.apply(this, args);
>+  }
>+  [$vertexAttribI4uiv](...args) {
>+    return this.vertexAttribI4uiv.apply(this, args);
>+  }
>+  [$vertexAttribIPointer](...args) {
>+    return this.vertexAttribIPointer.apply(this, args);
>+  }
>+  [$waitSync](...args) {
>+    return this.waitSync.apply(this, args);
>+  }
>+  get [$drawingBufferHeight]() {
>+    return this.drawingBufferHeight;
>+  }
>+  get [$drawingBufferWidth]() {
>+    return this.drawingBufferWidth;
>+  }
>+  [$activeTexture](...args) {
>+    return this.activeTexture.apply(this, args);
>+  }
>+  [$attachShader](...args) {
>+    return this.attachShader.apply(this, args);
>+  }
>+  [$bindAttribLocation](...args) {
>+    return this.bindAttribLocation.apply(this, args);
>+  }
>+  [$bindBuffer](...args) {
>+    return this.bindBuffer.apply(this, args);
>+  }
>+  [$bindFramebuffer](...args) {
>+    return this.bindFramebuffer.apply(this, args);
>+  }
>+  [$bindRenderbuffer](...args) {
>+    return this.bindRenderbuffer.apply(this, args);
>+  }
>+  [$bindTexture](...args) {
>+    return this.bindTexture.apply(this, args);
>+  }
>+  [$blendColor](...args) {
>+    return this.blendColor.apply(this, args);
>+  }
>+  [$blendEquation](...args) {
>+    return this.blendEquation.apply(this, args);
>+  }
>+  [$blendEquationSeparate](...args) {
>+    return this.blendEquationSeparate.apply(this, args);
>+  }
>+  [$blendFunc](...args) {
>+    return this.blendFunc.apply(this, args);
>+  }
>+  [$blendFuncSeparate](...args) {
>+    return this.blendFuncSeparate.apply(this, args);
>+  }
>+  [$bufferData](...args) {
>+    return this.bufferData.apply(this, args);
>+  }
>+  [$bufferSubData](...args) {
>+    return this.bufferSubData.apply(this, args);
>+  }
>+  [$checkFramebufferStatus](...args) {
>+    return this.checkFramebufferStatus.apply(this, args);
>+  }
>+  [$clear](...args) {
>+    return this.clear.apply(this, args);
>+  }
>+  [$clearColor](...args) {
>+    return this.clearColor.apply(this, args);
>+  }
>+  [$clearDepth](...args) {
>+    return this.clearDepth.apply(this, args);
>+  }
>+  [$clearStencil](...args) {
>+    return this.clearStencil.apply(this, args);
>+  }
>+  [$colorMask](...args) {
>+    return this.colorMask.apply(this, args);
>+  }
>+  [$commit]() {
>+    return html$.promiseToFuture(dart.dynamic, this.commit());
>+  }
>+  [$compileShader](...args) {
>+    return this.compileShader.apply(this, args);
>+  }
>+  [$compressedTexImage2D](...args) {
>+    return this.compressedTexImage2D.apply(this, args);
>+  }
>+  [$compressedTexSubImage2D](...args) {
>+    return this.compressedTexSubImage2D.apply(this, args);
>+  }
>+  [$copyTexImage2D](...args) {
>+    return this.copyTexImage2D.apply(this, args);
>+  }
>+  [$copyTexSubImage2D](...args) {
>+    return this.copyTexSubImage2D.apply(this, args);
>+  }
>+  [$createBuffer](...args) {
>+    return this.createBuffer.apply(this, args);
>+  }
>+  [$createFramebuffer](...args) {
>+    return this.createFramebuffer.apply(this, args);
>+  }
>+  [$createProgram](...args) {
>+    return this.createProgram.apply(this, args);
>+  }
>+  [$createRenderbuffer](...args) {
>+    return this.createRenderbuffer.apply(this, args);
>+  }
>+  [$createShader](...args) {
>+    return this.createShader.apply(this, args);
>+  }
>+  [$createTexture](...args) {
>+    return this.createTexture.apply(this, args);
>+  }
>+  [$cullFace](...args) {
>+    return this.cullFace.apply(this, args);
>+  }
>+  [$deleteBuffer](...args) {
>+    return this.deleteBuffer.apply(this, args);
>+  }
>+  [$deleteFramebuffer](...args) {
>+    return this.deleteFramebuffer.apply(this, args);
>+  }
>+  [$deleteProgram](...args) {
>+    return this.deleteProgram.apply(this, args);
>+  }
>+  [$deleteRenderbuffer](...args) {
>+    return this.deleteRenderbuffer.apply(this, args);
>+  }
>+  [$deleteShader](...args) {
>+    return this.deleteShader.apply(this, args);
>+  }
>+  [$deleteTexture](...args) {
>+    return this.deleteTexture.apply(this, args);
>+  }
>+  [$depthFunc](...args) {
>+    return this.depthFunc.apply(this, args);
>+  }
>+  [$depthMask](...args) {
>+    return this.depthMask.apply(this, args);
>+  }
>+  [$depthRange](...args) {
>+    return this.depthRange.apply(this, args);
>+  }
>+  [$detachShader](...args) {
>+    return this.detachShader.apply(this, args);
>+  }
>+  [$disable](...args) {
>+    return this.disable.apply(this, args);
>+  }
>+  [$disableVertexAttribArray](...args) {
>+    return this.disableVertexAttribArray.apply(this, args);
>+  }
>+  [$drawArrays](...args) {
>+    return this.drawArrays.apply(this, args);
>+  }
>+  [$drawElements](...args) {
>+    return this.drawElements.apply(this, args);
>+  }
>+  [$enable](...args) {
>+    return this.enable.apply(this, args);
>+  }
>+  [$enableVertexAttribArray](...args) {
>+    return this.enableVertexAttribArray.apply(this, args);
>+  }
>+  [$finish](...args) {
>+    return this.finish.apply(this, args);
>+  }
>+  [$flush](...args) {
>+    return this.flush.apply(this, args);
>+  }
>+  [$framebufferRenderbuffer](...args) {
>+    return this.framebufferRenderbuffer.apply(this, args);
>+  }
>+  [$framebufferTexture2D](...args) {
>+    return this.framebufferTexture2D.apply(this, args);
>+  }
>+  [$frontFace](...args) {
>+    return this.frontFace.apply(this, args);
>+  }
>+  [$generateMipmap](...args) {
>+    return this.generateMipmap.apply(this, args);
>+  }
>+  [$getActiveAttrib](...args) {
>+    return this.getActiveAttrib.apply(this, args);
>+  }
>+  [$getActiveUniform](...args) {
>+    return this.getActiveUniform.apply(this, args);
>+  }
>+  [$getAttachedShaders](...args) {
>+    return this.getAttachedShaders.apply(this, args);
>+  }
>+  [$getAttribLocation](...args) {
>+    return this.getAttribLocation.apply(this, args);
>+  }
>+  [$getBufferParameter](...args) {
>+    return this.getBufferParameter.apply(this, args);
>+  }
>+  [$getContextAttributes]() {
>+    return html_common.convertNativeToDart_Dictionary(this[_getContextAttributes_1$]());
>+  }
>+  [_getContextAttributes_1$](...args) {
>+    return this.getContextAttributes.apply(this, args);
>+  }
>+  [$getError](...args) {
>+    return this.getError.apply(this, args);
>+  }
>+  [$getExtension](...args) {
>+    return this.getExtension.apply(this, args);
>+  }
>+  [$getFramebufferAttachmentParameter](...args) {
>+    return this.getFramebufferAttachmentParameter.apply(this, args);
>+  }
>+  [$getParameter](...args) {
>+    return this.getParameter.apply(this, args);
>+  }
>+  [$getProgramInfoLog](...args) {
>+    return this.getProgramInfoLog.apply(this, args);
>+  }
>+  [$getProgramParameter](...args) {
>+    return this.getProgramParameter.apply(this, args);
>+  }
>+  [$getRenderbufferParameter](...args) {
>+    return this.getRenderbufferParameter.apply(this, args);
>+  }
>+  [$getShaderInfoLog](...args) {
>+    return this.getShaderInfoLog.apply(this, args);
>+  }
>+  [$getShaderParameter](...args) {
>+    return this.getShaderParameter.apply(this, args);
>+  }
>+  [$getShaderPrecisionFormat](...args) {
>+    return this.getShaderPrecisionFormat.apply(this, args);
>+  }
>+  [$getShaderSource](...args) {
>+    return this.getShaderSource.apply(this, args);
>+  }
>+  [$getSupportedExtensions](...args) {
>+    return this.getSupportedExtensions.apply(this, args);
>+  }
>+  [$getTexParameter](...args) {
>+    return this.getTexParameter.apply(this, args);
>+  }
>+  [$getUniform](...args) {
>+    return this.getUniform.apply(this, args);
>+  }
>+  [$getUniformLocation](...args) {
>+    return this.getUniformLocation.apply(this, args);
>+  }
>+  [$getVertexAttrib](...args) {
>+    return this.getVertexAttrib.apply(this, args);
>+  }
>+  [$getVertexAttribOffset](...args) {
>+    return this.getVertexAttribOffset.apply(this, args);
>+  }
>+  [$hint](...args) {
>+    return this.hint.apply(this, args);
>+  }
>+  [$isBuffer](...args) {
>+    return this.isBuffer.apply(this, args);
>+  }
>+  [$isContextLost](...args) {
>+    return this.isContextLost.apply(this, args);
>+  }
>+  [$isEnabled](...args) {
>+    return this.isEnabled.apply(this, args);
>+  }
>+  [$isFramebuffer](...args) {
>+    return this.isFramebuffer.apply(this, args);
>+  }
>+  [$isProgram](...args) {
>+    return this.isProgram.apply(this, args);
>+  }
>+  [$isRenderbuffer](...args) {
>+    return this.isRenderbuffer.apply(this, args);
>+  }
>+  [$isShader](...args) {
>+    return this.isShader.apply(this, args);
>+  }
>+  [$isTexture](...args) {
>+    return this.isTexture.apply(this, args);
>+  }
>+  [$lineWidth](...args) {
>+    return this.lineWidth.apply(this, args);
>+  }
>+  [$linkProgram](...args) {
>+    return this.linkProgram.apply(this, args);
>+  }
>+  [$pixelStorei](...args) {
>+    return this.pixelStorei.apply(this, args);
>+  }
>+  [$polygonOffset](...args) {
>+    return this.polygonOffset.apply(this, args);
>+  }
>+  [_readPixels](...args) {
>+    return this.readPixels.apply(this, args);
>+  }
>+  [$renderbufferStorage](...args) {
>+    return this.renderbufferStorage.apply(this, args);
>+  }
>+  [$sampleCoverage](...args) {
>+    return this.sampleCoverage.apply(this, args);
>+  }
>+  [$scissor](...args) {
>+    return this.scissor.apply(this, args);
>+  }
>+  [$shaderSource](...args) {
>+    return this.shaderSource.apply(this, args);
>+  }
>+  [$stencilFunc](...args) {
>+    return this.stencilFunc.apply(this, args);
>+  }
>+  [$stencilFuncSeparate](...args) {
>+    return this.stencilFuncSeparate.apply(this, args);
>+  }
>+  [$stencilMask](...args) {
>+    return this.stencilMask.apply(this, args);
>+  }
>+  [$stencilMaskSeparate](...args) {
>+    return this.stencilMaskSeparate.apply(this, args);
>+  }
>+  [$stencilOp](...args) {
>+    return this.stencilOp.apply(this, args);
>+  }
>+  [$stencilOpSeparate](...args) {
>+    return this.stencilOpSeparate.apply(this, args);
>+  }
>+  [$texImage2D](target, level, internalformat, format_OR_width, height_OR_type, bitmap_OR_border_OR_canvas_OR_image_OR_pixels_OR_video, format, type, pixels) {
>+    if (format === void 0) format = null;
>+    if (type === void 0) type = null;
>+    if (pixels === void 0) pixels = null;
>+    if (type != null && format != null && core.int.is(bitmap_OR_border_OR_canvas_OR_image_OR_pixels_OR_video)) {
>+      this[_texImage2D_1](target, level, internalformat, format_OR_width, height_OR_type, bitmap_OR_border_OR_canvas_OR_image_OR_pixels_OR_video, format, type, pixels);
>+      return;
>+    }
>+    if (html$.ImageData.is(bitmap_OR_border_OR_canvas_OR_image_OR_pixels_OR_video) && format == null && type == null && pixels == null) {
>+      let pixels_1 = html_common.convertDartToNative_ImageData(bitmap_OR_border_OR_canvas_OR_image_OR_pixels_OR_video);
>+      this[_texImage2D_2](target, level, internalformat, format_OR_width, height_OR_type, pixels_1);
>+      return;
>+    }
>+    if (html$.ImageElement.is(bitmap_OR_border_OR_canvas_OR_image_OR_pixels_OR_video) && format == null && type == null && pixels == null) {
>+      this[_texImage2D_3](target, level, internalformat, format_OR_width, height_OR_type, bitmap_OR_border_OR_canvas_OR_image_OR_pixels_OR_video);
>+      return;
>+    }
>+    if (html$.CanvasElement.is(bitmap_OR_border_OR_canvas_OR_image_OR_pixels_OR_video) && format == null && type == null && pixels == null) {
>+      this[_texImage2D_4](target, level, internalformat, format_OR_width, height_OR_type, bitmap_OR_border_OR_canvas_OR_image_OR_pixels_OR_video);
>+      return;
>+    }
>+    if (html$.VideoElement.is(bitmap_OR_border_OR_canvas_OR_image_OR_pixels_OR_video) && format == null && type == null && pixels == null) {
>+      this[_texImage2D_5](target, level, internalformat, format_OR_width, height_OR_type, bitmap_OR_border_OR_canvas_OR_image_OR_pixels_OR_video);
>+      return;
>+    }
>+    if (html$.ImageBitmap.is(bitmap_OR_border_OR_canvas_OR_image_OR_pixels_OR_video) && format == null && type == null && pixels == null) {
>+      this[_texImage2D_6](target, level, internalformat, format_OR_width, height_OR_type, bitmap_OR_border_OR_canvas_OR_image_OR_pixels_OR_video);
>+      return;
>+    }
>+    dart.throw(new core.ArgumentError.new("Incorrect number or type of arguments"));
>+  }
>+  [_texImage2D_1](...args) {
>+    return this.texImage2D.apply(this, args);
>+  }
>+  [_texImage2D_2](...args) {
>+    return this.texImage2D.apply(this, args);
>+  }
>+  [_texImage2D_3](...args) {
>+    return this.texImage2D.apply(this, args);
>+  }
>+  [_texImage2D_4](...args) {
>+    return this.texImage2D.apply(this, args);
>+  }
>+  [_texImage2D_5](...args) {
>+    return this.texImage2D.apply(this, args);
>+  }
>+  [_texImage2D_6](...args) {
>+    return this.texImage2D.apply(this, args);
>+  }
>+  [$texParameterf](...args) {
>+    return this.texParameterf.apply(this, args);
>+  }
>+  [$texParameteri](...args) {
>+    return this.texParameteri.apply(this, args);
>+  }
>+  [$texSubImage2D](target, level, xoffset, yoffset, format_OR_width, height_OR_type, bitmap_OR_canvas_OR_format_OR_image_OR_pixels_OR_video, type, pixels) {
>+    if (type === void 0) type = null;
>+    if (pixels === void 0) pixels = null;
>+    if (type != null && core.int.is(bitmap_OR_canvas_OR_format_OR_image_OR_pixels_OR_video)) {
>+      this[_texSubImage2D_1](target, level, xoffset, yoffset, format_OR_width, height_OR_type, bitmap_OR_canvas_OR_format_OR_image_OR_pixels_OR_video, type, pixels);
>+      return;
>+    }
>+    if (html$.ImageData.is(bitmap_OR_canvas_OR_format_OR_image_OR_pixels_OR_video) && type == null && pixels == null) {
>+      let pixels_1 = html_common.convertDartToNative_ImageData(bitmap_OR_canvas_OR_format_OR_image_OR_pixels_OR_video);
>+      this[_texSubImage2D_2](target, level, xoffset, yoffset, format_OR_width, height_OR_type, pixels_1);
>+      return;
>+    }
>+    if (html$.ImageElement.is(bitmap_OR_canvas_OR_format_OR_image_OR_pixels_OR_video) && type == null && pixels == null) {
>+      this[_texSubImage2D_3](target, level, xoffset, yoffset, format_OR_width, height_OR_type, bitmap_OR_canvas_OR_format_OR_image_OR_pixels_OR_video);
>+      return;
>+    }
>+    if (html$.CanvasElement.is(bitmap_OR_canvas_OR_format_OR_image_OR_pixels_OR_video) && type == null && pixels == null) {
>+      this[_texSubImage2D_4](target, level, xoffset, yoffset, format_OR_width, height_OR_type, bitmap_OR_canvas_OR_format_OR_image_OR_pixels_OR_video);
>+      return;
>+    }
>+    if (html$.VideoElement.is(bitmap_OR_canvas_OR_format_OR_image_OR_pixels_OR_video) && type == null && pixels == null) {
>+      this[_texSubImage2D_5](target, level, xoffset, yoffset, format_OR_width, height_OR_type, bitmap_OR_canvas_OR_format_OR_image_OR_pixels_OR_video);
>+      return;
>+    }
>+    if (html$.ImageBitmap.is(bitmap_OR_canvas_OR_format_OR_image_OR_pixels_OR_video) && type == null && pixels == null) {
>+      this[_texSubImage2D_6](target, level, xoffset, yoffset, format_OR_width, height_OR_type, bitmap_OR_canvas_OR_format_OR_image_OR_pixels_OR_video);
>+      return;
>+    }
>+    dart.throw(new core.ArgumentError.new("Incorrect number or type of arguments"));
>+  }
>+  [_texSubImage2D_1](...args) {
>+    return this.texSubImage2D.apply(this, args);
>+  }
>+  [_texSubImage2D_2](...args) {
>+    return this.texSubImage2D.apply(this, args);
>+  }
>+  [_texSubImage2D_3](...args) {
>+    return this.texSubImage2D.apply(this, args);
>+  }
>+  [_texSubImage2D_4](...args) {
>+    return this.texSubImage2D.apply(this, args);
>+  }
>+  [_texSubImage2D_5](...args) {
>+    return this.texSubImage2D.apply(this, args);
>+  }
>+  [_texSubImage2D_6](...args) {
>+    return this.texSubImage2D.apply(this, args);
>+  }
>+  [$uniform1f](...args) {
>+    return this.uniform1f.apply(this, args);
>+  }
>+  [$uniform1fv](...args) {
>+    return this.uniform1fv.apply(this, args);
>+  }
>+  [$uniform1i](...args) {
>+    return this.uniform1i.apply(this, args);
>+  }
>+  [$uniform1iv](...args) {
>+    return this.uniform1iv.apply(this, args);
>+  }
>+  [$uniform2f](...args) {
>+    return this.uniform2f.apply(this, args);
>+  }
>+  [$uniform2fv](...args) {
>+    return this.uniform2fv.apply(this, args);
>+  }
>+  [$uniform2i](...args) {
>+    return this.uniform2i.apply(this, args);
>+  }
>+  [$uniform2iv](...args) {
>+    return this.uniform2iv.apply(this, args);
>+  }
>+  [$uniform3f](...args) {
>+    return this.uniform3f.apply(this, args);
>+  }
>+  [$uniform3fv](...args) {
>+    return this.uniform3fv.apply(this, args);
>+  }
>+  [$uniform3i](...args) {
>+    return this.uniform3i.apply(this, args);
>+  }
>+  [$uniform3iv](...args) {
>+    return this.uniform3iv.apply(this, args);
>+  }
>+  [$uniform4f](...args) {
>+    return this.uniform4f.apply(this, args);
>+  }
>+  [$uniform4fv](...args) {
>+    return this.uniform4fv.apply(this, args);
>+  }
>+  [$uniform4i](...args) {
>+    return this.uniform4i.apply(this, args);
>+  }
>+  [$uniform4iv](...args) {
>+    return this.uniform4iv.apply(this, args);
>+  }
>+  [$uniformMatrix2fv](...args) {
>+    return this.uniformMatrix2fv.apply(this, args);
>+  }
>+  [$uniformMatrix3fv](...args) {
>+    return this.uniformMatrix3fv.apply(this, args);
>+  }
>+  [$uniformMatrix4fv](...args) {
>+    return this.uniformMatrix4fv.apply(this, args);
>+  }
>+  [$useProgram](...args) {
>+    return this.useProgram.apply(this, args);
>+  }
>+  [$validateProgram](...args) {
>+    return this.validateProgram.apply(this, args);
>+  }
>+  [$vertexAttrib1f](...args) {
>+    return this.vertexAttrib1f.apply(this, args);
>+  }
>+  [$vertexAttrib1fv](...args) {
>+    return this.vertexAttrib1fv.apply(this, args);
>+  }
>+  [$vertexAttrib2f](...args) {
>+    return this.vertexAttrib2f.apply(this, args);
>+  }
>+  [$vertexAttrib2fv](...args) {
>+    return this.vertexAttrib2fv.apply(this, args);
>+  }
>+  [$vertexAttrib3f](...args) {
>+    return this.vertexAttrib3f.apply(this, args);
>+  }
>+  [$vertexAttrib3fv](...args) {
>+    return this.vertexAttrib3fv.apply(this, args);
>+  }
>+  [$vertexAttrib4f](...args) {
>+    return this.vertexAttrib4f.apply(this, args);
>+  }
>+  [$vertexAttrib4fv](...args) {
>+    return this.vertexAttrib4fv.apply(this, args);
>+  }
>+  [$vertexAttribPointer](...args) {
>+    return this.vertexAttribPointer.apply(this, args);
>+  }
>+  [$viewport](...args) {
>+    return this.viewport.apply(this, args);
>+  }
>+  [$readPixels](x, y, width, height, format, type, pixels) {
>+    this[_readPixels](x, y, width, height, format, type, pixels);
>+  }
>+};
>+dart.addTypeTests(web_gl.RenderingContext2);
>+const canvas$4 = Symbol("RenderingContext2.canvas");
>+const drawingBufferHeight$ = Symbol("RenderingContext2.drawingBufferHeight");
>+const drawingBufferWidth$ = Symbol("RenderingContext2.drawingBufferWidth");
>+web_gl.RenderingContext2[dart.implements] = () => [web_gl._WebGL2RenderingContextBase, web_gl._WebGLRenderingContextBase];
>+dart.setMethodSignature(web_gl.RenderingContext2, () => ({
>+  __proto__: dart.getMethods(web_gl.RenderingContext2.__proto__),
>+  [$beginQuery]: dart.fnType(dart.void, [core.int, web_gl.Query]),
>+  [$beginTransformFeedback]: dart.fnType(dart.void, [core.int]),
>+  [$bindBufferBase]: dart.fnType(dart.void, [core.int, core.int, web_gl.Buffer]),
>+  [$bindBufferRange]: dart.fnType(dart.void, [core.int, core.int, web_gl.Buffer, core.int, core.int]),
>+  [$bindSampler]: dart.fnType(dart.void, [core.int, web_gl.Sampler]),
>+  [$bindTransformFeedback]: dart.fnType(dart.void, [core.int, web_gl.TransformFeedback]),
>+  [$bindVertexArray]: dart.fnType(dart.void, [web_gl.VertexArrayObject]),
>+  [$blitFramebuffer]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int]),
>+  [$bufferData2]: dart.fnType(dart.void, [core.int, typed_data.TypedData, core.int, core.int], [core.int]),
>+  [$bufferSubData2]: dart.fnType(dart.void, [core.int, core.int, typed_data.TypedData, core.int], [core.int]),
>+  [$clearBufferfi]: dart.fnType(dart.void, [core.int, core.int, core.num, core.int]),
>+  [$clearBufferfv]: dart.fnType(dart.void, [core.int, core.int, dart.dynamic], [core.int]),
>+  [$clearBufferiv]: dart.fnType(dart.void, [core.int, core.int, dart.dynamic], [core.int]),
>+  [$clearBufferuiv]: dart.fnType(dart.void, [core.int, core.int, dart.dynamic], [core.int]),
>+  [$clientWaitSync]: dart.fnType(core.int, [web_gl.Sync, core.int, core.int]),
>+  [$compressedTexImage2D2]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, typed_data.TypedData, core.int], [core.int]),
>+  [$compressedTexImage2D3]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int]),
>+  [$compressedTexImage3D]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, core.int, typed_data.TypedData], [core.int, core.int]),
>+  [$compressedTexImage3D2]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int]),
>+  [$compressedTexSubImage2D2]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, core.int, typed_data.TypedData, core.int], [core.int]),
>+  [$compressedTexSubImage2D3]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int]),
>+  [$compressedTexSubImage3D]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int, typed_data.TypedData], [core.int, core.int]),
>+  [$compressedTexSubImage3D2]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int]),
>+  [$copyBufferSubData]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int]),
>+  [$copyTexSubImage3D]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int]),
>+  [$createQuery]: dart.fnType(web_gl.Query, []),
>+  [$createSampler]: dart.fnType(web_gl.Sampler, []),
>+  [$createTransformFeedback]: dart.fnType(web_gl.TransformFeedback, []),
>+  [$createVertexArray]: dart.fnType(web_gl.VertexArrayObject, []),
>+  [$deleteQuery]: dart.fnType(dart.void, [web_gl.Query]),
>+  [$deleteSampler]: dart.fnType(dart.void, [web_gl.Sampler]),
>+  [$deleteSync]: dart.fnType(dart.void, [web_gl.Sync]),
>+  [$deleteTransformFeedback]: dart.fnType(dart.void, [web_gl.TransformFeedback]),
>+  [$deleteVertexArray]: dart.fnType(dart.void, [web_gl.VertexArrayObject]),
>+  [$drawArraysInstanced]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int]),
>+  [$drawBuffers]: dart.fnType(dart.void, [core.List$(core.int)]),
>+  [$drawElementsInstanced]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int]),
>+  [$drawRangeElements]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int]),
>+  [$endQuery]: dart.fnType(dart.void, [core.int]),
>+  [$endTransformFeedback]: dart.fnType(dart.void, []),
>+  [$fenceSync]: dart.fnType(web_gl.Sync, [core.int, core.int]),
>+  [$framebufferTextureLayer]: dart.fnType(dart.void, [core.int, core.int, web_gl.Texture, core.int, core.int]),
>+  [$getActiveUniformBlockName]: dart.fnType(core.String, [web_gl.Program, core.int]),
>+  [$getActiveUniformBlockParameter]: dart.fnType(core.Object, [web_gl.Program, core.int, core.int]),
>+  [$getActiveUniforms]: dart.fnType(core.Object, [web_gl.Program, core.List$(core.int), core.int]),
>+  [$getBufferSubData]: dart.fnType(dart.void, [core.int, core.int, typed_data.TypedData], [core.int, core.int]),
>+  [$getFragDataLocation]: dart.fnType(core.int, [web_gl.Program, core.String]),
>+  [$getIndexedParameter]: dart.fnType(core.Object, [core.int, core.int]),
>+  [$getInternalformatParameter]: dart.fnType(core.Object, [core.int, core.int, core.int]),
>+  [$getQuery]: dart.fnType(core.Object, [core.int, core.int]),
>+  [$getQueryParameter]: dart.fnType(core.Object, [web_gl.Query, core.int]),
>+  [$getSamplerParameter]: dart.fnType(core.Object, [web_gl.Sampler, core.int]),
>+  [$getSyncParameter]: dart.fnType(core.Object, [web_gl.Sync, core.int]),
>+  [$getTransformFeedbackVarying]: dart.fnType(web_gl.ActiveInfo, [web_gl.Program, core.int]),
>+  [$getUniformBlockIndex]: dart.fnType(core.int, [web_gl.Program, core.String]),
>+  [$getUniformIndices]: dart.fnType(core.List$(core.int), [web_gl.Program, core.List$(core.String)]),
>+  [_getUniformIndices_1]: dart.fnType(core.List$(core.int), [web_gl.Program, core.List]),
>+  [$invalidateFramebuffer]: dart.fnType(dart.void, [core.int, core.List$(core.int)]),
>+  [$invalidateSubFramebuffer]: dart.fnType(dart.void, [core.int, core.List$(core.int), core.int, core.int, core.int, core.int]),
>+  [$isQuery]: dart.fnType(core.bool, [web_gl.Query]),
>+  [$isSampler]: dart.fnType(core.bool, [web_gl.Sampler]),
>+  [$isSync]: dart.fnType(core.bool, [web_gl.Sync]),
>+  [$isTransformFeedback]: dart.fnType(core.bool, [web_gl.TransformFeedback]),
>+  [$isVertexArray]: dart.fnType(core.bool, [web_gl.VertexArrayObject]),
>+  [$pauseTransformFeedback]: dart.fnType(dart.void, []),
>+  [$readBuffer]: dart.fnType(dart.void, [core.int]),
>+  [$readPixels2]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, dart.dynamic], [core.int]),
>+  [$renderbufferStorageMultisample]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int]),
>+  [$resumeTransformFeedback]: dart.fnType(dart.void, []),
>+  [$samplerParameterf]: dart.fnType(dart.void, [web_gl.Sampler, core.int, core.num]),
>+  [$samplerParameteri]: dart.fnType(dart.void, [web_gl.Sampler, core.int, core.int]),
>+  [$texImage2D2]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int, dart.dynamic], [core.int]),
>+  [_texImage2D2_1]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, core.int]),
>+  [_texImage2D2_2]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic]),
>+  [_texImage2D2_3]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.ImageElement]),
>+  [_texImage2D2_4]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.CanvasElement]),
>+  [_texImage2D2_5]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.VideoElement]),
>+  [_texImage2D2_6]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.ImageBitmap]),
>+  [_texImage2D2_7]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, typed_data.TypedData, dart.dynamic]),
>+  [$texImage3D]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int, dart.dynamic], [core.int]),
>+  [_texImage3D_1]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, core.int]),
>+  [_texImage3D_2]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic]),
>+  [_texImage3D_3]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.ImageElement]),
>+  [_texImage3D_4]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.CanvasElement]),
>+  [_texImage3D_5]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.VideoElement]),
>+  [_texImage3D_6]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.ImageBitmap]),
>+  [_texImage3D_7]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, typed_data.TypedData]),
>+  [_texImage3D_8]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, typed_data.TypedData, dart.dynamic]),
>+  [$texStorage2D]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int]),
>+  [$texStorage3D]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int]),
>+  [$texSubImage2D2]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int, dart.dynamic], [core.int]),
>+  [_texSubImage2D2_1]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, core.int]),
>+  [_texSubImage2D2_2]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic]),
>+  [_texSubImage2D2_3]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.ImageElement]),
>+  [_texSubImage2D2_4]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.CanvasElement]),
>+  [_texSubImage2D2_5]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.VideoElement]),
>+  [_texSubImage2D2_6]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.ImageBitmap]),
>+  [_texSubImage2D2_7]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, typed_data.TypedData, dart.dynamic]),
>+  [$texSubImage3D]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int, dart.dynamic], [core.int]),
>+  [_texSubImage3D_1]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, core.int]),
>+  [_texSubImage3D_2]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic]),
>+  [_texSubImage3D_3]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.ImageElement]),
>+  [_texSubImage3D_4]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.CanvasElement]),
>+  [_texSubImage3D_5]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.VideoElement]),
>+  [_texSubImage3D_6]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.ImageBitmap]),
>+  [_texSubImage3D_7]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, typed_data.TypedData]),
>+  [_texSubImage3D_8]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, typed_data.TypedData, dart.dynamic]),
>+  [$transformFeedbackVaryings]: dart.fnType(dart.void, [web_gl.Program, core.List$(core.String), core.int]),
>+  [_transformFeedbackVaryings_1]: dart.fnType(dart.void, [web_gl.Program, core.List, dart.dynamic]),
>+  [$uniform1fv2]: dart.fnType(dart.void, [web_gl.UniformLocation, dart.dynamic, core.int], [core.int]),
>+  [$uniform1iv2]: dart.fnType(dart.void, [web_gl.UniformLocation, dart.dynamic, core.int], [core.int]),
>+  [$uniform1ui]: dart.fnType(dart.void, [web_gl.UniformLocation, core.int]),
>+  [$uniform1uiv]: dart.fnType(dart.void, [web_gl.UniformLocation, dart.dynamic], [core.int, core.int]),
>+  [$uniform2fv2]: dart.fnType(dart.void, [web_gl.UniformLocation, dart.dynamic, core.int], [core.int]),
>+  [$uniform2iv2]: dart.fnType(dart.void, [web_gl.UniformLocation, dart.dynamic, core.int], [core.int]),
>+  [$uniform2ui]: dart.fnType(dart.void, [web_gl.UniformLocation, core.int, core.int]),
>+  [$uniform2uiv]: dart.fnType(dart.void, [web_gl.UniformLocation, dart.dynamic], [core.int, core.int]),
>+  [$uniform3fv2]: dart.fnType(dart.void, [web_gl.UniformLocation, dart.dynamic, core.int], [core.int]),
>+  [$uniform3iv2]: dart.fnType(dart.void, [web_gl.UniformLocation, dart.dynamic, core.int], [core.int]),
>+  [$uniform3ui]: dart.fnType(dart.void, [web_gl.UniformLocation, core.int, core.int, core.int]),
>+  [$uniform3uiv]: dart.fnType(dart.void, [web_gl.UniformLocation, dart.dynamic], [core.int, core.int]),
>+  [$uniform4fv2]: dart.fnType(dart.void, [web_gl.UniformLocation, dart.dynamic, core.int], [core.int]),
>+  [$uniform4iv2]: dart.fnType(dart.void, [web_gl.UniformLocation, dart.dynamic, core.int], [core.int]),
>+  [$uniform4ui]: dart.fnType(dart.void, [web_gl.UniformLocation, core.int, core.int, core.int, core.int]),
>+  [$uniform4uiv]: dart.fnType(dart.void, [web_gl.UniformLocation, dart.dynamic], [core.int, core.int]),
>+  [$uniformBlockBinding]: dart.fnType(dart.void, [web_gl.Program, core.int, core.int]),
>+  [$uniformMatrix2fv2]: dart.fnType(dart.void, [web_gl.UniformLocation, core.bool, dart.dynamic, core.int], [core.int]),
>+  [$uniformMatrix2x3fv]: dart.fnType(dart.void, [web_gl.UniformLocation, core.bool, dart.dynamic], [core.int, core.int]),
>+  [$uniformMatrix2x4fv]: dart.fnType(dart.void, [web_gl.UniformLocation, core.bool, dart.dynamic], [core.int, core.int]),
>+  [$uniformMatrix3fv2]: dart.fnType(dart.void, [web_gl.UniformLocation, core.bool, dart.dynamic, core.int], [core.int]),
>+  [$uniformMatrix3x2fv]: dart.fnType(dart.void, [web_gl.UniformLocation, core.bool, dart.dynamic], [core.int, core.int]),
>+  [$uniformMatrix3x4fv]: dart.fnType(dart.void, [web_gl.UniformLocation, core.bool, dart.dynamic], [core.int, core.int]),
>+  [$uniformMatrix4fv2]: dart.fnType(dart.void, [web_gl.UniformLocation, core.bool, dart.dynamic, core.int], [core.int]),
>+  [$uniformMatrix4x2fv]: dart.fnType(dart.void, [web_gl.UniformLocation, core.bool, dart.dynamic], [core.int, core.int]),
>+  [$uniformMatrix4x3fv]: dart.fnType(dart.void, [web_gl.UniformLocation, core.bool, dart.dynamic], [core.int, core.int]),
>+  [$vertexAttribDivisor]: dart.fnType(dart.void, [core.int, core.int]),
>+  [$vertexAttribI4i]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int]),
>+  [$vertexAttribI4iv]: dart.fnType(dart.void, [core.int, dart.dynamic]),
>+  [$vertexAttribI4ui]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int]),
>+  [$vertexAttribI4uiv]: dart.fnType(dart.void, [core.int, dart.dynamic]),
>+  [$vertexAttribIPointer]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int]),
>+  [$waitSync]: dart.fnType(dart.void, [web_gl.Sync, core.int, core.int]),
>+  [$activeTexture]: dart.fnType(dart.void, [core.int]),
>+  [$attachShader]: dart.fnType(dart.void, [web_gl.Program, web_gl.Shader]),
>+  [$bindAttribLocation]: dart.fnType(dart.void, [web_gl.Program, core.int, core.String]),
>+  [$bindBuffer]: dart.fnType(dart.void, [core.int, web_gl.Buffer]),
>+  [$bindFramebuffer]: dart.fnType(dart.void, [core.int, web_gl.Framebuffer]),
>+  [$bindRenderbuffer]: dart.fnType(dart.void, [core.int, web_gl.Renderbuffer]),
>+  [$bindTexture]: dart.fnType(dart.void, [core.int, web_gl.Texture]),
>+  [$blendColor]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num]),
>+  [$blendEquation]: dart.fnType(dart.void, [core.int]),
>+  [$blendEquationSeparate]: dart.fnType(dart.void, [core.int, core.int]),
>+  [$blendFunc]: dart.fnType(dart.void, [core.int, core.int]),
>+  [$blendFuncSeparate]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int]),
>+  [$bufferData]: dart.fnType(dart.void, [core.int, dart.dynamic, core.int]),
>+  [$bufferSubData]: dart.fnType(dart.void, [core.int, core.int, dart.dynamic]),
>+  [$checkFramebufferStatus]: dart.fnType(core.int, [core.int]),
>+  [$clear]: dart.fnType(dart.void, [core.int]),
>+  [$clearColor]: dart.fnType(dart.void, [core.num, core.num, core.num, core.num]),
>+  [$clearDepth]: dart.fnType(dart.void, [core.num]),
>+  [$clearStencil]: dart.fnType(dart.void, [core.int]),
>+  [$colorMask]: dart.fnType(dart.void, [core.bool, core.bool, core.bool, core.bool]),
>+  [$commit]: dart.fnType(async.Future, []),
>+  [$compileShader]: dart.fnType(dart.void, [web_gl.Shader]),
>+  [$compressedTexImage2D]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, typed_data.TypedData]),
>+  [$compressedTexSubImage2D]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, core.int, typed_data.TypedData]),
>+  [$copyTexImage2D]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int]),
>+  [$copyTexSubImage2D]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, core.int, core.int]),
>+  [$createBuffer]: dart.fnType(web_gl.Buffer, []),
>+  [$createFramebuffer]: dart.fnType(web_gl.Framebuffer, []),
>+  [$createProgram]: dart.fnType(web_gl.Program, []),
>+  [$createRenderbuffer]: dart.fnType(web_gl.Renderbuffer, []),
>+  [$createShader]: dart.fnType(web_gl.Shader, [core.int]),
>+  [$createTexture]: dart.fnType(web_gl.Texture, []),
>+  [$cullFace]: dart.fnType(dart.void, [core.int]),
>+  [$deleteBuffer]: dart.fnType(dart.void, [web_gl.Buffer]),
>+  [$deleteFramebuffer]: dart.fnType(dart.void, [web_gl.Framebuffer]),
>+  [$deleteProgram]: dart.fnType(dart.void, [web_gl.Program]),
>+  [$deleteRenderbuffer]: dart.fnType(dart.void, [web_gl.Renderbuffer]),
>+  [$deleteShader]: dart.fnType(dart.void, [web_gl.Shader]),
>+  [$deleteTexture]: dart.fnType(dart.void, [web_gl.Texture]),
>+  [$depthFunc]: dart.fnType(dart.void, [core.int]),
>+  [$depthMask]: dart.fnType(dart.void, [core.bool]),
>+  [$depthRange]: dart.fnType(dart.void, [core.num, core.num]),
>+  [$detachShader]: dart.fnType(dart.void, [web_gl.Program, web_gl.Shader]),
>+  [$disable]: dart.fnType(dart.void, [core.int]),
>+  [$disableVertexAttribArray]: dart.fnType(dart.void, [core.int]),
>+  [$drawArrays]: dart.fnType(dart.void, [core.int, core.int, core.int]),
>+  [$drawElements]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int]),
>+  [$enable]: dart.fnType(dart.void, [core.int]),
>+  [$enableVertexAttribArray]: dart.fnType(dart.void, [core.int]),
>+  [$finish]: dart.fnType(dart.void, []),
>+  [$flush]: dart.fnType(dart.void, []),
>+  [$framebufferRenderbuffer]: dart.fnType(dart.void, [core.int, core.int, core.int, web_gl.Renderbuffer]),
>+  [$framebufferTexture2D]: dart.fnType(dart.void, [core.int, core.int, core.int, web_gl.Texture, core.int]),
>+  [$frontFace]: dart.fnType(dart.void, [core.int]),
>+  [$generateMipmap]: dart.fnType(dart.void, [core.int]),
>+  [$getActiveAttrib]: dart.fnType(web_gl.ActiveInfo, [web_gl.Program, core.int]),
>+  [$getActiveUniform]: dart.fnType(web_gl.ActiveInfo, [web_gl.Program, core.int]),
>+  [$getAttachedShaders]: dart.fnType(core.List$(web_gl.Shader), [web_gl.Program]),
>+  [$getAttribLocation]: dart.fnType(core.int, [web_gl.Program, core.String]),
>+  [$getBufferParameter]: dart.fnType(core.Object, [core.int, core.int]),
>+  [$getContextAttributes]: dart.fnType(core.Map, []),
>+  [_getContextAttributes_1$]: dart.fnType(dart.dynamic, []),
>+  [$getError]: dart.fnType(core.int, []),
>+  [$getExtension]: dart.fnType(core.Object, [core.String]),
>+  [$getFramebufferAttachmentParameter]: dart.fnType(core.Object, [core.int, core.int, core.int]),
>+  [$getParameter]: dart.fnType(core.Object, [core.int]),
>+  [$getProgramInfoLog]: dart.fnType(core.String, [web_gl.Program]),
>+  [$getProgramParameter]: dart.fnType(core.Object, [web_gl.Program, core.int]),
>+  [$getRenderbufferParameter]: dart.fnType(core.Object, [core.int, core.int]),
>+  [$getShaderInfoLog]: dart.fnType(core.String, [web_gl.Shader]),
>+  [$getShaderParameter]: dart.fnType(core.Object, [web_gl.Shader, core.int]),
>+  [$getShaderPrecisionFormat]: dart.fnType(web_gl.ShaderPrecisionFormat, [core.int, core.int]),
>+  [$getShaderSource]: dart.fnType(core.String, [web_gl.Shader]),
>+  [$getSupportedExtensions]: dart.fnType(core.List$(core.String), []),
>+  [$getTexParameter]: dart.fnType(core.Object, [core.int, core.int]),
>+  [$getUniform]: dart.fnType(core.Object, [web_gl.Program, web_gl.UniformLocation]),
>+  [$getUniformLocation]: dart.fnType(web_gl.UniformLocation, [web_gl.Program, core.String]),
>+  [$getVertexAttrib]: dart.fnType(core.Object, [core.int, core.int]),
>+  [$getVertexAttribOffset]: dart.fnType(core.int, [core.int, core.int]),
>+  [$hint]: dart.fnType(dart.void, [core.int, core.int]),
>+  [$isBuffer]: dart.fnType(core.bool, [web_gl.Buffer]),
>+  [$isContextLost]: dart.fnType(core.bool, []),
>+  [$isEnabled]: dart.fnType(core.bool, [core.int]),
>+  [$isFramebuffer]: dart.fnType(core.bool, [web_gl.Framebuffer]),
>+  [$isProgram]: dart.fnType(core.bool, [web_gl.Program]),
>+  [$isRenderbuffer]: dart.fnType(core.bool, [web_gl.Renderbuffer]),
>+  [$isShader]: dart.fnType(core.bool, [web_gl.Shader]),
>+  [$isTexture]: dart.fnType(core.bool, [web_gl.Texture]),
>+  [$lineWidth]: dart.fnType(dart.void, [core.num]),
>+  [$linkProgram]: dart.fnType(dart.void, [web_gl.Program]),
>+  [$pixelStorei]: dart.fnType(dart.void, [core.int, core.int]),
>+  [$polygonOffset]: dart.fnType(dart.void, [core.num, core.num]),
>+  [_readPixels]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, typed_data.TypedData]),
>+  [$renderbufferStorage]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int]),
>+  [$sampleCoverage]: dart.fnType(dart.void, [core.num, core.bool]),
>+  [$scissor]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int]),
>+  [$shaderSource]: dart.fnType(dart.void, [web_gl.Shader, core.String]),
>+  [$stencilFunc]: dart.fnType(dart.void, [core.int, core.int, core.int]),
>+  [$stencilFuncSeparate]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int]),
>+  [$stencilMask]: dart.fnType(dart.void, [core.int]),
>+  [$stencilMaskSeparate]: dart.fnType(dart.void, [core.int, core.int]),
>+  [$stencilOp]: dart.fnType(dart.void, [core.int, core.int, core.int]),
>+  [$stencilOpSeparate]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int]),
>+  [$texImage2D]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, dart.dynamic], [core.int, core.int, typed_data.TypedData]),
>+  [_texImage2D_1]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, core.int, dart.dynamic, dart.dynamic, typed_data.TypedData]),
>+  [_texImage2D_2]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic]),
>+  [_texImage2D_3]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.ImageElement]),
>+  [_texImage2D_4]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.CanvasElement]),
>+  [_texImage2D_5]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.VideoElement]),
>+  [_texImage2D_6]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.ImageBitmap]),
>+  [$texParameterf]: dart.fnType(dart.void, [core.int, core.int, core.num]),
>+  [$texParameteri]: dart.fnType(dart.void, [core.int, core.int, core.int]),
>+  [$texSubImage2D]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, dart.dynamic], [core.int, typed_data.TypedData]),
>+  [_texSubImage2D_1]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, core.int, dart.dynamic, typed_data.TypedData]),
>+  [_texSubImage2D_2]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic]),
>+  [_texSubImage2D_3]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.ImageElement]),
>+  [_texSubImage2D_4]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.CanvasElement]),
>+  [_texSubImage2D_5]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.VideoElement]),
>+  [_texSubImage2D_6]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, html$.ImageBitmap]),
>+  [$uniform1f]: dart.fnType(dart.void, [web_gl.UniformLocation, core.num]),
>+  [$uniform1fv]: dart.fnType(dart.void, [web_gl.UniformLocation, dart.dynamic]),
>+  [$uniform1i]: dart.fnType(dart.void, [web_gl.UniformLocation, core.int]),
>+  [$uniform1iv]: dart.fnType(dart.void, [web_gl.UniformLocation, dart.dynamic]),
>+  [$uniform2f]: dart.fnType(dart.void, [web_gl.UniformLocation, core.num, core.num]),
>+  [$uniform2fv]: dart.fnType(dart.void, [web_gl.UniformLocation, dart.dynamic]),
>+  [$uniform2i]: dart.fnType(dart.void, [web_gl.UniformLocation, core.int, core.int]),
>+  [$uniform2iv]: dart.fnType(dart.void, [web_gl.UniformLocation, dart.dynamic]),
>+  [$uniform3f]: dart.fnType(dart.void, [web_gl.UniformLocation, core.num, core.num, core.num]),
>+  [$uniform3fv]: dart.fnType(dart.void, [web_gl.UniformLocation, dart.dynamic]),
>+  [$uniform3i]: dart.fnType(dart.void, [web_gl.UniformLocation, core.int, core.int, core.int]),
>+  [$uniform3iv]: dart.fnType(dart.void, [web_gl.UniformLocation, dart.dynamic]),
>+  [$uniform4f]: dart.fnType(dart.void, [web_gl.UniformLocation, core.num, core.num, core.num, core.num]),
>+  [$uniform4fv]: dart.fnType(dart.void, [web_gl.UniformLocation, dart.dynamic]),
>+  [$uniform4i]: dart.fnType(dart.void, [web_gl.UniformLocation, core.int, core.int, core.int, core.int]),
>+  [$uniform4iv]: dart.fnType(dart.void, [web_gl.UniformLocation, dart.dynamic]),
>+  [$uniformMatrix2fv]: dart.fnType(dart.void, [web_gl.UniformLocation, core.bool, dart.dynamic]),
>+  [$uniformMatrix3fv]: dart.fnType(dart.void, [web_gl.UniformLocation, core.bool, dart.dynamic]),
>+  [$uniformMatrix4fv]: dart.fnType(dart.void, [web_gl.UniformLocation, core.bool, dart.dynamic]),
>+  [$useProgram]: dart.fnType(dart.void, [web_gl.Program]),
>+  [$validateProgram]: dart.fnType(dart.void, [web_gl.Program]),
>+  [$vertexAttrib1f]: dart.fnType(dart.void, [core.int, core.num]),
>+  [$vertexAttrib1fv]: dart.fnType(dart.void, [core.int, dart.dynamic]),
>+  [$vertexAttrib2f]: dart.fnType(dart.void, [core.int, core.num, core.num]),
>+  [$vertexAttrib2fv]: dart.fnType(dart.void, [core.int, dart.dynamic]),
>+  [$vertexAttrib3f]: dart.fnType(dart.void, [core.int, core.num, core.num, core.num]),
>+  [$vertexAttrib3fv]: dart.fnType(dart.void, [core.int, dart.dynamic]),
>+  [$vertexAttrib4f]: dart.fnType(dart.void, [core.int, core.num, core.num, core.num, core.num]),
>+  [$vertexAttrib4fv]: dart.fnType(dart.void, [core.int, dart.dynamic]),
>+  [$vertexAttribPointer]: dart.fnType(dart.void, [core.int, core.int, core.int, core.bool, core.int, core.int]),
>+  [$viewport]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int]),
>+  [$readPixels]: dart.fnType(dart.void, [core.int, core.int, core.int, core.int, core.int, core.int, typed_data.TypedData])
>+}));
>+dart.setLibraryUri(web_gl.RenderingContext2, "dart:web_gl");
>+dart.setFieldSignature(web_gl.RenderingContext2, () => ({
>+  __proto__: dart.getFields(web_gl.RenderingContext2.__proto__),
>+  [$canvas]: dart.finalFieldType(web_gl.Canvas),
>+  [$drawingBufferHeight]: dart.finalFieldType(core.int),
>+  [$drawingBufferWidth]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("WebGL2RenderingContext", web_gl.RenderingContext2);
>+web_gl.Sampler = class Sampler extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.Sampler);
>+dart.setLibraryUri(web_gl.Sampler, "dart:web_gl");
>+dart.registerExtension("WebGLSampler", web_gl.Sampler);
>+web_gl.Shader = class Shader extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.Shader);
>+dart.setLibraryUri(web_gl.Shader, "dart:web_gl");
>+dart.registerExtension("WebGLShader", web_gl.Shader);
>+web_gl.ShaderPrecisionFormat = class ShaderPrecisionFormat extends _interceptors.Interceptor {
>+  get [$precision]() {
>+    return this.precision;
>+  }
>+  get [$rangeMax]() {
>+    return this.rangeMax;
>+  }
>+  get [$rangeMin]() {
>+    return this.rangeMin;
>+  }
>+};
>+dart.addTypeTests(web_gl.ShaderPrecisionFormat);
>+const precision = Symbol("ShaderPrecisionFormat.precision");
>+const rangeMax = Symbol("ShaderPrecisionFormat.rangeMax");
>+const rangeMin = Symbol("ShaderPrecisionFormat.rangeMin");
>+dart.setLibraryUri(web_gl.ShaderPrecisionFormat, "dart:web_gl");
>+dart.setFieldSignature(web_gl.ShaderPrecisionFormat, () => ({
>+  __proto__: dart.getFields(web_gl.ShaderPrecisionFormat.__proto__),
>+  [$precision]: dart.finalFieldType(core.int),
>+  [$rangeMax]: dart.finalFieldType(core.int),
>+  [$rangeMin]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("WebGLShaderPrecisionFormat", web_gl.ShaderPrecisionFormat);
>+web_gl.Sync = class Sync extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.Sync);
>+dart.setLibraryUri(web_gl.Sync, "dart:web_gl");
>+dart.registerExtension("WebGLSync", web_gl.Sync);
>+web_gl.Texture = class Texture extends _interceptors.Interceptor {
>+  get [$lastUploadedVideoFrameWasSkipped]() {
>+    return this.lastUploadedVideoFrameWasSkipped;
>+  }
>+  get [$lastUploadedVideoHeight]() {
>+    return this.lastUploadedVideoHeight;
>+  }
>+  get [$lastUploadedVideoTimestamp]() {
>+    return this.lastUploadedVideoTimestamp;
>+  }
>+  get [$lastUploadedVideoWidth]() {
>+    return this.lastUploadedVideoWidth;
>+  }
>+};
>+dart.addTypeTests(web_gl.Texture);
>+const lastUploadedVideoFrameWasSkipped = Symbol("Texture.lastUploadedVideoFrameWasSkipped");
>+const lastUploadedVideoHeight = Symbol("Texture.lastUploadedVideoHeight");
>+const lastUploadedVideoTimestamp = Symbol("Texture.lastUploadedVideoTimestamp");
>+const lastUploadedVideoWidth = Symbol("Texture.lastUploadedVideoWidth");
>+dart.setLibraryUri(web_gl.Texture, "dart:web_gl");
>+dart.setFieldSignature(web_gl.Texture, () => ({
>+  __proto__: dart.getFields(web_gl.Texture.__proto__),
>+  [$lastUploadedVideoFrameWasSkipped]: dart.finalFieldType(core.bool),
>+  [$lastUploadedVideoHeight]: dart.finalFieldType(core.int),
>+  [$lastUploadedVideoTimestamp]: dart.finalFieldType(core.num),
>+  [$lastUploadedVideoWidth]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("WebGLTexture", web_gl.Texture);
>+web_gl.TimerQueryExt = class TimerQueryExt extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.TimerQueryExt);
>+dart.setLibraryUri(web_gl.TimerQueryExt, "dart:web_gl");
>+dart.registerExtension("WebGLTimerQueryEXT", web_gl.TimerQueryExt);
>+web_gl.TransformFeedback = class TransformFeedback extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.TransformFeedback);
>+dart.setLibraryUri(web_gl.TransformFeedback, "dart:web_gl");
>+dart.registerExtension("WebGLTransformFeedback", web_gl.TransformFeedback);
>+web_gl.UniformLocation = class UniformLocation extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.UniformLocation);
>+dart.setLibraryUri(web_gl.UniformLocation, "dart:web_gl");
>+dart.registerExtension("WebGLUniformLocation", web_gl.UniformLocation);
>+web_gl.VertexArrayObject = class VertexArrayObject extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.VertexArrayObject);
>+dart.setLibraryUri(web_gl.VertexArrayObject, "dart:web_gl");
>+dart.registerExtension("WebGLVertexArrayObject", web_gl.VertexArrayObject);
>+web_gl.VertexArrayObjectOes = class VertexArrayObjectOes extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl.VertexArrayObjectOes);
>+dart.setLibraryUri(web_gl.VertexArrayObjectOes, "dart:web_gl");
>+dart.registerExtension("WebGLVertexArrayObjectOES", web_gl.VertexArrayObjectOes);
>+web_gl.WebGL = class WebGL extends core.Object {};
>+(web_gl.WebGL[dart.mixinNew] = function() {
>+}).prototype = web_gl.WebGL.prototype;
>+dart.addTypeTests(web_gl.WebGL);
>+dart.setLibraryUri(web_gl.WebGL, "dart:web_gl");
>+dart.defineLazy(web_gl.WebGL, {
>+  /*web_gl.WebGL.ACTIVE_ATTRIBUTES*/get ACTIVE_ATTRIBUTES() {
>+    return 35721;
>+  },
>+  /*web_gl.WebGL.ACTIVE_TEXTURE*/get ACTIVE_TEXTURE() {
>+    return 34016;
>+  },
>+  /*web_gl.WebGL.ACTIVE_UNIFORMS*/get ACTIVE_UNIFORMS() {
>+    return 35718;
>+  },
>+  /*web_gl.WebGL.ACTIVE_UNIFORM_BLOCKS*/get ACTIVE_UNIFORM_BLOCKS() {
>+    return 35382;
>+  },
>+  /*web_gl.WebGL.ALIASED_LINE_WIDTH_RANGE*/get ALIASED_LINE_WIDTH_RANGE() {
>+    return 33902;
>+  },
>+  /*web_gl.WebGL.ALIASED_POINT_SIZE_RANGE*/get ALIASED_POINT_SIZE_RANGE() {
>+    return 33901;
>+  },
>+  /*web_gl.WebGL.ALPHA*/get ALPHA() {
>+    return 6406;
>+  },
>+  /*web_gl.WebGL.ALPHA_BITS*/get ALPHA_BITS() {
>+    return 3413;
>+  },
>+  /*web_gl.WebGL.ALREADY_SIGNALED*/get ALREADY_SIGNALED() {
>+    return 37146;
>+  },
>+  /*web_gl.WebGL.ALWAYS*/get ALWAYS() {
>+    return 519;
>+  },
>+  /*web_gl.WebGL.ANY_SAMPLES_PASSED*/get ANY_SAMPLES_PASSED() {
>+    return 35887;
>+  },
>+  /*web_gl.WebGL.ANY_SAMPLES_PASSED_CONSERVATIVE*/get ANY_SAMPLES_PASSED_CONSERVATIVE() {
>+    return 36202;
>+  },
>+  /*web_gl.WebGL.ARRAY_BUFFER*/get ARRAY_BUFFER() {
>+    return 34962;
>+  },
>+  /*web_gl.WebGL.ARRAY_BUFFER_BINDING*/get ARRAY_BUFFER_BINDING() {
>+    return 34964;
>+  },
>+  /*web_gl.WebGL.ATTACHED_SHADERS*/get ATTACHED_SHADERS() {
>+    return 35717;
>+  },
>+  /*web_gl.WebGL.BACK*/get BACK() {
>+    return 1029;
>+  },
>+  /*web_gl.WebGL.BLEND*/get BLEND() {
>+    return 3042;
>+  },
>+  /*web_gl.WebGL.BLEND_COLOR*/get BLEND_COLOR() {
>+    return 32773;
>+  },
>+  /*web_gl.WebGL.BLEND_DST_ALPHA*/get BLEND_DST_ALPHA() {
>+    return 32970;
>+  },
>+  /*web_gl.WebGL.BLEND_DST_RGB*/get BLEND_DST_RGB() {
>+    return 32968;
>+  },
>+  /*web_gl.WebGL.BLEND_EQUATION*/get BLEND_EQUATION() {
>+    return 32777;
>+  },
>+  /*web_gl.WebGL.BLEND_EQUATION_ALPHA*/get BLEND_EQUATION_ALPHA() {
>+    return 34877;
>+  },
>+  /*web_gl.WebGL.BLEND_EQUATION_RGB*/get BLEND_EQUATION_RGB() {
>+    return 32777;
>+  },
>+  /*web_gl.WebGL.BLEND_SRC_ALPHA*/get BLEND_SRC_ALPHA() {
>+    return 32971;
>+  },
>+  /*web_gl.WebGL.BLEND_SRC_RGB*/get BLEND_SRC_RGB() {
>+    return 32969;
>+  },
>+  /*web_gl.WebGL.BLUE_BITS*/get BLUE_BITS() {
>+    return 3412;
>+  },
>+  /*web_gl.WebGL.BOOL*/get BOOL() {
>+    return 35670;
>+  },
>+  /*web_gl.WebGL.BOOL_VEC2*/get BOOL_VEC2() {
>+    return 35671;
>+  },
>+  /*web_gl.WebGL.BOOL_VEC3*/get BOOL_VEC3() {
>+    return 35672;
>+  },
>+  /*web_gl.WebGL.BOOL_VEC4*/get BOOL_VEC4() {
>+    return 35673;
>+  },
>+  /*web_gl.WebGL.BROWSER_DEFAULT_WEBGL*/get BROWSER_DEFAULT_WEBGL() {
>+    return 37444;
>+  },
>+  /*web_gl.WebGL.BUFFER_SIZE*/get BUFFER_SIZE() {
>+    return 34660;
>+  },
>+  /*web_gl.WebGL.BUFFER_USAGE*/get BUFFER_USAGE() {
>+    return 34661;
>+  },
>+  /*web_gl.WebGL.BYTE*/get BYTE() {
>+    return 5120;
>+  },
>+  /*web_gl.WebGL.CCW*/get CCW() {
>+    return 2305;
>+  },
>+  /*web_gl.WebGL.CLAMP_TO_EDGE*/get CLAMP_TO_EDGE() {
>+    return 33071;
>+  },
>+  /*web_gl.WebGL.COLOR*/get COLOR() {
>+    return 6144;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT0*/get COLOR_ATTACHMENT0() {
>+    return 36064;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT0_WEBGL*/get COLOR_ATTACHMENT0_WEBGL() {
>+    return 36064;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT1*/get COLOR_ATTACHMENT1() {
>+    return 36065;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT10*/get COLOR_ATTACHMENT10() {
>+    return 36074;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT10_WEBGL*/get COLOR_ATTACHMENT10_WEBGL() {
>+    return 36074;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT11*/get COLOR_ATTACHMENT11() {
>+    return 36075;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT11_WEBGL*/get COLOR_ATTACHMENT11_WEBGL() {
>+    return 36075;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT12*/get COLOR_ATTACHMENT12() {
>+    return 36076;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT12_WEBGL*/get COLOR_ATTACHMENT12_WEBGL() {
>+    return 36076;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT13*/get COLOR_ATTACHMENT13() {
>+    return 36077;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT13_WEBGL*/get COLOR_ATTACHMENT13_WEBGL() {
>+    return 36077;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT14*/get COLOR_ATTACHMENT14() {
>+    return 36078;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT14_WEBGL*/get COLOR_ATTACHMENT14_WEBGL() {
>+    return 36078;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT15*/get COLOR_ATTACHMENT15() {
>+    return 36079;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT15_WEBGL*/get COLOR_ATTACHMENT15_WEBGL() {
>+    return 36079;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT1_WEBGL*/get COLOR_ATTACHMENT1_WEBGL() {
>+    return 36065;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT2*/get COLOR_ATTACHMENT2() {
>+    return 36066;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT2_WEBGL*/get COLOR_ATTACHMENT2_WEBGL() {
>+    return 36066;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT3*/get COLOR_ATTACHMENT3() {
>+    return 36067;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT3_WEBGL*/get COLOR_ATTACHMENT3_WEBGL() {
>+    return 36067;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT4*/get COLOR_ATTACHMENT4() {
>+    return 36068;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT4_WEBGL*/get COLOR_ATTACHMENT4_WEBGL() {
>+    return 36068;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT5*/get COLOR_ATTACHMENT5() {
>+    return 36069;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT5_WEBGL*/get COLOR_ATTACHMENT5_WEBGL() {
>+    return 36069;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT6*/get COLOR_ATTACHMENT6() {
>+    return 36070;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT6_WEBGL*/get COLOR_ATTACHMENT6_WEBGL() {
>+    return 36070;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT7*/get COLOR_ATTACHMENT7() {
>+    return 36071;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT7_WEBGL*/get COLOR_ATTACHMENT7_WEBGL() {
>+    return 36071;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT8*/get COLOR_ATTACHMENT8() {
>+    return 36072;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT8_WEBGL*/get COLOR_ATTACHMENT8_WEBGL() {
>+    return 36072;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT9*/get COLOR_ATTACHMENT9() {
>+    return 36073;
>+  },
>+  /*web_gl.WebGL.COLOR_ATTACHMENT9_WEBGL*/get COLOR_ATTACHMENT9_WEBGL() {
>+    return 36073;
>+  },
>+  /*web_gl.WebGL.COLOR_BUFFER_BIT*/get COLOR_BUFFER_BIT() {
>+    return 16384;
>+  },
>+  /*web_gl.WebGL.COLOR_CLEAR_VALUE*/get COLOR_CLEAR_VALUE() {
>+    return 3106;
>+  },
>+  /*web_gl.WebGL.COLOR_WRITEMASK*/get COLOR_WRITEMASK() {
>+    return 3107;
>+  },
>+  /*web_gl.WebGL.COMPARE_REF_TO_TEXTURE*/get COMPARE_REF_TO_TEXTURE() {
>+    return 34894;
>+  },
>+  /*web_gl.WebGL.COMPILE_STATUS*/get COMPILE_STATUS() {
>+    return 35713;
>+  },
>+  /*web_gl.WebGL.COMPRESSED_TEXTURE_FORMATS*/get COMPRESSED_TEXTURE_FORMATS() {
>+    return 34467;
>+  },
>+  /*web_gl.WebGL.CONDITION_SATISFIED*/get CONDITION_SATISFIED() {
>+    return 37148;
>+  },
>+  /*web_gl.WebGL.CONSTANT_ALPHA*/get CONSTANT_ALPHA() {
>+    return 32771;
>+  },
>+  /*web_gl.WebGL.CONSTANT_COLOR*/get CONSTANT_COLOR() {
>+    return 32769;
>+  },
>+  /*web_gl.WebGL.CONTEXT_LOST_WEBGL*/get CONTEXT_LOST_WEBGL() {
>+    return 37442;
>+  },
>+  /*web_gl.WebGL.COPY_READ_BUFFER*/get COPY_READ_BUFFER() {
>+    return 36662;
>+  },
>+  /*web_gl.WebGL.COPY_READ_BUFFER_BINDING*/get COPY_READ_BUFFER_BINDING() {
>+    return 36662;
>+  },
>+  /*web_gl.WebGL.COPY_WRITE_BUFFER*/get COPY_WRITE_BUFFER() {
>+    return 36663;
>+  },
>+  /*web_gl.WebGL.COPY_WRITE_BUFFER_BINDING*/get COPY_WRITE_BUFFER_BINDING() {
>+    return 36663;
>+  },
>+  /*web_gl.WebGL.CULL_FACE*/get CULL_FACE() {
>+    return 2884;
>+  },
>+  /*web_gl.WebGL.CULL_FACE_MODE*/get CULL_FACE_MODE() {
>+    return 2885;
>+  },
>+  /*web_gl.WebGL.CURRENT_PROGRAM*/get CURRENT_PROGRAM() {
>+    return 35725;
>+  },
>+  /*web_gl.WebGL.CURRENT_QUERY*/get CURRENT_QUERY() {
>+    return 34917;
>+  },
>+  /*web_gl.WebGL.CURRENT_VERTEX_ATTRIB*/get CURRENT_VERTEX_ATTRIB() {
>+    return 34342;
>+  },
>+  /*web_gl.WebGL.CW*/get CW() {
>+    return 2304;
>+  },
>+  /*web_gl.WebGL.DECR*/get DECR() {
>+    return 7683;
>+  },
>+  /*web_gl.WebGL.DECR_WRAP*/get DECR_WRAP() {
>+    return 34056;
>+  },
>+  /*web_gl.WebGL.DELETE_STATUS*/get DELETE_STATUS() {
>+    return 35712;
>+  },
>+  /*web_gl.WebGL.DEPTH*/get DEPTH() {
>+    return 6145;
>+  },
>+  /*web_gl.WebGL.DEPTH24_STENCIL8*/get DEPTH24_STENCIL8() {
>+    return 35056;
>+  },
>+  /*web_gl.WebGL.DEPTH32F_STENCIL8*/get DEPTH32F_STENCIL8() {
>+    return 36013;
>+  },
>+  /*web_gl.WebGL.DEPTH_ATTACHMENT*/get DEPTH_ATTACHMENT() {
>+    return 36096;
>+  },
>+  /*web_gl.WebGL.DEPTH_BITS*/get DEPTH_BITS() {
>+    return 3414;
>+  },
>+  /*web_gl.WebGL.DEPTH_BUFFER_BIT*/get DEPTH_BUFFER_BIT() {
>+    return 256;
>+  },
>+  /*web_gl.WebGL.DEPTH_CLEAR_VALUE*/get DEPTH_CLEAR_VALUE() {
>+    return 2931;
>+  },
>+  /*web_gl.WebGL.DEPTH_COMPONENT*/get DEPTH_COMPONENT() {
>+    return 6402;
>+  },
>+  /*web_gl.WebGL.DEPTH_COMPONENT16*/get DEPTH_COMPONENT16() {
>+    return 33189;
>+  },
>+  /*web_gl.WebGL.DEPTH_COMPONENT24*/get DEPTH_COMPONENT24() {
>+    return 33190;
>+  },
>+  /*web_gl.WebGL.DEPTH_COMPONENT32F*/get DEPTH_COMPONENT32F() {
>+    return 36012;
>+  },
>+  /*web_gl.WebGL.DEPTH_FUNC*/get DEPTH_FUNC() {
>+    return 2932;
>+  },
>+  /*web_gl.WebGL.DEPTH_RANGE*/get DEPTH_RANGE() {
>+    return 2928;
>+  },
>+  /*web_gl.WebGL.DEPTH_STENCIL*/get DEPTH_STENCIL() {
>+    return 34041;
>+  },
>+  /*web_gl.WebGL.DEPTH_STENCIL_ATTACHMENT*/get DEPTH_STENCIL_ATTACHMENT() {
>+    return 33306;
>+  },
>+  /*web_gl.WebGL.DEPTH_TEST*/get DEPTH_TEST() {
>+    return 2929;
>+  },
>+  /*web_gl.WebGL.DEPTH_WRITEMASK*/get DEPTH_WRITEMASK() {
>+    return 2930;
>+  },
>+  /*web_gl.WebGL.DITHER*/get DITHER() {
>+    return 3024;
>+  },
>+  /*web_gl.WebGL.DONT_CARE*/get DONT_CARE() {
>+    return 4352;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER0*/get DRAW_BUFFER0() {
>+    return 34853;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER0_WEBGL*/get DRAW_BUFFER0_WEBGL() {
>+    return 34853;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER1*/get DRAW_BUFFER1() {
>+    return 34854;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER10*/get DRAW_BUFFER10() {
>+    return 34863;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER10_WEBGL*/get DRAW_BUFFER10_WEBGL() {
>+    return 34863;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER11*/get DRAW_BUFFER11() {
>+    return 34864;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER11_WEBGL*/get DRAW_BUFFER11_WEBGL() {
>+    return 34864;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER12*/get DRAW_BUFFER12() {
>+    return 34865;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER12_WEBGL*/get DRAW_BUFFER12_WEBGL() {
>+    return 34865;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER13*/get DRAW_BUFFER13() {
>+    return 34866;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER13_WEBGL*/get DRAW_BUFFER13_WEBGL() {
>+    return 34866;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER14*/get DRAW_BUFFER14() {
>+    return 34867;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER14_WEBGL*/get DRAW_BUFFER14_WEBGL() {
>+    return 34867;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER15*/get DRAW_BUFFER15() {
>+    return 34868;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER15_WEBGL*/get DRAW_BUFFER15_WEBGL() {
>+    return 34868;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER1_WEBGL*/get DRAW_BUFFER1_WEBGL() {
>+    return 34854;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER2*/get DRAW_BUFFER2() {
>+    return 34855;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER2_WEBGL*/get DRAW_BUFFER2_WEBGL() {
>+    return 34855;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER3*/get DRAW_BUFFER3() {
>+    return 34856;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER3_WEBGL*/get DRAW_BUFFER3_WEBGL() {
>+    return 34856;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER4*/get DRAW_BUFFER4() {
>+    return 34857;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER4_WEBGL*/get DRAW_BUFFER4_WEBGL() {
>+    return 34857;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER5*/get DRAW_BUFFER5() {
>+    return 34858;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER5_WEBGL*/get DRAW_BUFFER5_WEBGL() {
>+    return 34858;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER6*/get DRAW_BUFFER6() {
>+    return 34859;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER6_WEBGL*/get DRAW_BUFFER6_WEBGL() {
>+    return 34859;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER7*/get DRAW_BUFFER7() {
>+    return 34860;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER7_WEBGL*/get DRAW_BUFFER7_WEBGL() {
>+    return 34860;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER8*/get DRAW_BUFFER8() {
>+    return 34861;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER8_WEBGL*/get DRAW_BUFFER8_WEBGL() {
>+    return 34861;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER9*/get DRAW_BUFFER9() {
>+    return 34862;
>+  },
>+  /*web_gl.WebGL.DRAW_BUFFER9_WEBGL*/get DRAW_BUFFER9_WEBGL() {
>+    return 34862;
>+  },
>+  /*web_gl.WebGL.DRAW_FRAMEBUFFER*/get DRAW_FRAMEBUFFER() {
>+    return 36009;
>+  },
>+  /*web_gl.WebGL.DRAW_FRAMEBUFFER_BINDING*/get DRAW_FRAMEBUFFER_BINDING() {
>+    return 36006;
>+  },
>+  /*web_gl.WebGL.DST_ALPHA*/get DST_ALPHA() {
>+    return 772;
>+  },
>+  /*web_gl.WebGL.DST_COLOR*/get DST_COLOR() {
>+    return 774;
>+  },
>+  /*web_gl.WebGL.DYNAMIC_COPY*/get DYNAMIC_COPY() {
>+    return 35050;
>+  },
>+  /*web_gl.WebGL.DYNAMIC_DRAW*/get DYNAMIC_DRAW() {
>+    return 35048;
>+  },
>+  /*web_gl.WebGL.DYNAMIC_READ*/get DYNAMIC_READ() {
>+    return 35049;
>+  },
>+  /*web_gl.WebGL.ELEMENT_ARRAY_BUFFER*/get ELEMENT_ARRAY_BUFFER() {
>+    return 34963;
>+  },
>+  /*web_gl.WebGL.ELEMENT_ARRAY_BUFFER_BINDING*/get ELEMENT_ARRAY_BUFFER_BINDING() {
>+    return 34965;
>+  },
>+  /*web_gl.WebGL.EQUAL*/get EQUAL() {
>+    return 514;
>+  },
>+  /*web_gl.WebGL.FASTEST*/get FASTEST() {
>+    return 4353;
>+  },
>+  /*web_gl.WebGL.FLOAT*/get FLOAT() {
>+    return 5126;
>+  },
>+  /*web_gl.WebGL.FLOAT_32_UNSIGNED_INT_24_8_REV*/get FLOAT_32_UNSIGNED_INT_24_8_REV() {
>+    return 36269;
>+  },
>+  /*web_gl.WebGL.FLOAT_MAT2*/get FLOAT_MAT2() {
>+    return 35674;
>+  },
>+  /*web_gl.WebGL.FLOAT_MAT2x3*/get FLOAT_MAT2x3() {
>+    return 35685;
>+  },
>+  /*web_gl.WebGL.FLOAT_MAT2x4*/get FLOAT_MAT2x4() {
>+    return 35686;
>+  },
>+  /*web_gl.WebGL.FLOAT_MAT3*/get FLOAT_MAT3() {
>+    return 35675;
>+  },
>+  /*web_gl.WebGL.FLOAT_MAT3x2*/get FLOAT_MAT3x2() {
>+    return 35687;
>+  },
>+  /*web_gl.WebGL.FLOAT_MAT3x4*/get FLOAT_MAT3x4() {
>+    return 35688;
>+  },
>+  /*web_gl.WebGL.FLOAT_MAT4*/get FLOAT_MAT4() {
>+    return 35676;
>+  },
>+  /*web_gl.WebGL.FLOAT_MAT4x2*/get FLOAT_MAT4x2() {
>+    return 35689;
>+  },
>+  /*web_gl.WebGL.FLOAT_MAT4x3*/get FLOAT_MAT4x3() {
>+    return 35690;
>+  },
>+  /*web_gl.WebGL.FLOAT_VEC2*/get FLOAT_VEC2() {
>+    return 35664;
>+  },
>+  /*web_gl.WebGL.FLOAT_VEC3*/get FLOAT_VEC3() {
>+    return 35665;
>+  },
>+  /*web_gl.WebGL.FLOAT_VEC4*/get FLOAT_VEC4() {
>+    return 35666;
>+  },
>+  /*web_gl.WebGL.FRAGMENT_SHADER*/get FRAGMENT_SHADER() {
>+    return 35632;
>+  },
>+  /*web_gl.WebGL.FRAGMENT_SHADER_DERIVATIVE_HINT*/get FRAGMENT_SHADER_DERIVATIVE_HINT() {
>+    return 35723;
>+  },
>+  /*web_gl.WebGL.FRAMEBUFFER*/get FRAMEBUFFER() {
>+    return 36160;
>+  },
>+  /*web_gl.WebGL.FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE*/get FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE() {
>+    return 33301;
>+  },
>+  /*web_gl.WebGL.FRAMEBUFFER_ATTACHMENT_BLUE_SIZE*/get FRAMEBUFFER_ATTACHMENT_BLUE_SIZE() {
>+    return 33300;
>+  },
>+  /*web_gl.WebGL.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING*/get FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING() {
>+    return 33296;
>+  },
>+  /*web_gl.WebGL.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE*/get FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE() {
>+    return 33297;
>+  },
>+  /*web_gl.WebGL.FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE*/get FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE() {
>+    return 33302;
>+  },
>+  /*web_gl.WebGL.FRAMEBUFFER_ATTACHMENT_GREEN_SIZE*/get FRAMEBUFFER_ATTACHMENT_GREEN_SIZE() {
>+    return 33299;
>+  },
>+  /*web_gl.WebGL.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME*/get FRAMEBUFFER_ATTACHMENT_OBJECT_NAME() {
>+    return 36049;
>+  },
>+  /*web_gl.WebGL.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE*/get FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE() {
>+    return 36048;
>+  },
>+  /*web_gl.WebGL.FRAMEBUFFER_ATTACHMENT_RED_SIZE*/get FRAMEBUFFER_ATTACHMENT_RED_SIZE() {
>+    return 33298;
>+  },
>+  /*web_gl.WebGL.FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE*/get FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE() {
>+    return 33303;
>+  },
>+  /*web_gl.WebGL.FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE*/get FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE() {
>+    return 36051;
>+  },
>+  /*web_gl.WebGL.FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER*/get FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER() {
>+    return 36052;
>+  },
>+  /*web_gl.WebGL.FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL*/get FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL() {
>+    return 36050;
>+  },
>+  /*web_gl.WebGL.FRAMEBUFFER_BINDING*/get FRAMEBUFFER_BINDING() {
>+    return 36006;
>+  },
>+  /*web_gl.WebGL.FRAMEBUFFER_COMPLETE*/get FRAMEBUFFER_COMPLETE() {
>+    return 36053;
>+  },
>+  /*web_gl.WebGL.FRAMEBUFFER_DEFAULT*/get FRAMEBUFFER_DEFAULT() {
>+    return 33304;
>+  },
>+  /*web_gl.WebGL.FRAMEBUFFER_INCOMPLETE_ATTACHMENT*/get FRAMEBUFFER_INCOMPLETE_ATTACHMENT() {
>+    return 36054;
>+  },
>+  /*web_gl.WebGL.FRAMEBUFFER_INCOMPLETE_DIMENSIONS*/get FRAMEBUFFER_INCOMPLETE_DIMENSIONS() {
>+    return 36057;
>+  },
>+  /*web_gl.WebGL.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT*/get FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT() {
>+    return 36055;
>+  },
>+  /*web_gl.WebGL.FRAMEBUFFER_INCOMPLETE_MULTISAMPLE*/get FRAMEBUFFER_INCOMPLETE_MULTISAMPLE() {
>+    return 36182;
>+  },
>+  /*web_gl.WebGL.FRAMEBUFFER_UNSUPPORTED*/get FRAMEBUFFER_UNSUPPORTED() {
>+    return 36061;
>+  },
>+  /*web_gl.WebGL.FRONT*/get FRONT() {
>+    return 1028;
>+  },
>+  /*web_gl.WebGL.FRONT_AND_BACK*/get FRONT_AND_BACK() {
>+    return 1032;
>+  },
>+  /*web_gl.WebGL.FRONT_FACE*/get FRONT_FACE() {
>+    return 2886;
>+  },
>+  /*web_gl.WebGL.FUNC_ADD*/get FUNC_ADD() {
>+    return 32774;
>+  },
>+  /*web_gl.WebGL.FUNC_REVERSE_SUBTRACT*/get FUNC_REVERSE_SUBTRACT() {
>+    return 32779;
>+  },
>+  /*web_gl.WebGL.FUNC_SUBTRACT*/get FUNC_SUBTRACT() {
>+    return 32778;
>+  },
>+  /*web_gl.WebGL.GENERATE_MIPMAP_HINT*/get GENERATE_MIPMAP_HINT() {
>+    return 33170;
>+  },
>+  /*web_gl.WebGL.GEQUAL*/get GEQUAL() {
>+    return 518;
>+  },
>+  /*web_gl.WebGL.GREATER*/get GREATER() {
>+    return 516;
>+  },
>+  /*web_gl.WebGL.GREEN_BITS*/get GREEN_BITS() {
>+    return 3411;
>+  },
>+  /*web_gl.WebGL.HALF_FLOAT*/get HALF_FLOAT() {
>+    return 5131;
>+  },
>+  /*web_gl.WebGL.HIGH_FLOAT*/get HIGH_FLOAT() {
>+    return 36338;
>+  },
>+  /*web_gl.WebGL.HIGH_INT*/get HIGH_INT() {
>+    return 36341;
>+  },
>+  /*web_gl.WebGL.IMPLEMENTATION_COLOR_READ_FORMAT*/get IMPLEMENTATION_COLOR_READ_FORMAT() {
>+    return 35739;
>+  },
>+  /*web_gl.WebGL.IMPLEMENTATION_COLOR_READ_TYPE*/get IMPLEMENTATION_COLOR_READ_TYPE() {
>+    return 35738;
>+  },
>+  /*web_gl.WebGL.INCR*/get INCR() {
>+    return 7682;
>+  },
>+  /*web_gl.WebGL.INCR_WRAP*/get INCR_WRAP() {
>+    return 34055;
>+  },
>+  /*web_gl.WebGL.INT*/get INT() {
>+    return 5124;
>+  },
>+  /*web_gl.WebGL.INTERLEAVED_ATTRIBS*/get INTERLEAVED_ATTRIBS() {
>+    return 35980;
>+  },
>+  /*web_gl.WebGL.INT_2_10_10_10_REV*/get INT_2_10_10_10_REV() {
>+    return 36255;
>+  },
>+  /*web_gl.WebGL.INT_SAMPLER_2D*/get INT_SAMPLER_2D() {
>+    return 36298;
>+  },
>+  /*web_gl.WebGL.INT_SAMPLER_2D_ARRAY*/get INT_SAMPLER_2D_ARRAY() {
>+    return 36303;
>+  },
>+  /*web_gl.WebGL.INT_SAMPLER_3D*/get INT_SAMPLER_3D() {
>+    return 36299;
>+  },
>+  /*web_gl.WebGL.INT_SAMPLER_CUBE*/get INT_SAMPLER_CUBE() {
>+    return 36300;
>+  },
>+  /*web_gl.WebGL.INT_VEC2*/get INT_VEC2() {
>+    return 35667;
>+  },
>+  /*web_gl.WebGL.INT_VEC3*/get INT_VEC3() {
>+    return 35668;
>+  },
>+  /*web_gl.WebGL.INT_VEC4*/get INT_VEC4() {
>+    return 35669;
>+  },
>+  /*web_gl.WebGL.INVALID_ENUM*/get INVALID_ENUM() {
>+    return 1280;
>+  },
>+  /*web_gl.WebGL.INVALID_FRAMEBUFFER_OPERATION*/get INVALID_FRAMEBUFFER_OPERATION() {
>+    return 1286;
>+  },
>+  /*web_gl.WebGL.INVALID_INDEX*/get INVALID_INDEX() {
>+    return 4294967295;
>+  },
>+  /*web_gl.WebGL.INVALID_OPERATION*/get INVALID_OPERATION() {
>+    return 1282;
>+  },
>+  /*web_gl.WebGL.INVALID_VALUE*/get INVALID_VALUE() {
>+    return 1281;
>+  },
>+  /*web_gl.WebGL.INVERT*/get INVERT() {
>+    return 5386;
>+  },
>+  /*web_gl.WebGL.KEEP*/get KEEP() {
>+    return 7680;
>+  },
>+  /*web_gl.WebGL.LEQUAL*/get LEQUAL() {
>+    return 515;
>+  },
>+  /*web_gl.WebGL.LESS*/get LESS() {
>+    return 513;
>+  },
>+  /*web_gl.WebGL.LINEAR*/get LINEAR() {
>+    return 9729;
>+  },
>+  /*web_gl.WebGL.LINEAR_MIPMAP_LINEAR*/get LINEAR_MIPMAP_LINEAR() {
>+    return 9987;
>+  },
>+  /*web_gl.WebGL.LINEAR_MIPMAP_NEAREST*/get LINEAR_MIPMAP_NEAREST() {
>+    return 9985;
>+  },
>+  /*web_gl.WebGL.LINES*/get LINES() {
>+    return 1;
>+  },
>+  /*web_gl.WebGL.LINE_LOOP*/get LINE_LOOP() {
>+    return 2;
>+  },
>+  /*web_gl.WebGL.LINE_STRIP*/get LINE_STRIP() {
>+    return 3;
>+  },
>+  /*web_gl.WebGL.LINE_WIDTH*/get LINE_WIDTH() {
>+    return 2849;
>+  },
>+  /*web_gl.WebGL.LINK_STATUS*/get LINK_STATUS() {
>+    return 35714;
>+  },
>+  /*web_gl.WebGL.LOW_FLOAT*/get LOW_FLOAT() {
>+    return 36336;
>+  },
>+  /*web_gl.WebGL.LOW_INT*/get LOW_INT() {
>+    return 36339;
>+  },
>+  /*web_gl.WebGL.LUMINANCE*/get LUMINANCE() {
>+    return 6409;
>+  },
>+  /*web_gl.WebGL.LUMINANCE_ALPHA*/get LUMINANCE_ALPHA() {
>+    return 6410;
>+  },
>+  /*web_gl.WebGL.MAX*/get MAX() {
>+    return 32776;
>+  },
>+  /*web_gl.WebGL.MAX_3D_TEXTURE_SIZE*/get MAX_3D_TEXTURE_SIZE() {
>+    return 32883;
>+  },
>+  /*web_gl.WebGL.MAX_ARRAY_TEXTURE_LAYERS*/get MAX_ARRAY_TEXTURE_LAYERS() {
>+    return 35071;
>+  },
>+  /*web_gl.WebGL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL*/get MAX_CLIENT_WAIT_TIMEOUT_WEBGL() {
>+    return 37447;
>+  },
>+  /*web_gl.WebGL.MAX_COLOR_ATTACHMENTS*/get MAX_COLOR_ATTACHMENTS() {
>+    return 36063;
>+  },
>+  /*web_gl.WebGL.MAX_COLOR_ATTACHMENTS_WEBGL*/get MAX_COLOR_ATTACHMENTS_WEBGL() {
>+    return 36063;
>+  },
>+  /*web_gl.WebGL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS*/get MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS() {
>+    return 35379;
>+  },
>+  /*web_gl.WebGL.MAX_COMBINED_TEXTURE_IMAGE_UNITS*/get MAX_COMBINED_TEXTURE_IMAGE_UNITS() {
>+    return 35661;
>+  },
>+  /*web_gl.WebGL.MAX_COMBINED_UNIFORM_BLOCKS*/get MAX_COMBINED_UNIFORM_BLOCKS() {
>+    return 35374;
>+  },
>+  /*web_gl.WebGL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS*/get MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS() {
>+    return 35377;
>+  },
>+  /*web_gl.WebGL.MAX_CUBE_MAP_TEXTURE_SIZE*/get MAX_CUBE_MAP_TEXTURE_SIZE() {
>+    return 34076;
>+  },
>+  /*web_gl.WebGL.MAX_DRAW_BUFFERS*/get MAX_DRAW_BUFFERS() {
>+    return 34852;
>+  },
>+  /*web_gl.WebGL.MAX_DRAW_BUFFERS_WEBGL*/get MAX_DRAW_BUFFERS_WEBGL() {
>+    return 34852;
>+  },
>+  /*web_gl.WebGL.MAX_ELEMENTS_INDICES*/get MAX_ELEMENTS_INDICES() {
>+    return 33001;
>+  },
>+  /*web_gl.WebGL.MAX_ELEMENTS_VERTICES*/get MAX_ELEMENTS_VERTICES() {
>+    return 33000;
>+  },
>+  /*web_gl.WebGL.MAX_ELEMENT_INDEX*/get MAX_ELEMENT_INDEX() {
>+    return 36203;
>+  },
>+  /*web_gl.WebGL.MAX_FRAGMENT_INPUT_COMPONENTS*/get MAX_FRAGMENT_INPUT_COMPONENTS() {
>+    return 37157;
>+  },
>+  /*web_gl.WebGL.MAX_FRAGMENT_UNIFORM_BLOCKS*/get MAX_FRAGMENT_UNIFORM_BLOCKS() {
>+    return 35373;
>+  },
>+  /*web_gl.WebGL.MAX_FRAGMENT_UNIFORM_COMPONENTS*/get MAX_FRAGMENT_UNIFORM_COMPONENTS() {
>+    return 35657;
>+  },
>+  /*web_gl.WebGL.MAX_FRAGMENT_UNIFORM_VECTORS*/get MAX_FRAGMENT_UNIFORM_VECTORS() {
>+    return 36349;
>+  },
>+  /*web_gl.WebGL.MAX_PROGRAM_TEXEL_OFFSET*/get MAX_PROGRAM_TEXEL_OFFSET() {
>+    return 35077;
>+  },
>+  /*web_gl.WebGL.MAX_RENDERBUFFER_SIZE*/get MAX_RENDERBUFFER_SIZE() {
>+    return 34024;
>+  },
>+  /*web_gl.WebGL.MAX_SAMPLES*/get MAX_SAMPLES() {
>+    return 36183;
>+  },
>+  /*web_gl.WebGL.MAX_SERVER_WAIT_TIMEOUT*/get MAX_SERVER_WAIT_TIMEOUT() {
>+    return 37137;
>+  },
>+  /*web_gl.WebGL.MAX_TEXTURE_IMAGE_UNITS*/get MAX_TEXTURE_IMAGE_UNITS() {
>+    return 34930;
>+  },
>+  /*web_gl.WebGL.MAX_TEXTURE_LOD_BIAS*/get MAX_TEXTURE_LOD_BIAS() {
>+    return 34045;
>+  },
>+  /*web_gl.WebGL.MAX_TEXTURE_SIZE*/get MAX_TEXTURE_SIZE() {
>+    return 3379;
>+  },
>+  /*web_gl.WebGL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS*/get MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS() {
>+    return 35978;
>+  },
>+  /*web_gl.WebGL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS*/get MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS() {
>+    return 35979;
>+  },
>+  /*web_gl.WebGL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS*/get MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS() {
>+    return 35968;
>+  },
>+  /*web_gl.WebGL.MAX_UNIFORM_BLOCK_SIZE*/get MAX_UNIFORM_BLOCK_SIZE() {
>+    return 35376;
>+  },
>+  /*web_gl.WebGL.MAX_UNIFORM_BUFFER_BINDINGS*/get MAX_UNIFORM_BUFFER_BINDINGS() {
>+    return 35375;
>+  },
>+  /*web_gl.WebGL.MAX_VARYING_COMPONENTS*/get MAX_VARYING_COMPONENTS() {
>+    return 35659;
>+  },
>+  /*web_gl.WebGL.MAX_VARYING_VECTORS*/get MAX_VARYING_VECTORS() {
>+    return 36348;
>+  },
>+  /*web_gl.WebGL.MAX_VERTEX_ATTRIBS*/get MAX_VERTEX_ATTRIBS() {
>+    return 34921;
>+  },
>+  /*web_gl.WebGL.MAX_VERTEX_OUTPUT_COMPONENTS*/get MAX_VERTEX_OUTPUT_COMPONENTS() {
>+    return 37154;
>+  },
>+  /*web_gl.WebGL.MAX_VERTEX_TEXTURE_IMAGE_UNITS*/get MAX_VERTEX_TEXTURE_IMAGE_UNITS() {
>+    return 35660;
>+  },
>+  /*web_gl.WebGL.MAX_VERTEX_UNIFORM_BLOCKS*/get MAX_VERTEX_UNIFORM_BLOCKS() {
>+    return 35371;
>+  },
>+  /*web_gl.WebGL.MAX_VERTEX_UNIFORM_COMPONENTS*/get MAX_VERTEX_UNIFORM_COMPONENTS() {
>+    return 35658;
>+  },
>+  /*web_gl.WebGL.MAX_VERTEX_UNIFORM_VECTORS*/get MAX_VERTEX_UNIFORM_VECTORS() {
>+    return 36347;
>+  },
>+  /*web_gl.WebGL.MAX_VIEWPORT_DIMS*/get MAX_VIEWPORT_DIMS() {
>+    return 3386;
>+  },
>+  /*web_gl.WebGL.MEDIUM_FLOAT*/get MEDIUM_FLOAT() {
>+    return 36337;
>+  },
>+  /*web_gl.WebGL.MEDIUM_INT*/get MEDIUM_INT() {
>+    return 36340;
>+  },
>+  /*web_gl.WebGL.MIN*/get MIN() {
>+    return 32775;
>+  },
>+  /*web_gl.WebGL.MIN_PROGRAM_TEXEL_OFFSET*/get MIN_PROGRAM_TEXEL_OFFSET() {
>+    return 35076;
>+  },
>+  /*web_gl.WebGL.MIRRORED_REPEAT*/get MIRRORED_REPEAT() {
>+    return 33648;
>+  },
>+  /*web_gl.WebGL.NEAREST*/get NEAREST() {
>+    return 9728;
>+  },
>+  /*web_gl.WebGL.NEAREST_MIPMAP_LINEAR*/get NEAREST_MIPMAP_LINEAR() {
>+    return 9986;
>+  },
>+  /*web_gl.WebGL.NEAREST_MIPMAP_NEAREST*/get NEAREST_MIPMAP_NEAREST() {
>+    return 9984;
>+  },
>+  /*web_gl.WebGL.NEVER*/get NEVER() {
>+    return 512;
>+  },
>+  /*web_gl.WebGL.NICEST*/get NICEST() {
>+    return 4354;
>+  },
>+  /*web_gl.WebGL.NONE*/get NONE() {
>+    return 0;
>+  },
>+  /*web_gl.WebGL.NOTEQUAL*/get NOTEQUAL() {
>+    return 517;
>+  },
>+  /*web_gl.WebGL.NO_ERROR*/get NO_ERROR() {
>+    return 0;
>+  },
>+  /*web_gl.WebGL.OBJECT_TYPE*/get OBJECT_TYPE() {
>+    return 37138;
>+  },
>+  /*web_gl.WebGL.ONE*/get ONE() {
>+    return 1;
>+  },
>+  /*web_gl.WebGL.ONE_MINUS_CONSTANT_ALPHA*/get ONE_MINUS_CONSTANT_ALPHA() {
>+    return 32772;
>+  },
>+  /*web_gl.WebGL.ONE_MINUS_CONSTANT_COLOR*/get ONE_MINUS_CONSTANT_COLOR() {
>+    return 32770;
>+  },
>+  /*web_gl.WebGL.ONE_MINUS_DST_ALPHA*/get ONE_MINUS_DST_ALPHA() {
>+    return 773;
>+  },
>+  /*web_gl.WebGL.ONE_MINUS_DST_COLOR*/get ONE_MINUS_DST_COLOR() {
>+    return 775;
>+  },
>+  /*web_gl.WebGL.ONE_MINUS_SRC_ALPHA*/get ONE_MINUS_SRC_ALPHA() {
>+    return 771;
>+  },
>+  /*web_gl.WebGL.ONE_MINUS_SRC_COLOR*/get ONE_MINUS_SRC_COLOR() {
>+    return 769;
>+  },
>+  /*web_gl.WebGL.OUT_OF_MEMORY*/get OUT_OF_MEMORY() {
>+    return 1285;
>+  },
>+  /*web_gl.WebGL.PACK_ALIGNMENT*/get PACK_ALIGNMENT() {
>+    return 3333;
>+  },
>+  /*web_gl.WebGL.PACK_ROW_LENGTH*/get PACK_ROW_LENGTH() {
>+    return 3330;
>+  },
>+  /*web_gl.WebGL.PACK_SKIP_PIXELS*/get PACK_SKIP_PIXELS() {
>+    return 3332;
>+  },
>+  /*web_gl.WebGL.PACK_SKIP_ROWS*/get PACK_SKIP_ROWS() {
>+    return 3331;
>+  },
>+  /*web_gl.WebGL.PIXEL_PACK_BUFFER*/get PIXEL_PACK_BUFFER() {
>+    return 35051;
>+  },
>+  /*web_gl.WebGL.PIXEL_PACK_BUFFER_BINDING*/get PIXEL_PACK_BUFFER_BINDING() {
>+    return 35053;
>+  },
>+  /*web_gl.WebGL.PIXEL_UNPACK_BUFFER*/get PIXEL_UNPACK_BUFFER() {
>+    return 35052;
>+  },
>+  /*web_gl.WebGL.PIXEL_UNPACK_BUFFER_BINDING*/get PIXEL_UNPACK_BUFFER_BINDING() {
>+    return 35055;
>+  },
>+  /*web_gl.WebGL.POINTS*/get POINTS() {
>+    return 0;
>+  },
>+  /*web_gl.WebGL.POLYGON_OFFSET_FACTOR*/get POLYGON_OFFSET_FACTOR() {
>+    return 32824;
>+  },
>+  /*web_gl.WebGL.POLYGON_OFFSET_FILL*/get POLYGON_OFFSET_FILL() {
>+    return 32823;
>+  },
>+  /*web_gl.WebGL.POLYGON_OFFSET_UNITS*/get POLYGON_OFFSET_UNITS() {
>+    return 10752;
>+  },
>+  /*web_gl.WebGL.QUERY_RESULT*/get QUERY_RESULT() {
>+    return 34918;
>+  },
>+  /*web_gl.WebGL.QUERY_RESULT_AVAILABLE*/get QUERY_RESULT_AVAILABLE() {
>+    return 34919;
>+  },
>+  /*web_gl.WebGL.R11F_G11F_B10F*/get R11F_G11F_B10F() {
>+    return 35898;
>+  },
>+  /*web_gl.WebGL.R16F*/get R16F() {
>+    return 33325;
>+  },
>+  /*web_gl.WebGL.R16I*/get R16I() {
>+    return 33331;
>+  },
>+  /*web_gl.WebGL.R16UI*/get R16UI() {
>+    return 33332;
>+  },
>+  /*web_gl.WebGL.R32F*/get R32F() {
>+    return 33326;
>+  },
>+  /*web_gl.WebGL.R32I*/get R32I() {
>+    return 33333;
>+  },
>+  /*web_gl.WebGL.R32UI*/get R32UI() {
>+    return 33334;
>+  },
>+  /*web_gl.WebGL.R8*/get R8() {
>+    return 33321;
>+  },
>+  /*web_gl.WebGL.R8I*/get R8I() {
>+    return 33329;
>+  },
>+  /*web_gl.WebGL.R8UI*/get R8UI() {
>+    return 33330;
>+  },
>+  /*web_gl.WebGL.R8_SNORM*/get R8_SNORM() {
>+    return 36756;
>+  },
>+  /*web_gl.WebGL.RASTERIZER_DISCARD*/get RASTERIZER_DISCARD() {
>+    return 35977;
>+  },
>+  /*web_gl.WebGL.READ_BUFFER*/get READ_BUFFER() {
>+    return 3074;
>+  },
>+  /*web_gl.WebGL.READ_FRAMEBUFFER*/get READ_FRAMEBUFFER() {
>+    return 36008;
>+  },
>+  /*web_gl.WebGL.READ_FRAMEBUFFER_BINDING*/get READ_FRAMEBUFFER_BINDING() {
>+    return 36010;
>+  },
>+  /*web_gl.WebGL.RED*/get RED() {
>+    return 6403;
>+  },
>+  /*web_gl.WebGL.RED_BITS*/get RED_BITS() {
>+    return 3410;
>+  },
>+  /*web_gl.WebGL.RED_INTEGER*/get RED_INTEGER() {
>+    return 36244;
>+  },
>+  /*web_gl.WebGL.RENDERBUFFER*/get RENDERBUFFER() {
>+    return 36161;
>+  },
>+  /*web_gl.WebGL.RENDERBUFFER_ALPHA_SIZE*/get RENDERBUFFER_ALPHA_SIZE() {
>+    return 36179;
>+  },
>+  /*web_gl.WebGL.RENDERBUFFER_BINDING*/get RENDERBUFFER_BINDING() {
>+    return 36007;
>+  },
>+  /*web_gl.WebGL.RENDERBUFFER_BLUE_SIZE*/get RENDERBUFFER_BLUE_SIZE() {
>+    return 36178;
>+  },
>+  /*web_gl.WebGL.RENDERBUFFER_DEPTH_SIZE*/get RENDERBUFFER_DEPTH_SIZE() {
>+    return 36180;
>+  },
>+  /*web_gl.WebGL.RENDERBUFFER_GREEN_SIZE*/get RENDERBUFFER_GREEN_SIZE() {
>+    return 36177;
>+  },
>+  /*web_gl.WebGL.RENDERBUFFER_HEIGHT*/get RENDERBUFFER_HEIGHT() {
>+    return 36163;
>+  },
>+  /*web_gl.WebGL.RENDERBUFFER_INTERNAL_FORMAT*/get RENDERBUFFER_INTERNAL_FORMAT() {
>+    return 36164;
>+  },
>+  /*web_gl.WebGL.RENDERBUFFER_RED_SIZE*/get RENDERBUFFER_RED_SIZE() {
>+    return 36176;
>+  },
>+  /*web_gl.WebGL.RENDERBUFFER_SAMPLES*/get RENDERBUFFER_SAMPLES() {
>+    return 36011;
>+  },
>+  /*web_gl.WebGL.RENDERBUFFER_STENCIL_SIZE*/get RENDERBUFFER_STENCIL_SIZE() {
>+    return 36181;
>+  },
>+  /*web_gl.WebGL.RENDERBUFFER_WIDTH*/get RENDERBUFFER_WIDTH() {
>+    return 36162;
>+  },
>+  /*web_gl.WebGL.RENDERER*/get RENDERER() {
>+    return 7937;
>+  },
>+  /*web_gl.WebGL.REPEAT*/get REPEAT() {
>+    return 10497;
>+  },
>+  /*web_gl.WebGL.REPLACE*/get REPLACE() {
>+    return 7681;
>+  },
>+  /*web_gl.WebGL.RG*/get RG() {
>+    return 33319;
>+  },
>+  /*web_gl.WebGL.RG16F*/get RG16F() {
>+    return 33327;
>+  },
>+  /*web_gl.WebGL.RG16I*/get RG16I() {
>+    return 33337;
>+  },
>+  /*web_gl.WebGL.RG16UI*/get RG16UI() {
>+    return 33338;
>+  },
>+  /*web_gl.WebGL.RG32F*/get RG32F() {
>+    return 33328;
>+  },
>+  /*web_gl.WebGL.RG32I*/get RG32I() {
>+    return 33339;
>+  },
>+  /*web_gl.WebGL.RG32UI*/get RG32UI() {
>+    return 33340;
>+  },
>+  /*web_gl.WebGL.RG8*/get RG8() {
>+    return 33323;
>+  },
>+  /*web_gl.WebGL.RG8I*/get RG8I() {
>+    return 33335;
>+  },
>+  /*web_gl.WebGL.RG8UI*/get RG8UI() {
>+    return 33336;
>+  },
>+  /*web_gl.WebGL.RG8_SNORM*/get RG8_SNORM() {
>+    return 36757;
>+  },
>+  /*web_gl.WebGL.RGB*/get RGB() {
>+    return 6407;
>+  },
>+  /*web_gl.WebGL.RGB10_A2*/get RGB10_A2() {
>+    return 32857;
>+  },
>+  /*web_gl.WebGL.RGB10_A2UI*/get RGB10_A2UI() {
>+    return 36975;
>+  },
>+  /*web_gl.WebGL.RGB16F*/get RGB16F() {
>+    return 34843;
>+  },
>+  /*web_gl.WebGL.RGB16I*/get RGB16I() {
>+    return 36233;
>+  },
>+  /*web_gl.WebGL.RGB16UI*/get RGB16UI() {
>+    return 36215;
>+  },
>+  /*web_gl.WebGL.RGB32F*/get RGB32F() {
>+    return 34837;
>+  },
>+  /*web_gl.WebGL.RGB32I*/get RGB32I() {
>+    return 36227;
>+  },
>+  /*web_gl.WebGL.RGB32UI*/get RGB32UI() {
>+    return 36209;
>+  },
>+  /*web_gl.WebGL.RGB565*/get RGB565() {
>+    return 36194;
>+  },
>+  /*web_gl.WebGL.RGB5_A1*/get RGB5_A1() {
>+    return 32855;
>+  },
>+  /*web_gl.WebGL.RGB8*/get RGB8() {
>+    return 32849;
>+  },
>+  /*web_gl.WebGL.RGB8I*/get RGB8I() {
>+    return 36239;
>+  },
>+  /*web_gl.WebGL.RGB8UI*/get RGB8UI() {
>+    return 36221;
>+  },
>+  /*web_gl.WebGL.RGB8_SNORM*/get RGB8_SNORM() {
>+    return 36758;
>+  },
>+  /*web_gl.WebGL.RGB9_E5*/get RGB9_E5() {
>+    return 35901;
>+  },
>+  /*web_gl.WebGL.RGBA*/get RGBA() {
>+    return 6408;
>+  },
>+  /*web_gl.WebGL.RGBA16F*/get RGBA16F() {
>+    return 34842;
>+  },
>+  /*web_gl.WebGL.RGBA16I*/get RGBA16I() {
>+    return 36232;
>+  },
>+  /*web_gl.WebGL.RGBA16UI*/get RGBA16UI() {
>+    return 36214;
>+  },
>+  /*web_gl.WebGL.RGBA32F*/get RGBA32F() {
>+    return 34836;
>+  },
>+  /*web_gl.WebGL.RGBA32I*/get RGBA32I() {
>+    return 36226;
>+  },
>+  /*web_gl.WebGL.RGBA32UI*/get RGBA32UI() {
>+    return 36208;
>+  },
>+  /*web_gl.WebGL.RGBA4*/get RGBA4() {
>+    return 32854;
>+  },
>+  /*web_gl.WebGL.RGBA8*/get RGBA8() {
>+    return 32856;
>+  },
>+  /*web_gl.WebGL.RGBA8I*/get RGBA8I() {
>+    return 36238;
>+  },
>+  /*web_gl.WebGL.RGBA8UI*/get RGBA8UI() {
>+    return 36220;
>+  },
>+  /*web_gl.WebGL.RGBA8_SNORM*/get RGBA8_SNORM() {
>+    return 36759;
>+  },
>+  /*web_gl.WebGL.RGBA_INTEGER*/get RGBA_INTEGER() {
>+    return 36249;
>+  },
>+  /*web_gl.WebGL.RGB_INTEGER*/get RGB_INTEGER() {
>+    return 36248;
>+  },
>+  /*web_gl.WebGL.RG_INTEGER*/get RG_INTEGER() {
>+    return 33320;
>+  },
>+  /*web_gl.WebGL.SAMPLER_2D*/get SAMPLER_2D() {
>+    return 35678;
>+  },
>+  /*web_gl.WebGL.SAMPLER_2D_ARRAY*/get SAMPLER_2D_ARRAY() {
>+    return 36289;
>+  },
>+  /*web_gl.WebGL.SAMPLER_2D_ARRAY_SHADOW*/get SAMPLER_2D_ARRAY_SHADOW() {
>+    return 36292;
>+  },
>+  /*web_gl.WebGL.SAMPLER_2D_SHADOW*/get SAMPLER_2D_SHADOW() {
>+    return 35682;
>+  },
>+  /*web_gl.WebGL.SAMPLER_3D*/get SAMPLER_3D() {
>+    return 35679;
>+  },
>+  /*web_gl.WebGL.SAMPLER_BINDING*/get SAMPLER_BINDING() {
>+    return 35097;
>+  },
>+  /*web_gl.WebGL.SAMPLER_CUBE*/get SAMPLER_CUBE() {
>+    return 35680;
>+  },
>+  /*web_gl.WebGL.SAMPLER_CUBE_SHADOW*/get SAMPLER_CUBE_SHADOW() {
>+    return 36293;
>+  },
>+  /*web_gl.WebGL.SAMPLES*/get SAMPLES() {
>+    return 32937;
>+  },
>+  /*web_gl.WebGL.SAMPLE_ALPHA_TO_COVERAGE*/get SAMPLE_ALPHA_TO_COVERAGE() {
>+    return 32926;
>+  },
>+  /*web_gl.WebGL.SAMPLE_BUFFERS*/get SAMPLE_BUFFERS() {
>+    return 32936;
>+  },
>+  /*web_gl.WebGL.SAMPLE_COVERAGE*/get SAMPLE_COVERAGE() {
>+    return 32928;
>+  },
>+  /*web_gl.WebGL.SAMPLE_COVERAGE_INVERT*/get SAMPLE_COVERAGE_INVERT() {
>+    return 32939;
>+  },
>+  /*web_gl.WebGL.SAMPLE_COVERAGE_VALUE*/get SAMPLE_COVERAGE_VALUE() {
>+    return 32938;
>+  },
>+  /*web_gl.WebGL.SCISSOR_BOX*/get SCISSOR_BOX() {
>+    return 3088;
>+  },
>+  /*web_gl.WebGL.SCISSOR_TEST*/get SCISSOR_TEST() {
>+    return 3089;
>+  },
>+  /*web_gl.WebGL.SEPARATE_ATTRIBS*/get SEPARATE_ATTRIBS() {
>+    return 35981;
>+  },
>+  /*web_gl.WebGL.SHADER_TYPE*/get SHADER_TYPE() {
>+    return 35663;
>+  },
>+  /*web_gl.WebGL.SHADING_LANGUAGE_VERSION*/get SHADING_LANGUAGE_VERSION() {
>+    return 35724;
>+  },
>+  /*web_gl.WebGL.SHORT*/get SHORT() {
>+    return 5122;
>+  },
>+  /*web_gl.WebGL.SIGNALED*/get SIGNALED() {
>+    return 37145;
>+  },
>+  /*web_gl.WebGL.SIGNED_NORMALIZED*/get SIGNED_NORMALIZED() {
>+    return 36764;
>+  },
>+  /*web_gl.WebGL.SRC_ALPHA*/get SRC_ALPHA() {
>+    return 770;
>+  },
>+  /*web_gl.WebGL.SRC_ALPHA_SATURATE*/get SRC_ALPHA_SATURATE() {
>+    return 776;
>+  },
>+  /*web_gl.WebGL.SRC_COLOR*/get SRC_COLOR() {
>+    return 768;
>+  },
>+  /*web_gl.WebGL.SRGB*/get SRGB() {
>+    return 35904;
>+  },
>+  /*web_gl.WebGL.SRGB8*/get SRGB8() {
>+    return 35905;
>+  },
>+  /*web_gl.WebGL.SRGB8_ALPHA8*/get SRGB8_ALPHA8() {
>+    return 35907;
>+  },
>+  /*web_gl.WebGL.STATIC_COPY*/get STATIC_COPY() {
>+    return 35046;
>+  },
>+  /*web_gl.WebGL.STATIC_DRAW*/get STATIC_DRAW() {
>+    return 35044;
>+  },
>+  /*web_gl.WebGL.STATIC_READ*/get STATIC_READ() {
>+    return 35045;
>+  },
>+  /*web_gl.WebGL.STENCIL*/get STENCIL() {
>+    return 6146;
>+  },
>+  /*web_gl.WebGL.STENCIL_ATTACHMENT*/get STENCIL_ATTACHMENT() {
>+    return 36128;
>+  },
>+  /*web_gl.WebGL.STENCIL_BACK_FAIL*/get STENCIL_BACK_FAIL() {
>+    return 34817;
>+  },
>+  /*web_gl.WebGL.STENCIL_BACK_FUNC*/get STENCIL_BACK_FUNC() {
>+    return 34816;
>+  },
>+  /*web_gl.WebGL.STENCIL_BACK_PASS_DEPTH_FAIL*/get STENCIL_BACK_PASS_DEPTH_FAIL() {
>+    return 34818;
>+  },
>+  /*web_gl.WebGL.STENCIL_BACK_PASS_DEPTH_PASS*/get STENCIL_BACK_PASS_DEPTH_PASS() {
>+    return 34819;
>+  },
>+  /*web_gl.WebGL.STENCIL_BACK_REF*/get STENCIL_BACK_REF() {
>+    return 36003;
>+  },
>+  /*web_gl.WebGL.STENCIL_BACK_VALUE_MASK*/get STENCIL_BACK_VALUE_MASK() {
>+    return 36004;
>+  },
>+  /*web_gl.WebGL.STENCIL_BACK_WRITEMASK*/get STENCIL_BACK_WRITEMASK() {
>+    return 36005;
>+  },
>+  /*web_gl.WebGL.STENCIL_BITS*/get STENCIL_BITS() {
>+    return 3415;
>+  },
>+  /*web_gl.WebGL.STENCIL_BUFFER_BIT*/get STENCIL_BUFFER_BIT() {
>+    return 1024;
>+  },
>+  /*web_gl.WebGL.STENCIL_CLEAR_VALUE*/get STENCIL_CLEAR_VALUE() {
>+    return 2961;
>+  },
>+  /*web_gl.WebGL.STENCIL_FAIL*/get STENCIL_FAIL() {
>+    return 2964;
>+  },
>+  /*web_gl.WebGL.STENCIL_FUNC*/get STENCIL_FUNC() {
>+    return 2962;
>+  },
>+  /*web_gl.WebGL.STENCIL_INDEX8*/get STENCIL_INDEX8() {
>+    return 36168;
>+  },
>+  /*web_gl.WebGL.STENCIL_PASS_DEPTH_FAIL*/get STENCIL_PASS_DEPTH_FAIL() {
>+    return 2965;
>+  },
>+  /*web_gl.WebGL.STENCIL_PASS_DEPTH_PASS*/get STENCIL_PASS_DEPTH_PASS() {
>+    return 2966;
>+  },
>+  /*web_gl.WebGL.STENCIL_REF*/get STENCIL_REF() {
>+    return 2967;
>+  },
>+  /*web_gl.WebGL.STENCIL_TEST*/get STENCIL_TEST() {
>+    return 2960;
>+  },
>+  /*web_gl.WebGL.STENCIL_VALUE_MASK*/get STENCIL_VALUE_MASK() {
>+    return 2963;
>+  },
>+  /*web_gl.WebGL.STENCIL_WRITEMASK*/get STENCIL_WRITEMASK() {
>+    return 2968;
>+  },
>+  /*web_gl.WebGL.STREAM_COPY*/get STREAM_COPY() {
>+    return 35042;
>+  },
>+  /*web_gl.WebGL.STREAM_DRAW*/get STREAM_DRAW() {
>+    return 35040;
>+  },
>+  /*web_gl.WebGL.STREAM_READ*/get STREAM_READ() {
>+    return 35041;
>+  },
>+  /*web_gl.WebGL.SUBPIXEL_BITS*/get SUBPIXEL_BITS() {
>+    return 3408;
>+  },
>+  /*web_gl.WebGL.SYNC_CONDITION*/get SYNC_CONDITION() {
>+    return 37139;
>+  },
>+  /*web_gl.WebGL.SYNC_FENCE*/get SYNC_FENCE() {
>+    return 37142;
>+  },
>+  /*web_gl.WebGL.SYNC_FLAGS*/get SYNC_FLAGS() {
>+    return 37141;
>+  },
>+  /*web_gl.WebGL.SYNC_FLUSH_COMMANDS_BIT*/get SYNC_FLUSH_COMMANDS_BIT() {
>+    return 1;
>+  },
>+  /*web_gl.WebGL.SYNC_GPU_COMMANDS_COMPLETE*/get SYNC_GPU_COMMANDS_COMPLETE() {
>+    return 37143;
>+  },
>+  /*web_gl.WebGL.SYNC_STATUS*/get SYNC_STATUS() {
>+    return 37140;
>+  },
>+  /*web_gl.WebGL.TEXTURE*/get TEXTURE() {
>+    return 5890;
>+  },
>+  /*web_gl.WebGL.TEXTURE0*/get TEXTURE0() {
>+    return 33984;
>+  },
>+  /*web_gl.WebGL.TEXTURE1*/get TEXTURE1() {
>+    return 33985;
>+  },
>+  /*web_gl.WebGL.TEXTURE10*/get TEXTURE10() {
>+    return 33994;
>+  },
>+  /*web_gl.WebGL.TEXTURE11*/get TEXTURE11() {
>+    return 33995;
>+  },
>+  /*web_gl.WebGL.TEXTURE12*/get TEXTURE12() {
>+    return 33996;
>+  },
>+  /*web_gl.WebGL.TEXTURE13*/get TEXTURE13() {
>+    return 33997;
>+  },
>+  /*web_gl.WebGL.TEXTURE14*/get TEXTURE14() {
>+    return 33998;
>+  },
>+  /*web_gl.WebGL.TEXTURE15*/get TEXTURE15() {
>+    return 33999;
>+  },
>+  /*web_gl.WebGL.TEXTURE16*/get TEXTURE16() {
>+    return 34000;
>+  },
>+  /*web_gl.WebGL.TEXTURE17*/get TEXTURE17() {
>+    return 34001;
>+  },
>+  /*web_gl.WebGL.TEXTURE18*/get TEXTURE18() {
>+    return 34002;
>+  },
>+  /*web_gl.WebGL.TEXTURE19*/get TEXTURE19() {
>+    return 34003;
>+  },
>+  /*web_gl.WebGL.TEXTURE2*/get TEXTURE2() {
>+    return 33986;
>+  },
>+  /*web_gl.WebGL.TEXTURE20*/get TEXTURE20() {
>+    return 34004;
>+  },
>+  /*web_gl.WebGL.TEXTURE21*/get TEXTURE21() {
>+    return 34005;
>+  },
>+  /*web_gl.WebGL.TEXTURE22*/get TEXTURE22() {
>+    return 34006;
>+  },
>+  /*web_gl.WebGL.TEXTURE23*/get TEXTURE23() {
>+    return 34007;
>+  },
>+  /*web_gl.WebGL.TEXTURE24*/get TEXTURE24() {
>+    return 34008;
>+  },
>+  /*web_gl.WebGL.TEXTURE25*/get TEXTURE25() {
>+    return 34009;
>+  },
>+  /*web_gl.WebGL.TEXTURE26*/get TEXTURE26() {
>+    return 34010;
>+  },
>+  /*web_gl.WebGL.TEXTURE27*/get TEXTURE27() {
>+    return 34011;
>+  },
>+  /*web_gl.WebGL.TEXTURE28*/get TEXTURE28() {
>+    return 34012;
>+  },
>+  /*web_gl.WebGL.TEXTURE29*/get TEXTURE29() {
>+    return 34013;
>+  },
>+  /*web_gl.WebGL.TEXTURE3*/get TEXTURE3() {
>+    return 33987;
>+  },
>+  /*web_gl.WebGL.TEXTURE30*/get TEXTURE30() {
>+    return 34014;
>+  },
>+  /*web_gl.WebGL.TEXTURE31*/get TEXTURE31() {
>+    return 34015;
>+  },
>+  /*web_gl.WebGL.TEXTURE4*/get TEXTURE4() {
>+    return 33988;
>+  },
>+  /*web_gl.WebGL.TEXTURE5*/get TEXTURE5() {
>+    return 33989;
>+  },
>+  /*web_gl.WebGL.TEXTURE6*/get TEXTURE6() {
>+    return 33990;
>+  },
>+  /*web_gl.WebGL.TEXTURE7*/get TEXTURE7() {
>+    return 33991;
>+  },
>+  /*web_gl.WebGL.TEXTURE8*/get TEXTURE8() {
>+    return 33992;
>+  },
>+  /*web_gl.WebGL.TEXTURE9*/get TEXTURE9() {
>+    return 33993;
>+  },
>+  /*web_gl.WebGL.TEXTURE_2D*/get TEXTURE_2D() {
>+    return 3553;
>+  },
>+  /*web_gl.WebGL.TEXTURE_2D_ARRAY*/get TEXTURE_2D_ARRAY() {
>+    return 35866;
>+  },
>+  /*web_gl.WebGL.TEXTURE_3D*/get TEXTURE_3D() {
>+    return 32879;
>+  },
>+  /*web_gl.WebGL.TEXTURE_BASE_LEVEL*/get TEXTURE_BASE_LEVEL() {
>+    return 33084;
>+  },
>+  /*web_gl.WebGL.TEXTURE_BINDING_2D*/get TEXTURE_BINDING_2D() {
>+    return 32873;
>+  },
>+  /*web_gl.WebGL.TEXTURE_BINDING_2D_ARRAY*/get TEXTURE_BINDING_2D_ARRAY() {
>+    return 35869;
>+  },
>+  /*web_gl.WebGL.TEXTURE_BINDING_3D*/get TEXTURE_BINDING_3D() {
>+    return 32874;
>+  },
>+  /*web_gl.WebGL.TEXTURE_BINDING_CUBE_MAP*/get TEXTURE_BINDING_CUBE_MAP() {
>+    return 34068;
>+  },
>+  /*web_gl.WebGL.TEXTURE_COMPARE_FUNC*/get TEXTURE_COMPARE_FUNC() {
>+    return 34893;
>+  },
>+  /*web_gl.WebGL.TEXTURE_COMPARE_MODE*/get TEXTURE_COMPARE_MODE() {
>+    return 34892;
>+  },
>+  /*web_gl.WebGL.TEXTURE_CUBE_MAP*/get TEXTURE_CUBE_MAP() {
>+    return 34067;
>+  },
>+  /*web_gl.WebGL.TEXTURE_CUBE_MAP_NEGATIVE_X*/get TEXTURE_CUBE_MAP_NEGATIVE_X() {
>+    return 34070;
>+  },
>+  /*web_gl.WebGL.TEXTURE_CUBE_MAP_NEGATIVE_Y*/get TEXTURE_CUBE_MAP_NEGATIVE_Y() {
>+    return 34072;
>+  },
>+  /*web_gl.WebGL.TEXTURE_CUBE_MAP_NEGATIVE_Z*/get TEXTURE_CUBE_MAP_NEGATIVE_Z() {
>+    return 34074;
>+  },
>+  /*web_gl.WebGL.TEXTURE_CUBE_MAP_POSITIVE_X*/get TEXTURE_CUBE_MAP_POSITIVE_X() {
>+    return 34069;
>+  },
>+  /*web_gl.WebGL.TEXTURE_CUBE_MAP_POSITIVE_Y*/get TEXTURE_CUBE_MAP_POSITIVE_Y() {
>+    return 34071;
>+  },
>+  /*web_gl.WebGL.TEXTURE_CUBE_MAP_POSITIVE_Z*/get TEXTURE_CUBE_MAP_POSITIVE_Z() {
>+    return 34073;
>+  },
>+  /*web_gl.WebGL.TEXTURE_IMMUTABLE_FORMAT*/get TEXTURE_IMMUTABLE_FORMAT() {
>+    return 37167;
>+  },
>+  /*web_gl.WebGL.TEXTURE_IMMUTABLE_LEVELS*/get TEXTURE_IMMUTABLE_LEVELS() {
>+    return 33503;
>+  },
>+  /*web_gl.WebGL.TEXTURE_MAG_FILTER*/get TEXTURE_MAG_FILTER() {
>+    return 10240;
>+  },
>+  /*web_gl.WebGL.TEXTURE_MAX_LEVEL*/get TEXTURE_MAX_LEVEL() {
>+    return 33085;
>+  },
>+  /*web_gl.WebGL.TEXTURE_MAX_LOD*/get TEXTURE_MAX_LOD() {
>+    return 33083;
>+  },
>+  /*web_gl.WebGL.TEXTURE_MIN_FILTER*/get TEXTURE_MIN_FILTER() {
>+    return 10241;
>+  },
>+  /*web_gl.WebGL.TEXTURE_MIN_LOD*/get TEXTURE_MIN_LOD() {
>+    return 33082;
>+  },
>+  /*web_gl.WebGL.TEXTURE_WRAP_R*/get TEXTURE_WRAP_R() {
>+    return 32882;
>+  },
>+  /*web_gl.WebGL.TEXTURE_WRAP_S*/get TEXTURE_WRAP_S() {
>+    return 10242;
>+  },
>+  /*web_gl.WebGL.TEXTURE_WRAP_T*/get TEXTURE_WRAP_T() {
>+    return 10243;
>+  },
>+  /*web_gl.WebGL.TIMEOUT_EXPIRED*/get TIMEOUT_EXPIRED() {
>+    return 37147;
>+  },
>+  /*web_gl.WebGL.TIMEOUT_IGNORED*/get TIMEOUT_IGNORED() {
>+    return -1;
>+  },
>+  /*web_gl.WebGL.TRANSFORM_FEEDBACK*/get TRANSFORM_FEEDBACK() {
>+    return 36386;
>+  },
>+  /*web_gl.WebGL.TRANSFORM_FEEDBACK_ACTIVE*/get TRANSFORM_FEEDBACK_ACTIVE() {
>+    return 36388;
>+  },
>+  /*web_gl.WebGL.TRANSFORM_FEEDBACK_BINDING*/get TRANSFORM_FEEDBACK_BINDING() {
>+    return 36389;
>+  },
>+  /*web_gl.WebGL.TRANSFORM_FEEDBACK_BUFFER*/get TRANSFORM_FEEDBACK_BUFFER() {
>+    return 35982;
>+  },
>+  /*web_gl.WebGL.TRANSFORM_FEEDBACK_BUFFER_BINDING*/get TRANSFORM_FEEDBACK_BUFFER_BINDING() {
>+    return 35983;
>+  },
>+  /*web_gl.WebGL.TRANSFORM_FEEDBACK_BUFFER_MODE*/get TRANSFORM_FEEDBACK_BUFFER_MODE() {
>+    return 35967;
>+  },
>+  /*web_gl.WebGL.TRANSFORM_FEEDBACK_BUFFER_SIZE*/get TRANSFORM_FEEDBACK_BUFFER_SIZE() {
>+    return 35973;
>+  },
>+  /*web_gl.WebGL.TRANSFORM_FEEDBACK_BUFFER_START*/get TRANSFORM_FEEDBACK_BUFFER_START() {
>+    return 35972;
>+  },
>+  /*web_gl.WebGL.TRANSFORM_FEEDBACK_PAUSED*/get TRANSFORM_FEEDBACK_PAUSED() {
>+    return 36387;
>+  },
>+  /*web_gl.WebGL.TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN*/get TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN() {
>+    return 35976;
>+  },
>+  /*web_gl.WebGL.TRANSFORM_FEEDBACK_VARYINGS*/get TRANSFORM_FEEDBACK_VARYINGS() {
>+    return 35971;
>+  },
>+  /*web_gl.WebGL.TRIANGLES*/get TRIANGLES() {
>+    return 4;
>+  },
>+  /*web_gl.WebGL.TRIANGLE_FAN*/get TRIANGLE_FAN() {
>+    return 6;
>+  },
>+  /*web_gl.WebGL.TRIANGLE_STRIP*/get TRIANGLE_STRIP() {
>+    return 5;
>+  },
>+  /*web_gl.WebGL.UNIFORM_ARRAY_STRIDE*/get UNIFORM_ARRAY_STRIDE() {
>+    return 35388;
>+  },
>+  /*web_gl.WebGL.UNIFORM_BLOCK_ACTIVE_UNIFORMS*/get UNIFORM_BLOCK_ACTIVE_UNIFORMS() {
>+    return 35394;
>+  },
>+  /*web_gl.WebGL.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES*/get UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES() {
>+    return 35395;
>+  },
>+  /*web_gl.WebGL.UNIFORM_BLOCK_BINDING*/get UNIFORM_BLOCK_BINDING() {
>+    return 35391;
>+  },
>+  /*web_gl.WebGL.UNIFORM_BLOCK_DATA_SIZE*/get UNIFORM_BLOCK_DATA_SIZE() {
>+    return 35392;
>+  },
>+  /*web_gl.WebGL.UNIFORM_BLOCK_INDEX*/get UNIFORM_BLOCK_INDEX() {
>+    return 35386;
>+  },
>+  /*web_gl.WebGL.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER*/get UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER() {
>+    return 35398;
>+  },
>+  /*web_gl.WebGL.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER*/get UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER() {
>+    return 35396;
>+  },
>+  /*web_gl.WebGL.UNIFORM_BUFFER*/get UNIFORM_BUFFER() {
>+    return 35345;
>+  },
>+  /*web_gl.WebGL.UNIFORM_BUFFER_BINDING*/get UNIFORM_BUFFER_BINDING() {
>+    return 35368;
>+  },
>+  /*web_gl.WebGL.UNIFORM_BUFFER_OFFSET_ALIGNMENT*/get UNIFORM_BUFFER_OFFSET_ALIGNMENT() {
>+    return 35380;
>+  },
>+  /*web_gl.WebGL.UNIFORM_BUFFER_SIZE*/get UNIFORM_BUFFER_SIZE() {
>+    return 35370;
>+  },
>+  /*web_gl.WebGL.UNIFORM_BUFFER_START*/get UNIFORM_BUFFER_START() {
>+    return 35369;
>+  },
>+  /*web_gl.WebGL.UNIFORM_IS_ROW_MAJOR*/get UNIFORM_IS_ROW_MAJOR() {
>+    return 35390;
>+  },
>+  /*web_gl.WebGL.UNIFORM_MATRIX_STRIDE*/get UNIFORM_MATRIX_STRIDE() {
>+    return 35389;
>+  },
>+  /*web_gl.WebGL.UNIFORM_OFFSET*/get UNIFORM_OFFSET() {
>+    return 35387;
>+  },
>+  /*web_gl.WebGL.UNIFORM_SIZE*/get UNIFORM_SIZE() {
>+    return 35384;
>+  },
>+  /*web_gl.WebGL.UNIFORM_TYPE*/get UNIFORM_TYPE() {
>+    return 35383;
>+  },
>+  /*web_gl.WebGL.UNPACK_ALIGNMENT*/get UNPACK_ALIGNMENT() {
>+    return 3317;
>+  },
>+  /*web_gl.WebGL.UNPACK_COLORSPACE_CONVERSION_WEBGL*/get UNPACK_COLORSPACE_CONVERSION_WEBGL() {
>+    return 37443;
>+  },
>+  /*web_gl.WebGL.UNPACK_FLIP_Y_WEBGL*/get UNPACK_FLIP_Y_WEBGL() {
>+    return 37440;
>+  },
>+  /*web_gl.WebGL.UNPACK_IMAGE_HEIGHT*/get UNPACK_IMAGE_HEIGHT() {
>+    return 32878;
>+  },
>+  /*web_gl.WebGL.UNPACK_PREMULTIPLY_ALPHA_WEBGL*/get UNPACK_PREMULTIPLY_ALPHA_WEBGL() {
>+    return 37441;
>+  },
>+  /*web_gl.WebGL.UNPACK_ROW_LENGTH*/get UNPACK_ROW_LENGTH() {
>+    return 3314;
>+  },
>+  /*web_gl.WebGL.UNPACK_SKIP_IMAGES*/get UNPACK_SKIP_IMAGES() {
>+    return 32877;
>+  },
>+  /*web_gl.WebGL.UNPACK_SKIP_PIXELS*/get UNPACK_SKIP_PIXELS() {
>+    return 3316;
>+  },
>+  /*web_gl.WebGL.UNPACK_SKIP_ROWS*/get UNPACK_SKIP_ROWS() {
>+    return 3315;
>+  },
>+  /*web_gl.WebGL.UNSIGNALED*/get UNSIGNALED() {
>+    return 37144;
>+  },
>+  /*web_gl.WebGL.UNSIGNED_BYTE*/get UNSIGNED_BYTE() {
>+    return 5121;
>+  },
>+  /*web_gl.WebGL.UNSIGNED_INT*/get UNSIGNED_INT() {
>+    return 5125;
>+  },
>+  /*web_gl.WebGL.UNSIGNED_INT_10F_11F_11F_REV*/get UNSIGNED_INT_10F_11F_11F_REV() {
>+    return 35899;
>+  },
>+  /*web_gl.WebGL.UNSIGNED_INT_24_8*/get UNSIGNED_INT_24_8() {
>+    return 34042;
>+  },
>+  /*web_gl.WebGL.UNSIGNED_INT_2_10_10_10_REV*/get UNSIGNED_INT_2_10_10_10_REV() {
>+    return 33640;
>+  },
>+  /*web_gl.WebGL.UNSIGNED_INT_5_9_9_9_REV*/get UNSIGNED_INT_5_9_9_9_REV() {
>+    return 35902;
>+  },
>+  /*web_gl.WebGL.UNSIGNED_INT_SAMPLER_2D*/get UNSIGNED_INT_SAMPLER_2D() {
>+    return 36306;
>+  },
>+  /*web_gl.WebGL.UNSIGNED_INT_SAMPLER_2D_ARRAY*/get UNSIGNED_INT_SAMPLER_2D_ARRAY() {
>+    return 36311;
>+  },
>+  /*web_gl.WebGL.UNSIGNED_INT_SAMPLER_3D*/get UNSIGNED_INT_SAMPLER_3D() {
>+    return 36307;
>+  },
>+  /*web_gl.WebGL.UNSIGNED_INT_SAMPLER_CUBE*/get UNSIGNED_INT_SAMPLER_CUBE() {
>+    return 36308;
>+  },
>+  /*web_gl.WebGL.UNSIGNED_INT_VEC2*/get UNSIGNED_INT_VEC2() {
>+    return 36294;
>+  },
>+  /*web_gl.WebGL.UNSIGNED_INT_VEC3*/get UNSIGNED_INT_VEC3() {
>+    return 36295;
>+  },
>+  /*web_gl.WebGL.UNSIGNED_INT_VEC4*/get UNSIGNED_INT_VEC4() {
>+    return 36296;
>+  },
>+  /*web_gl.WebGL.UNSIGNED_NORMALIZED*/get UNSIGNED_NORMALIZED() {
>+    return 35863;
>+  },
>+  /*web_gl.WebGL.UNSIGNED_SHORT*/get UNSIGNED_SHORT() {
>+    return 5123;
>+  },
>+  /*web_gl.WebGL.UNSIGNED_SHORT_4_4_4_4*/get UNSIGNED_SHORT_4_4_4_4() {
>+    return 32819;
>+  },
>+  /*web_gl.WebGL.UNSIGNED_SHORT_5_5_5_1*/get UNSIGNED_SHORT_5_5_5_1() {
>+    return 32820;
>+  },
>+  /*web_gl.WebGL.UNSIGNED_SHORT_5_6_5*/get UNSIGNED_SHORT_5_6_5() {
>+    return 33635;
>+  },
>+  /*web_gl.WebGL.VALIDATE_STATUS*/get VALIDATE_STATUS() {
>+    return 35715;
>+  },
>+  /*web_gl.WebGL.VENDOR*/get VENDOR() {
>+    return 7936;
>+  },
>+  /*web_gl.WebGL.VERSION*/get VERSION() {
>+    return 7938;
>+  },
>+  /*web_gl.WebGL.VERTEX_ARRAY_BINDING*/get VERTEX_ARRAY_BINDING() {
>+    return 34229;
>+  },
>+  /*web_gl.WebGL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING*/get VERTEX_ATTRIB_ARRAY_BUFFER_BINDING() {
>+    return 34975;
>+  },
>+  /*web_gl.WebGL.VERTEX_ATTRIB_ARRAY_DIVISOR*/get VERTEX_ATTRIB_ARRAY_DIVISOR() {
>+    return 35070;
>+  },
>+  /*web_gl.WebGL.VERTEX_ATTRIB_ARRAY_ENABLED*/get VERTEX_ATTRIB_ARRAY_ENABLED() {
>+    return 34338;
>+  },
>+  /*web_gl.WebGL.VERTEX_ATTRIB_ARRAY_INTEGER*/get VERTEX_ATTRIB_ARRAY_INTEGER() {
>+    return 35069;
>+  },
>+  /*web_gl.WebGL.VERTEX_ATTRIB_ARRAY_NORMALIZED*/get VERTEX_ATTRIB_ARRAY_NORMALIZED() {
>+    return 34922;
>+  },
>+  /*web_gl.WebGL.VERTEX_ATTRIB_ARRAY_POINTER*/get VERTEX_ATTRIB_ARRAY_POINTER() {
>+    return 34373;
>+  },
>+  /*web_gl.WebGL.VERTEX_ATTRIB_ARRAY_SIZE*/get VERTEX_ATTRIB_ARRAY_SIZE() {
>+    return 34339;
>+  },
>+  /*web_gl.WebGL.VERTEX_ATTRIB_ARRAY_STRIDE*/get VERTEX_ATTRIB_ARRAY_STRIDE() {
>+    return 34340;
>+  },
>+  /*web_gl.WebGL.VERTEX_ATTRIB_ARRAY_TYPE*/get VERTEX_ATTRIB_ARRAY_TYPE() {
>+    return 34341;
>+  },
>+  /*web_gl.WebGL.VERTEX_SHADER*/get VERTEX_SHADER() {
>+    return 35633;
>+  },
>+  /*web_gl.WebGL.VIEWPORT*/get VIEWPORT() {
>+    return 2978;
>+  },
>+  /*web_gl.WebGL.WAIT_FAILED*/get WAIT_FAILED() {
>+    return 37149;
>+  },
>+  /*web_gl.WebGL.ZERO*/get ZERO() {
>+    return 0;
>+  }
>+});
>+dart.registerExtension("WebGL", web_gl.WebGL);
>+web_gl._WebGL2RenderingContextBase = class _WebGL2RenderingContextBase extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl._WebGL2RenderingContextBase);
>+web_gl._WebGL2RenderingContextBase[dart.implements] = () => [web_gl._WebGLRenderingContextBase];
>+dart.setLibraryUri(web_gl._WebGL2RenderingContextBase, "dart:web_gl");
>+dart.registerExtension("WebGL2RenderingContextBase", web_gl._WebGL2RenderingContextBase);
>+web_gl._WebGLRenderingContextBase = class _WebGLRenderingContextBase extends _interceptors.Interceptor {};
>+dart.addTypeTests(web_gl._WebGLRenderingContextBase);
>+dart.setLibraryUri(web_gl._WebGLRenderingContextBase, "dart:web_gl");
>+const _changeVersion = dart.privateName(web_sql, "_changeVersion");
>+const _readTransaction = dart.privateName(web_sql, "_readTransaction");
>+web_sql.SqlDatabase = class SqlDatabase extends _interceptors.Interceptor {
>+  static get supported() {
>+    return !!window.openDatabase;
>+  }
>+  get [$version]() {
>+    return this.version;
>+  }
>+  [_changeVersion](...args) {
>+    return this.changeVersion.apply(this, args);
>+  }
>+  [$changeVersion](oldVersion, newVersion) {
>+    let completer = CompleterOfSqlTransaction().new();
>+    this[_changeVersion](oldVersion, newVersion, dart.fn(value => {
>+      completer.complete(value);
>+    }, SqlTransactionToNull()), dart.fn(error => {
>+      completer.completeError(error);
>+    }, SqlErrorToNull()));
>+    return completer.future;
>+  }
>+  [_readTransaction](...args) {
>+    return this.readTransaction.apply(this, args);
>+  }
>+  [$readTransaction]() {
>+    let completer = CompleterOfSqlTransaction().new();
>+    this[_readTransaction](dart.fn(value => {
>+      completer.complete(value);
>+    }, SqlTransactionToNull()), dart.fn(error => {
>+      completer.completeError(error);
>+    }, SqlErrorToNull()));
>+    return completer.future;
>+  }
>+  [$transaction](...args) {
>+    return this.transaction.apply(this, args);
>+  }
>+  [$transaction_future]() {
>+    let completer = CompleterOfSqlTransaction().new();
>+    this.transaction(dart.fn(value => {
>+      _js_helper.applyExtension("SQLTransaction", value);
>+      completer.complete(value);
>+    }, SqlTransactionToNull()), dart.fn(error => {
>+      completer.completeError(error);
>+    }, SqlErrorToNull()));
>+    return completer.future;
>+  }
>+};
>+dart.addTypeTests(web_sql.SqlDatabase);
>+const version$1 = Symbol("SqlDatabase.version");
>+dart.setMethodSignature(web_sql.SqlDatabase, () => ({
>+  __proto__: dart.getMethods(web_sql.SqlDatabase.__proto__),
>+  [_changeVersion]: dart.fnType(dart.void, [core.String, core.String], [dart.fnType(dart.void, [web_sql.SqlTransaction]), dart.fnType(dart.void, [web_sql.SqlError]), dart.fnType(dart.void, [])]),
>+  [$changeVersion]: dart.fnType(async.Future$(web_sql.SqlTransaction), [core.String, core.String]),
>+  [_readTransaction]: dart.fnType(dart.void, [dart.fnType(dart.void, [web_sql.SqlTransaction])], [dart.fnType(dart.void, [web_sql.SqlError]), dart.fnType(dart.void, [])]),
>+  [$readTransaction]: dart.fnType(async.Future$(web_sql.SqlTransaction), []),
>+  [$transaction]: dart.fnType(dart.void, [dart.fnType(dart.void, [web_sql.SqlTransaction])], [dart.fnType(dart.void, [web_sql.SqlError]), dart.fnType(dart.void, [])]),
>+  [$transaction_future]: dart.fnType(async.Future$(web_sql.SqlTransaction), [])
>+}));
>+dart.setLibraryUri(web_sql.SqlDatabase, "dart:web_sql");
>+dart.setFieldSignature(web_sql.SqlDatabase, () => ({
>+  __proto__: dart.getFields(web_sql.SqlDatabase.__proto__),
>+  [$version]: dart.finalFieldType(core.String)
>+}));
>+dart.registerExtension("Database", web_sql.SqlDatabase);
>+web_sql.SqlError = class SqlError extends _interceptors.Interceptor {
>+  get [$code]() {
>+    return this.code;
>+  }
>+  get [$message]() {
>+    return this.message;
>+  }
>+};
>+dart.addTypeTests(web_sql.SqlError);
>+const code$2 = Symbol("SqlError.code");
>+const message$28 = Symbol("SqlError.message");
>+dart.setLibraryUri(web_sql.SqlError, "dart:web_sql");
>+dart.setFieldSignature(web_sql.SqlError, () => ({
>+  __proto__: dart.getFields(web_sql.SqlError.__proto__),
>+  [$code]: dart.finalFieldType(core.int),
>+  [$message]: dart.finalFieldType(core.String)
>+}));
>+dart.defineLazy(web_sql.SqlError, {
>+  /*web_sql.SqlError.CONSTRAINT_ERR*/get CONSTRAINT_ERR() {
>+    return 6;
>+  },
>+  /*web_sql.SqlError.DATABASE_ERR*/get DATABASE_ERR() {
>+    return 1;
>+  },
>+  /*web_sql.SqlError.QUOTA_ERR*/get QUOTA_ERR() {
>+    return 4;
>+  },
>+  /*web_sql.SqlError.SYNTAX_ERR*/get SYNTAX_ERR() {
>+    return 5;
>+  },
>+  /*web_sql.SqlError.TIMEOUT_ERR*/get TIMEOUT_ERR() {
>+    return 7;
>+  },
>+  /*web_sql.SqlError.TOO_LARGE_ERR*/get TOO_LARGE_ERR() {
>+    return 3;
>+  },
>+  /*web_sql.SqlError.UNKNOWN_ERR*/get UNKNOWN_ERR() {
>+    return 0;
>+  },
>+  /*web_sql.SqlError.VERSION_ERR*/get VERSION_ERR() {
>+    return 2;
>+  }
>+});
>+dart.registerExtension("SQLError", web_sql.SqlError);
>+web_sql.SqlResultSet = class SqlResultSet extends _interceptors.Interceptor {
>+  get [$insertId]() {
>+    return this.insertId;
>+  }
>+  get [$rows]() {
>+    return this.rows;
>+  }
>+  get [$rowsAffected]() {
>+    return this.rowsAffected;
>+  }
>+};
>+dart.addTypeTests(web_sql.SqlResultSet);
>+const insertId = Symbol("SqlResultSet.insertId");
>+const rows$ = Symbol("SqlResultSet.rows");
>+const rowsAffected = Symbol("SqlResultSet.rowsAffected");
>+dart.setLibraryUri(web_sql.SqlResultSet, "dart:web_sql");
>+dart.setFieldSignature(web_sql.SqlResultSet, () => ({
>+  __proto__: dart.getFields(web_sql.SqlResultSet.__proto__),
>+  [$insertId]: dart.finalFieldType(core.int),
>+  [$rows]: dart.finalFieldType(web_sql.SqlResultSetRowList),
>+  [$rowsAffected]: dart.finalFieldType(core.int)
>+}));
>+dart.registerExtension("SQLResultSet", web_sql.SqlResultSet);
>+const _item_1 = dart.privateName(web_sql, "_item_1");
>+const Interceptor_ListMixin$$17 = class Interceptor_ListMixin extends _interceptors.Interceptor {};
>+(Interceptor_ListMixin$$17.new = function() {
>+  Interceptor_ListMixin$$17.__proto__.new.call(this);
>+}).prototype = Interceptor_ListMixin$$17.prototype;
>+dart.applyMixin(Interceptor_ListMixin$$17, collection.ListMixin$(core.Map));
>+const Interceptor_ImmutableListMixin$$17 = class Interceptor_ImmutableListMixin extends Interceptor_ListMixin$$17 {};
>+(Interceptor_ImmutableListMixin$$17.new = function() {
>+  Interceptor_ImmutableListMixin$$17.__proto__.new.call(this);
>+}).prototype = Interceptor_ImmutableListMixin$$17.prototype;
>+dart.applyMixin(Interceptor_ImmutableListMixin$$17, html$.ImmutableListMixin$(core.Map));
>+web_sql.SqlResultSetRowList = class SqlResultSetRowList extends Interceptor_ImmutableListMixin$$17 {
>+  get [$length]() {
>+    return this.length;
>+  }
>+  [$_get](index) {
>+    if (index >>> 0 !== index || index >= this[$length]) dart.throw(core.RangeError.index(index, this));
>+    return this[$item](index);
>+  }
>+  [$_set](index, value) {
>+    core.Map._check(value);
>+    dart.throw(new core.UnsupportedError.new("Cannot assign element of immutable List."));
>+    return value;
>+  }
>+  set [$length](value) {
>+    dart.throw(new core.UnsupportedError.new("Cannot resize immutable List."));
>+  }
>+  get [$first]() {
>+    if (dart.notNull(this[$length]) > 0) {
>+      return this[0];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$first](value) {
>+    super[$first] = value;
>+  }
>+  get [$last]() {
>+    let len = this[$length];
>+    if (dart.notNull(len) > 0) {
>+      return this[dart.notNull(len) - 1];
>+    }
>+    dart.throw(new core.StateError.new("No elements"));
>+  }
>+  set [$last](value) {
>+    super[$last] = value;
>+  }
>+  get [$single]() {
>+    let len = this[$length];
>+    if (len === 1) {
>+      return this[0];
>+    }
>+    if (len === 0) dart.throw(new core.StateError.new("No elements"));
>+    dart.throw(new core.StateError.new("More than one element"));
>+  }
>+  [$elementAt](index) {
>+    return this[$_get](index);
>+  }
>+  [$item](index) {
>+    return html_common.convertNativeToDart_Dictionary(this[_item_1](index));
>+  }
>+  [_item_1](...args) {
>+    return this.item.apply(this, args);
>+  }
>+};
>+web_sql.SqlResultSetRowList.prototype[dart.isList] = true;
>+dart.addTypeTests(web_sql.SqlResultSetRowList);
>+web_sql.SqlResultSetRowList[dart.implements] = () => [ListOfMap()];
>+dart.setMethodSignature(web_sql.SqlResultSetRowList, () => ({
>+  __proto__: dart.getMethods(web_sql.SqlResultSetRowList.__proto__),
>+  [$_get]: dart.fnType(core.Map, [core.int]),
>+  [$_set]: dart.fnType(dart.void, [core.int, core.Object]),
>+  [$elementAt]: dart.fnType(core.Map, [core.int]),
>+  [$item]: dart.fnType(core.Map, [core.int]),
>+  [_item_1]: dart.fnType(dart.dynamic, [dart.dynamic])
>+}));
>+dart.setGetterSignature(web_sql.SqlResultSetRowList, () => ({
>+  __proto__: dart.getGetters(web_sql.SqlResultSetRowList.__proto__),
>+  [$length]: core.int,
>+  [$first]: core.Map,
>+  [$last]: core.Map,
>+  [$single]: core.Map
>+}));
>+dart.setSetterSignature(web_sql.SqlResultSetRowList, () => ({
>+  __proto__: dart.getSetters(web_sql.SqlResultSetRowList.__proto__),
>+  [$length]: core.int
>+}));
>+dart.setLibraryUri(web_sql.SqlResultSetRowList, "dart:web_sql");
>+dart.registerExtension("SQLResultSetRowList", web_sql.SqlResultSetRowList);
>+const _executeSql = dart.privateName(web_sql, "_executeSql");
>+web_sql.SqlTransaction = class SqlTransaction extends _interceptors.Interceptor {
>+  [_executeSql](...args) {
>+    return this.executeSql.apply(this, args);
>+  }
>+  [$executeSql](sqlStatement, arguments$0) {
>+    if (arguments$0 === void 0) arguments$0 = null;
>+    let completer = CompleterOfSqlResultSet().new();
>+    this[_executeSql](sqlStatement, arguments$0, dart.fn((transaction, resultSet) => {
>+      _js_helper.applyExtension("SQLResultSet", resultSet);
>+      _js_helper.applyExtension("SQLResultSetRowList", resultSet.rows);
>+      completer.complete(resultSet);
>+    }, SqlTransactionAndSqlResultSetToNull()), dart.fn((transaction, error) => {
>+      completer.completeError(error);
>+    }, SqlTransactionAndSqlErrorToNull()));
>+    return completer.future;
>+  }
>+};
>+dart.addTypeTests(web_sql.SqlTransaction);
>+dart.setMethodSignature(web_sql.SqlTransaction, () => ({
>+  __proto__: dart.getMethods(web_sql.SqlTransaction.__proto__),
>+  [_executeSql]: dart.fnType(dart.void, [core.String], [core.List, dart.fnType(dart.void, [web_sql.SqlTransaction, web_sql.SqlResultSet]), dart.fnType(dart.void, [web_sql.SqlTransaction, web_sql.SqlError])]),
>+  [$executeSql]: dart.fnType(async.Future$(web_sql.SqlResultSet), [core.String], [core.List])
>+}));
>+dart.setLibraryUri(web_sql.SqlTransaction, "dart:web_sql");
>+dart.registerExtension("SQLTransaction", web_sql.SqlTransaction);
>+_http.HttpServer = class HttpServer extends core.Object {
>+  static bind(address, port, opts) {
>+    let backlog = opts && 'backlog' in opts ? opts.backlog : 0;
>+    let v6Only = opts && 'v6Only' in opts ? opts.v6Only : false;
>+    let shared = opts && 'shared' in opts ? opts.shared : false;
>+    return _http._HttpServer.bind(address, port, backlog, v6Only, shared);
>+  }
>+  static bindSecure(address, port, context, opts) {
>+    let backlog = opts && 'backlog' in opts ? opts.backlog : 0;
>+    let v6Only = opts && 'v6Only' in opts ? opts.v6Only : false;
>+    let requestClientCertificate = opts && 'requestClientCertificate' in opts ? opts.requestClientCertificate : false;
>+    let shared = opts && 'shared' in opts ? opts.shared : false;
>+    return _http._HttpServer.bindSecure(address, port, context, backlog, v6Only, requestClientCertificate, shared);
>+  }
>+  static listenOn(serverSocket) {
>+    return new _http._HttpServer.listenOn(serverSocket);
>+  }
>+};
>+(_http.HttpServer[dart.mixinNew] = function() {
>+  this.serverHeader = null;
>+  this.autoCompress = null;
>+  this.idleTimeout = null;
>+}).prototype = _http.HttpServer.prototype;
>+_http.HttpServer.prototype[dart.isStream] = true;
>+dart.addTypeTests(_http.HttpServer);
>+_http.HttpServer[dart.implements] = () => [StreamOfHttpRequest()];
>+dart.setLibraryUri(_http.HttpServer, "dart:_http");
>+dart.setFieldSignature(_http.HttpServer, () => ({
>+  __proto__: dart.getFields(_http.HttpServer.__proto__),
>+  serverHeader: dart.fieldType(core.String),
>+  autoCompress: dart.fieldType(core.bool),
>+  idleTimeout: dart.fieldType(core.Duration)
>+}));
>+_http.HttpConnectionsInfo = class HttpConnectionsInfo extends core.Object {};
>+(_http.HttpConnectionsInfo.new = function() {
>+  this.total = 0;
>+  this.active = 0;
>+  this.idle = 0;
>+  this.closing = 0;
>+}).prototype = _http.HttpConnectionsInfo.prototype;
>+dart.addTypeTests(_http.HttpConnectionsInfo);
>+dart.setLibraryUri(_http.HttpConnectionsInfo, "dart:_http");
>+dart.setFieldSignature(_http.HttpConnectionsInfo, () => ({
>+  __proto__: dart.getFields(_http.HttpConnectionsInfo.__proto__),
>+  total: dart.fieldType(core.int),
>+  active: dart.fieldType(core.int),
>+  idle: dart.fieldType(core.int),
>+  closing: dart.fieldType(core.int)
>+}));
>+_http.HttpHeaders = class HttpHeaders extends core.Object {};
>+(_http.HttpHeaders.new = function() {
>+  this.date = null;
>+  this.expires = null;
>+  this.ifModifiedSince = null;
>+  this.host = null;
>+  this.port = null;
>+  this.contentType = null;
>+  this.contentLength = null;
>+  this.persistentConnection = null;
>+  this.chunkedTransferEncoding = null;
>+}).prototype = _http.HttpHeaders.prototype;
>+dart.addTypeTests(_http.HttpHeaders);
>+dart.setLibraryUri(_http.HttpHeaders, "dart:_http");
>+dart.setFieldSignature(_http.HttpHeaders, () => ({
>+  __proto__: dart.getFields(_http.HttpHeaders.__proto__),
>+  date: dart.fieldType(core.DateTime),
>+  expires: dart.fieldType(core.DateTime),
>+  ifModifiedSince: dart.fieldType(core.DateTime),
>+  host: dart.fieldType(core.String),
>+  port: dart.fieldType(core.int),
>+  contentType: dart.fieldType(_http.ContentType),
>+  contentLength: dart.fieldType(core.int),
>+  persistentConnection: dart.fieldType(core.bool),
>+  chunkedTransferEncoding: dart.fieldType(core.bool)
>+}));
>+dart.defineLazy(_http.HttpHeaders, {
>+  /*_http.HttpHeaders.acceptHeader*/get acceptHeader() {
>+    return "accept";
>+  },
>+  /*_http.HttpHeaders.acceptCharsetHeader*/get acceptCharsetHeader() {
>+    return "accept-charset";
>+  },
>+  /*_http.HttpHeaders.acceptEncodingHeader*/get acceptEncodingHeader() {
>+    return "accept-encoding";
>+  },
>+  /*_http.HttpHeaders.acceptLanguageHeader*/get acceptLanguageHeader() {
>+    return "accept-language";
>+  },
>+  /*_http.HttpHeaders.acceptRangesHeader*/get acceptRangesHeader() {
>+    return "accept-ranges";
>+  },
>+  /*_http.HttpHeaders.ageHeader*/get ageHeader() {
>+    return "age";
>+  },
>+  /*_http.HttpHeaders.allowHeader*/get allowHeader() {
>+    return "allow";
>+  },
>+  /*_http.HttpHeaders.authorizationHeader*/get authorizationHeader() {
>+    return "authorization";
>+  },
>+  /*_http.HttpHeaders.cacheControlHeader*/get cacheControlHeader() {
>+    return "cache-control";
>+  },
>+  /*_http.HttpHeaders.connectionHeader*/get connectionHeader() {
>+    return "connection";
>+  },
>+  /*_http.HttpHeaders.contentEncodingHeader*/get contentEncodingHeader() {
>+    return "content-encoding";
>+  },
>+  /*_http.HttpHeaders.contentLanguageHeader*/get contentLanguageHeader() {
>+    return "content-language";
>+  },
>+  /*_http.HttpHeaders.contentLengthHeader*/get contentLengthHeader() {
>+    return "content-length";
>+  },
>+  /*_http.HttpHeaders.contentLocationHeader*/get contentLocationHeader() {
>+    return "content-location";
>+  },
>+  /*_http.HttpHeaders.contentMD5Header*/get contentMD5Header() {
>+    return "content-md5";
>+  },
>+  /*_http.HttpHeaders.contentRangeHeader*/get contentRangeHeader() {
>+    return "content-range";
>+  },
>+  /*_http.HttpHeaders.contentTypeHeader*/get contentTypeHeader() {
>+    return "content-type";
>+  },
>+  /*_http.HttpHeaders.dateHeader*/get dateHeader() {
>+    return "date";
>+  },
>+  /*_http.HttpHeaders.etagHeader*/get etagHeader() {
>+    return "etag";
>+  },
>+  /*_http.HttpHeaders.expectHeader*/get expectHeader() {
>+    return "expect";
>+  },
>+  /*_http.HttpHeaders.expiresHeader*/get expiresHeader() {
>+    return "expires";
>+  },
>+  /*_http.HttpHeaders.fromHeader*/get fromHeader() {
>+    return "from";
>+  },
>+  /*_http.HttpHeaders.hostHeader*/get hostHeader() {
>+    return "host";
>+  },
>+  /*_http.HttpHeaders.ifMatchHeader*/get ifMatchHeader() {
>+    return "if-match";
>+  },
>+  /*_http.HttpHeaders.ifModifiedSinceHeader*/get ifModifiedSinceHeader() {
>+    return "if-modified-since";
>+  },
>+  /*_http.HttpHeaders.ifNoneMatchHeader*/get ifNoneMatchHeader() {
>+    return "if-none-match";
>+  },
>+  /*_http.HttpHeaders.ifRangeHeader*/get ifRangeHeader() {
>+    return "if-range";
>+  },
>+  /*_http.HttpHeaders.ifUnmodifiedSinceHeader*/get ifUnmodifiedSinceHeader() {
>+    return "if-unmodified-since";
>+  },
>+  /*_http.HttpHeaders.lastModifiedHeader*/get lastModifiedHeader() {
>+    return "last-modified";
>+  },
>+  /*_http.HttpHeaders.locationHeader*/get locationHeader() {
>+    return "location";
>+  },
>+  /*_http.HttpHeaders.maxForwardsHeader*/get maxForwardsHeader() {
>+    return "max-forwards";
>+  },
>+  /*_http.HttpHeaders.pragmaHeader*/get pragmaHeader() {
>+    return "pragma";
>+  },
>+  /*_http.HttpHeaders.proxyAuthenticateHeader*/get proxyAuthenticateHeader() {
>+    return "proxy-authenticate";
>+  },
>+  /*_http.HttpHeaders.proxyAuthorizationHeader*/get proxyAuthorizationHeader() {
>+    return "proxy-authorization";
>+  },
>+  /*_http.HttpHeaders.rangeHeader*/get rangeHeader() {
>+    return "range";
>+  },
>+  /*_http.HttpHeaders.refererHeader*/get refererHeader() {
>+    return "referer";
>+  },
>+  /*_http.HttpHeaders.retryAfterHeader*/get retryAfterHeader() {
>+    return "retry-after";
>+  },
>+  /*_http.HttpHeaders.serverHeader*/get serverHeader() {
>+    return "server";
>+  },
>+  /*_http.HttpHeaders.teHeader*/get teHeader() {
>+    return "te";
>+  },
>+  /*_http.HttpHeaders.trailerHeader*/get trailerHeader() {
>+    return "trailer";
>+  },
>+  /*_http.HttpHeaders.transferEncodingHeader*/get transferEncodingHeader() {
>+    return "transfer-encoding";
>+  },
>+  /*_http.HttpHeaders.upgradeHeader*/get upgradeHeader() {
>+    return "upgrade";
>+  },
>+  /*_http.HttpHeaders.userAgentHeader*/get userAgentHeader() {
>+    return "user-agent";
>+  },
>+  /*_http.HttpHeaders.varyHeader*/get varyHeader() {
>+    return "vary";
>+  },
>+  /*_http.HttpHeaders.viaHeader*/get viaHeader() {
>+    return "via";
>+  },
>+  /*_http.HttpHeaders.warningHeader*/get warningHeader() {
>+    return "warning";
>+  },
>+  /*_http.HttpHeaders.wwwAuthenticateHeader*/get wwwAuthenticateHeader() {
>+    return "www-authenticate";
>+  },
>+  /*_http.HttpHeaders.ACCEPT*/get ACCEPT() {
>+    return "accept";
>+  },
>+  /*_http.HttpHeaders.ACCEPT_CHARSET*/get ACCEPT_CHARSET() {
>+    return "accept-charset";
>+  },
>+  /*_http.HttpHeaders.ACCEPT_ENCODING*/get ACCEPT_ENCODING() {
>+    return "accept-encoding";
>+  },
>+  /*_http.HttpHeaders.ACCEPT_LANGUAGE*/get ACCEPT_LANGUAGE() {
>+    return "accept-language";
>+  },
>+  /*_http.HttpHeaders.ACCEPT_RANGES*/get ACCEPT_RANGES() {
>+    return "accept-ranges";
>+  },
>+  /*_http.HttpHeaders.AGE*/get AGE() {
>+    return "age";
>+  },
>+  /*_http.HttpHeaders.ALLOW*/get ALLOW() {
>+    return "allow";
>+  },
>+  /*_http.HttpHeaders.AUTHORIZATION*/get AUTHORIZATION() {
>+    return "authorization";
>+  },
>+  /*_http.HttpHeaders.CACHE_CONTROL*/get CACHE_CONTROL() {
>+    return "cache-control";
>+  },
>+  /*_http.HttpHeaders.CONNECTION*/get CONNECTION() {
>+    return "connection";
>+  },
>+  /*_http.HttpHeaders.CONTENT_ENCODING*/get CONTENT_ENCODING() {
>+    return "content-encoding";
>+  },
>+  /*_http.HttpHeaders.CONTENT_LANGUAGE*/get CONTENT_LANGUAGE() {
>+    return "content-language";
>+  },
>+  /*_http.HttpHeaders.CONTENT_LENGTH*/get CONTENT_LENGTH() {
>+    return "content-length";
>+  },
>+  /*_http.HttpHeaders.CONTENT_LOCATION*/get CONTENT_LOCATION() {
>+    return "content-location";
>+  },
>+  /*_http.HttpHeaders.CONTENT_MD5*/get CONTENT_MD5() {
>+    return "content-md5";
>+  },
>+  /*_http.HttpHeaders.CONTENT_RANGE*/get CONTENT_RANGE() {
>+    return "content-range";
>+  },
>+  /*_http.HttpHeaders.CONTENT_TYPE*/get CONTENT_TYPE() {
>+    return "content-type";
>+  },
>+  /*_http.HttpHeaders.DATE*/get DATE() {
>+    return "date";
>+  },
>+  /*_http.HttpHeaders.ETAG*/get ETAG() {
>+    return "etag";
>+  },
>+  /*_http.HttpHeaders.EXPECT*/get EXPECT() {
>+    return "expect";
>+  },
>+  /*_http.HttpHeaders.EXPIRES*/get EXPIRES() {
>+    return "expires";
>+  },
>+  /*_http.HttpHeaders.FROM*/get FROM() {
>+    return "from";
>+  },
>+  /*_http.HttpHeaders.HOST*/get HOST() {
>+    return "host";
>+  },
>+  /*_http.HttpHeaders.IF_MATCH*/get IF_MATCH() {
>+    return "if-match";
>+  },
>+  /*_http.HttpHeaders.IF_MODIFIED_SINCE*/get IF_MODIFIED_SINCE() {
>+    return "if-modified-since";
>+  },
>+  /*_http.HttpHeaders.IF_NONE_MATCH*/get IF_NONE_MATCH() {
>+    return "if-none-match";
>+  },
>+  /*_http.HttpHeaders.IF_RANGE*/get IF_RANGE() {
>+    return "if-range";
>+  },
>+  /*_http.HttpHeaders.IF_UNMODIFIED_SINCE*/get IF_UNMODIFIED_SINCE() {
>+    return "if-unmodified-since";
>+  },
>+  /*_http.HttpHeaders.LAST_MODIFIED*/get LAST_MODIFIED() {
>+    return "last-modified";
>+  },
>+  /*_http.HttpHeaders.LOCATION*/get LOCATION() {
>+    return "location";
>+  },
>+  /*_http.HttpHeaders.MAX_FORWARDS*/get MAX_FORWARDS() {
>+    return "max-forwards";
>+  },
>+  /*_http.HttpHeaders.PRAGMA*/get PRAGMA() {
>+    return "pragma";
>+  },
>+  /*_http.HttpHeaders.PROXY_AUTHENTICATE*/get PROXY_AUTHENTICATE() {
>+    return "proxy-authenticate";
>+  },
>+  /*_http.HttpHeaders.PROXY_AUTHORIZATION*/get PROXY_AUTHORIZATION() {
>+    return "proxy-authorization";
>+  },
>+  /*_http.HttpHeaders.RANGE*/get RANGE() {
>+    return "range";
>+  },
>+  /*_http.HttpHeaders.REFERER*/get REFERER() {
>+    return "referer";
>+  },
>+  /*_http.HttpHeaders.RETRY_AFTER*/get RETRY_AFTER() {
>+    return "retry-after";
>+  },
>+  /*_http.HttpHeaders.SERVER*/get SERVER() {
>+    return "server";
>+  },
>+  /*_http.HttpHeaders.TE*/get TE() {
>+    return "te";
>+  },
>+  /*_http.HttpHeaders.TRAILER*/get TRAILER() {
>+    return "trailer";
>+  },
>+  /*_http.HttpHeaders.TRANSFER_ENCODING*/get TRANSFER_ENCODING() {
>+    return "transfer-encoding";
>+  },
>+  /*_http.HttpHeaders.UPGRADE*/get UPGRADE() {
>+    return "upgrade";
>+  },
>+  /*_http.HttpHeaders.USER_AGENT*/get USER_AGENT() {
>+    return "user-agent";
>+  },
>+  /*_http.HttpHeaders.VARY*/get VARY() {
>+    return "vary";
>+  },
>+  /*_http.HttpHeaders.VIA*/get VIA() {
>+    return "via";
>+  },
>+  /*_http.HttpHeaders.WARNING*/get WARNING() {
>+    return "warning";
>+  },
>+  /*_http.HttpHeaders.WWW_AUTHENTICATE*/get WWW_AUTHENTICATE() {
>+    return "www-authenticate";
>+  },
>+  /*_http.HttpHeaders.cookieHeader*/get cookieHeader() {
>+    return "cookie";
>+  },
>+  /*_http.HttpHeaders.setCookieHeader*/get setCookieHeader() {
>+    return "set-cookie";
>+  },
>+  /*_http.HttpHeaders.COOKIE*/get COOKIE() {
>+    return "cookie";
>+  },
>+  /*_http.HttpHeaders.SET_COOKIE*/get SET_COOKIE() {
>+    return "set-cookie";
>+  },
>+  /*_http.HttpHeaders.generalHeaders*/get generalHeaders() {
>+    return dart.constList(["cache-control", "connection", "date", "pragma", "trailer", "transfer-encoding", "upgrade", "via", "warning"], core.String);
>+  },
>+  /*_http.HttpHeaders.GENERAL_HEADERS*/get GENERAL_HEADERS() {
>+    return _http.HttpHeaders.generalHeaders;
>+  },
>+  /*_http.HttpHeaders.entityHeaders*/get entityHeaders() {
>+    return dart.constList(["allow", "content-encoding", "content-language", "content-length", "content-location", "content-md5", "content-range", "content-type", "expires", "last-modified"], core.String);
>+  },
>+  /*_http.HttpHeaders.ENTITY_HEADERS*/get ENTITY_HEADERS() {
>+    return _http.HttpHeaders.entityHeaders;
>+  },
>+  /*_http.HttpHeaders.responseHeaders*/get responseHeaders() {
>+    return dart.constList(["accept-ranges", "age", "etag", "location", "proxy-authenticate", "retry-after", "server", "vary", "www-authenticate"], core.String);
>+  },
>+  /*_http.HttpHeaders.RESPONSE_HEADERS*/get RESPONSE_HEADERS() {
>+    return _http.HttpHeaders.responseHeaders;
>+  },
>+  /*_http.HttpHeaders.requestHeaders*/get requestHeaders() {
>+    return dart.constList(["accept", "accept-charset", "accept-encoding", "accept-language", "authorization", "expect", "from", "host", "if-match", "if-modified-since", "if-none-match", "if-range", "if-unmodified-since", "max-forwards", "proxy-authorization", "range", "referer", "te", "user-agent"], core.String);
>+  },
>+  /*_http.HttpHeaders.REQUEST_HEADERS*/get REQUEST_HEADERS() {
>+    return _http.HttpHeaders.requestHeaders;
>+  }
>+});
>+_http.HeaderValue = class HeaderValue extends core.Object {
>+  static new(value, parameters) {
>+    if (value === void 0) value = "";
>+    if (parameters === void 0) parameters = null;
>+    return new _http._HeaderValue.new(value, parameters);
>+  }
>+  static parse(value, opts) {
>+    let parameterSeparator = opts && 'parameterSeparator' in opts ? opts.parameterSeparator : ";";
>+    let valueSeparator = opts && 'valueSeparator' in opts ? opts.valueSeparator : null;
>+    let preserveBackslash = opts && 'preserveBackslash' in opts ? opts.preserveBackslash : false;
>+    return _http._HeaderValue.parse(value, {parameterSeparator: parameterSeparator, valueSeparator: valueSeparator, preserveBackslash: preserveBackslash});
>+  }
>+};
>+(_http.HeaderValue[dart.mixinNew] = function() {
>+}).prototype = _http.HeaderValue.prototype;
>+dart.addTypeTests(_http.HeaderValue);
>+dart.setLibraryUri(_http.HeaderValue, "dart:_http");
>+_http.HttpSession = class HttpSession extends core.Object {};
>+(_http.HttpSession.new = function() {
>+}).prototype = _http.HttpSession.prototype;
>+_http.HttpSession.prototype[dart.isMap] = true;
>+dart.addTypeTests(_http.HttpSession);
>+_http.HttpSession[dart.implements] = () => [core.Map];
>+dart.setLibraryUri(_http.HttpSession, "dart:_http");
>+_http.ContentType = class ContentType extends core.Object {
>+  static new(primaryType, subType, opts) {
>+    let charset = opts && 'charset' in opts ? opts.charset : null;
>+    let parameters = opts && 'parameters' in opts ? opts.parameters : null;
>+    return new _http._ContentType.new(primaryType, subType, charset, parameters);
>+  }
>+  static parse(value) {
>+    return _http._ContentType.parse(value);
>+  }
>+};
>+(_http.ContentType[dart.mixinNew] = function() {
>+}).prototype = _http.ContentType.prototype;
>+dart.addTypeTests(_http.ContentType);
>+_http.ContentType[dart.implements] = () => [_http.HeaderValue];
>+dart.setLibraryUri(_http.ContentType, "dart:_http");
>+dart.defineLazy(_http.ContentType, {
>+  /*_http.ContentType.text*/get text() {
>+    return _http.ContentType.new("text", "plain", {charset: "utf-8"});
>+  },
>+  /*_http.ContentType.TEXT*/get TEXT() {
>+    return _http.ContentType.text;
>+  },
>+  /*_http.ContentType.html*/get html() {
>+    return _http.ContentType.new("text", "html", {charset: "utf-8"});
>+  },
>+  /*_http.ContentType.HTML*/get HTML() {
>+    return _http.ContentType.html;
>+  },
>+  /*_http.ContentType.json*/get json() {
>+    return _http.ContentType.new("application", "json", {charset: "utf-8"});
>+  },
>+  /*_http.ContentType.JSON*/get JSON() {
>+    return _http.ContentType.json;
>+  },
>+  /*_http.ContentType.binary*/get binary() {
>+    return _http.ContentType.new("application", "octet-stream");
>+  },
>+  /*_http.ContentType.BINARY*/get BINARY() {
>+    return _http.ContentType.binary;
>+  }
>+});
>+_http.Cookie = class Cookie extends core.Object {
>+  static new(name, value) {
>+    if (name === void 0) name = null;
>+    if (value === void 0) value = null;
>+    return new _http._Cookie.new(name, value);
>+  }
>+  static fromSetCookieValue(value) {
>+    return new _http._Cookie.fromSetCookieValue(value);
>+  }
>+};
>+(_http.Cookie[dart.mixinNew] = function() {
>+  this.name = null;
>+  this.value = null;
>+  this.expires = null;
>+  this.maxAge = null;
>+  this.domain = null;
>+  this.path = null;
>+  this.secure = null;
>+  this.httpOnly = null;
>+}).prototype = _http.Cookie.prototype;
>+dart.addTypeTests(_http.Cookie);
>+dart.setLibraryUri(_http.Cookie, "dart:_http");
>+dart.setFieldSignature(_http.Cookie, () => ({
>+  __proto__: dart.getFields(_http.Cookie.__proto__),
>+  name: dart.fieldType(core.String),
>+  value: dart.fieldType(core.String),
>+  expires: dart.fieldType(core.DateTime),
>+  maxAge: dart.fieldType(core.int),
>+  domain: dart.fieldType(core.String),
>+  path: dart.fieldType(core.String),
>+  secure: dart.fieldType(core.bool),
>+  httpOnly: dart.fieldType(core.bool)
>+}));
>+_http.HttpRequest = class HttpRequest extends core.Object {};
>+(_http.HttpRequest.new = function() {
>+}).prototype = _http.HttpRequest.prototype;
>+_http.HttpRequest.prototype[dart.isStream] = true;
>+dart.addTypeTests(_http.HttpRequest);
>+_http.HttpRequest[dart.implements] = () => [StreamOfListOfint()];
>+dart.setLibraryUri(_http.HttpRequest, "dart:_http");
>+_http.HttpResponse = class HttpResponse extends core.Object {};
>+(_http.HttpResponse.new = function() {
>+  this.contentLength = null;
>+  this.statusCode = null;
>+  this.reasonPhrase = null;
>+  this.persistentConnection = null;
>+  this.deadline = null;
>+  this.bufferOutput = null;
>+}).prototype = _http.HttpResponse.prototype;
>+dart.addTypeTests(_http.HttpResponse);
>+_http.HttpResponse[dart.implements] = () => [io.IOSink];
>+dart.setLibraryUri(_http.HttpResponse, "dart:_http");
>+dart.setFieldSignature(_http.HttpResponse, () => ({
>+  __proto__: dart.getFields(_http.HttpResponse.__proto__),
>+  contentLength: dart.fieldType(core.int),
>+  statusCode: dart.fieldType(core.int),
>+  reasonPhrase: dart.fieldType(core.String),
>+  persistentConnection: dart.fieldType(core.bool),
>+  deadline: dart.fieldType(core.Duration),
>+  bufferOutput: dart.fieldType(core.bool)
>+}));
>+_http.HttpClient = class HttpClient extends core.Object {
>+  static new(opts) {
>+    let context = opts && 'context' in opts ? opts.context : null;
>+    let overrides = _http.HttpOverrides.current;
>+    if (overrides == null) {
>+      return new _http._HttpClient.new(context);
>+    }
>+    return overrides.createHttpClient(context);
>+  }
>+  static findProxyFromEnvironment(url, opts) {
>+    let environment = opts && 'environment' in opts ? opts.environment : null;
>+    let overrides = _http.HttpOverrides.current;
>+    if (overrides == null) {
>+      return _http._HttpClient._findProxyFromEnvironment(url, environment);
>+    }
>+    return overrides.findProxyFromEnvironment(url, environment);
>+  }
>+};
>+(_http.HttpClient[dart.mixinNew] = function() {
>+  this.idleTimeout = null;
>+  this.connectionTimeout = null;
>+  this.maxConnectionsPerHost = null;
>+  this.autoUncompress = null;
>+  this.userAgent = null;
>+}).prototype = _http.HttpClient.prototype;
>+dart.addTypeTests(_http.HttpClient);
>+dart.setLibraryUri(_http.HttpClient, "dart:_http");
>+dart.setFieldSignature(_http.HttpClient, () => ({
>+  __proto__: dart.getFields(_http.HttpClient.__proto__),
>+  idleTimeout: dart.fieldType(core.Duration),
>+  connectionTimeout: dart.fieldType(core.Duration),
>+  maxConnectionsPerHost: dart.fieldType(core.int),
>+  autoUncompress: dart.fieldType(core.bool),
>+  userAgent: dart.fieldType(core.String)
>+}));
>+dart.defineLazy(_http.HttpClient, {
>+  /*_http.HttpClient.defaultHttpPort*/get defaultHttpPort() {
>+    return 80;
>+  },
>+  /*_http.HttpClient.DEFAULT_HTTP_PORT*/get DEFAULT_HTTP_PORT() {
>+    return 80;
>+  },
>+  /*_http.HttpClient.defaultHttpsPort*/get defaultHttpsPort() {
>+    return 443;
>+  },
>+  /*_http.HttpClient.DEFAULT_HTTPS_PORT*/get DEFAULT_HTTPS_PORT() {
>+    return 443;
>+  }
>+});
>+_http.HttpClientRequest = class HttpClientRequest extends core.Object {};
>+(_http.HttpClientRequest.new = function() {
>+  this.persistentConnection = null;
>+  this.followRedirects = null;
>+  this.maxRedirects = null;
>+  this.contentLength = null;
>+  this.bufferOutput = null;
>+}).prototype = _http.HttpClientRequest.prototype;
>+dart.addTypeTests(_http.HttpClientRequest);
>+_http.HttpClientRequest[dart.implements] = () => [io.IOSink];
>+dart.setLibraryUri(_http.HttpClientRequest, "dart:_http");
>+dart.setFieldSignature(_http.HttpClientRequest, () => ({
>+  __proto__: dart.getFields(_http.HttpClientRequest.__proto__),
>+  persistentConnection: dart.fieldType(core.bool),
>+  followRedirects: dart.fieldType(core.bool),
>+  maxRedirects: dart.fieldType(core.int),
>+  contentLength: dart.fieldType(core.int),
>+  bufferOutput: dart.fieldType(core.bool)
>+}));
>+_http.HttpClientResponse = class HttpClientResponse extends core.Object {};
>+(_http.HttpClientResponse.new = function() {
>+}).prototype = _http.HttpClientResponse.prototype;
>+_http.HttpClientResponse.prototype[dart.isStream] = true;
>+dart.addTypeTests(_http.HttpClientResponse);
>+_http.HttpClientResponse[dart.implements] = () => [StreamOfListOfint()];
>+dart.setLibraryUri(_http.HttpClientResponse, "dart:_http");
>+_http.HttpClientResponseCompressionState = class HttpClientResponseCompressionState extends core.Object {
>+  toString() {
>+    return {
>+      0: "HttpClientResponseCompressionState.notCompressed",
>+      1: "HttpClientResponseCompressionState.decompressed",
>+      2: "HttpClientResponseCompressionState.compressed"
>+    }[this.index];
>+  }
>+};
>+(_http.HttpClientResponseCompressionState.new = function(x) {
>+  this.index = x;
>+}).prototype = _http.HttpClientResponseCompressionState.prototype;
>+dart.addTypeTests(_http.HttpClientResponseCompressionState);
>+dart.setLibraryUri(_http.HttpClientResponseCompressionState, "dart:_http");
>+dart.setFieldSignature(_http.HttpClientResponseCompressionState, () => ({
>+  __proto__: dart.getFields(_http.HttpClientResponseCompressionState.__proto__),
>+  index: dart.finalFieldType(core.int)
>+}));
>+dart.defineExtensionMethods(_http.HttpClientResponseCompressionState, ['toString']);
>+_http.HttpClientResponseCompressionState.notCompressed = dart.const(new _http.HttpClientResponseCompressionState.new(0));
>+_http.HttpClientResponseCompressionState.decompressed = dart.const(new _http.HttpClientResponseCompressionState.new(1));
>+_http.HttpClientResponseCompressionState.compressed = dart.const(new _http.HttpClientResponseCompressionState.new(2));
>+_http.HttpClientResponseCompressionState.values = dart.constList([_http.HttpClientResponseCompressionState.notCompressed, _http.HttpClientResponseCompressionState.decompressed, _http.HttpClientResponseCompressionState.compressed], _http.HttpClientResponseCompressionState);
>+_http.HttpClientCredentials = class HttpClientCredentials extends core.Object {};
>+(_http.HttpClientCredentials.new = function() {
>+}).prototype = _http.HttpClientCredentials.prototype;
>+dart.addTypeTests(_http.HttpClientCredentials);
>+dart.setLibraryUri(_http.HttpClientCredentials, "dart:_http");
>+_http.HttpClientBasicCredentials = class HttpClientBasicCredentials extends _http.HttpClientCredentials {
>+  static new(username, password) {
>+    return new _http._HttpClientBasicCredentials.new(username, password);
>+  }
>+};
>+dart.addTypeTests(_http.HttpClientBasicCredentials);
>+dart.setLibraryUri(_http.HttpClientBasicCredentials, "dart:_http");
>+_http.HttpClientDigestCredentials = class HttpClientDigestCredentials extends _http.HttpClientCredentials {
>+  static new(username, password) {
>+    return new _http._HttpClientDigestCredentials.new(username, password);
>+  }
>+};
>+dart.addTypeTests(_http.HttpClientDigestCredentials);
>+dart.setLibraryUri(_http.HttpClientDigestCredentials, "dart:_http");
>+_http.HttpConnectionInfo = class HttpConnectionInfo extends core.Object {};
>+(_http.HttpConnectionInfo.new = function() {
>+}).prototype = _http.HttpConnectionInfo.prototype;
>+dart.addTypeTests(_http.HttpConnectionInfo);
>+dart.setLibraryUri(_http.HttpConnectionInfo, "dart:_http");
>+_http.RedirectInfo = class RedirectInfo extends core.Object {};
>+(_http.RedirectInfo.new = function() {
>+}).prototype = _http.RedirectInfo.prototype;
>+dart.addTypeTests(_http.RedirectInfo);
>+dart.setLibraryUri(_http.RedirectInfo, "dart:_http");
>+_http.DetachedSocket = class DetachedSocket extends core.Object {};
>+(_http.DetachedSocket.new = function() {
>+}).prototype = _http.DetachedSocket.prototype;
>+dart.addTypeTests(_http.DetachedSocket);
>+dart.setLibraryUri(_http.DetachedSocket, "dart:_http");
>+_http.HttpException = class HttpException extends core.Object {
>+  toString() {
>+    let b = new core.StringBuffer.new();
>+    b.write("HttpException: ");
>+    b.write(this.message);
>+    if (this.uri != null) {
>+      b.write(", uri = " + dart.str(this.uri));
>+    }
>+    return b.toString();
>+  }
>+};
>+(_http.HttpException.new = function(message, opts) {
>+  let uri = opts && 'uri' in opts ? opts.uri : null;
>+  this.message = message;
>+  this.uri = uri;
>+}).prototype = _http.HttpException.prototype;
>+dart.addTypeTests(_http.HttpException);
>+_http.HttpException[dart.implements] = () => [io.IOException];
>+dart.setLibraryUri(_http.HttpException, "dart:_http");
>+dart.setFieldSignature(_http.HttpException, () => ({
>+  __proto__: dart.getFields(_http.HttpException.__proto__),
>+  message: dart.finalFieldType(core.String),
>+  uri: dart.finalFieldType(core.Uri)
>+}));
>+dart.defineExtensionMethods(_http.HttpException, ['toString']);
>+_http.RedirectException = class RedirectException extends core.Object {
>+  toString() {
>+    return "RedirectException: " + dart.str(this.message);
>+  }
>+  get uri() {
>+    return this.redirects[$last].location;
>+  }
>+};
>+(_http.RedirectException.new = function(message, redirects) {
>+  this.message = message;
>+  this.redirects = redirects;
>+}).prototype = _http.RedirectException.prototype;
>+dart.addTypeTests(_http.RedirectException);
>+_http.RedirectException[dart.implements] = () => [_http.HttpException];
>+dart.setGetterSignature(_http.RedirectException, () => ({
>+  __proto__: dart.getGetters(_http.RedirectException.__proto__),
>+  uri: core.Uri
>+}));
>+dart.setLibraryUri(_http.RedirectException, "dart:_http");
>+dart.setFieldSignature(_http.RedirectException, () => ({
>+  __proto__: dart.getFields(_http.RedirectException.__proto__),
>+  message: dart.finalFieldType(core.String),
>+  redirects: dart.finalFieldType(ListOfRedirectInfo())
>+}));
>+dart.defineExtensionMethods(_http.RedirectException, ['toString']);
>+_http._CryptoUtils = class _CryptoUtils extends core.Object {
>+  static getRandomBytes(count) {
>+    let result = typed_data.Uint8List.new(count);
>+    for (let i = 0; i < dart.notNull(count); i++) {
>+      result[$_set](i, _http._CryptoUtils._rng.nextInt(255));
>+    }
>+    return result;
>+  }
>+  static bytesToHex(bytes) {
>+    let result = new core.StringBuffer.new();
>+    for (let part of bytes) {
>+      result.write((dart.notNull(part) < 16 ? "0" : "") + part[$toRadixString](16));
>+    }
>+    return result.toString();
>+  }
>+  static bytesToBase64(bytes, urlSafe, addLineSeparator) {
>+    if (urlSafe === void 0) urlSafe = false;
>+    if (addLineSeparator === void 0) addLineSeparator = false;
>+    let len = bytes[$length];
>+    if (len === 0) {
>+      return "";
>+    }
>+    let lookup = dart.test(urlSafe) ? "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_" : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
>+    let remainderLength = dart.asInt(len[$remainder](3));
>+    let chunkLength = dart.notNull(len) - dart.notNull(remainderLength);
>+    let outputLen = (dart.notNull(len) / 3)[$truncate]() * 4 + (dart.notNull(remainderLength) > 0 ? 4 : 0);
>+    if (dart.test(addLineSeparator)) {
>+      outputLen = outputLen + (((outputLen - 1) / 76)[$truncate]() << 1 >>> 0);
>+    }
>+    let out = ListOfint().new(outputLen);
>+    let j = 0, i = 0, c = 0;
>+    while (i < chunkLength) {
>+      let x = (dart.notNull(bytes[$_get](i++)) << 16 & 16777215 | dart.notNull(bytes[$_get](i++)) << 8 & 16777215 | dart.notNull(bytes[$_get](i++))) >>> 0;
>+      out[$_set](j++, lookup[$codeUnitAt](x[$rightShift](18)));
>+      out[$_set](j++, lookup[$codeUnitAt](x >> 12 & 63));
>+      out[$_set](j++, lookup[$codeUnitAt](x >> 6 & 63));
>+      out[$_set](j++, lookup[$codeUnitAt](x & 63));
>+      if (dart.test(addLineSeparator) && ++c === 19 && j < outputLen - 2) {
>+        out[$_set](j++, 13);
>+        out[$_set](j++, 10);
>+        c = 0;
>+      }
>+    }
>+    if (remainderLength === 1) {
>+      let x = bytes[$_get](i);
>+      out[$_set](j++, lookup[$codeUnitAt](x[$rightShift](2)));
>+      out[$_set](j++, lookup[$codeUnitAt](dart.notNull(x) << 4 & 63));
>+      out[$_set](j++, 61);
>+      out[$_set](j++, 61);
>+    } else if (remainderLength === 2) {
>+      let x = bytes[$_get](i);
>+      let y = bytes[$_get](i + 1);
>+      out[$_set](j++, lookup[$codeUnitAt](x[$rightShift](2)));
>+      out[$_set](j++, lookup[$codeUnitAt]((dart.notNull(x) << 4 | dart.notNull(y) >> 4) & 63));
>+      out[$_set](j++, lookup[$codeUnitAt](dart.notNull(y) << 2 & 63));
>+      out[$_set](j++, 61);
>+    }
>+    return core.String.fromCharCodes(out);
>+  }
>+  static base64StringToBytes(input, ignoreInvalidCharacters) {
>+    if (ignoreInvalidCharacters === void 0) ignoreInvalidCharacters = true;
>+    let len = input.length;
>+    if (len === 0) {
>+      return ListOfint().new(0);
>+    }
>+    let extrasLen = 0;
>+    for (let i = 0; i < len; i++) {
>+      let c = _http._CryptoUtils._decodeTable[$_get](input[$codeUnitAt](i));
>+      if (dart.notNull(c) < 0) {
>+        extrasLen++;
>+        if (c === -2 && !dart.test(ignoreInvalidCharacters)) {
>+          dart.throw(new core.FormatException.new("Invalid character: " + dart.str(input[$_get](i))));
>+        }
>+      }
>+    }
>+    if ((len - extrasLen)[$modulo](4) !== 0) {
>+      dart.throw(new core.FormatException.new("Size of Base 64 characters in Input\n          must be a multiple of 4. Input: " + dart.str(input)));
>+    }
>+    let padLength = 0;
>+    for (let i = len - 1; i >= 0; i--) {
>+      let currentCodeUnit = input[$codeUnitAt](i);
>+      if (dart.notNull(_http._CryptoUtils._decodeTable[$_get](currentCodeUnit)) > 0) break;
>+      if (currentCodeUnit === 61) padLength++;
>+    }
>+    let outputLen = ((len - extrasLen) * 6)[$rightShift](3) - padLength;
>+    let out = ListOfint().new(outputLen);
>+    for (let i = 0, o = 0; o < outputLen;) {
>+      let x = 0;
>+      for (let j = 4; j > 0;) {
>+        let c = _http._CryptoUtils._decodeTable[$_get](input[$codeUnitAt](i++));
>+        if (dart.notNull(c) >= 0) {
>+          x = (x << 6 & 16777215 | dart.notNull(c)) >>> 0;
>+          j--;
>+        }
>+      }
>+      out[$_set](o++, x[$rightShift](16));
>+      if (o < outputLen) {
>+        out[$_set](o++, x >> 8 & 255);
>+        if (o < outputLen) out[$_set](o++, x & 255);
>+      }
>+    }
>+    return out;
>+  }
>+};
>+(_http._CryptoUtils.new = function() {
>+}).prototype = _http._CryptoUtils.prototype;
>+dart.addTypeTests(_http._CryptoUtils);
>+dart.setLibraryUri(_http._CryptoUtils, "dart:_http");
>+dart.defineLazy(_http._CryptoUtils, {
>+  /*_http._CryptoUtils.PAD*/get PAD() {
>+    return 61;
>+  },
>+  /*_http._CryptoUtils.CR*/get CR() {
>+    return 13;
>+  },
>+  /*_http._CryptoUtils.LF*/get LF() {
>+    return 10;
>+  },
>+  /*_http._CryptoUtils.LINE_LENGTH*/get LINE_LENGTH() {
>+    return 76;
>+  },
>+  /*_http._CryptoUtils._encodeTable*/get _encodeTable() {
>+    return "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
>+  },
>+  /*_http._CryptoUtils._encodeTableUrlSafe*/get _encodeTableUrlSafe() {
>+    return "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
>+  },
>+  /*_http._CryptoUtils._decodeTable*/get _decodeTable() {
>+    return dart.constList([-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -2, -2, -1, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 62, -2, 62, -2, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -2, -2, -2, 0, -2, -2, -2, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -2, -2, -2, -2, 63, -2, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2], core.int);
>+  },
>+  /*_http._CryptoUtils._rng*/get _rng() {
>+    return math.Random.secure();
>+  },
>+  set _rng(_) {}
>+});
>+dart.defineLazy(_http, {
>+  /*_http._MASK_8*/get _MASK_8() {
>+    return 255;
>+  },
>+  /*_http._MASK_32*/get _MASK_32() {
>+    return 4294967295;
>+  },
>+  /*_http._BITS_PER_BYTE*/get _BITS_PER_BYTE() {
>+    return 8;
>+  },
>+  /*_http._BYTES_PER_WORD*/get _BYTES_PER_WORD() {
>+    return 4;
>+  }
>+});
>+const _chunkSizeInWords = dart.privateName(_http, "_chunkSizeInWords");
>+const _digestSizeInWords = dart.privateName(_http, "_digestSizeInWords");
>+const _bigEndianWords = dart.privateName(_http, "_bigEndianWords");
>+const _pendingData = dart.privateName(_http, "_pendingData");
>+const _lengthInBytes = dart.privateName(_http, "_lengthInBytes");
>+const _currentChunk = dart.privateName(_http, "_currentChunk");
>+const _h = dart.privateName(_http, "_h");
>+const _digestCalled = dart.privateName(_http, "_digestCalled");
>+const _iterate = dart.privateName(_http, "_iterate");
>+const _resultAsBytes = dart.privateName(_http, "_resultAsBytes");
>+const _finalizeData = dart.privateName(_http, "_finalizeData");
>+const _add32 = dart.privateName(_http, "_add32");
>+const _roundUp = dart.privateName(_http, "_roundUp");
>+const _rotl32 = dart.privateName(_http, "_rotl32");
>+const _wordToBytes = dart.privateName(_http, "_wordToBytes");
>+const _bytesToChunk = dart.privateName(_http, "_bytesToChunk");
>+const _updateHash = dart.privateName(_http, "_updateHash");
>+_http._HashBase = class _HashBase extends core.Object {
>+  add(data) {
>+    if (dart.test(this[_digestCalled])) {
>+      dart.throw(new core.StateError.new("Hash update method called after digest was retrieved"));
>+    }
>+    this[_lengthInBytes] = dart.notNull(this[_lengthInBytes]) + dart.notNull(data[$length]);
>+    this[_pendingData][$addAll](data);
>+    this[_iterate]();
>+  }
>+  close() {
>+    if (dart.test(this[_digestCalled])) {
>+      return this[_resultAsBytes]();
>+    }
>+    this[_digestCalled] = true;
>+    this[_finalizeData]();
>+    this[_iterate]();
>+    if (!(this[_pendingData][$length] === 0)) dart.assertFailed(null, "dart:_http/crypto.dart", 217, 12, "_pendingData.length == 0");
>+    return this[_resultAsBytes]();
>+  }
>+  get blockSize() {
>+    return dart.notNull(this[_chunkSizeInWords]) * 4;
>+  }
>+  [_add32](x, y) {
>+    return dart.dsend(dart.dsend(x, '+', [y]), '&', [4294967295]);
>+  }
>+  [_roundUp](val, n) {
>+    return dart.dsend(dart.dsend(dart.dsend(val, '+', [n]), '-', [1]), '&', [dart.dsend(n, '_negate', [])]);
>+  }
>+  [_rotl32](val, shift) {
>+    let mod_shift = dart.notNull(shift) & 31;
>+    return (val[$leftShift](mod_shift) & 4294967295 | ((dart.notNull(val) & 4294967295) >>> 0)[$rightShift](32 - mod_shift)) >>> 0;
>+  }
>+  [_resultAsBytes]() {
>+    let result = JSArrayOfint().of([]);
>+    for (let i = 0; i < dart.notNull(this[_h][$length]); i++) {
>+      result[$addAll](this[_wordToBytes](this[_h][$_get](i)));
>+    }
>+    return result;
>+  }
>+  [_bytesToChunk](data, dataIndex) {
>+    if (!(dart.notNull(data[$length]) - dart.notNull(dataIndex) >= dart.notNull(this[_chunkSizeInWords]) * 4)) dart.assertFailed(null, "dart:_http/crypto.dart", 254, 12, "(data.length - dataIndex) >= (_chunkSizeInWords * _BYTES_PER_WORD)");
>+    for (let wordIndex = 0; wordIndex < dart.notNull(this[_chunkSizeInWords]); wordIndex++) {
>+      let w3 = dart.test(this[_bigEndianWords]) ? data[$_get](dataIndex) : data[$_get](dart.notNull(dataIndex) + 3);
>+      let w2 = dart.test(this[_bigEndianWords]) ? data[$_get](dart.notNull(dataIndex) + 1) : data[$_get](dart.notNull(dataIndex) + 2);
>+      let w1 = dart.test(this[_bigEndianWords]) ? data[$_get](dart.notNull(dataIndex) + 2) : data[$_get](dart.notNull(dataIndex) + 1);
>+      let w0 = dart.test(this[_bigEndianWords]) ? data[$_get](dart.notNull(dataIndex) + 3) : data[$_get](dataIndex);
>+      dataIndex = dart.notNull(dataIndex) + 4;
>+      let word = (dart.notNull(w3) & 255) << 24 >>> 0;
>+      word = (word | (dart.notNull(w2) & 255) << 16) >>> 0;
>+      word = (word | (dart.notNull(w1) & 255) << 8) >>> 0;
>+      word = (word | dart.notNull(w0) & 255) >>> 0;
>+      this[_currentChunk][$_set](wordIndex, word);
>+    }
>+  }
>+  [_wordToBytes](word) {
>+    let bytes = ListOfint().new(4);
>+    bytes[$_set](0, word[$rightShift](dart.test(this[_bigEndianWords]) ? 24 : 0) & 255);
>+    bytes[$_set](1, word[$rightShift](dart.test(this[_bigEndianWords]) ? 16 : 8) & 255);
>+    bytes[$_set](2, word[$rightShift](dart.test(this[_bigEndianWords]) ? 8 : 16) & 255);
>+    bytes[$_set](3, word[$rightShift](dart.test(this[_bigEndianWords]) ? 0 : 24) & 255);
>+    return bytes;
>+  }
>+  [_iterate]() {
>+    let len = this[_pendingData][$length];
>+    let chunkSizeInBytes = dart.notNull(this[_chunkSizeInWords]) * 4;
>+    if (dart.notNull(len) >= chunkSizeInBytes) {
>+      let index = 0;
>+      for (; dart.notNull(len) - index >= chunkSizeInBytes; index = index + chunkSizeInBytes) {
>+        this[_bytesToChunk](this[_pendingData], index);
>+        this[_updateHash](this[_currentChunk]);
>+      }
>+      this[_pendingData] = this[_pendingData][$sublist](index, len);
>+    }
>+  }
>+  [_finalizeData]() {
>+    this[_pendingData][$add](128);
>+    let contentsLength = dart.notNull(this[_lengthInBytes]) + 9;
>+    let chunkSizeInBytes = dart.notNull(this[_chunkSizeInWords]) * 4;
>+    let finalizedLength = this[_roundUp](contentsLength, chunkSizeInBytes);
>+    let zeroPadding = dart.dsend(finalizedLength, '-', [contentsLength]);
>+    for (let i = 0; i < dart.notNull(core.num._check(zeroPadding)); i++) {
>+      this[_pendingData][$add](0);
>+    }
>+    let lengthInBits = dart.notNull(this[_lengthInBytes]) * 8;
>+    if (!(lengthInBits < math.pow(2, 32))) dart.assertFailed(null, "dart:_http/crypto.dart", 307, 12, "lengthInBits < pow(2, 32)");
>+    if (dart.test(this[_bigEndianWords])) {
>+      this[_pendingData][$addAll](this[_wordToBytes](0));
>+      this[_pendingData][$addAll](this[_wordToBytes]((lengthInBits & 4294967295) >>> 0));
>+    } else {
>+      this[_pendingData][$addAll](this[_wordToBytes]((lengthInBits & 4294967295) >>> 0));
>+      this[_pendingData][$addAll](this[_wordToBytes](0));
>+    }
>+  }
>+};
>+(_http._HashBase.new = function(chunkSizeInWords, digestSizeInWords, bigEndianWords) {
>+  this[_lengthInBytes] = 0;
>+  this[_currentChunk] = null;
>+  this[_h] = null;
>+  this[_digestCalled] = false;
>+  this[_chunkSizeInWords] = chunkSizeInWords;
>+  this[_digestSizeInWords] = digestSizeInWords;
>+  this[_bigEndianWords] = bigEndianWords;
>+  this[_pendingData] = JSArrayOfint().of([]);
>+  this[_currentChunk] = ListOfint().new(this[_chunkSizeInWords]);
>+  this[_h] = ListOfint().new(this[_digestSizeInWords]);
>+}).prototype = _http._HashBase.prototype;
>+dart.addTypeTests(_http._HashBase);
>+dart.setMethodSignature(_http._HashBase, () => ({
>+  __proto__: dart.getMethods(_http._HashBase.__proto__),
>+  add: dart.fnType(dart.dynamic, [core.List$(core.int)]),
>+  close: dart.fnType(core.List$(core.int), []),
>+  [_add32]: dart.fnType(dart.dynamic, [dart.dynamic, dart.dynamic]),
>+  [_roundUp]: dart.fnType(dart.dynamic, [dart.dynamic, dart.dynamic]),
>+  [_rotl32]: dart.fnType(core.int, [core.int, core.int]),
>+  [_resultAsBytes]: dart.fnType(core.List$(core.int), []),
>+  [_bytesToChunk]: dart.fnType(dart.dynamic, [core.List$(core.int), core.int]),
>+  [_wordToBytes]: dart.fnType(core.List$(core.int), [core.int]),
>+  [_iterate]: dart.fnType(dart.dynamic, []),
>+  [_finalizeData]: dart.fnType(dart.dynamic, [])
>+}));
>+dart.setGetterSignature(_http._HashBase, () => ({
>+  __proto__: dart.getGetters(_http._HashBase.__proto__),
>+  blockSize: core.int
>+}));
>+dart.setLibraryUri(_http._HashBase, "dart:_http");
>+dart.setFieldSignature(_http._HashBase, () => ({
>+  __proto__: dart.getFields(_http._HashBase.__proto__),
>+  [_chunkSizeInWords]: dart.finalFieldType(core.int),
>+  [_digestSizeInWords]: dart.finalFieldType(core.int),
>+  [_bigEndianWords]: dart.finalFieldType(core.bool),
>+  [_lengthInBytes]: dart.fieldType(core.int),
>+  [_pendingData]: dart.fieldType(ListOfint()),
>+  [_currentChunk]: dart.fieldType(ListOfint()),
>+  [_h]: dart.fieldType(ListOfint()),
>+  [_digestCalled]: dart.fieldType(core.bool)
>+}));
>+_http._MD5 = class _MD5 extends _http._HashBase {
>+  newInstance() {
>+    return new _http._MD5.new();
>+  }
>+  [_updateHash](m) {
>+    if (!(m[$length] === 16)) dart.assertFailed(null, "dart:_http/crypto.dart", 356, 12, "m.length == 16");
>+    let a = this[_h][$_get](0);
>+    let b = this[_h][$_get](1);
>+    let c = this[_h][$_get](2);
>+    let d = this[_h][$_get](3);
>+    let t0 = null;
>+    let t1 = null;
>+    for (let i = 0; i < 64; i++) {
>+      if (i < 16) {
>+        t0 = (dart.notNull(b) & dart.notNull(c) | ~dart.notNull(b) & 4294967295 & dart.notNull(d)) >>> 0;
>+        t1 = i;
>+      } else if (i < 32) {
>+        t0 = (dart.notNull(d) & dart.notNull(b) | ~dart.notNull(d) & 4294967295 & dart.notNull(c)) >>> 0;
>+        t1 = (5 * i + 1)[$modulo](16);
>+      } else if (i < 48) {
>+        t0 = (dart.notNull(b) ^ dart.notNull(c) ^ dart.notNull(d)) >>> 0;
>+        t1 = (3 * i + 5)[$modulo](16);
>+      } else {
>+        t0 = (dart.notNull(c) ^ (dart.notNull(b) | ~dart.notNull(d) & 4294967295)) >>> 0;
>+        t1 = (7 * i)[$modulo](16);
>+      }
>+      let temp = d;
>+      d = c;
>+      c = b;
>+      b = core.int._check(this[_add32](b, this[_rotl32](core.int._check(this[_add32](this[_add32](a, t0), this[_add32](_http._MD5._k[$_get](i), m[$_get](core.int._check(t1))))), _http._MD5._r[$_get](i))));
>+      a = temp;
>+    }
>+    this[_h][$_set](0, core.int._check(this[_add32](a, this[_h][$_get](0))));
>+    this[_h][$_set](1, core.int._check(this[_add32](b, this[_h][$_get](1))));
>+    this[_h][$_set](2, core.int._check(this[_add32](c, this[_h][$_get](2))));
>+    this[_h][$_set](3, core.int._check(this[_add32](d, this[_h][$_get](3))));
>+  }
>+};
>+(_http._MD5.new = function() {
>+  _http._MD5.__proto__.new.call(this, 16, 4, false);
>+  this[_h][$_set](0, 1732584193);
>+  this[_h][$_set](1, 4023233417);
>+  this[_h][$_set](2, 2562383102);
>+  this[_h][$_set](3, 271733878);
>+}).prototype = _http._MD5.prototype;
>+dart.addTypeTests(_http._MD5);
>+dart.setMethodSignature(_http._MD5, () => ({
>+  __proto__: dart.getMethods(_http._MD5.__proto__),
>+  newInstance: dart.fnType(_http._MD5, []),
>+  [_updateHash]: dart.fnType(dart.void, [core.List$(core.int)])
>+}));
>+dart.setLibraryUri(_http._MD5, "dart:_http");
>+dart.defineLazy(_http._MD5, {
>+  /*_http._MD5._k*/get _k() {
>+    return dart.constList([3614090360, 3905402710, 606105819, 3250441966, 4118548399, 1200080426, 2821735955, 4249261313, 1770035416, 2336552879, 4294925233, 2304563134, 1804603682, 4254626195, 2792965006, 1236535329, 4129170786, 3225465664, 643717713, 3921069994, 3593408605, 38016083, 3634488961, 3889429448, 568446438, 3275163606, 4107603335, 1163531501, 2850285829, 4243563512, 1735328473, 2368359562, 4294588738, 2272392833, 1839030562, 4259657740, 2763975236, 1272893353, 4139469664, 3200236656, 681279174, 3936430074, 3572445317, 76029189, 3654602809, 3873151461, 530742520, 3299628645, 4096336452, 1126891415, 2878612391, 4237533241, 1700485571, 2399980690, 4293915773, 2240044497, 1873313359, 4264355552, 2734768916, 1309151649, 4149444226, 3174756917, 718787259, 3951481745], core.int);
>+  },
>+  /*_http._MD5._r*/get _r() {
>+    return dart.constList([7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21], core.int);
>+  }
>+});
>+const _w = dart.privateName(_http, "_w");
>+_http._SHA1 = class _SHA1 extends _http._HashBase {
>+  newInstance() {
>+    return new _http._SHA1.new();
>+  }
>+  [_updateHash](m) {
>+    if (!(m[$length] === 16)) dart.assertFailed(null, "dart:_http/crypto.dart", 417, 12, "m.length == 16");
>+    let a = this[_h][$_get](0);
>+    let b = this[_h][$_get](1);
>+    let c = this[_h][$_get](2);
>+    let d = this[_h][$_get](3);
>+    let e = this[_h][$_get](4);
>+    for (let i = 0; i < 80; i++) {
>+      if (i < 16) {
>+        this[_w][$_set](i, m[$_get](i));
>+      } else {
>+        let n = (dart.notNull(this[_w][$_get](i - 3)) ^ dart.notNull(this[_w][$_get](i - 8)) ^ dart.notNull(this[_w][$_get](i - 14)) ^ dart.notNull(this[_w][$_get](i - 16))) >>> 0;
>+        this[_w][$_set](i, this[_rotl32](n, 1));
>+      }
>+      let t = this[_add32](this[_add32](this[_rotl32](a, 5), e), this[_w][$_get](i));
>+      if (i < 20) {
>+        t = this[_add32](this[_add32](t, (dart.notNull(b) & dart.notNull(c) | ~dart.notNull(b) & dart.notNull(d)) >>> 0), 1518500249);
>+      } else if (i < 40) {
>+        t = this[_add32](this[_add32](t, (dart.notNull(b) ^ dart.notNull(c) ^ dart.notNull(d)) >>> 0), 1859775393);
>+      } else if (i < 60) {
>+        t = this[_add32](this[_add32](t, (dart.notNull(b) & dart.notNull(c) | dart.notNull(b) & dart.notNull(d) | dart.notNull(c) & dart.notNull(d)) >>> 0), 2400959708);
>+      } else {
>+        t = this[_add32](this[_add32](t, (dart.notNull(b) ^ dart.notNull(c) ^ dart.notNull(d)) >>> 0), 3395469782);
>+      }
>+      e = d;
>+      d = c;
>+      c = this[_rotl32](b, 30);
>+      b = a;
>+      a = core.int._check(dart.dsend(t, '&', [4294967295]));
>+    }
>+    this[_h][$_set](0, core.int._check(this[_add32](a, this[_h][$_get](0))));
>+    this[_h][$_set](1, core.int._check(this[_add32](b, this[_h][$_get](1))));
>+    this[_h][$_set](2, core.int._check(this[_add32](c, this[_h][$_get](2))));
>+    this[_h][$_set](3, core.int._check(this[_add32](d, this[_h][$_get](3))));
>+    this[_h][$_set](4, core.int._check(this[_add32](e, this[_h][$_get](4))));
>+  }
>+};
>+(_http._SHA1.new = function() {
>+  this[_w] = ListOfint().new(80);
>+  _http._SHA1.__proto__.new.call(this, 16, 5, true);
>+  this[_h][$_set](0, 1732584193);
>+  this[_h][$_set](1, 4023233417);
>+  this[_h][$_set](2, 2562383102);
>+  this[_h][$_set](3, 271733878);
>+  this[_h][$_set](4, 3285377520);
>+}).prototype = _http._SHA1.prototype;
>+dart.addTypeTests(_http._SHA1);
>+dart.setMethodSignature(_http._SHA1, () => ({
>+  __proto__: dart.getMethods(_http._SHA1.__proto__),
>+  newInstance: dart.fnType(_http._SHA1, []),
>+  [_updateHash]: dart.fnType(dart.void, [core.List$(core.int)])
>+}));
>+dart.setLibraryUri(_http._SHA1, "dart:_http");
>+dart.setFieldSignature(_http._SHA1, () => ({
>+  __proto__: dart.getFields(_http._SHA1.__proto__),
>+  [_w]: dart.fieldType(ListOfint())
>+}));
>+let const$89;
>+let const$90;
>+let const$91;
>+let const$92;
>+let const$93;
>+let const$94;
>+let const$95;
>+let const$96;
>+let const$97;
>+_http.HttpDate = class HttpDate extends core.Object {
>+  static format(date) {
>+    let wkday = const$89 || (const$89 = dart.constList(["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"], dart.dynamic));
>+    let month = const$90 || (const$90 = dart.constList(["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], dart.dynamic));
>+    let d = date.toUtc();
>+    let sb = new core.StringBuffer.new();
>+    sb.write(wkday[$_get](dart.notNull(d.weekday) - 1));
>+    sb.write(", ");
>+    sb.write(dart.notNull(d.day) <= 9 ? "0" : "");
>+    sb.write(dart.toString(d.day));
>+    sb.write(" ");
>+    sb.write(month[$_get](dart.notNull(d.month) - 1));
>+    sb.write(" ");
>+    sb.write(dart.toString(d.year));
>+    sb.write(dart.notNull(d.hour) <= 9 ? " 0" : " ");
>+    sb.write(dart.toString(d.hour));
>+    sb.write(dart.notNull(d.minute) <= 9 ? ":0" : ":");
>+    sb.write(dart.toString(d.minute));
>+    sb.write(dart.notNull(d.second) <= 9 ? ":0" : ":");
>+    sb.write(dart.toString(d.second));
>+    sb.write(" GMT");
>+    return sb.toString();
>+  }
>+  static parse(date) {
>+    let SP = 32;
>+    let wkdays = const$91 || (const$91 = dart.constList(["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"], dart.dynamic));
>+    let weekdays = const$92 || (const$92 = dart.constList(["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"], dart.dynamic));
>+    let months = const$93 || (const$93 = dart.constList(["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], dart.dynamic));
>+    let wkdaysLowerCase = const$94 || (const$94 = dart.constList(["mon", "tue", "wed", "thu", "fri", "sat", "sun"], dart.dynamic));
>+    let weekdaysLowerCase = const$95 || (const$95 = dart.constList(["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"], dart.dynamic));
>+    let monthsLowerCase = const$96 || (const$96 = dart.constList(["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"], dart.dynamic));
>+    let formatRfc1123 = 0;
>+    let formatRfc850 = 1;
>+    let formatAsctime = 2;
>+    let index = 0;
>+    let tmp = null;
>+    let format = null;
>+    function expect(s) {
>+      if (date.length - index < s.length) {
>+        dart.throw(new _http.HttpException.new("Invalid HTTP date " + dart.str(date)));
>+      }
>+      let tmp = date[$substring](index, index + s.length);
>+      if (tmp !== s) {
>+        dart.throw(new _http.HttpException.new("Invalid HTTP date " + dart.str(date)));
>+      }
>+      index = index + s.length;
>+    }
>+    dart.fn(expect, StringTovoid());
>+    function expectWeekday() {
>+      let weekday = null;
>+      let pos = date[$indexOf](",", index);
>+      if (pos === -1) {
>+        let pos = date[$indexOf](" ", index);
>+        if (pos === -1) dart.throw(new _http.HttpException.new("Invalid HTTP date " + dart.str(date)));
>+        tmp = date[$substring](index, pos);
>+        index = pos + 1;
>+        weekday = wkdays[$indexOf](tmp);
>+        if (weekday !== -1) {
>+          format = formatAsctime;
>+          return weekday;
>+        }
>+      } else {
>+        tmp = date[$substring](index, pos);
>+        index = pos + 1;
>+        weekday = wkdays[$indexOf](tmp);
>+        if (weekday !== -1) {
>+          format = formatRfc1123;
>+          return weekday;
>+        }
>+        weekday = weekdays[$indexOf](tmp);
>+        if (weekday !== -1) {
>+          format = formatRfc850;
>+          return weekday;
>+        }
>+      }
>+      dart.throw(new _http.HttpException.new("Invalid HTTP date " + dart.str(date)));
>+    }
>+    dart.fn(expectWeekday, VoidToint());
>+    function expectMonth(separator) {
>+      let pos = date[$indexOf](separator, index);
>+      if (pos - index !== 3) dart.throw(new _http.HttpException.new("Invalid HTTP date " + dart.str(date)));
>+      tmp = date[$substring](index, pos);
>+      index = pos + 1;
>+      let month = months[$indexOf](tmp);
>+      if (month !== -1) return month;
>+      dart.throw(new _http.HttpException.new("Invalid HTTP date " + dart.str(date)));
>+    }
>+    dart.fn(expectMonth, StringToint());
>+    function expectNum(separator) {
>+      let pos = null;
>+      if (separator.length > 0) {
>+        pos = date[$indexOf](separator, index);
>+      } else {
>+        pos = date.length;
>+      }
>+      let tmp = date[$substring](index, pos);
>+      index = dart.notNull(pos) + separator.length;
>+      try {
>+        let value = core.int.parse(tmp);
>+        return value;
>+      } catch (e$) {
>+        let e = dart.getThrown(e$);
>+        if (core.FormatException.is(e)) {
>+          dart.throw(new _http.HttpException.new("Invalid HTTP date " + dart.str(date)));
>+        } else
>+          throw e$;
>+      }
>+    }
>+    dart.fn(expectNum, StringToint());
>+    function expectEnd() {
>+      if (index !== date.length) {
>+        dart.throw(new _http.HttpException.new("Invalid HTTP date " + dart.str(date)));
>+      }
>+    }
>+    dart.fn(expectEnd, VoidTovoid());
>+    let weekday = expectWeekday();
>+    let day = null;
>+    let month = null;
>+    let year = null;
>+    let hours = null;
>+    let minutes = null;
>+    let seconds = null;
>+    if (format === formatAsctime) {
>+      month = expectMonth(" ");
>+      if (date[$codeUnitAt](index) === SP) index++;
>+      day = expectNum(" ");
>+      hours = expectNum(":");
>+      minutes = expectNum(":");
>+      seconds = expectNum(" ");
>+      year = expectNum("");
>+    } else {
>+      expect(" ");
>+      day = expectNum(format === formatRfc1123 ? " " : "-");
>+      month = expectMonth(format === formatRfc1123 ? " " : "-");
>+      year = expectNum(" ");
>+      hours = expectNum(":");
>+      minutes = expectNum(":");
>+      seconds = expectNum(" ");
>+      expect("GMT");
>+    }
>+    expectEnd();
>+    return new core.DateTime.utc(year, dart.notNull(month) + 1, day, hours, minutes, seconds, 0);
>+  }
>+  static _parseCookieDate(date) {
>+    let monthsLowerCase = const$97 || (const$97 = dart.constList(["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"], dart.dynamic));
>+    let position = 0;
>+    function error() {
>+      dart.throw(new _http.HttpException.new("Invalid cookie date " + dart.str(date)));
>+    }
>+    dart.fn(error, VoidTovoid());
>+    function isEnd() {
>+      return position === date.length;
>+    }
>+    dart.fn(isEnd, VoidTobool());
>+    function isDelimiter(s) {
>+      let char = s[$codeUnitAt](0);
>+      if (char === 9) return true;
>+      if (char >= 32 && char <= 47) return true;
>+      if (char >= 59 && char <= 64) return true;
>+      if (char >= 91 && char <= 96) return true;
>+      if (char >= 123 && char <= 126) return true;
>+      return false;
>+    }
>+    dart.fn(isDelimiter, StringTobool());
>+    function isNonDelimiter(s) {
>+      let char = s[$codeUnitAt](0);
>+      if (char >= 0 && char <= 8) return true;
>+      if (char >= 10 && char <= 31) return true;
>+      if (char >= 48 && char <= 57) return true;
>+      if (char === 58) return true;
>+      if (char >= 65 && char <= 90) return true;
>+      if (char >= 97 && char <= 122) return true;
>+      if (char >= 127 && char <= 255) return true;
>+      return false;
>+    }
>+    dart.fn(isNonDelimiter, StringTobool());
>+    function isDigit(s) {
>+      let char = s[$codeUnitAt](0);
>+      if (char > 47 && char < 58) return true;
>+      return false;
>+    }
>+    dart.fn(isDigit, StringTobool());
>+    function getMonth(month) {
>+      if (month.length < 3) return -1;
>+      return monthsLowerCase[$indexOf](month[$substring](0, 3));
>+    }
>+    dart.fn(getMonth, StringToint());
>+    function toInt(s) {
>+      let index = 0;
>+      for (; index < s.length && dart.test(isDigit(s[$_get](index))); index++)
>+        ;
>+      return core.int.parse(s[$substring](0, index));
>+    }
>+    dart.fn(toInt, StringToint());
>+    let tokens = [];
>+    while (!dart.test(isEnd())) {
>+      while (!dart.test(isEnd()) && dart.test(isDelimiter(date[$_get](position))))
>+        position++;
>+      let start = position;
>+      while (!dart.test(isEnd()) && dart.test(isNonDelimiter(date[$_get](position))))
>+        position++;
>+      tokens[$add](date[$substring](start, position)[$toLowerCase]());
>+      while (!dart.test(isEnd()) && dart.test(isDelimiter(date[$_get](position))))
>+        position++;
>+    }
>+    let timeStr = null;
>+    let dayOfMonthStr = null;
>+    let monthStr = null;
>+    let yearStr = null;
>+    for (let token of tokens) {
>+      if (dart.dtest(dart.dsend(dart.dload(token, 'length'), '<', [1]))) continue;
>+      if (timeStr == null && dart.dtest(dart.dsend(dart.dload(token, 'length'), '>=', [5])) && dart.test(isDigit(core.String._check(dart.dindex(token, 0)))) && (dart.equals(dart.dindex(token, 1), ":") || dart.test(isDigit(core.String._check(dart.dindex(token, 1)))) && dart.equals(dart.dindex(token, 2), ":"))) {
>+        timeStr = core.String._check(token);
>+      } else if (dayOfMonthStr == null && dart.test(isDigit(core.String._check(dart.dindex(token, 0))))) {
>+        dayOfMonthStr = core.String._check(token);
>+      } else if (monthStr == null && dart.notNull(getMonth(core.String._check(token))) >= 0) {
>+        monthStr = core.String._check(token);
>+      } else if (yearStr == null && dart.dtest(dart.dsend(dart.dload(token, 'length'), '>=', [2])) && dart.test(isDigit(core.String._check(dart.dindex(token, 0)))) && dart.test(isDigit(core.String._check(dart.dindex(token, 1))))) {
>+        yearStr = core.String._check(token);
>+      }
>+    }
>+    if (timeStr == null || dayOfMonthStr == null || monthStr == null || yearStr == null) {
>+      error();
>+    }
>+    let year = toInt(yearStr);
>+    if (dart.notNull(year) >= 70 && dart.notNull(year) <= 99) {
>+      year = dart.notNull(year) + 1900;
>+    } else if (dart.notNull(year) >= 0 && dart.notNull(year) <= 69) {
>+      year = dart.notNull(year) + 2000;
>+    }
>+    if (dart.notNull(year) < 1601) error();
>+    let dayOfMonth = toInt(dayOfMonthStr);
>+    if (dart.notNull(dayOfMonth) < 1 || dart.notNull(dayOfMonth) > 31) error();
>+    let month = dart.notNull(getMonth(monthStr)) + 1;
>+    let timeList = timeStr[$split](":");
>+    if (timeList[$length] !== 3) error();
>+    let hour = toInt(timeList[$_get](0));
>+    let minute = toInt(timeList[$_get](1));
>+    let second = toInt(timeList[$_get](2));
>+    if (dart.notNull(hour) > 23) error();
>+    if (dart.notNull(minute) > 59) error();
>+    if (dart.notNull(second) > 59) error();
>+    return new core.DateTime.utc(year, month, dayOfMonth, hour, minute, second, 0);
>+  }
>+};
>+(_http.HttpDate.new = function() {
>+}).prototype = _http.HttpDate.prototype;
>+dart.addTypeTests(_http.HttpDate);
>+dart.setLibraryUri(_http.HttpDate, "dart:_http");
>+const _headers = dart.privateName(_http, "_headers");
>+const _defaultPortForScheme = dart.privateName(_http, "_defaultPortForScheme");
>+const _mutable = dart.privateName(_http, "_mutable");
>+const _noFoldingHeaders = dart.privateName(_http, "_noFoldingHeaders");
>+const _contentLength = dart.privateName(_http, "_contentLength");
>+const _persistentConnection = dart.privateName(_http, "_persistentConnection");
>+const _chunkedTransferEncoding = dart.privateName(_http, "_chunkedTransferEncoding");
>+const _host$ = dart.privateName(_http, "_host");
>+const _port$ = dart.privateName(_http, "_port");
>+const _checkMutable = dart.privateName(_http, "_checkMutable");
>+const _addAll = dart.privateName(_http, "_addAll");
>+const _add$2 = dart.privateName(_http, "_add");
>+const _set = dart.privateName(_http, "_set");
>+const _addValue = dart.privateName(_http, "_addValue");
>+const _updateHostHeader = dart.privateName(_http, "_updateHostHeader");
>+const _addDate = dart.privateName(_http, "_addDate");
>+const _addHost = dart.privateName(_http, "_addHost");
>+const _addExpires = dart.privateName(_http, "_addExpires");
>+const _addConnection = dart.privateName(_http, "_addConnection");
>+const _addContentType = dart.privateName(_http, "_addContentType");
>+const _addContentLength = dart.privateName(_http, "_addContentLength");
>+const _addTransferEncoding = dart.privateName(_http, "_addTransferEncoding");
>+const _addIfModifiedSince = dart.privateName(_http, "_addIfModifiedSince");
>+const _foldHeader = dart.privateName(_http, "_foldHeader");
>+const _finalize = dart.privateName(_http, "_finalize");
>+const _build = dart.privateName(_http, "_build");
>+const _parseCookies = dart.privateName(_http, "_parseCookies");
>+_http._HttpHeaders = class _HttpHeaders extends core.Object {
>+  _get(name) {
>+    return this[_headers][$_get](name[$toLowerCase]());
>+  }
>+  value(name) {
>+    name = name[$toLowerCase]();
>+    let values = this[_headers][$_get](name);
>+    if (values == null) return null;
>+    if (dart.notNull(values[$length]) > 1) {
>+      dart.throw(new _http.HttpException.new("More than one value for header " + dart.str(name)));
>+    }
>+    return values[$_get](0);
>+  }
>+  add(name, value) {
>+    this[_checkMutable]();
>+    this[_addAll](_http._HttpHeaders._validateField(name), value);
>+  }
>+  [_addAll](name, value) {
>+    if (!(name == _http._HttpHeaders._validateField(name))) dart.assertFailed(null, "dart:_http/http_headers.dart", 59, 12, "name == _validateField(name)");
>+    if (core.Iterable.is(value)) {
>+      for (let v of value) {
>+        this[_add$2](name, _http._HttpHeaders._validateValue(v));
>+      }
>+    } else {
>+      this[_add$2](name, _http._HttpHeaders._validateValue(value));
>+    }
>+  }
>+  set(name, value) {
>+    this[_checkMutable]();
>+    name = _http._HttpHeaders._validateField(name);
>+    this[_headers][$remove](name);
>+    if (name === _http.HttpHeaders.transferEncodingHeader) {
>+      this[_chunkedTransferEncoding] = false;
>+    }
>+    this[_addAll](name, value);
>+  }
>+  remove(name, value) {
>+    this[_checkMutable]();
>+    name = _http._HttpHeaders._validateField(name);
>+    value = _http._HttpHeaders._validateValue(value);
>+    let values = this[_headers][$_get](name);
>+    if (values != null) {
>+      let index = values[$indexOf](core.String._check(value));
>+      if (index !== -1) {
>+        values[$removeRange](index, dart.notNull(index) + 1);
>+      }
>+      if (values[$length] === 0) this[_headers][$remove](name);
>+    }
>+    if (name === _http.HttpHeaders.transferEncodingHeader && dart.equals(value, "chunked")) {
>+      this[_chunkedTransferEncoding] = false;
>+    }
>+  }
>+  removeAll(name) {
>+    this[_checkMutable]();
>+    name = _http._HttpHeaders._validateField(name);
>+    this[_headers][$remove](name);
>+  }
>+  forEach(f) {
>+    this[_headers][$forEach](f);
>+  }
>+  noFolding(name) {
>+    if (this[_noFoldingHeaders] == null) this[_noFoldingHeaders] = JSArrayOfString().of([]);
>+    this[_noFoldingHeaders][$add](name);
>+  }
>+  get persistentConnection() {
>+    return this[_persistentConnection];
>+  }
>+  set persistentConnection(persistentConnection) {
>+    this[_checkMutable]();
>+    if (persistentConnection == this[_persistentConnection]) return;
>+    if (dart.test(persistentConnection)) {
>+      if (this.protocolVersion === "1.1") {
>+        this.remove(_http.HttpHeaders.connectionHeader, "close");
>+      } else {
>+        if (this[_contentLength] === -1) {
>+          dart.throw(new _http.HttpException.new("Trying to set 'Connection: Keep-Alive' on HTTP 1.0 headers with " + "no ContentLength"));
>+        }
>+        this.add(_http.HttpHeaders.connectionHeader, "keep-alive");
>+      }
>+    } else {
>+      if (this.protocolVersion === "1.1") {
>+        this.add(_http.HttpHeaders.connectionHeader, "close");
>+      } else {
>+        this.remove(_http.HttpHeaders.connectionHeader, "keep-alive");
>+      }
>+    }
>+    this[_persistentConnection] = persistentConnection;
>+  }
>+  get contentLength() {
>+    return this[_contentLength];
>+  }
>+  set contentLength(contentLength) {
>+    this[_checkMutable]();
>+    if (this.protocolVersion === "1.0" && dart.test(this.persistentConnection) && contentLength === -1) {
>+      dart.throw(new _http.HttpException.new("Trying to clear ContentLength on HTTP 1.0 headers with " + "'Connection: Keep-Alive' set"));
>+    }
>+    if (this[_contentLength] == contentLength) return;
>+    this[_contentLength] = contentLength;
>+    if (dart.notNull(this[_contentLength]) >= 0) {
>+      if (dart.test(this.chunkedTransferEncoding)) this.chunkedTransferEncoding = false;
>+      this[_set](_http.HttpHeaders.contentLengthHeader, dart.toString(contentLength));
>+    } else {
>+      this.removeAll(_http.HttpHeaders.contentLengthHeader);
>+      if (this.protocolVersion === "1.1") {
>+        this.chunkedTransferEncoding = true;
>+      }
>+    }
>+  }
>+  get chunkedTransferEncoding() {
>+    return this[_chunkedTransferEncoding];
>+  }
>+  set chunkedTransferEncoding(chunkedTransferEncoding) {
>+    this[_checkMutable]();
>+    if (dart.test(chunkedTransferEncoding) && this.protocolVersion === "1.0") {
>+      dart.throw(new _http.HttpException.new("Trying to set 'Transfer-Encoding: Chunked' on HTTP 1.0 headers"));
>+    }
>+    if (chunkedTransferEncoding == this[_chunkedTransferEncoding]) return;
>+    if (dart.test(chunkedTransferEncoding)) {
>+      let values = this[_headers][$_get](_http.HttpHeaders.transferEncodingHeader);
>+      if (values == null || values[$last] !== "chunked") {
>+        this[_addValue](_http.HttpHeaders.transferEncodingHeader, "chunked");
>+      }
>+      this.contentLength = -1;
>+    } else {
>+      this.remove(_http.HttpHeaders.transferEncodingHeader, "chunked");
>+    }
>+    this[_chunkedTransferEncoding] = chunkedTransferEncoding;
>+  }
>+  get host() {
>+    return this[_host$];
>+  }
>+  set host(host) {
>+    this[_checkMutable]();
>+    this[_host$] = host;
>+    this[_updateHostHeader]();
>+  }
>+  get port() {
>+    return this[_port$];
>+  }
>+  set port(port) {
>+    this[_checkMutable]();
>+    this[_port$] = port;
>+    this[_updateHostHeader]();
>+  }
>+  get ifModifiedSince() {
>+    let values = this[_headers][$_get](_http.HttpHeaders.ifModifiedSinceHeader);
>+    if (values != null) {
>+      try {
>+        return _http.HttpDate.parse(values[$_get](0));
>+      } catch (e$) {
>+        let e = dart.getThrown(e$);
>+        if (core.Exception.is(e)) {
>+          return null;
>+        } else
>+          throw e$;
>+      }
>+    }
>+    return null;
>+  }
>+  set ifModifiedSince(ifModifiedSince) {
>+    this[_checkMutable]();
>+    let formatted = _http.HttpDate.format(ifModifiedSince.toUtc());
>+    this[_set](_http.HttpHeaders.ifModifiedSinceHeader, formatted);
>+  }
>+  get date() {
>+    let values = this[_headers][$_get](_http.HttpHeaders.dateHeader);
>+    if (values != null) {
>+      try {
>+        return _http.HttpDate.parse(values[$_get](0));
>+      } catch (e$) {
>+        let e = dart.getThrown(e$);
>+        if (core.Exception.is(e)) {
>+          return null;
>+        } else
>+          throw e$;
>+      }
>+    }
>+    return null;
>+  }
>+  set date(date) {
>+    this[_checkMutable]();
>+    let formatted = _http.HttpDate.format(date.toUtc());
>+    this[_set]("date", formatted);
>+  }
>+  get expires() {
>+    let values = this[_headers][$_get](_http.HttpHeaders.expiresHeader);
>+    if (values != null) {
>+      try {
>+        return _http.HttpDate.parse(values[$_get](0));
>+      } catch (e$) {
>+        let e = dart.getThrown(e$);
>+        if (core.Exception.is(e)) {
>+          return null;
>+        } else
>+          throw e$;
>+      }
>+    }
>+    return null;
>+  }
>+  set expires(expires) {
>+    this[_checkMutable]();
>+    let formatted = _http.HttpDate.format(expires.toUtc());
>+    this[_set](_http.HttpHeaders.expiresHeader, formatted);
>+  }
>+  get contentType() {
>+    let values = this[_headers][$_get]("content-type");
>+    if (values != null) {
>+      return _http.ContentType.parse(values[$_get](0));
>+    } else {
>+      return null;
>+    }
>+  }
>+  set contentType(contentType) {
>+    this[_checkMutable]();
>+    this[_set](_http.HttpHeaders.contentTypeHeader, dart.toString(contentType));
>+  }
>+  clear() {
>+    this[_checkMutable]();
>+    this[_headers][$clear]();
>+    this[_contentLength] = -1;
>+    this[_persistentConnection] = true;
>+    this[_chunkedTransferEncoding] = false;
>+    this[_host$] = null;
>+    this[_port$] = null;
>+  }
>+  [_add$2](name, value) {
>+    if (!(name == _http._HttpHeaders._validateField(name))) dart.assertFailed(null, "dart:_http/http_headers.dart", 283, 12, "name == _validateField(name)");
>+    switch (name.length) {
>+      case 4:
>+      {
>+        if (_http.HttpHeaders.dateHeader === name) {
>+          this[_addDate](name, value);
>+          return;
>+        }
>+        if (_http.HttpHeaders.hostHeader === name) {
>+          this[_addHost](name, value);
>+          return;
>+        }
>+        break;
>+      }
>+      case 7:
>+      {
>+        if (_http.HttpHeaders.expiresHeader === name) {
>+          this[_addExpires](name, value);
>+          return;
>+        }
>+        break;
>+      }
>+      case 10:
>+      {
>+        if (_http.HttpHeaders.connectionHeader === name) {
>+          this[_addConnection](name, value);
>+          return;
>+        }
>+        break;
>+      }
>+      case 12:
>+      {
>+        if (_http.HttpHeaders.contentTypeHeader === name) {
>+          this[_addContentType](name, value);
>+          return;
>+        }
>+        break;
>+      }
>+      case 14:
>+      {
>+        if (_http.HttpHeaders.contentLengthHeader === name) {
>+          this[_addContentLength](name, value);
>+          return;
>+        }
>+        break;
>+      }
>+      case 17:
>+      {
>+        if (_http.HttpHeaders.transferEncodingHeader === name) {
>+          this[_addTransferEncoding](name, value);
>+          return;
>+        }
>+        if (_http.HttpHeaders.ifModifiedSinceHeader === name) {
>+          this[_addIfModifiedSince](name, value);
>+          return;
>+        }
>+      }
>+    }
>+    this[_addValue](name, value);
>+  }
>+  [_addContentLength](name, value) {
>+    if (core.int.is(value)) {
>+      this.contentLength = value;
>+    } else if (typeof value == 'string') {
>+      this.contentLength = core.int.parse(value);
>+    } else {
>+      dart.throw(new _http.HttpException.new("Unexpected type for header named " + dart.str(name)));
>+    }
>+  }
>+  [_addTransferEncoding](name, value) {
>+    if (dart.equals(value, "chunked")) {
>+      this.chunkedTransferEncoding = true;
>+    } else {
>+      this[_addValue](_http.HttpHeaders.transferEncodingHeader, value);
>+    }
>+  }
>+  [_addDate](name, value) {
>+    if (core.DateTime.is(value)) {
>+      this.date = value;
>+    } else if (typeof value == 'string') {
>+      this[_set](_http.HttpHeaders.dateHeader, value);
>+    } else {
>+      dart.throw(new _http.HttpException.new("Unexpected type for header named " + dart.str(name)));
>+    }
>+  }
>+  [_addExpires](name, value) {
>+    if (core.DateTime.is(value)) {
>+      this.expires = value;
>+    } else if (typeof value == 'string') {
>+      this[_set](_http.HttpHeaders.expiresHeader, value);
>+    } else {
>+      dart.throw(new _http.HttpException.new("Unexpected type for header named " + dart.str(name)));
>+    }
>+  }
>+  [_addIfModifiedSince](name, value) {
>+    if (core.DateTime.is(value)) {
>+      this.ifModifiedSince = value;
>+    } else if (typeof value == 'string') {
>+      this[_set](_http.HttpHeaders.ifModifiedSinceHeader, value);
>+    } else {
>+      dart.throw(new _http.HttpException.new("Unexpected type for header named " + dart.str(name)));
>+    }
>+  }
>+  [_addHost](name, value) {
>+    if (typeof value == 'string') {
>+      let pos = value[$indexOf](":");
>+      if (pos === -1) {
>+        this[_host$] = value;
>+        this[_port$] = _http.HttpClient.defaultHttpPort;
>+      } else {
>+        if (pos > 0) {
>+          this[_host$] = value[$substring](0, pos);
>+        } else {
>+          this[_host$] = null;
>+        }
>+        if (pos + 1 === value.length) {
>+          this[_port$] = _http.HttpClient.defaultHttpPort;
>+        } else {
>+          try {
>+            this[_port$] = core.int.parse(value[$substring](pos + 1));
>+          } catch (e$) {
>+            let e = dart.getThrown(e$);
>+            if (core.FormatException.is(e)) {
>+              this[_port$] = null;
>+            } else
>+              throw e$;
>+          }
>+        }
>+      }
>+      this[_set](_http.HttpHeaders.hostHeader, value);
>+    } else {
>+      dart.throw(new _http.HttpException.new("Unexpected type for header named " + dart.str(name)));
>+    }
>+  }
>+  [_addConnection](name, value) {
>+    let lowerCaseValue = dart.dsend(value, 'toLowerCase', []);
>+    if (dart.equals(lowerCaseValue, "close")) {
>+      this[_persistentConnection] = false;
>+    } else if (dart.equals(lowerCaseValue, "keep-alive")) {
>+      this[_persistentConnection] = true;
>+    }
>+    this[_addValue](name, value);
>+  }
>+  [_addContentType](name, value) {
>+    this[_set](_http.HttpHeaders.contentTypeHeader, core.String._check(value));
>+  }
>+  [_addValue](name, value) {
>+    let values = this[_headers][$_get](name);
>+    if (values == null) {
>+      values = JSArrayOfString().of([]);
>+      this[_headers][$_set](name, values);
>+    }
>+    if (core.DateTime.is(value)) {
>+      values[$add](_http.HttpDate.format(value));
>+    } else if (typeof value == 'string') {
>+      values[$add](value);
>+    } else {
>+      values[$add](core.String._check(_http._HttpHeaders._validateValue(dart.toString(value))));
>+    }
>+  }
>+  [_set](name, value) {
>+    if (!(name == _http._HttpHeaders._validateField(name))) dart.assertFailed(null, "dart:_http/http_headers.dart", 440, 12, "name == _validateField(name)");
>+    let values = JSArrayOfString().of([]);
>+    this[_headers][$_set](name, values);
>+    values[$add](value);
>+  }
>+  [_checkMutable]() {
>+    if (!dart.test(this[_mutable])) dart.throw(new _http.HttpException.new("HTTP headers are not mutable"));
>+  }
>+  [_updateHostHeader]() {
>+    let defaultPort = this[_port$] == null || this[_port$] == this[_defaultPortForScheme];
>+    this[_set]("host", defaultPort ? this.host : dart.str(this.host) + ":" + dart.str(this[_port$]));
>+  }
>+  [_foldHeader](name) {
>+    if (name === _http.HttpHeaders.setCookieHeader || this[_noFoldingHeaders] != null && this[_noFoldingHeaders][$indexOf](name) !== -1) {
>+      return false;
>+    }
>+    return true;
>+  }
>+  [_finalize]() {
>+    this[_mutable] = false;
>+  }
>+  [_build](builder) {
>+    for (let name of this[_headers][$keys]) {
>+      let values = this[_headers][$_get](name);
>+      let fold = core.bool._check(this[_foldHeader](name));
>+      let nameData = name[$codeUnits];
>+      builder.add(nameData);
>+      builder.addByte(_http._CharCode.COLON);
>+      builder.addByte(_http._CharCode.SP);
>+      for (let i = 0; i < dart.notNull(values[$length]); i++) {
>+        if (i > 0) {
>+          if (dart.test(fold)) {
>+            builder.addByte(_http._CharCode.COMMA);
>+            builder.addByte(_http._CharCode.SP);
>+          } else {
>+            builder.addByte(_http._CharCode.CR);
>+            builder.addByte(_http._CharCode.LF);
>+            builder.add(nameData);
>+            builder.addByte(_http._CharCode.COLON);
>+            builder.addByte(_http._CharCode.SP);
>+          }
>+        }
>+        builder.add(values[$_get](i)[$codeUnits]);
>+      }
>+      builder.addByte(_http._CharCode.CR);
>+      builder.addByte(_http._CharCode.LF);
>+    }
>+  }
>+  toString() {
>+    let sb = new core.StringBuffer.new();
>+    this[_headers][$forEach](dart.fn((name, values) => {
>+      sb.write(name);
>+      sb.write(": ");
>+      let fold = core.bool._check(this[_foldHeader](name));
>+      for (let i = 0; i < dart.notNull(values[$length]); i++) {
>+        if (i > 0) {
>+          if (dart.test(fold)) {
>+            sb.write(", ");
>+          } else {
>+            sb.write("\n");
>+            sb.write(name);
>+            sb.write(": ");
>+          }
>+        }
>+        sb.write(values[$_get](i));
>+      }
>+      sb.write("\n");
>+    }, StringAndListOfStringToNull()));
>+    return sb.toString();
>+  }
>+  [_parseCookies]() {
>+    let cookies = JSArrayOfCookie().of([]);
>+    function parseCookieString(s) {
>+      let index = 0;
>+      function done() {
>+        return index === -1 || index === s.length;
>+      }
>+      dart.fn(done, VoidTobool());
>+      function skipWS() {
>+        while (!dart.test(done())) {
>+          if (s[$_get](index) !== " " && s[$_get](index) !== "\t") return;
>+          index++;
>+        }
>+      }
>+      dart.fn(skipWS, VoidTovoid());
>+      function parseName() {
>+        let start = index;
>+        while (!dart.test(done())) {
>+          if (s[$_get](index) === " " || s[$_get](index) === "\t" || s[$_get](index) === "=") break;
>+          index++;
>+        }
>+        return s[$substring](start, index);
>+      }
>+      dart.fn(parseName, VoidToString());
>+      function parseValue() {
>+        let start = index;
>+        while (!dart.test(done())) {
>+          if (s[$_get](index) === " " || s[$_get](index) === "\t" || s[$_get](index) === ";") break;
>+          index++;
>+        }
>+        return s[$substring](start, index);
>+      }
>+      dart.fn(parseValue, VoidToString());
>+      function expect(expected) {
>+        if (dart.test(done())) return false;
>+        if (s[$_get](index) != expected) return false;
>+        index++;
>+        return true;
>+      }
>+      dart.fn(expect, StringTobool());
>+      while (!dart.test(done())) {
>+        skipWS();
>+        if (dart.test(done())) return;
>+        let name = parseName();
>+        skipWS();
>+        if (!dart.test(expect("="))) {
>+          index = s[$indexOf](";", index);
>+          continue;
>+        }
>+        skipWS();
>+        let value = parseValue();
>+        try {
>+          cookies[$add](new _http._Cookie.new(name, value));
>+        } catch (e) {
>+          let _ = dart.getThrown(e);
>+        }
>+        skipWS();
>+        if (dart.test(done())) return;
>+        if (!dart.test(expect(";"))) {
>+          index = s[$indexOf](";", index);
>+          continue;
>+        }
>+      }
>+    }
>+    dart.fn(parseCookieString, StringTovoid());
>+    let values = this[_headers][$_get](_http.HttpHeaders.cookieHeader);
>+    if (values != null) {
>+      values[$forEach](dart.fn(headerValue => parseCookieString(headerValue), StringTovoid()));
>+    }
>+    return cookies;
>+  }
>+  static _validateField(field) {
>+    for (let i = 0; i < field.length; i++) {
>+      if (!dart.test(_http._HttpParser._isTokenChar(field[$codeUnitAt](i)))) {
>+        dart.throw(new core.FormatException.new("Invalid HTTP header field name: " + dart.str(convert.json.encode(field))));
>+      }
>+    }
>+    return field[$toLowerCase]();
>+  }
>+  static _validateValue(value) {
>+    if (!(typeof value == 'string')) return value;
>+    for (let i = 0; i < dart.notNull(core.num._check(dart.dload(value, 'length'))); i++) {
>+      if (!dart.test(_http._HttpParser._isValueChar(core.int._check(dart.dsend(value, 'codeUnitAt', [i]))))) {
>+        dart.throw(new core.FormatException.new("Invalid HTTP header field value: " + dart.str(convert.json.encode(value))));
>+      }
>+    }
>+    return value;
>+  }
>+};
>+(_http._HttpHeaders.new = function(protocolVersion, opts) {
>+  let defaultPortForScheme = opts && 'defaultPortForScheme' in opts ? opts.defaultPortForScheme : _http.HttpClient.defaultHttpPort;
>+  let initialHeaders = opts && 'initialHeaders' in opts ? opts.initialHeaders : null;
>+  this[_mutable] = true;
>+  this[_noFoldingHeaders] = null;
>+  this[_contentLength] = -1;
>+  this[_persistentConnection] = true;
>+  this[_chunkedTransferEncoding] = false;
>+  this[_host$] = null;
>+  this[_port$] = null;
>+  this.protocolVersion = protocolVersion;
>+  this[_headers] = new (IdentityMapOfString$ListOfString()).new();
>+  this[_defaultPortForScheme] = defaultPortForScheme;
>+  if (initialHeaders != null) {
>+    initialHeaders[_headers][$forEach](dart.fn((name, value) => this[_headers][$_set](name, value), StringAndListOfStringToListOfString()));
>+    this[_contentLength] = initialHeaders[_contentLength];
>+    this[_persistentConnection] = initialHeaders[_persistentConnection];
>+    this[_chunkedTransferEncoding] = initialHeaders[_chunkedTransferEncoding];
>+    this[_host$] = initialHeaders[_host$];
>+    this[_port$] = initialHeaders[_port$];
>+  }
>+  if (this.protocolVersion === "1.0") {
>+    this[_persistentConnection] = false;
>+    this[_chunkedTransferEncoding] = false;
>+  }
>+}).prototype = _http._HttpHeaders.prototype;
>+dart.addTypeTests(_http._HttpHeaders);
>+_http._HttpHeaders[dart.implements] = () => [_http.HttpHeaders];
>+dart.setMethodSignature(_http._HttpHeaders, () => ({
>+  __proto__: dart.getMethods(_http._HttpHeaders.__proto__),
>+  _get: dart.fnType(core.List$(core.String), [core.String]),
>+  value: dart.fnType(core.String, [core.String]),
>+  add: dart.fnType(dart.void, [core.String, core.Object]),
>+  [_addAll]: dart.fnType(dart.void, [core.String, dart.dynamic]),
>+  set: dart.fnType(dart.void, [core.String, core.Object]),
>+  remove: dart.fnType(dart.void, [core.String, core.Object]),
>+  removeAll: dart.fnType(dart.void, [core.String]),
>+  forEach: dart.fnType(dart.void, [dart.fnType(dart.void, [core.String, core.List$(core.String)])]),
>+  noFolding: dart.fnType(dart.void, [core.String]),
>+  clear: dart.fnType(dart.void, []),
>+  [_add$2]: dart.fnType(dart.void, [core.String, dart.dynamic]),
>+  [_addContentLength]: dart.fnType(dart.void, [core.String, dart.dynamic]),
>+  [_addTransferEncoding]: dart.fnType(dart.void, [core.String, dart.dynamic]),
>+  [_addDate]: dart.fnType(dart.void, [core.String, dart.dynamic]),
>+  [_addExpires]: dart.fnType(dart.void, [core.String, dart.dynamic]),
>+  [_addIfModifiedSince]: dart.fnType(dart.void, [core.String, dart.dynamic]),
>+  [_addHost]: dart.fnType(dart.void, [core.String, dart.dynamic]),
>+  [_addConnection]: dart.fnType(dart.void, [core.String, dart.dynamic]),
>+  [_addContentType]: dart.fnType(dart.void, [core.String, dart.dynamic]),
>+  [_addValue]: dart.fnType(dart.void, [core.String, core.Object]),
>+  [_set]: dart.fnType(dart.void, [core.String, core.String]),
>+  [_checkMutable]: dart.fnType(dart.dynamic, []),
>+  [_updateHostHeader]: dart.fnType(dart.dynamic, []),
>+  [_foldHeader]: dart.fnType(dart.dynamic, [core.String]),
>+  [_finalize]: dart.fnType(dart.void, []),
>+  [_build]: dart.fnType(dart.void, [io.BytesBuilder]),
>+  [_parseCookies]: dart.fnType(core.List$(_http.Cookie), [])
>+}));
>+dart.setGetterSignature(_http._HttpHeaders, () => ({
>+  __proto__: dart.getGetters(_http._HttpHeaders.__proto__),
>+  persistentConnection: core.bool,
>+  contentLength: core.int,
>+  chunkedTransferEncoding: core.bool,
>+  host: core.String,
>+  port: core.int,
>+  ifModifiedSince: core.DateTime,
>+  date: core.DateTime,
>+  expires: core.DateTime,
>+  contentType: _http.ContentType
>+}));
>+dart.setSetterSignature(_http._HttpHeaders, () => ({
>+  __proto__: dart.getSetters(_http._HttpHeaders.__proto__),
>+  persistentConnection: core.bool,
>+  contentLength: core.int,
>+  chunkedTransferEncoding: core.bool,
>+  host: core.String,
>+  port: core.int,
>+  ifModifiedSince: core.DateTime,
>+  date: core.DateTime,
>+  expires: core.DateTime,
>+  contentType: _http.ContentType
>+}));
>+dart.setLibraryUri(_http._HttpHeaders, "dart:_http");
>+dart.setFieldSignature(_http._HttpHeaders, () => ({
>+  __proto__: dart.getFields(_http._HttpHeaders.__proto__),
>+  [_headers]: dart.finalFieldType(MapOfString$ListOfString()),
>+  protocolVersion: dart.finalFieldType(core.String),
>+  [_mutable]: dart.fieldType(core.bool),
>+  [_noFoldingHeaders]: dart.fieldType(ListOfString()),
>+  [_contentLength]: dart.fieldType(core.int),
>+  [_persistentConnection]: dart.fieldType(core.bool),
>+  [_chunkedTransferEncoding]: dart.fieldType(core.bool),
>+  [_host$]: dart.fieldType(core.String),
>+  [_port$]: dart.fieldType(core.int),
>+  [_defaultPortForScheme]: dart.finalFieldType(core.int)
>+}));
>+dart.defineExtensionMethods(_http._HttpHeaders, ['toString']);
>+const _value$4 = dart.privateName(_http, "_value");
>+const _parameters = dart.privateName(_http, "_parameters");
>+const _unmodifiableParameters = dart.privateName(_http, "_unmodifiableParameters");
>+const _parse = dart.privateName(_http, "_parse");
>+const _ensureParameters = dart.privateName(_http, "_ensureParameters");
>+_http._HeaderValue = class _HeaderValue extends core.Object {
>+  static parse(value, opts) {
>+    let parameterSeparator = opts && 'parameterSeparator' in opts ? opts.parameterSeparator : ";";
>+    let valueSeparator = opts && 'valueSeparator' in opts ? opts.valueSeparator : null;
>+    let preserveBackslash = opts && 'preserveBackslash' in opts ? opts.preserveBackslash : false;
>+    let result = new _http._HeaderValue.new();
>+    result[_parse](value, core.String._check(parameterSeparator), core.String._check(valueSeparator), core.bool._check(preserveBackslash));
>+    return result;
>+  }
>+  get value() {
>+    return this[_value$4];
>+  }
>+  [_ensureParameters]() {
>+    if (this[_parameters] == null) {
>+      this[_parameters] = new (IdentityMapOfString$String()).new();
>+    }
>+  }
>+  get parameters() {
>+    this[_ensureParameters]();
>+    if (this[_unmodifiableParameters] == null) {
>+      this[_unmodifiableParameters] = new (UnmodifiableMapViewOfString$String()).new(this[_parameters]);
>+    }
>+    return this[_unmodifiableParameters];
>+  }
>+  toString() {
>+    let sb = new core.StringBuffer.new();
>+    sb.write(this[_value$4]);
>+    if (this.parameters != null && dart.notNull(this.parameters[$length]) > 0) {
>+      this[_parameters][$forEach](dart.fn((name, value) => {
>+        sb.write("; ");
>+        sb.write(name);
>+        sb.write("=");
>+        sb.write(value);
>+      }, StringAndStringToNull()));
>+    }
>+    return sb.toString();
>+  }
>+  [_parse](s, parameterSeparator, valueSeparator, preserveBackslash) {
>+    let index = 0;
>+    function done() {
>+      return index === s.length;
>+    }
>+    dart.fn(done, VoidTobool());
>+    function skipWS() {
>+      while (!dart.test(done())) {
>+        if (s[$_get](index) !== " " && s[$_get](index) !== "\t") return;
>+        index++;
>+      }
>+    }
>+    dart.fn(skipWS, VoidTovoid());
>+    function parseValue() {
>+      let start = index;
>+      while (!dart.test(done())) {
>+        if (s[$_get](index) === " " || s[$_get](index) === "\t" || s[$_get](index) == valueSeparator || s[$_get](index) == parameterSeparator) break;
>+        index++;
>+      }
>+      return s[$substring](start, index);
>+    }
>+    dart.fn(parseValue, VoidToString());
>+    function expect(expected) {
>+      if (dart.test(done()) || s[$_get](index) != expected) {
>+        dart.throw(new _http.HttpException.new("Failed to parse header value"));
>+      }
>+      index++;
>+    }
>+    dart.fn(expect, StringTovoid());
>+    function maybeExpect(expected) {
>+      if (s[$_get](index) == expected) index++;
>+    }
>+    dart.fn(maybeExpect, StringTovoid());
>+    const parseParameters = () => {
>+      let parameters = new (IdentityMapOfString$String()).new();
>+      this[_parameters] = new (UnmodifiableMapViewOfString$String()).new(parameters);
>+      function parseParameterName() {
>+        let start = index;
>+        while (!dart.test(done())) {
>+          if (s[$_get](index) === " " || s[$_get](index) === "\t" || s[$_get](index) === "=" || s[$_get](index) == parameterSeparator || s[$_get](index) == valueSeparator) break;
>+          index++;
>+        }
>+        return s[$substring](start, index)[$toLowerCase]();
>+      }
>+      dart.fn(parseParameterName, VoidToString());
>+      function parseParameterValue() {
>+        if (!dart.test(done()) && s[$_get](index) === "\"") {
>+          let sb = new core.StringBuffer.new();
>+          index++;
>+          while (!dart.test(done())) {
>+            if (s[$_get](index) === "\\") {
>+              if (index + 1 === s.length) {
>+                dart.throw(new _http.HttpException.new("Failed to parse header value"));
>+              }
>+              if (dart.test(preserveBackslash) && s[$_get](index + 1) !== "\"") {
>+                sb.write(s[$_get](index));
>+              }
>+              index++;
>+            } else if (s[$_get](index) === "\"") {
>+              index++;
>+              break;
>+            }
>+            sb.write(s[$_get](index));
>+            index++;
>+          }
>+          return sb.toString();
>+        } else {
>+          let val = parseValue();
>+          return val === "" ? null : val;
>+        }
>+      }
>+      dart.fn(parseParameterValue, VoidToString());
>+      while (!dart.test(done())) {
>+        skipWS();
>+        if (dart.test(done())) return;
>+        let name = parseParameterName();
>+        skipWS();
>+        if (dart.test(done())) {
>+          parameters._set(name, null);
>+          return;
>+        }
>+        maybeExpect("=");
>+        skipWS();
>+        if (dart.test(done())) {
>+          parameters._set(name, null);
>+          return;
>+        }
>+        let value = parseParameterValue();
>+        if (name === "charset" && _http._ContentType.is(this) && value != null) {
>+          value = value[$toLowerCase]();
>+        }
>+        parameters._set(name, value);
>+        skipWS();
>+        if (dart.test(done())) return;
>+        if (s[$_get](index) == valueSeparator) return;
>+        expect(parameterSeparator);
>+      }
>+    };
>+    dart.fn(parseParameters, VoidTovoid());
>+    skipWS();
>+    this[_value$4] = parseValue();
>+    skipWS();
>+    if (dart.test(done())) return;
>+    maybeExpect(parameterSeparator);
>+    parseParameters();
>+  }
>+};
>+(_http._HeaderValue.new = function(value, parameters) {
>+  if (value === void 0) value = "";
>+  if (parameters === void 0) parameters = null;
>+  this[_parameters] = null;
>+  this[_unmodifiableParameters] = null;
>+  this[_value$4] = value;
>+  if (parameters != null) {
>+    this[_parameters] = HashMapOfString$String().from(parameters);
>+  }
>+}).prototype = _http._HeaderValue.prototype;
>+dart.addTypeTests(_http._HeaderValue);
>+_http._HeaderValue[dart.implements] = () => [_http.HeaderValue];
>+dart.setMethodSignature(_http._HeaderValue, () => ({
>+  __proto__: dart.getMethods(_http._HeaderValue.__proto__),
>+  [_ensureParameters]: dart.fnType(dart.void, []),
>+  [_parse]: dart.fnType(dart.void, [core.String, core.String, core.String, core.bool])
>+}));
>+dart.setGetterSignature(_http._HeaderValue, () => ({
>+  __proto__: dart.getGetters(_http._HeaderValue.__proto__),
>+  value: core.String,
>+  parameters: core.Map$(core.String, core.String)
>+}));
>+dart.setLibraryUri(_http._HeaderValue, "dart:_http");
>+dart.setFieldSignature(_http._HeaderValue, () => ({
>+  __proto__: dart.getFields(_http._HeaderValue.__proto__),
>+  [_value$4]: dart.fieldType(core.String),
>+  [_parameters]: dart.fieldType(MapOfString$String()),
>+  [_unmodifiableParameters]: dart.fieldType(MapOfString$String())
>+}));
>+dart.defineExtensionMethods(_http._HeaderValue, ['toString']);
>+const _primaryType = dart.privateName(_http, "_primaryType");
>+const _subType = dart.privateName(_http, "_subType");
>+_http._ContentType = class _ContentType extends _http._HeaderValue {
>+  static parse(value) {
>+    let result = new _http._ContentType.__();
>+    result[_parse](value, ";", null, false);
>+    let index = result[_value$4][$indexOf]("/");
>+    if (index === -1 || index === result[_value$4].length - 1) {
>+      result[_primaryType] = result[_value$4][$trim]()[$toLowerCase]();
>+      result[_subType] = "";
>+    } else {
>+      result[_primaryType] = result[_value$4][$substring](0, index)[$trim]()[$toLowerCase]();
>+      result[_subType] = result[_value$4][$substring](index + 1)[$trim]()[$toLowerCase]();
>+    }
>+    return result;
>+  }
>+  get mimeType() {
>+    return dart.str(this.primaryType) + "/" + dart.str(this.subType);
>+  }
>+  get primaryType() {
>+    return this[_primaryType];
>+  }
>+  get subType() {
>+    return this[_subType];
>+  }
>+  get charset() {
>+    return this.parameters[$_get]("charset");
>+  }
>+};
>+(_http._ContentType.new = function(primaryType, subType, charset, parameters) {
>+  this[_primaryType] = primaryType;
>+  this[_subType] = subType;
>+  _http._ContentType.__proto__.new.call(this, "");
>+  if (this[_primaryType] == null) this[_primaryType] = "";
>+  if (this[_subType] == null) this[_subType] = "";
>+  this[_value$4] = dart.str(this[_primaryType]) + "/" + dart.str(this[_subType]);
>+  if (parameters != null) {
>+    this[_ensureParameters]();
>+    parameters[$forEach](dart.fn((key, value) => {
>+      let lowerCaseKey = key[$toLowerCase]();
>+      if (lowerCaseKey === "charset") {
>+        value = value[$toLowerCase]();
>+      }
>+      this[_parameters][$_set](lowerCaseKey, value);
>+    }, StringAndStringToNull()));
>+  }
>+  if (charset != null) {
>+    this[_ensureParameters]();
>+    this[_parameters][$_set]("charset", charset[$toLowerCase]());
>+  }
>+}).prototype = _http._ContentType.prototype;
>+(_http._ContentType.__ = function() {
>+  this[_primaryType] = "";
>+  this[_subType] = "";
>+  _http._ContentType.__proto__.new.call(this);
>+}).prototype = _http._ContentType.prototype;
>+dart.addTypeTests(_http._ContentType);
>+_http._ContentType[dart.implements] = () => [_http.ContentType];
>+dart.setGetterSignature(_http._ContentType, () => ({
>+  __proto__: dart.getGetters(_http._ContentType.__proto__),
>+  mimeType: core.String,
>+  primaryType: core.String,
>+  subType: core.String,
>+  charset: core.String
>+}));
>+dart.setLibraryUri(_http._ContentType, "dart:_http");
>+dart.setFieldSignature(_http._ContentType, () => ({
>+  __proto__: dart.getFields(_http._ContentType.__proto__),
>+  [_primaryType]: dart.fieldType(core.String),
>+  [_subType]: dart.fieldType(core.String)
>+}));
>+const _validate = dart.privateName(_http, "_validate");
>+const _parseSetCookieValue = dart.privateName(_http, "_parseSetCookieValue");
>+let const$98;
>+_http._Cookie = class _Cookie extends core.Object {
>+  [_parseSetCookieValue](s) {
>+    let index = 0;
>+    function done() {
>+      return index === s.length;
>+    }
>+    dart.fn(done, VoidTobool());
>+    function parseName() {
>+      let start = index;
>+      while (!dart.test(done())) {
>+        if (s[$_get](index) === "=") break;
>+        index++;
>+      }
>+      return s[$substring](start, index)[$trim]();
>+    }
>+    dart.fn(parseName, VoidToString());
>+    function parseValue() {
>+      let start = index;
>+      while (!dart.test(done())) {
>+        if (s[$_get](index) === ";") break;
>+        index++;
>+      }
>+      return s[$substring](start, index)[$trim]();
>+    }
>+    dart.fn(parseValue, VoidToString());
>+    function expect(expected) {
>+      if (dart.test(done())) dart.throw(new _http.HttpException.new("Failed to parse header value [" + dart.str(s) + "]"));
>+      if (s[$_get](index) != expected) {
>+        dart.throw(new _http.HttpException.new("Failed to parse header value [" + dart.str(s) + "]"));
>+      }
>+      index++;
>+    }
>+    dart.fn(expect, StringTovoid());
>+    const parseAttributes = () => {
>+      function parseAttributeName() {
>+        let start = index;
>+        while (!dart.test(done())) {
>+          if (s[$_get](index) === "=" || s[$_get](index) === ";") break;
>+          index++;
>+        }
>+        return s[$substring](start, index)[$trim]()[$toLowerCase]();
>+      }
>+      dart.fn(parseAttributeName, VoidToString());
>+      function parseAttributeValue() {
>+        let start = index;
>+        while (!dart.test(done())) {
>+          if (s[$_get](index) === ";") break;
>+          index++;
>+        }
>+        return s[$substring](start, index)[$trim]()[$toLowerCase]();
>+      }
>+      dart.fn(parseAttributeValue, VoidToString());
>+      while (!dart.test(done())) {
>+        let name = parseAttributeName();
>+        let value = "";
>+        if (!dart.test(done()) && s[$_get](index) === "=") {
>+          index++;
>+          value = parseAttributeValue();
>+        }
>+        if (name === "expires") {
>+          this.expires = _http.HttpDate._parseCookieDate(value);
>+        } else if (name === "max-age") {
>+          this.maxAge = core.int.parse(value);
>+        } else if (name === "domain") {
>+          this.domain = value;
>+        } else if (name === "path") {
>+          this.path = value;
>+        } else if (name === "httponly") {
>+          this.httpOnly = true;
>+        } else if (name === "secure") {
>+          this.secure = true;
>+        }
>+        if (!dart.test(done())) index++;
>+      }
>+    };
>+    dart.fn(parseAttributes, VoidTovoid());
>+    this.name = parseName();
>+    if (dart.test(done()) || this.name.length === 0) {
>+      dart.throw(new _http.HttpException.new("Failed to parse header value [" + dart.str(s) + "]"));
>+    }
>+    index++;
>+    this.value = parseValue();
>+    this[_validate]();
>+    if (dart.test(done())) return;
>+    index++;
>+    parseAttributes();
>+  }
>+  toString() {
>+    let sb = new core.StringBuffer.new();
>+    sb.write(this.name);
>+    sb.write("=");
>+    sb.write(this.value);
>+    if (this.expires != null) {
>+      sb.write("; Expires=");
>+      sb.write(_http.HttpDate.format(this.expires));
>+    }
>+    if (this.maxAge != null) {
>+      sb.write("; Max-Age=");
>+      sb.write(this.maxAge);
>+    }
>+    if (this.domain != null) {
>+      sb.write("; Domain=");
>+      sb.write(this.domain);
>+    }
>+    if (this.path != null) {
>+      sb.write("; Path=");
>+      sb.write(this.path);
>+    }
>+    if (dart.test(this.secure)) sb.write("; Secure");
>+    if (dart.test(this.httpOnly)) sb.write("; HttpOnly");
>+    return sb.toString();
>+  }
>+  [_validate]() {
>+    let separators = const$98 || (const$98 = dart.constList(["(", ")", "<", ">", "@", ",", ";", ":", "\\", "\"", "/", "[", "]", "?", "=", "{", "}"], core.String));
>+    for (let i = 0; i < this.name.length; i++) {
>+      let codeUnit = this.name[$codeUnits][$_get](i);
>+      if (dart.notNull(codeUnit) <= 32 || dart.notNull(codeUnit) >= 127 || dart.notNull(separators[$indexOf](this.name[$_get](i))) >= 0) {
>+        dart.throw(new core.FormatException.new("Invalid character in cookie name, code unit: '" + dart.str(codeUnit) + "'", this.name, i));
>+      }
>+    }
>+    let start = 0;
>+    let end = this.value.length;
>+    if (2 <= this.value.length && this.value[$codeUnits][$_get](start) === 34 && this.value[$codeUnits][$_get](end - 1) === 34) {
>+      start++;
>+      end--;
>+    }
>+    for (let i = start; i < end; i++) {
>+      let codeUnit = this.value[$codeUnits][$_get](i);
>+      if (!(codeUnit === 33 || dart.notNull(codeUnit) >= 35 && dart.notNull(codeUnit) <= 43 || dart.notNull(codeUnit) >= 45 && dart.notNull(codeUnit) <= 58 || dart.notNull(codeUnit) >= 60 && dart.notNull(codeUnit) <= 91 || dart.notNull(codeUnit) >= 93 && dart.notNull(codeUnit) <= 126)) {
>+        dart.throw(new core.FormatException.new("Invalid character in cookie value, code unit: '" + dart.str(codeUnit) + "'", this.value, i));
>+      }
>+    }
>+  }
>+};
>+(_http._Cookie.new = function(name, value) {
>+  if (name === void 0) name = null;
>+  if (value === void 0) value = null;
>+  this.expires = null;
>+  this.maxAge = null;
>+  this.domain = null;
>+  this.path = null;
>+  this.httpOnly = false;
>+  this.secure = false;
>+  this.name = name;
>+  this.value = value;
>+  this.httpOnly = true;
>+  this[_validate]();
>+}).prototype = _http._Cookie.prototype;
>+(_http._Cookie.fromSetCookieValue = function(value) {
>+  this.name = null;
>+  this.value = null;
>+  this.expires = null;
>+  this.maxAge = null;
>+  this.domain = null;
>+  this.path = null;
>+  this.httpOnly = false;
>+  this.secure = false;
>+  this[_parseSetCookieValue](value);
>+}).prototype = _http._Cookie.prototype;
>+dart.addTypeTests(_http._Cookie);
>+_http._Cookie[dart.implements] = () => [_http.Cookie];
>+dart.setMethodSignature(_http._Cookie, () => ({
>+  __proto__: dart.getMethods(_http._Cookie.__proto__),
>+  [_parseSetCookieValue]: dart.fnType(dart.void, [core.String]),
>+  [_validate]: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(_http._Cookie, "dart:_http");
>+dart.setFieldSignature(_http._Cookie, () => ({
>+  __proto__: dart.getFields(_http._Cookie.__proto__),
>+  name: dart.fieldType(core.String),
>+  value: dart.fieldType(core.String),
>+  expires: dart.fieldType(core.DateTime),
>+  maxAge: dart.fieldType(core.int),
>+  domain: dart.fieldType(core.String),
>+  path: dart.fieldType(core.String),
>+  httpOnly: dart.fieldType(core.bool),
>+  secure: dart.fieldType(core.bool)
>+}));
>+dart.defineExtensionMethods(_http._Cookie, ['toString']);
>+dart.defineLazy(_http, {
>+  /*_http._nextServiceId*/get _nextServiceId() {
>+    return 1;
>+  },
>+  set _nextServiceId(_) {}
>+});
>+const __serviceId$ = dart.privateName(_http, "__serviceId");
>+const _serviceId$ = dart.privateName(_http, "_serviceId");
>+const _serviceTypePath$ = dart.privateName(_http, "_serviceTypePath");
>+const _servicePath$ = dart.privateName(_http, "_servicePath");
>+const _serviceTypeName$ = dart.privateName(_http, "_serviceTypeName");
>+const _serviceType$ = dart.privateName(_http, "_serviceType");
>+_http._ServiceObject = class _ServiceObject extends core.Object {
>+  get [_serviceId$]() {
>+    if (this[__serviceId$] === 0) {
>+      let x = _http._nextServiceId;
>+      _http._nextServiceId = dart.notNull(x) + 1;
>+      this[__serviceId$] = x;
>+    }
>+    return this[__serviceId$];
>+  }
>+  get [_servicePath$]() {
>+    return dart.str(this[_serviceTypePath$]) + "/" + dart.str(this[_serviceId$]);
>+  }
>+  [_serviceType$](ref) {
>+    if (dart.test(ref)) return "@" + dart.str(this[_serviceTypeName$]);
>+    return this[_serviceTypeName$];
>+  }
>+};
>+(_http._ServiceObject.new = function() {
>+  this[__serviceId$] = 0;
>+}).prototype = _http._ServiceObject.prototype;
>+dart.addTypeTests(_http._ServiceObject);
>+dart.setMethodSignature(_http._ServiceObject, () => ({
>+  __proto__: dart.getMethods(_http._ServiceObject.__proto__),
>+  [_serviceType$]: dart.fnType(core.String, [core.bool])
>+}));
>+dart.setGetterSignature(_http._ServiceObject, () => ({
>+  __proto__: dart.getGetters(_http._ServiceObject.__proto__),
>+  [_serviceId$]: core.int,
>+  [_servicePath$]: core.String
>+}));
>+dart.setLibraryUri(_http._ServiceObject, "dart:_http");
>+dart.setFieldSignature(_http._ServiceObject, () => ({
>+  __proto__: dart.getFields(_http._ServiceObject.__proto__),
>+  [__serviceId$]: dart.fieldType(core.int)
>+}));
>+const _buffer$1 = dart.privateName(_http, "_buffer");
>+const _length$3 = dart.privateName(_http, "_length");
>+const _grow$0 = dart.privateName(_http, "_grow");
>+_http._CopyingBytesBuilder = class _CopyingBytesBuilder extends core.Object {
>+  add(bytes) {
>+    let bytesLength = bytes[$length];
>+    if (bytesLength === 0) return;
>+    let required = dart.notNull(this[_length$3]) + dart.notNull(bytesLength);
>+    if (dart.notNull(this[_buffer$1][$length]) < required) {
>+      this[_grow$0](required);
>+    }
>+    if (!(dart.notNull(this[_buffer$1][$length]) >= required)) dart.assertFailed(null, "dart:_http/http_impl.dart", 52, 12, "_buffer.length >= required");
>+    if (typed_data.Uint8List.is(bytes)) {
>+      this[_buffer$1][$setRange](this[_length$3], required, bytes);
>+    } else {
>+      for (let i = 0; i < dart.notNull(bytesLength); i++) {
>+        this[_buffer$1][$_set](dart.notNull(this[_length$3]) + i, bytes[$_get](i));
>+      }
>+    }
>+    this[_length$3] = required;
>+  }
>+  addByte(byte) {
>+    if (this[_buffer$1][$length] == this[_length$3]) {
>+      this[_grow$0](this[_length$3]);
>+    }
>+    if (!(dart.notNull(this[_buffer$1][$length]) > dart.notNull(this[_length$3]))) dart.assertFailed(null, "dart:_http/http_impl.dart", 69, 12, "_buffer.length > _length");
>+    this[_buffer$1][$_set](this[_length$3], byte);
>+    this[_length$3] = dart.notNull(this[_length$3]) + 1;
>+  }
>+  [_grow$0](required) {
>+    let newSize = dart.notNull(required) * 2;
>+    if (dart.notNull(newSize) < 1024) {
>+      newSize = 1024;
>+    } else {
>+      newSize = _http._CopyingBytesBuilder._pow2roundup(newSize);
>+    }
>+    let newBuffer = typed_data.Uint8List.new(newSize);
>+    newBuffer[$setRange](0, this[_buffer$1][$length], this[_buffer$1]);
>+    this[_buffer$1] = newBuffer;
>+  }
>+  takeBytes() {
>+    if (this[_length$3] === 0) return _http._CopyingBytesBuilder._emptyList;
>+    let buffer = typed_data.Uint8List.view(this[_buffer$1][$buffer], 0, this[_length$3]);
>+    this.clear();
>+    return buffer;
>+  }
>+  toBytes() {
>+    if (this[_length$3] === 0) return _http._CopyingBytesBuilder._emptyList;
>+    return typed_data.Uint8List.fromList(typed_data.Uint8List.view(this[_buffer$1][$buffer], 0, this[_length$3]));
>+  }
>+  get length() {
>+    return this[_length$3];
>+  }
>+  get isEmpty() {
>+    return this[_length$3] === 0;
>+  }
>+  get isNotEmpty() {
>+    return this[_length$3] !== 0;
>+  }
>+  clear() {
>+    this[_length$3] = 0;
>+    this[_buffer$1] = _http._CopyingBytesBuilder._emptyList;
>+  }
>+  static _pow2roundup(x) {
>+    if (!(dart.notNull(x) > 0)) dart.assertFailed(null, "dart:_http/http_impl.dart", 113, 12, "x > 0");
>+    x = dart.notNull(x) - 1;
>+    x = (dart.notNull(x) | x[$rightShift](1)) >>> 0;
>+    x = (dart.notNull(x) | x[$rightShift](2)) >>> 0;
>+    x = (dart.notNull(x) | x[$rightShift](4)) >>> 0;
>+    x = (dart.notNull(x) | x[$rightShift](8)) >>> 0;
>+    x = (dart.notNull(x) | x[$rightShift](16)) >>> 0;
>+    return dart.notNull(x) + 1;
>+  }
>+};
>+(_http._CopyingBytesBuilder.new = function(initialCapacity) {
>+  if (initialCapacity === void 0) initialCapacity = 0;
>+  this[_length$3] = 0;
>+  this[_buffer$1] = dart.notNull(initialCapacity) <= 0 ? _http._CopyingBytesBuilder._emptyList : typed_data.Uint8List.new(_http._CopyingBytesBuilder._pow2roundup(initialCapacity));
>+}).prototype = _http._CopyingBytesBuilder.prototype;
>+dart.addTypeTests(_http._CopyingBytesBuilder);
>+_http._CopyingBytesBuilder[dart.implements] = () => [io.BytesBuilder];
>+dart.setMethodSignature(_http._CopyingBytesBuilder, () => ({
>+  __proto__: dart.getMethods(_http._CopyingBytesBuilder.__proto__),
>+  add: dart.fnType(dart.void, [core.List$(core.int)]),
>+  addByte: dart.fnType(dart.void, [core.int]),
>+  [_grow$0]: dart.fnType(dart.void, [core.int]),
>+  takeBytes: dart.fnType(core.List$(core.int), []),
>+  toBytes: dart.fnType(core.List$(core.int), []),
>+  clear: dart.fnType(dart.void, [])
>+}));
>+dart.setGetterSignature(_http._CopyingBytesBuilder, () => ({
>+  __proto__: dart.getGetters(_http._CopyingBytesBuilder.__proto__),
>+  length: core.int,
>+  isEmpty: core.bool,
>+  isNotEmpty: core.bool
>+}));
>+dart.setLibraryUri(_http._CopyingBytesBuilder, "dart:_http");
>+dart.setFieldSignature(_http._CopyingBytesBuilder, () => ({
>+  __proto__: dart.getFields(_http._CopyingBytesBuilder.__proto__),
>+  [_length$3]: dart.fieldType(core.int),
>+  [_buffer$1]: dart.fieldType(typed_data.Uint8List)
>+}));
>+dart.defineLazy(_http._CopyingBytesBuilder, {
>+  /*_http._CopyingBytesBuilder._INIT_SIZE*/get _INIT_SIZE() {
>+    return 1024;
>+  },
>+  /*_http._CopyingBytesBuilder._emptyList*/get _emptyList() {
>+    return typed_data.Uint8List.new(0);
>+  }
>+});
>+dart.defineLazy(_http, {
>+  /*_http._OUTGOING_BUFFER_SIZE*/get _OUTGOING_BUFFER_SIZE() {
>+    return 8 * 1024;
>+  }
>+});
>+const _transferLength = dart.privateName(_http, "_transferLength");
>+const _stream$1 = dart.privateName(_http, "_stream");
>+const _dataCompleter = dart.privateName(_http, "_dataCompleter");
>+_http._HttpIncoming = class _HttpIncoming extends async.Stream$(core.List$(core.int)) {
>+  get transferLength() {
>+    return this[_transferLength];
>+  }
>+  listen(onData, opts) {
>+    let onError = opts && 'onError' in opts ? opts.onError : null;
>+    let onDone = opts && 'onDone' in opts ? opts.onDone : null;
>+    let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
>+    this.hasSubscriber = true;
>+    return this[_stream$1].handleError(dart.fn(error => {
>+      dart.throw(new _http.HttpException.new(core.String._check(dart.dload(error, 'message')), {uri: this.uri}));
>+    }, dynamicToNull())).listen(onData, {onError: onError, onDone: onDone, cancelOnError: cancelOnError});
>+  }
>+  get dataDone() {
>+    return this[_dataCompleter].future;
>+  }
>+  close(closing) {
>+    this.fullBodyRead = true;
>+    this.hasSubscriber = true;
>+    this[_dataCompleter].complete(closing);
>+  }
>+};
>+(_http._HttpIncoming.new = function(headers, transferLength, stream) {
>+  this[_dataCompleter] = async.Completer.new();
>+  this.fullBodyRead = false;
>+  this.upgraded = false;
>+  this.statusCode = null;
>+  this.reasonPhrase = null;
>+  this.method = null;
>+  this.uri = null;
>+  this.hasSubscriber = false;
>+  this.headers = headers;
>+  this[_transferLength] = transferLength;
>+  this[_stream$1] = stream;
>+  _http._HttpIncoming.__proto__.new.call(this);
>+}).prototype = _http._HttpIncoming.prototype;
>+dart.addTypeTests(_http._HttpIncoming);
>+dart.setMethodSignature(_http._HttpIncoming, () => ({
>+  __proto__: dart.getMethods(_http._HttpIncoming.__proto__),
>+  listen: dart.fnType(async.StreamSubscription$(core.List$(core.int)), [dart.fnType(dart.void, [core.List$(core.int)])], {onError: core.Function, onDone: dart.fnType(dart.void, []), cancelOnError: core.bool}),
>+  close: dart.fnType(dart.void, [core.bool])
>+}));
>+dart.setGetterSignature(_http._HttpIncoming, () => ({
>+  __proto__: dart.getGetters(_http._HttpIncoming.__proto__),
>+  transferLength: core.int,
>+  dataDone: async.Future
>+}));
>+dart.setLibraryUri(_http._HttpIncoming, "dart:_http");
>+dart.setFieldSignature(_http._HttpIncoming, () => ({
>+  __proto__: dart.getFields(_http._HttpIncoming.__proto__),
>+  [_transferLength]: dart.finalFieldType(core.int),
>+  [_dataCompleter]: dart.finalFieldType(async.Completer),
>+  [_stream$1]: dart.fieldType(StreamOfListOfint()),
>+  fullBodyRead: dart.fieldType(core.bool),
>+  headers: dart.finalFieldType(_http._HttpHeaders),
>+  upgraded: dart.fieldType(core.bool),
>+  statusCode: dart.fieldType(core.int),
>+  reasonPhrase: dart.fieldType(core.String),
>+  method: dart.fieldType(core.String),
>+  uri: dart.fieldType(core.Uri),
>+  hasSubscriber: dart.fieldType(core.bool)
>+}));
>+const _incoming = dart.privateName(_http, "_incoming");
>+const _cookies = dart.privateName(_http, "_cookies");
>+_http._HttpInboundMessage = class _HttpInboundMessage extends async.Stream$(core.List$(core.int)) {
>+  get cookies() {
>+    if (this[_cookies] != null) return this[_cookies];
>+    return this[_cookies] = this.headers[_parseCookies]();
>+  }
>+  get headers() {
>+    return this[_incoming].headers;
>+  }
>+  get protocolVersion() {
>+    return this.headers.protocolVersion;
>+  }
>+  get contentLength() {
>+    return this.headers.contentLength;
>+  }
>+  get persistentConnection() {
>+    return this.headers.persistentConnection;
>+  }
>+};
>+(_http._HttpInboundMessage.new = function(incoming) {
>+  this[_cookies] = null;
>+  this[_incoming] = incoming;
>+  _http._HttpInboundMessage.__proto__.new.call(this);
>+}).prototype = _http._HttpInboundMessage.prototype;
>+dart.addTypeTests(_http._HttpInboundMessage);
>+dart.setGetterSignature(_http._HttpInboundMessage, () => ({
>+  __proto__: dart.getGetters(_http._HttpInboundMessage.__proto__),
>+  cookies: core.List$(_http.Cookie),
>+  headers: _http._HttpHeaders,
>+  protocolVersion: core.String,
>+  contentLength: core.int,
>+  persistentConnection: core.bool
>+}));
>+dart.setLibraryUri(_http._HttpInboundMessage, "dart:_http");
>+dart.setFieldSignature(_http._HttpInboundMessage, () => ({
>+  __proto__: dart.getFields(_http._HttpInboundMessage.__proto__),
>+  [_incoming]: dart.finalFieldType(_http._HttpIncoming),
>+  [_cookies]: dart.fieldType(ListOfCookie())
>+}));
>+const _httpServer = dart.privateName(_http, "_httpServer");
>+const _httpConnection = dart.privateName(_http, "_httpConnection");
>+const _session = dart.privateName(_http, "_session");
>+const _requestedUri = dart.privateName(_http, "_requestedUri");
>+const _sessionManagerInstance = dart.privateName(_http, "_sessionManagerInstance");
>+const _sessionManager = dart.privateName(_http, "_sessionManager");
>+const _markSeen = dart.privateName(_http, "_markSeen");
>+const _socket$ = dart.privateName(_http, "_socket");
>+const _destroyed = dart.privateName(_http, "_destroyed");
>+_http._HttpRequest = class _HttpRequest extends _http._HttpInboundMessage {
>+  listen(onData, opts) {
>+    let onError = opts && 'onError' in opts ? opts.onError : null;
>+    let onDone = opts && 'onDone' in opts ? opts.onDone : null;
>+    let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
>+    return this[_incoming].listen(onData, {onError: onError, onDone: onDone, cancelOnError: cancelOnError});
>+  }
>+  get uri() {
>+    return this[_incoming].uri;
>+  }
>+  get requestedUri() {
>+    if (this[_requestedUri] == null) {
>+      let proto = this.headers._get("x-forwarded-proto");
>+      let scheme = proto != null ? proto[$first] : io.SecureSocket.is(this[_httpConnection][_socket$]) ? "https" : "http";
>+      let hostList = this.headers._get("x-forwarded-host");
>+      let host = null;
>+      if (hostList != null) {
>+        host = hostList[$first];
>+      } else {
>+        hostList = this.headers._get("host");
>+        if (hostList != null) {
>+          host = hostList[$first];
>+        } else {
>+          host = dart.str(this[_httpServer].address.host) + ":" + dart.str(this[_httpServer].port);
>+        }
>+      }
>+      this[_requestedUri] = core.Uri.parse(dart.str(scheme) + "://" + dart.str(host) + dart.str(this.uri));
>+    }
>+    return this[_requestedUri];
>+  }
>+  get method() {
>+    return this[_incoming].method;
>+  }
>+  get session() {
>+    if (this[_session] != null) {
>+      if (dart.test(this[_session][_destroyed])) {
>+        this[_session] = null;
>+        return this.session;
>+      }
>+      return this[_session];
>+    }
>+    return this[_session] = this[_httpServer][_sessionManager].createSession();
>+  }
>+  get connectionInfo() {
>+    return this[_httpConnection].connectionInfo;
>+  }
>+  get certificate() {
>+    let socket = this[_httpConnection][_socket$];
>+    if (io.SecureSocket.is(socket)) return socket.peerCertificate;
>+    return null;
>+  }
>+};
>+(_http._HttpRequest.new = function(response, _incoming, httpServer, httpConnection) {
>+  this[_session] = null;
>+  this[_requestedUri] = null;
>+  this.response = response;
>+  this[_httpServer] = httpServer;
>+  this[_httpConnection] = httpConnection;
>+  _http._HttpRequest.__proto__.new.call(this, _incoming);
>+  if (this.headers.protocolVersion === "1.1") {
>+    let _ = this.response.headers;
>+    _.chunkedTransferEncoding = true;
>+    _.persistentConnection = this.headers.persistentConnection;
>+  }
>+  if (this[_httpServer][_sessionManagerInstance] != null) {
>+    let sessionIds = IterableOfString()._check(this.cookies[$where](dart.fn(cookie => cookie.name[$toUpperCase]() === "DARTSESSID", CookieTobool()))[$map](core.String, dart.fn(cookie => cookie.value, CookieToString())));
>+    for (let sessionId of sessionIds) {
>+      this[_session] = this[_httpServer][_sessionManager].getSession(sessionId);
>+      if (this[_session] != null) {
>+        this[_session][_markSeen]();
>+        break;
>+      }
>+    }
>+  }
>+}).prototype = _http._HttpRequest.prototype;
>+dart.addTypeTests(_http._HttpRequest);
>+_http._HttpRequest[dart.implements] = () => [_http.HttpRequest];
>+dart.setMethodSignature(_http._HttpRequest, () => ({
>+  __proto__: dart.getMethods(_http._HttpRequest.__proto__),
>+  listen: dart.fnType(async.StreamSubscription$(core.List$(core.int)), [dart.fnType(dart.void, [core.List$(core.int)])], {onError: core.Function, onDone: dart.fnType(dart.void, []), cancelOnError: core.bool})
>+}));
>+dart.setGetterSignature(_http._HttpRequest, () => ({
>+  __proto__: dart.getGetters(_http._HttpRequest.__proto__),
>+  uri: core.Uri,
>+  requestedUri: core.Uri,
>+  method: core.String,
>+  session: _http.HttpSession,
>+  connectionInfo: _http.HttpConnectionInfo,
>+  certificate: io.X509Certificate
>+}));
>+dart.setLibraryUri(_http._HttpRequest, "dart:_http");
>+dart.setFieldSignature(_http._HttpRequest, () => ({
>+  __proto__: dart.getFields(_http._HttpRequest.__proto__),
>+  response: dart.finalFieldType(_http.HttpResponse),
>+  [_httpServer]: dart.finalFieldType(_http._HttpServer),
>+  [_httpConnection]: dart.finalFieldType(_http._HttpConnection),
>+  [_session]: dart.fieldType(_http._HttpSession),
>+  [_requestedUri]: dart.fieldType(core.Uri)
>+}));
>+const _httpRequest = dart.privateName(_http, "_httpRequest");
>+const _httpClient = dart.privateName(_http, "_httpClient");
>+const _responseRedirects = dart.privateName(_http, "_responseRedirects");
>+const _httpClientConnection = dart.privateName(_http, "_httpClientConnection");
>+const _openUrlFromRequest = dart.privateName(_http, "_openUrlFromRequest");
>+const _connectionClosed = dart.privateName(_http, "_connectionClosed");
>+const _shouldAuthenticateProxy = dart.privateName(_http, "_shouldAuthenticateProxy");
>+const _shouldAuthenticate = dart.privateName(_http, "_shouldAuthenticate");
>+const _proxy = dart.privateName(_http, "_proxy");
>+const _findProxyCredentials = dart.privateName(_http, "_findProxyCredentials");
>+const _findCredentials = dart.privateName(_http, "_findCredentials");
>+const _removeProxyCredentials = dart.privateName(_http, "_removeProxyCredentials");
>+const _removeCredentials = dart.privateName(_http, "_removeCredentials");
>+const _authenticateProxy = dart.privateName(_http, "_authenticateProxy");
>+const _authenticate = dart.privateName(_http, "_authenticate");
>+_http._HttpClientResponse = class _HttpClientResponse extends _http._HttpInboundMessage {
>+  get redirects() {
>+    return this[_httpRequest][_responseRedirects];
>+  }
>+  static _getCompressionState(httpClient, headers) {
>+    if (headers.value(_http.HttpHeaders.contentEncodingHeader) === "gzip") {
>+      return dart.test(httpClient.autoUncompress) ? _http.HttpClientResponseCompressionState.decompressed : _http.HttpClientResponseCompressionState.compressed;
>+    } else {
>+      return _http.HttpClientResponseCompressionState.notCompressed;
>+    }
>+  }
>+  get statusCode() {
>+    return this[_incoming].statusCode;
>+  }
>+  get reasonPhrase() {
>+    return this[_incoming].reasonPhrase;
>+  }
>+  get certificate() {
>+    let socket = this[_httpRequest][_httpClientConnection][_socket$];
>+    if (io.SecureSocket.is(socket)) return socket.peerCertificate;
>+    return null;
>+  }
>+  get cookies() {
>+    if (this[_cookies] != null) return this[_cookies];
>+    this[_cookies] = JSArrayOfCookie().of([]);
>+    let values = this.headers._get(_http.HttpHeaders.setCookieHeader);
>+    if (values != null) {
>+      values[$forEach](dart.fn(value => {
>+        this[_cookies][$add](_http.Cookie.fromSetCookieValue(value));
>+      }, StringToNull()));
>+    }
>+    return this[_cookies];
>+  }
>+  get isRedirect() {
>+    if (this[_httpRequest].method === "GET" || this[_httpRequest].method === "HEAD") {
>+      return this.statusCode === _internal.HttpStatus.movedPermanently || this.statusCode === _internal.HttpStatus.found || this.statusCode === _internal.HttpStatus.seeOther || this.statusCode === _internal.HttpStatus.temporaryRedirect;
>+    } else if (this[_httpRequest].method === "POST") {
>+      return this.statusCode === _internal.HttpStatus.seeOther;
>+    }
>+    return false;
>+  }
>+  redirect(method, url, followLoops) {
>+    if (method === void 0) method = null;
>+    if (url === void 0) url = null;
>+    if (followLoops === void 0) followLoops = null;
>+    if (method == null) {
>+      if (this.statusCode === _internal.HttpStatus.seeOther && this[_httpRequest].method === "POST") {
>+        method = "GET";
>+      } else {
>+        method = this[_httpRequest].method;
>+      }
>+    }
>+    if (url == null) {
>+      let location = this.headers.value(_http.HttpHeaders.locationHeader);
>+      if (location == null) {
>+        dart.throw(new core.StateError.new("Response has no Location header for redirect"));
>+      }
>+      url = core.Uri.parse(location);
>+    }
>+    if (followLoops !== true) {
>+      for (let redirect of this.redirects) {
>+        if (dart.equals(redirect.location, url)) {
>+          return FutureOfHttpClientResponse().error(new _http.RedirectException.new("Redirect loop detected", this.redirects));
>+        }
>+      }
>+    }
>+    return FutureOfHttpClientResponse()._check(this[_httpClient][_openUrlFromRequest](method, url, this[_httpRequest]).then(_http.HttpClientResponse, dart.fn(request => {
>+      let _ = request[_responseRedirects];
>+      _[$addAll](this.redirects);
>+      _[$add](new _http._RedirectInfo.new(this.statusCode, method, url));
>+      return request.close();
>+    }, _HttpClientRequestToFutureOfHttpClientResponse())));
>+  }
>+  listen(onData, opts) {
>+    let onError = opts && 'onError' in opts ? opts.onError : null;
>+    let onDone = opts && 'onDone' in opts ? opts.onDone : null;
>+    let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
>+    if (dart.test(this[_incoming].upgraded)) {
>+      this[_httpRequest][_httpClientConnection].destroy();
>+      return StreamOfListOfint().empty().listen(null, {onDone: onDone});
>+    }
>+    let stream = this[_incoming];
>+    if (this.compressionState === _http.HttpClientResponseCompressionState.decompressed) {
>+      stream = StreamOfListOfint()._check(stream.transform(ListOfint(), io.gzip.decoder));
>+    }
>+    return stream.listen(onData, {onError: onError, onDone: onDone, cancelOnError: cancelOnError});
>+  }
>+  detachSocket() {
>+    this[_httpClient][_connectionClosed](this[_httpRequest][_httpClientConnection]);
>+    return this[_httpRequest][_httpClientConnection].detachSocket();
>+  }
>+  get connectionInfo() {
>+    return this[_httpRequest].connectionInfo;
>+  }
>+  get [_shouldAuthenticateProxy]() {
>+    let challenge = this.headers._get(_http.HttpHeaders.proxyAuthenticateHeader);
>+    return this.statusCode === _internal.HttpStatus.proxyAuthenticationRequired && challenge != null && challenge[$length] === 1;
>+  }
>+  get [_shouldAuthenticate]() {
>+    let challenge = this.headers._get(_http.HttpHeaders.wwwAuthenticateHeader);
>+    return this.statusCode === _internal.HttpStatus.unauthorized && challenge != null && challenge[$length] === 1;
>+  }
>+  [_authenticate](proxyAuth) {
>+    const retry = () => {
>+      return FutureOfHttpClientResponse()._check(this.drain(dart.dynamic).then(_http.HttpClientResponse, dart.fn(_ => FutureOfHttpClientResponse()._check(this[_httpClient][_openUrlFromRequest](this[_httpRequest].method, this[_httpRequest].uri, this[_httpRequest]).then(_http.HttpClientResponse, dart.fn(request => request.close(), _HttpClientRequestToFutureOfHttpClientResponse()))), dynamicToFutureOfHttpClientResponse())));
>+    };
>+    dart.fn(retry, VoidToFutureOfHttpClientResponse());
>+    const authChallenge = () => {
>+      return dart.test(proxyAuth) ? this.headers._get(_http.HttpHeaders.proxyAuthenticateHeader) : this.headers._get(_http.HttpHeaders.wwwAuthenticateHeader);
>+    };
>+    dart.fn(authChallenge, VoidToListOfString());
>+    const findCredentials = scheme => {
>+      return dart.test(proxyAuth) ? this[_httpClient][_findProxyCredentials](this[_httpRequest][_proxy], scheme) : this[_httpClient][_findCredentials](this[_httpRequest].uri, scheme);
>+    };
>+    dart.fn(findCredentials, _AuthenticationSchemeTo_Credentials());
>+    const removeCredentials = cr => {
>+      if (dart.test(proxyAuth)) {
>+        this[_httpClient][_removeProxyCredentials](cr);
>+      } else {
>+        this[_httpClient][_removeCredentials](cr);
>+      }
>+    };
>+    dart.fn(removeCredentials, _CredentialsTovoid());
>+    const requestAuthentication = (scheme, realm) => {
>+      if (dart.test(proxyAuth)) {
>+        if (this[_httpClient][_authenticateProxy] == null) {
>+          return async.Future.value(false);
>+        }
>+        let proxy = this[_httpRequest][_proxy];
>+        return async.Future._check(dart.dsend(this[_httpClient], _authenticateProxy, [proxy.host, proxy.port, dart.toString(scheme), realm]));
>+      } else {
>+        if (this[_httpClient][_authenticate] == null) {
>+          return async.Future.value(false);
>+        }
>+        return async.Future._check(dart.dsend(this[_httpClient], _authenticate, [this[_httpRequest].uri, dart.toString(scheme), realm]));
>+      }
>+    };
>+    dart.fn(requestAuthentication, _AuthenticationSchemeAndStringToFuture());
>+    let challenge = authChallenge();
>+    if (!(challenge != null || challenge[$length] === 1)) dart.assertFailed(null, "dart:_http/http_impl.dart", 474, 12, "challenge != null || challenge.length == 1");
>+    let header = _http._HeaderValue.parse(challenge[$_get](0), {parameterSeparator: ","});
>+    let scheme = _http._AuthenticationScheme.fromString(header.value);
>+    let realm = header.parameters[$_get]("realm");
>+    let cr = findCredentials(scheme);
>+    if (cr != null) {
>+      if (dart.equals(cr.scheme, _http._AuthenticationScheme.BASIC) && !dart.test(cr.used)) {
>+        return retry();
>+      }
>+      if (dart.equals(cr.scheme, _http._AuthenticationScheme.DIGEST) && (header.parameters[$_get]("algorithm") == null || header.parameters[$_get]("algorithm")[$toLowerCase]() === "md5")) {
>+        if (cr.nonce == null || cr.nonce == header.parameters[$_get]("nonce")) {
>+          if (cr.nonce == null) {
>+            let _ = cr;
>+            _.nonce = header.parameters[$_get]("nonce");
>+            _.algorithm = "MD5";
>+            _.qop = header.parameters[$_get]("qop");
>+            _.nonceCount = 0;
>+          }
>+          return retry();
>+        } else if (header.parameters[$_get]("stale") != null && header.parameters[$_get]("stale")[$toLowerCase]() === "true") {
>+          cr.nonce = header.parameters[$_get]("nonce");
>+          return retry();
>+        }
>+      }
>+    }
>+    if (cr != null) {
>+      removeCredentials(cr);
>+      cr = null;
>+    }
>+    return FutureOfHttpClientResponse()._check(requestAuthentication(scheme, realm).then(_http.HttpClientResponse, dart.fn(credsAvailable => {
>+      if (dart.dtest(credsAvailable)) {
>+        cr = this[_httpClient][_findCredentials](this[_httpRequest].uri, scheme);
>+        return retry();
>+      } else {
>+        return this;
>+      }
>+    }, dynamicToFutureOrOfHttpClientResponse())));
>+  }
>+};
>+(_http._HttpClientResponse.new = function(_incoming, httpRequest, httpClient) {
>+  this[_httpRequest] = httpRequest;
>+  this[_httpClient] = httpClient;
>+  this.compressionState = _http._HttpClientResponse._getCompressionState(httpClient, _incoming.headers);
>+  _http._HttpClientResponse.__proto__.new.call(this, _incoming);
>+  _incoming.uri = this[_httpRequest].uri;
>+}).prototype = _http._HttpClientResponse.prototype;
>+dart.addTypeTests(_http._HttpClientResponse);
>+_http._HttpClientResponse[dart.implements] = () => [_http.HttpClientResponse];
>+dart.setMethodSignature(_http._HttpClientResponse, () => ({
>+  __proto__: dart.getMethods(_http._HttpClientResponse.__proto__),
>+  redirect: dart.fnType(async.Future$(_http.HttpClientResponse), [], [core.String, core.Uri, core.bool]),
>+  listen: dart.fnType(async.StreamSubscription$(core.List$(core.int)), [dart.fnType(dart.void, [core.List$(core.int)])], {onError: core.Function, onDone: dart.fnType(dart.void, []), cancelOnError: core.bool}),
>+  detachSocket: dart.fnType(async.Future$(io.Socket), []),
>+  [_authenticate]: dart.fnType(async.Future$(_http.HttpClientResponse), [core.bool])
>+}));
>+dart.setGetterSignature(_http._HttpClientResponse, () => ({
>+  __proto__: dart.getGetters(_http._HttpClientResponse.__proto__),
>+  redirects: core.List$(_http.RedirectInfo),
>+  statusCode: core.int,
>+  reasonPhrase: core.String,
>+  certificate: io.X509Certificate,
>+  isRedirect: core.bool,
>+  connectionInfo: _http.HttpConnectionInfo,
>+  [_shouldAuthenticateProxy]: core.bool,
>+  [_shouldAuthenticate]: core.bool
>+}));
>+dart.setLibraryUri(_http._HttpClientResponse, "dart:_http");
>+dart.setFieldSignature(_http._HttpClientResponse, () => ({
>+  __proto__: dart.getFields(_http._HttpClientResponse.__proto__),
>+  [_httpClient]: dart.finalFieldType(_http._HttpClient),
>+  [_httpRequest]: dart.finalFieldType(_http._HttpClientRequest),
>+  compressionState: dart.finalFieldType(_http.HttpClientResponseCompressionState)
>+}));
>+const _target$1 = dart.privateName(_http, "_target");
>+const _doneCompleter$ = dart.privateName(_http, "_doneCompleter");
>+const _controllerInstance$ = dart.privateName(_http, "_controllerInstance");
>+const _controllerCompleter$ = dart.privateName(_http, "_controllerCompleter");
>+const _isClosed$0 = dart.privateName(_http, "_isClosed");
>+const _isBound$ = dart.privateName(_http, "_isBound");
>+const _hasError$0 = dart.privateName(_http, "_hasError");
>+const _controller$1 = dart.privateName(_http, "_controller");
>+const _closeTarget$ = dart.privateName(_http, "_closeTarget");
>+const _completeDoneValue$ = dart.privateName(_http, "_completeDoneValue");
>+const _completeDoneError$ = dart.privateName(_http, "_completeDoneError");
>+const _is__StreamSinkImpl_default$ = Symbol('_is__StreamSinkImpl_default');
>+_http._StreamSinkImpl$ = dart.generic(T => {
>+  let StreamOfT = () => (StreamOfT = dart.constFn(async.Stream$(T)))();
>+  let StreamControllerOfT = () => (StreamControllerOfT = dart.constFn(async.StreamController$(T)))();
>+  let StreamSinkOfT = () => (StreamSinkOfT = dart.constFn(async.StreamSink$(T)))();
>+  let StreamConsumerOfT = () => (StreamConsumerOfT = dart.constFn(async.StreamConsumer$(T)))();
>+  class _StreamSinkImpl extends core.Object {
>+    add(data) {
>+      T._check(data);
>+      if (dart.test(this[_isClosed$0])) {
>+        dart.throw(new core.StateError.new("StreamSink is closed"));
>+      }
>+      this[_controller$1].add(data);
>+    }
>+    addError(error, stackTrace) {
>+      if (stackTrace === void 0) stackTrace = null;
>+      if (dart.test(this[_isClosed$0])) {
>+        dart.throw(new core.StateError.new("StreamSink is closed"));
>+      }
>+      this[_controller$1].addError(error, stackTrace);
>+    }
>+    addStream(stream) {
>+      StreamOfT()._check(stream);
>+      if (dart.test(this[_isBound$])) {
>+        dart.throw(new core.StateError.new("StreamSink is already bound to a stream"));
>+      }
>+      this[_isBound$] = true;
>+      if (dart.test(this[_hasError$0])) return this.done;
>+      const targetAddStream = () => {
>+        return this[_target$1].addStream(stream).whenComplete(dart.fn(() => {
>+          this[_isBound$] = false;
>+        }, VoidToNull()));
>+      };
>+      dart.fn(targetAddStream, VoidToFuture());
>+      if (this[_controllerInstance$] == null) return targetAddStream();
>+      let future = this[_controllerCompleter$].future;
>+      this[_controllerInstance$].close();
>+      return future.then(dart.dynamic, dart.fn(_ => targetAddStream(), dynamicToFuture()));
>+    }
>+    flush() {
>+      if (dart.test(this[_isBound$])) {
>+        dart.throw(new core.StateError.new("StreamSink is bound to a stream"));
>+      }
>+      if (this[_controllerInstance$] == null) return async.Future.value(this);
>+      this[_isBound$] = true;
>+      let future = this[_controllerCompleter$].future;
>+      this[_controllerInstance$].close();
>+      return future.whenComplete(dart.fn(() => {
>+        this[_isBound$] = false;
>+      }, VoidToNull()));
>+    }
>+    close() {
>+      if (dart.test(this[_isBound$])) {
>+        dart.throw(new core.StateError.new("StreamSink is bound to a stream"));
>+      }
>+      if (!dart.test(this[_isClosed$0])) {
>+        this[_isClosed$0] = true;
>+        if (this[_controllerInstance$] != null) {
>+          this[_controllerInstance$].close();
>+        } else {
>+          this[_closeTarget$]();
>+        }
>+      }
>+      return this.done;
>+    }
>+    [_closeTarget$]() {
>+      this[_target$1].close().then(dart.void, dart.bind(this, _completeDoneValue$), {onError: dart.bind(this, _completeDoneError$)});
>+    }
>+    get done() {
>+      return this[_doneCompleter$].future;
>+    }
>+    [_completeDoneValue$](value) {
>+      if (!dart.test(this[_doneCompleter$].isCompleted)) {
>+        this[_doneCompleter$].complete(value);
>+      }
>+    }
>+    [_completeDoneError$](error, stackTrace) {
>+      if (!dart.test(this[_doneCompleter$].isCompleted)) {
>+        this[_hasError$0] = true;
>+        this[_doneCompleter$].completeError(error, stackTrace);
>+      }
>+    }
>+    get [_controller$1]() {
>+      if (dart.test(this[_isBound$])) {
>+        dart.throw(new core.StateError.new("StreamSink is bound to a stream"));
>+      }
>+      if (dart.test(this[_isClosed$0])) {
>+        dart.throw(new core.StateError.new("StreamSink is closed"));
>+      }
>+      if (this[_controllerInstance$] == null) {
>+        this[_controllerInstance$] = StreamControllerOfT().new({sync: true});
>+        this[_controllerCompleter$] = async.Completer.new();
>+        FutureOfNull()._check(this[_target$1].addStream(this[_controller$1].stream).then(core.Null, dart.fn(_ => {
>+          if (dart.test(this[_isBound$])) {
>+            this[_controllerCompleter$].complete(this);
>+            this[_controllerCompleter$] = null;
>+            this[_controllerInstance$] = null;
>+          } else {
>+            this[_closeTarget$]();
>+          }
>+        }, dynamicToNull()), {onError: dart.fn((error, stackTrace) => {
>+            if (dart.test(this[_isBound$])) {
>+              this[_controllerCompleter$].completeError(error, core.StackTrace._check(stackTrace));
>+              this[_controllerCompleter$] = null;
>+              this[_controllerInstance$] = null;
>+            } else {
>+              this[_completeDoneError$](error, core.StackTrace._check(stackTrace));
>+            }
>+          }, dynamicAnddynamicToNull())}));
>+      }
>+      return this[_controllerInstance$];
>+    }
>+  }
>+  (_StreamSinkImpl.new = function(target) {
>+    this[_doneCompleter$] = async.Completer.new();
>+    this[_controllerInstance$] = null;
>+    this[_controllerCompleter$] = null;
>+    this[_isClosed$0] = false;
>+    this[_isBound$] = false;
>+    this[_hasError$0] = false;
>+    this[_target$1] = target;
>+  }).prototype = _StreamSinkImpl.prototype;
>+  dart.addTypeTests(_StreamSinkImpl);
>+  _StreamSinkImpl.prototype[_is__StreamSinkImpl_default$] = true;
>+  _StreamSinkImpl[dart.implements] = () => [StreamSinkOfT()];
>+  dart.setMethodSignature(_StreamSinkImpl, () => ({
>+    __proto__: dart.getMethods(_StreamSinkImpl.__proto__),
>+    add: dart.fnType(dart.void, [core.Object]),
>+    addError: dart.fnType(dart.void, [core.Object], [core.StackTrace]),
>+    addStream: dart.fnType(async.Future, [core.Object]),
>+    flush: dart.fnType(async.Future, []),
>+    close: dart.fnType(async.Future, []),
>+    [_closeTarget$]: dart.fnType(dart.void, []),
>+    [_completeDoneValue$]: dart.fnType(dart.void, [dart.dynamic]),
>+    [_completeDoneError$]: dart.fnType(dart.void, [dart.dynamic, core.StackTrace])
>+  }));
>+  dart.setGetterSignature(_StreamSinkImpl, () => ({
>+    __proto__: dart.getGetters(_StreamSinkImpl.__proto__),
>+    done: async.Future,
>+    [_controller$1]: async.StreamController$(T)
>+  }));
>+  dart.setLibraryUri(_StreamSinkImpl, "dart:_http");
>+  dart.setFieldSignature(_StreamSinkImpl, () => ({
>+    __proto__: dart.getFields(_StreamSinkImpl.__proto__),
>+    [_target$1]: dart.finalFieldType(StreamConsumerOfT()),
>+    [_doneCompleter$]: dart.finalFieldType(async.Completer),
>+    [_controllerInstance$]: dart.fieldType(StreamControllerOfT()),
>+    [_controllerCompleter$]: dart.fieldType(async.Completer),
>+    [_isClosed$0]: dart.fieldType(core.bool),
>+    [_isBound$]: dart.fieldType(core.bool),
>+    [_hasError$0]: dart.fieldType(core.bool)
>+  }));
>+  return _StreamSinkImpl;
>+});
>+_http._StreamSinkImpl = _http._StreamSinkImpl$();
>+dart.addTypeTests(_http._StreamSinkImpl, _is__StreamSinkImpl_default$);
>+const _encoding$ = dart.privateName(_http, "_encoding");
>+const _encodingMutable$ = dart.privateName(_http, "_encodingMutable");
>+_http._IOSinkImpl = class _IOSinkImpl extends _http._StreamSinkImpl$(core.List$(core.int)) {
>+  get encoding() {
>+    return this[_encoding$];
>+  }
>+  set encoding(value) {
>+    if (!dart.test(this[_encodingMutable$])) {
>+      dart.throw(new core.StateError.new("IOSink encoding is not mutable"));
>+    }
>+    this[_encoding$] = value;
>+  }
>+  write(obj) {
>+    let string = dart.str(obj);
>+    if (string[$isEmpty]) return;
>+    this.add(this[_encoding$].encode(string));
>+  }
>+  writeAll(objects, separator) {
>+    if (separator === void 0) separator = "";
>+    let iterator = objects[$iterator];
>+    if (!dart.test(iterator.moveNext())) return;
>+    if (separator[$isEmpty]) {
>+      do {
>+        this.write(iterator.current);
>+      } while (dart.test(iterator.moveNext()));
>+    } else {
>+      this.write(iterator.current);
>+      while (dart.test(iterator.moveNext())) {
>+        this.write(separator);
>+        this.write(iterator.current);
>+      }
>+    }
>+  }
>+  writeln(object) {
>+    if (object === void 0) object = "";
>+    this.write(object);
>+    this.write("\n");
>+  }
>+  writeCharCode(charCode) {
>+    this.write(core.String.fromCharCode(charCode));
>+  }
>+};
>+(_http._IOSinkImpl.new = function(target, encoding) {
>+  this[_encodingMutable$] = true;
>+  this[_encoding$] = encoding;
>+  _http._IOSinkImpl.__proto__.new.call(this, target);
>+}).prototype = _http._IOSinkImpl.prototype;
>+dart.addTypeTests(_http._IOSinkImpl);
>+_http._IOSinkImpl[dart.implements] = () => [io.IOSink];
>+dart.setMethodSignature(_http._IOSinkImpl, () => ({
>+  __proto__: dart.getMethods(_http._IOSinkImpl.__proto__),
>+  write: dart.fnType(dart.void, [core.Object]),
>+  writeAll: dart.fnType(dart.void, [core.Iterable], [core.String]),
>+  writeln: dart.fnType(dart.void, [], [core.Object]),
>+  writeCharCode: dart.fnType(dart.void, [core.int])
>+}));
>+dart.setGetterSignature(_http._IOSinkImpl, () => ({
>+  __proto__: dart.getGetters(_http._IOSinkImpl.__proto__),
>+  encoding: convert.Encoding
>+}));
>+dart.setSetterSignature(_http._IOSinkImpl, () => ({
>+  __proto__: dart.getSetters(_http._IOSinkImpl.__proto__),
>+  encoding: convert.Encoding
>+}));
>+dart.setLibraryUri(_http._IOSinkImpl, "dart:_http");
>+dart.setFieldSignature(_http._IOSinkImpl, () => ({
>+  __proto__: dart.getFields(_http._IOSinkImpl.__proto__),
>+  [_encoding$]: dart.fieldType(convert.Encoding),
>+  [_encodingMutable$]: dart.fieldType(core.bool)
>+}));
>+const _uri$ = dart.privateName(_http, "_uri");
>+const _outgoing = dart.privateName(_http, "_outgoing");
>+const _encodingSet = dart.privateName(_http, "_encodingSet");
>+const _bufferOutput = dart.privateName(_http, "_bufferOutput");
>+const _isConnectionClosed = dart.privateName(_http, "_isConnectionClosed");
>+const _is__HttpOutboundMessage_default = Symbol('_is__HttpOutboundMessage_default');
>+_http._HttpOutboundMessage$ = dart.generic(T => {
>+  class _HttpOutboundMessage extends _http._IOSinkImpl {
>+    get contentLength() {
>+      return this.headers.contentLength;
>+    }
>+    set contentLength(contentLength) {
>+      this.headers.contentLength = contentLength;
>+    }
>+    get persistentConnection() {
>+      return this.headers.persistentConnection;
>+    }
>+    set persistentConnection(p) {
>+      this.headers.persistentConnection = p;
>+    }
>+    get bufferOutput() {
>+      return this[_bufferOutput];
>+    }
>+    set bufferOutput(bufferOutput) {
>+      if (dart.test(this[_outgoing].headersWritten)) dart.throw(new core.StateError.new("Header already sent"));
>+      this[_bufferOutput] = bufferOutput;
>+    }
>+    get encoding() {
>+      if (dart.test(this[_encodingSet]) && dart.test(this[_outgoing].headersWritten)) {
>+        return this[_encoding$];
>+      }
>+      let charset = null;
>+      if (this.headers.contentType != null && this.headers.contentType.charset != null) {
>+        charset = this.headers.contentType.charset;
>+      } else {
>+        charset = "iso-8859-1";
>+      }
>+      return convert.Encoding.getByName(core.String._check(charset));
>+    }
>+    set encoding(value) {
>+      super.encoding = value;
>+    }
>+    add(data) {
>+      ListOfint()._check(data);
>+      if (data[$length] === 0) return;
>+      super.add(data);
>+    }
>+    write(obj) {
>+      if (!dart.test(this[_encodingSet])) {
>+        this[_encoding$] = this.encoding;
>+        this[_encodingSet] = true;
>+      }
>+      super.write(obj);
>+    }
>+    get [_isConnectionClosed]() {
>+      return false;
>+    }
>+  }
>+  (_HttpOutboundMessage.new = function(uri, protocolVersion, outgoing, opts) {
>+    let initialHeaders = opts && 'initialHeaders' in opts ? opts.initialHeaders : null;
>+    this[_encodingSet] = false;
>+    this[_bufferOutput] = true;
>+    this[_uri$] = uri;
>+    this.headers = new _http._HttpHeaders.new(protocolVersion, {defaultPortForScheme: uri.scheme === "https" ? _http.HttpClient.defaultHttpsPort : _http.HttpClient.defaultHttpPort, initialHeaders: initialHeaders});
>+    this[_outgoing] = outgoing;
>+    _HttpOutboundMessage.__proto__.new.call(this, outgoing, null);
>+    this[_outgoing].outbound = this;
>+    this[_encodingMutable$] = false;
>+  }).prototype = _HttpOutboundMessage.prototype;
>+  dart.addTypeTests(_HttpOutboundMessage);
>+  _HttpOutboundMessage.prototype[_is__HttpOutboundMessage_default] = true;
>+  dart.setMethodSignature(_HttpOutboundMessage, () => ({
>+    __proto__: dart.getMethods(_HttpOutboundMessage.__proto__),
>+    add: dart.fnType(dart.void, [core.Object]),
>+    write: dart.fnType(dart.void, [core.Object])
>+  }));
>+  dart.setGetterSignature(_HttpOutboundMessage, () => ({
>+    __proto__: dart.getGetters(_HttpOutboundMessage.__proto__),
>+    contentLength: core.int,
>+    persistentConnection: core.bool,
>+    bufferOutput: core.bool,
>+    encoding: convert.Encoding,
>+    [_isConnectionClosed]: core.bool
>+  }));
>+  dart.setSetterSignature(_HttpOutboundMessage, () => ({
>+    __proto__: dart.getSetters(_HttpOutboundMessage.__proto__),
>+    contentLength: core.int,
>+    persistentConnection: core.bool,
>+    bufferOutput: core.bool
>+  }));
>+  dart.setLibraryUri(_HttpOutboundMessage, "dart:_http");
>+  dart.setFieldSignature(_HttpOutboundMessage, () => ({
>+    __proto__: dart.getFields(_HttpOutboundMessage.__proto__),
>+    [_encodingSet]: dart.fieldType(core.bool),
>+    [_bufferOutput]: dart.fieldType(core.bool),
>+    [_uri$]: dart.finalFieldType(core.Uri),
>+    [_outgoing]: dart.finalFieldType(_http._HttpOutgoing),
>+    headers: dart.finalFieldType(_http._HttpHeaders)
>+  }));
>+  return _HttpOutboundMessage;
>+});
>+_http._HttpOutboundMessage = _http._HttpOutboundMessage$();
>+dart.addTypeTests(_http._HttpOutboundMessage, _is__HttpOutboundMessage_default);
>+const _statusCode = dart.privateName(_http, "_statusCode");
>+const _reasonPhrase = dart.privateName(_http, "_reasonPhrase");
>+const _deadline = dart.privateName(_http, "_deadline");
>+const _deadlineTimer = dart.privateName(_http, "_deadlineTimer");
>+const _isClosing = dart.privateName(_http, "_isClosing");
>+const _findReasonPhrase = dart.privateName(_http, "_findReasonPhrase");
>+const _isNew = dart.privateName(_http, "_isNew");
>+const _writeHeader = dart.privateName(_http, "_writeHeader");
>+_http._HttpResponse = class _HttpResponse extends _http._HttpOutboundMessage$(_http.HttpResponse) {
>+  get [_isConnectionClosed]() {
>+    return this[_httpRequest][_httpConnection][_isClosing];
>+  }
>+  get cookies() {
>+    if (this[_cookies] == null) this[_cookies] = JSArrayOfCookie().of([]);
>+    return this[_cookies];
>+  }
>+  get statusCode() {
>+    return this[_statusCode];
>+  }
>+  set statusCode(statusCode) {
>+    if (dart.test(this[_outgoing].headersWritten)) dart.throw(new core.StateError.new("Header already sent"));
>+    this[_statusCode] = statusCode;
>+  }
>+  get reasonPhrase() {
>+    return this[_findReasonPhrase](this.statusCode);
>+  }
>+  set reasonPhrase(reasonPhrase) {
>+    if (dart.test(this[_outgoing].headersWritten)) dart.throw(new core.StateError.new("Header already sent"));
>+    this[_reasonPhrase] = reasonPhrase;
>+  }
>+  redirect(location, opts) {
>+    let status = opts && 'status' in opts ? opts.status : _internal.HttpStatus.movedTemporarily;
>+    if (dart.test(this[_outgoing].headersWritten)) dart.throw(new core.StateError.new("Header already sent"));
>+    this.statusCode = status;
>+    this.headers.set("location", dart.toString(location));
>+    return this.close();
>+  }
>+  detachSocket(opts) {
>+    let writeHeaders = opts && 'writeHeaders' in opts ? opts.writeHeaders : true;
>+    if (dart.test(this[_outgoing].headersWritten)) dart.throw(new core.StateError.new("Headers already sent"));
>+    this.deadline = null;
>+    let future = this[_httpRequest][_httpConnection].detachSocket();
>+    if (dart.test(writeHeaders)) {
>+      let headersFuture = this[_outgoing].writeHeaders({drainRequest: false, setOutgoing: false});
>+      if (!(headersFuture == null)) dart.assertFailed(null, "dart:_http/http_impl.dart", 835, 14, "headersFuture == null");
>+    } else {
>+      this[_outgoing].headersWritten = true;
>+    }
>+    this.close();
>+    this.done.catchError(dart.fn(_ => {
>+    }, dynamicToNull()));
>+    return future;
>+  }
>+  get connectionInfo() {
>+    return this[_httpRequest].connectionInfo;
>+  }
>+  get deadline() {
>+    return this[_deadline];
>+  }
>+  set deadline(d) {
>+    if (this[_deadlineTimer] != null) this[_deadlineTimer].cancel();
>+    this[_deadline] = d;
>+    if (this[_deadline] == null) return;
>+    this[_deadlineTimer] = async.Timer.new(this[_deadline], dart.fn(() => {
>+      this[_httpRequest][_httpConnection].destroy();
>+    }, VoidToNull()));
>+  }
>+  [_writeHeader]() {
>+    let buffer = new _http._CopyingBytesBuilder.new(8192);
>+    if (this.headers.protocolVersion === "1.1") {
>+      buffer.add(_http._Const.HTTP11);
>+    } else {
>+      buffer.add(_http._Const.HTTP10);
>+    }
>+    buffer.addByte(_http._CharCode.SP);
>+    buffer.add(dart.toString(this.statusCode)[$codeUnits]);
>+    buffer.addByte(_http._CharCode.SP);
>+    buffer.add(this.reasonPhrase[$codeUnits]);
>+    buffer.addByte(_http._CharCode.CR);
>+    buffer.addByte(_http._CharCode.LF);
>+    let session = this[_httpRequest][_session];
>+    if (session != null && !dart.test(session[_destroyed])) {
>+      session[_isNew] = false;
>+      let found = false;
>+      for (let i = 0; i < dart.notNull(this.cookies[$length]); i++) {
>+        if (this.cookies[$_get](i).name[$toUpperCase]() === "DARTSESSID") {
>+          let _ = this.cookies[$_get](i);
>+          _.value = session.id;
>+          _.httpOnly = true;
>+          _.path = "/";
>+          found = true;
>+        }
>+      }
>+      if (!found) {
>+        let cookie = _http.Cookie.new("DARTSESSID", session.id);
>+        this.cookies[$add]((() => {
>+          cookie.httpOnly = true;
>+          cookie.path = "/";
>+          return cookie;
>+        })());
>+      }
>+    }
>+    if (this[_cookies] != null) {
>+      this[_cookies][$forEach](dart.fn(cookie => {
>+        this.headers.add(_http.HttpHeaders.setCookieHeader, cookie);
>+      }, CookieToNull()));
>+    }
>+    this.headers[_finalize]();
>+    this.headers[_build](buffer);
>+    buffer.addByte(_http._CharCode.CR);
>+    buffer.addByte(_http._CharCode.LF);
>+    let headerBytes = typed_data.Uint8List._check(buffer.takeBytes());
>+    this[_outgoing].setHeader(headerBytes, headerBytes[$length]);
>+  }
>+  [_findReasonPhrase](statusCode) {
>+    if (this[_reasonPhrase] != null) {
>+      return this[_reasonPhrase];
>+    }
>+    switch (statusCode) {
>+      case _internal.HttpStatus.continue__:
>+      {
>+        return "Continue";
>+      }
>+      case _internal.HttpStatus.switchingProtocols:
>+      {
>+        return "Switching Protocols";
>+      }
>+      case _internal.HttpStatus.ok:
>+      {
>+        return "OK";
>+      }
>+      case _internal.HttpStatus.created:
>+      {
>+        return "Created";
>+      }
>+      case _internal.HttpStatus.accepted:
>+      {
>+        return "Accepted";
>+      }
>+      case _internal.HttpStatus.nonAuthoritativeInformation:
>+      {
>+        return "Non-Authoritative Information";
>+      }
>+      case _internal.HttpStatus.noContent:
>+      {
>+        return "No Content";
>+      }
>+      case _internal.HttpStatus.resetContent:
>+      {
>+        return "Reset Content";
>+      }
>+      case _internal.HttpStatus.partialContent:
>+      {
>+        return "Partial Content";
>+      }
>+      case _internal.HttpStatus.multipleChoices:
>+      {
>+        return "Multiple Choices";
>+      }
>+      case _internal.HttpStatus.movedPermanently:
>+      {
>+        return "Moved Permanently";
>+      }
>+      case _internal.HttpStatus.found:
>+      {
>+        return "Found";
>+      }
>+      case _internal.HttpStatus.seeOther:
>+      {
>+        return "See Other";
>+      }
>+      case _internal.HttpStatus.notModified:
>+      {
>+        return "Not Modified";
>+      }
>+      case _internal.HttpStatus.useProxy:
>+      {
>+        return "Use Proxy";
>+      }
>+      case _internal.HttpStatus.temporaryRedirect:
>+      {
>+        return "Temporary Redirect";
>+      }
>+      case _internal.HttpStatus.badRequest:
>+      {
>+        return "Bad Request";
>+      }
>+      case _internal.HttpStatus.unauthorized:
>+      {
>+        return "Unauthorized";
>+      }
>+      case _internal.HttpStatus.paymentRequired:
>+      {
>+        return "Payment Required";
>+      }
>+      case _internal.HttpStatus.forbidden:
>+      {
>+        return "Forbidden";
>+      }
>+      case _internal.HttpStatus.notFound:
>+      {
>+        return "Not Found";
>+      }
>+      case _internal.HttpStatus.methodNotAllowed:
>+      {
>+        return "Method Not Allowed";
>+      }
>+      case _internal.HttpStatus.notAcceptable:
>+      {
>+        return "Not Acceptable";
>+      }
>+      case _internal.HttpStatus.proxyAuthenticationRequired:
>+      {
>+        return "Proxy Authentication Required";
>+      }
>+      case _internal.HttpStatus.requestTimeout:
>+      {
>+        return "Request Time-out";
>+      }
>+      case _internal.HttpStatus.conflict:
>+      {
>+        return "Conflict";
>+      }
>+      case _internal.HttpStatus.gone:
>+      {
>+        return "Gone";
>+      }
>+      case _internal.HttpStatus.lengthRequired:
>+      {
>+        return "Length Required";
>+      }
>+      case _internal.HttpStatus.preconditionFailed:
>+      {
>+        return "Precondition Failed";
>+      }
>+      case _internal.HttpStatus.requestEntityTooLarge:
>+      {
>+        return "Request Entity Too Large";
>+      }
>+      case _internal.HttpStatus.requestUriTooLong:
>+      {
>+        return "Request-URI Too Long";
>+      }
>+      case _internal.HttpStatus.unsupportedMediaType:
>+      {
>+        return "Unsupported Media Type";
>+      }
>+      case _internal.HttpStatus.requestedRangeNotSatisfiable:
>+      {
>+        return "Requested range not satisfiable";
>+      }
>+      case _internal.HttpStatus.expectationFailed:
>+      {
>+        return "Expectation Failed";
>+      }
>+      case _internal.HttpStatus.internalServerError:
>+      {
>+        return "Internal Server Error";
>+      }
>+      case _internal.HttpStatus.notImplemented:
>+      {
>+        return "Not Implemented";
>+      }
>+      case _internal.HttpStatus.badGateway:
>+      {
>+        return "Bad Gateway";
>+      }
>+      case _internal.HttpStatus.serviceUnavailable:
>+      {
>+        return "Service Unavailable";
>+      }
>+      case _internal.HttpStatus.gatewayTimeout:
>+      {
>+        return "Gateway Time-out";
>+      }
>+      case _internal.HttpStatus.httpVersionNotSupported:
>+      {
>+        return "Http Version not supported";
>+      }
>+      default:
>+      {
>+        return "Status " + dart.str(statusCode);
>+      }
>+    }
>+  }
>+};
>+(_http._HttpResponse.new = function(uri, protocolVersion, outgoing, defaultHeaders, serverHeader) {
>+  this[_statusCode] = 200;
>+  this[_reasonPhrase] = null;
>+  this[_cookies] = null;
>+  this[_httpRequest] = null;
>+  this[_deadline] = null;
>+  this[_deadlineTimer] = null;
>+  _http._HttpResponse.__proto__.new.call(this, uri, protocolVersion, outgoing, {initialHeaders: _http._HttpHeaders._check(defaultHeaders)});
>+  if (serverHeader != null) this.headers.set("server", serverHeader);
>+}).prototype = _http._HttpResponse.prototype;
>+dart.addTypeTests(_http._HttpResponse);
>+_http._HttpResponse[dart.implements] = () => [_http.HttpResponse];
>+dart.setMethodSignature(_http._HttpResponse, () => ({
>+  __proto__: dart.getMethods(_http._HttpResponse.__proto__),
>+  redirect: dart.fnType(async.Future, [core.Uri], {status: core.int}),
>+  detachSocket: dart.fnType(async.Future$(io.Socket), [], {writeHeaders: core.bool}),
>+  [_writeHeader]: dart.fnType(dart.void, []),
>+  [_findReasonPhrase]: dart.fnType(core.String, [core.int])
>+}));
>+dart.setGetterSignature(_http._HttpResponse, () => ({
>+  __proto__: dart.getGetters(_http._HttpResponse.__proto__),
>+  [_isConnectionClosed]: core.bool,
>+  cookies: core.List$(_http.Cookie),
>+  statusCode: core.int,
>+  reasonPhrase: core.String,
>+  connectionInfo: _http.HttpConnectionInfo,
>+  deadline: core.Duration
>+}));
>+dart.setSetterSignature(_http._HttpResponse, () => ({
>+  __proto__: dart.getSetters(_http._HttpResponse.__proto__),
>+  statusCode: core.int,
>+  reasonPhrase: core.String,
>+  deadline: core.Duration
>+}));
>+dart.setLibraryUri(_http._HttpResponse, "dart:_http");
>+dart.setFieldSignature(_http._HttpResponse, () => ({
>+  __proto__: dart.getFields(_http._HttpResponse.__proto__),
>+  [_statusCode]: dart.fieldType(core.int),
>+  [_reasonPhrase]: dart.fieldType(core.String),
>+  [_cookies]: dart.fieldType(ListOfCookie()),
>+  [_httpRequest]: dart.fieldType(_http._HttpRequest),
>+  [_deadline]: dart.fieldType(core.Duration),
>+  [_deadlineTimer]: dart.fieldType(async.Timer)
>+}));
>+const _responseCompleter = dart.privateName(_http, "_responseCompleter");
>+const _response = dart.privateName(_http, "_response");
>+const _followRedirects = dart.privateName(_http, "_followRedirects");
>+const _maxRedirects = dart.privateName(_http, "_maxRedirects");
>+const _onIncoming = dart.privateName(_http, "_onIncoming");
>+const _onError$ = dart.privateName(_http, "_onError");
>+const _proxyTunnel = dart.privateName(_http, "_proxyTunnel");
>+const _requestUri = dart.privateName(_http, "_requestUri");
>+_http._HttpClientRequest = class _HttpClientRequest extends _http._HttpOutboundMessage$(_http.HttpClientResponse) {
>+  get done() {
>+    if (this[_response] == null) {
>+      this[_response] = FutureOfHttpClientResponse()._check(async.Future.wait(dart.dynamic, JSArrayOfFuture().of([this[_responseCompleter].future, super.done]), {eagerError: true}).then(_http.HttpClientResponse, dart.fn(list => FutureOrOfHttpClientResponse()._check(list[$_get](0)), ListToFutureOrOfHttpClientResponse())));
>+    }
>+    return this[_response];
>+  }
>+  close() {
>+    super.close();
>+    return this.done;
>+  }
>+  get maxRedirects() {
>+    return this[_maxRedirects];
>+  }
>+  set maxRedirects(maxRedirects) {
>+    if (dart.test(this[_outgoing].headersWritten)) dart.throw(new core.StateError.new("Request already sent"));
>+    this[_maxRedirects] = maxRedirects;
>+  }
>+  get followRedirects() {
>+    return this[_followRedirects];
>+  }
>+  set followRedirects(followRedirects) {
>+    if (dart.test(this[_outgoing].headersWritten)) dart.throw(new core.StateError.new("Request already sent"));
>+    this[_followRedirects] = followRedirects;
>+  }
>+  get connectionInfo() {
>+    return this[_httpClientConnection].connectionInfo;
>+  }
>+  [_onIncoming](incoming) {
>+    let response = new _http._HttpClientResponse.new(incoming, this, this[_httpClient]);
>+    let future = null;
>+    if (dart.test(this.followRedirects) && dart.test(response.isRedirect)) {
>+      if (dart.notNull(response.redirects[$length]) < dart.notNull(this.maxRedirects)) {
>+        future = FutureOfHttpClientResponse()._check(response.drain(dart.dynamic).then(_http.HttpClientResponse, dart.fn(_ => response.redirect(), dynamicToFutureOfHttpClientResponse())));
>+      } else {
>+        future = FutureOfHttpClientResponse()._check(response.drain(dart.dynamic).then(_http.HttpClientResponse, dart.fn(_ => FutureOfHttpClientResponse().error(new _http.RedirectException.new("Redirect limit exceeded", response.redirects)), dynamicToFutureOfHttpClientResponse())));
>+      }
>+    } else if (dart.test(response[_shouldAuthenticateProxy])) {
>+      future = response[_authenticate](true);
>+    } else if (dart.test(response[_shouldAuthenticate])) {
>+      future = response[_authenticate](false);
>+    } else {
>+      future = FutureOfHttpClientResponse().value(response);
>+    }
>+    future.then(dart.void, dart.fn(v => this[_responseCompleter].complete(v), HttpClientResponseTovoid()), {onError: dart.bind(this[_responseCompleter], 'completeError')});
>+  }
>+  [_onError$](error, stackTrace) {
>+    this[_responseCompleter].completeError(error, stackTrace);
>+  }
>+  [_requestUri]() {
>+    const uriStartingFromPath = () => {
>+      let result = this.uri.path;
>+      if (result[$isEmpty]) result = "/";
>+      if (dart.test(this.uri.hasQuery)) {
>+        result = dart.str(result) + "?" + dart.str(this.uri.query);
>+      }
>+      return result;
>+    };
>+    dart.fn(uriStartingFromPath, VoidToString());
>+    if (dart.test(this[_proxy].isDirect)) {
>+      return uriStartingFromPath();
>+    } else {
>+      if (this.method === "CONNECT") {
>+        return dart.str(this.uri.host) + ":" + dart.str(this.uri.port);
>+      } else {
>+        if (dart.test(this[_httpClientConnection][_proxyTunnel])) {
>+          return uriStartingFromPath();
>+        } else {
>+          return dart.toString(this.uri.removeFragment());
>+        }
>+      }
>+    }
>+  }
>+  [_writeHeader]() {
>+    let buffer = new _http._CopyingBytesBuilder.new(8192);
>+    buffer.add(this.method[$codeUnits]);
>+    buffer.addByte(_http._CharCode.SP);
>+    buffer.add(this[_requestUri]()[$codeUnits]);
>+    buffer.addByte(_http._CharCode.SP);
>+    buffer.add(_http._Const.HTTP11);
>+    buffer.addByte(_http._CharCode.CR);
>+    buffer.addByte(_http._CharCode.LF);
>+    if (!dart.test(this.cookies[$isEmpty])) {
>+      let sb = new core.StringBuffer.new();
>+      for (let i = 0; i < dart.notNull(this.cookies[$length]); i++) {
>+        if (i > 0) sb.write("; ");
>+        sb.write(this.cookies[$_get](i).name);
>+        sb.write("=");
>+        sb.write(this.cookies[$_get](i).value);
>+      }
>+      this.headers.add(_http.HttpHeaders.cookieHeader, sb.toString());
>+    }
>+    this.headers[_finalize]();
>+    this.headers[_build](buffer);
>+    buffer.addByte(_http._CharCode.CR);
>+    buffer.addByte(_http._CharCode.LF);
>+    let headerBytes = typed_data.Uint8List._check(buffer.takeBytes());
>+    this[_outgoing].setHeader(headerBytes, headerBytes[$length]);
>+  }
>+};
>+(_http._HttpClientRequest.new = function(outgoing, uri, method, proxy, httpClient, httpClientConnection) {
>+  this.cookies = JSArrayOfCookie().of([]);
>+  this[_responseCompleter] = CompleterOfHttpClientResponse().new();
>+  this[_response] = null;
>+  this[_followRedirects] = true;
>+  this[_maxRedirects] = 5;
>+  this[_responseRedirects] = JSArrayOfRedirectInfo().of([]);
>+  this.method = method;
>+  this[_proxy] = proxy;
>+  this[_httpClient] = httpClient;
>+  this[_httpClientConnection] = httpClientConnection;
>+  this.uri = uri;
>+  _http._HttpClientRequest.__proto__.new.call(this, uri, "1.1", outgoing);
>+  if (this.method === "GET" || this.method === "HEAD") {
>+    this.contentLength = 0;
>+  } else {
>+    this.headers.chunkedTransferEncoding = true;
>+  }
>+}).prototype = _http._HttpClientRequest.prototype;
>+dart.addTypeTests(_http._HttpClientRequest);
>+_http._HttpClientRequest[dart.implements] = () => [_http.HttpClientRequest];
>+dart.setMethodSignature(_http._HttpClientRequest, () => ({
>+  __proto__: dart.getMethods(_http._HttpClientRequest.__proto__),
>+  close: dart.fnType(async.Future$(_http.HttpClientResponse), []),
>+  [_onIncoming]: dart.fnType(dart.void, [_http._HttpIncoming]),
>+  [_onError$]: dart.fnType(dart.void, [dart.dynamic, core.StackTrace]),
>+  [_requestUri]: dart.fnType(core.String, []),
>+  [_writeHeader]: dart.fnType(dart.void, [])
>+}));
>+dart.setGetterSignature(_http._HttpClientRequest, () => ({
>+  __proto__: dart.getGetters(_http._HttpClientRequest.__proto__),
>+  done: async.Future$(_http.HttpClientResponse),
>+  maxRedirects: core.int,
>+  followRedirects: core.bool,
>+  connectionInfo: _http.HttpConnectionInfo
>+}));
>+dart.setSetterSignature(_http._HttpClientRequest, () => ({
>+  __proto__: dart.getSetters(_http._HttpClientRequest.__proto__),
>+  maxRedirects: core.int,
>+  followRedirects: core.bool
>+}));
>+dart.setLibraryUri(_http._HttpClientRequest, "dart:_http");
>+dart.setFieldSignature(_http._HttpClientRequest, () => ({
>+  __proto__: dart.getFields(_http._HttpClientRequest.__proto__),
>+  method: dart.finalFieldType(core.String),
>+  uri: dart.finalFieldType(core.Uri),
>+  cookies: dart.finalFieldType(ListOfCookie()),
>+  [_httpClient]: dart.finalFieldType(_http._HttpClient),
>+  [_httpClientConnection]: dart.finalFieldType(_http._HttpClientConnection),
>+  [_responseCompleter]: dart.finalFieldType(CompleterOfHttpClientResponse()),
>+  [_proxy]: dart.finalFieldType(_http._Proxy),
>+  [_response]: dart.fieldType(FutureOfHttpClientResponse()),
>+  [_followRedirects]: dart.fieldType(core.bool),
>+  [_maxRedirects]: dart.fieldType(core.int),
>+  [_responseRedirects]: dart.fieldType(ListOfRedirectInfo())
>+}));
>+const _consume = dart.privateName(_http, "_consume");
>+_http._HttpGZipSink = class _HttpGZipSink extends convert.ByteConversionSink {
>+  add(chunk) {
>+    ListOfint()._check(chunk);
>+    this[_consume](chunk);
>+  }
>+  addSlice(chunk, start, end, isLast) {
>+    if (typed_data.Uint8List.is(chunk)) {
>+      this[_consume](typed_data.Uint8List.view(chunk[$buffer], start, dart.notNull(end) - dart.notNull(start)));
>+    } else {
>+      this[_consume](chunk[$sublist](start, dart.notNull(end) - dart.notNull(start)));
>+    }
>+  }
>+  close() {}
>+};
>+(_http._HttpGZipSink.new = function(consume) {
>+  this[_consume] = consume;
>+  _http._HttpGZipSink.__proto__.new.call(this);
>+}).prototype = _http._HttpGZipSink.prototype;
>+dart.addTypeTests(_http._HttpGZipSink);
>+dart.setMethodSignature(_http._HttpGZipSink, () => ({
>+  __proto__: dart.getMethods(_http._HttpGZipSink.__proto__),
>+  add: dart.fnType(dart.void, [core.Object]),
>+  addSlice: dart.fnType(dart.void, [core.List$(core.int), core.int, core.int, core.bool]),
>+  close: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(_http._HttpGZipSink, "dart:_http");
>+dart.setFieldSignature(_http._HttpGZipSink, () => ({
>+  __proto__: dart.getFields(_http._HttpGZipSink.__proto__),
>+  [_consume]: dart.finalFieldType(ListOfintTovoid())
>+}));
>+const _closeFuture = dart.privateName(_http, "_closeFuture");
>+const _pendingChunkedFooter = dart.privateName(_http, "_pendingChunkedFooter");
>+const _bytesWritten = dart.privateName(_http, "_bytesWritten");
>+const _gzip = dart.privateName(_http, "_gzip");
>+const _gzipSink = dart.privateName(_http, "_gzipSink");
>+const _gzipAdd = dart.privateName(_http, "_gzipAdd");
>+const _gzipBuffer = dart.privateName(_http, "_gzipBuffer");
>+const _gzipBufferLength = dart.privateName(_http, "_gzipBufferLength");
>+const _socketError = dart.privateName(_http, "_socketError");
>+const _addGZipChunk = dart.privateName(_http, "_addGZipChunk");
>+const _chunkHeader = dart.privateName(_http, "_chunkHeader");
>+const _addChunk$ = dart.privateName(_http, "_addChunk");
>+const _ignoreError = dart.privateName(_http, "_ignoreError");
>+let const$99;
>+_http._HttpOutgoing = class _HttpOutgoing extends core.Object {
>+  writeHeaders(opts) {
>+    let drainRequest = opts && 'drainRequest' in opts ? opts.drainRequest : true;
>+    let setOutgoing = opts && 'setOutgoing' in opts ? opts.setOutgoing : true;
>+    if (dart.test(this.headersWritten)) return null;
>+    this.headersWritten = true;
>+    let drainFuture = null;
>+    let gzip = false;
>+    if (_http._HttpResponse.is(this.outbound)) {
>+      let response = _http._HttpResponse._check(this.outbound);
>+      if (dart.test(response[_httpRequest][_httpServer].autoCompress) && dart.test(this.outbound.bufferOutput) && dart.test(this.outbound.headers.chunkedTransferEncoding)) {
>+        let acceptEncodings = response[_httpRequest].headers._get(_http.HttpHeaders.acceptEncodingHeader);
>+        let contentEncoding = this.outbound.headers._get(_http.HttpHeaders.contentEncodingHeader);
>+        if (acceptEncodings != null && dart.test(acceptEncodings[$expand](dart.dynamic, dart.fn(list => core.Iterable._check(dart.dsend(list, 'split', [","])), dynamicToIterable()))[$any](dart.fn(encoding => dart.equals(dart.dsend(dart.dsend(encoding, 'trim', []), 'toLowerCase', []), "gzip"), dynamicTobool()))) && contentEncoding == null) {
>+          this.outbound.headers.set(_http.HttpHeaders.contentEncodingHeader, "gzip");
>+          gzip = true;
>+        }
>+      }
>+      if (dart.test(drainRequest) && !dart.test(response[_httpRequest][_incoming].hasSubscriber)) {
>+        drainFuture = response[_httpRequest].drain(dart.dynamic).catchError(dart.fn(_ => {
>+        }, dynamicToNull()));
>+      }
>+    } else {
>+      drainRequest = false;
>+    }
>+    if (!dart.test(this.ignoreBody)) {
>+      if (dart.test(setOutgoing)) {
>+        let contentLength = this.outbound.headers.contentLength;
>+        if (dart.test(this.outbound.headers.chunkedTransferEncoding)) {
>+          this.chunked = true;
>+          if (gzip) this.gzip = true;
>+        } else if (dart.notNull(contentLength) >= 0) {
>+          this.contentLength = contentLength;
>+        }
>+      }
>+      if (drainFuture != null) {
>+        return drainFuture.then(dart.dynamic, dart.fn(_ => this.outbound[_writeHeader](), dynamicTovoid()));
>+      }
>+    }
>+    this.outbound[_writeHeader]();
>+    return null;
>+  }
>+  addStream(stream) {
>+    StreamOfListOfint()._check(stream);
>+    if (dart.test(this[_socketError])) {
>+      stream.listen(null).cancel();
>+      return async.Future.value(this.outbound);
>+    }
>+    if (dart.test(this.ignoreBody)) {
>+      stream.drain(dart.dynamic).catchError(dart.fn(_ => {
>+      }, dynamicToNull()));
>+      let future = this.writeHeaders();
>+      if (future != null) {
>+        return future.then(dart.dynamic, dart.fn(_ => this.close(), dynamicToFuture()));
>+      }
>+      return this.close();
>+    }
>+    let sub = null;
>+    let controller = StreamControllerOfListOfint().new({onPause: dart.fn(() => sub.pause(), VoidTovoid()), onResume: dart.fn(() => sub.resume(), VoidTovoid()), sync: true});
>+    const onData = data => {
>+      if (dart.test(this[_socketError])) return;
>+      if (data[$length] === 0) return;
>+      if (dart.test(this.chunked)) {
>+        if (dart.test(this[_gzip])) {
>+          this[_gzipAdd] = dart.bind(controller, 'add');
>+          this[_addGZipChunk](data, dart.bind(this[_gzipSink], 'add'));
>+          this[_gzipAdd] = null;
>+          return;
>+        }
>+        this[_addChunk$](this[_chunkHeader](data[$length]), dart.bind(controller, 'add'));
>+        this[_pendingChunkedFooter] = 2;
>+      } else {
>+        if (this.contentLength != null) {
>+          this[_bytesWritten] = dart.notNull(this[_bytesWritten]) + dart.notNull(data[$length]);
>+          if (dart.notNull(this[_bytesWritten]) > dart.notNull(this.contentLength)) {
>+            controller.addError(new _http.HttpException.new("Content size exceeds specified contentLength. " + (dart.str(this[_bytesWritten]) + " bytes written while expected ") + (dart.str(this.contentLength) + ". ") + ("[" + core.String.fromCharCodes(data) + "]")));
>+            return;
>+          }
>+        }
>+      }
>+      this[_addChunk$](data, dart.bind(controller, 'add'));
>+    };
>+    dart.fn(onData, ListOfintTovoid());
>+    sub = stream.listen(onData, {onError: dart.bind(controller, 'addError'), onDone: dart.bind(controller, 'close'), cancelOnError: true});
>+    if (!dart.test(this.headersWritten)) {
>+      let future = this.writeHeaders();
>+      if (future != null) {
>+        sub.pause(future);
>+      }
>+    }
>+    return this.socket.addStream(controller.stream).then(dart.dynamic, dart.fn(_ => this.outbound, dynamicTo_HttpOutboundMessage()), {onError: dart.fn((error, stackTrace) => {
>+        if (dart.test(this[_gzip])) this[_gzipSink].close();
>+        this[_socketError] = true;
>+        this[_doneCompleter$].completeError(error, core.StackTrace._check(stackTrace));
>+        if (dart.test(this[_ignoreError](error))) {
>+          return this.outbound;
>+        } else {
>+          dart.throw(error);
>+        }
>+      }, dynamicAnddynamicTo_HttpOutboundMessage())});
>+  }
>+  close() {
>+    if (this[_closeFuture] != null) return this[_closeFuture];
>+    if (dart.test(this[_socketError])) return async.Future.value(this.outbound);
>+    if (dart.test(this.outbound[_isConnectionClosed])) return async.Future.value(this.outbound);
>+    if (!dart.test(this.headersWritten) && !dart.test(this.ignoreBody)) {
>+      if (this.outbound.headers.contentLength === -1) {
>+        this.outbound.headers.chunkedTransferEncoding = false;
>+        this.outbound.headers.contentLength = 0;
>+      } else if (dart.notNull(this.outbound.headers.contentLength) > 0) {
>+        let error = new _http.HttpException.new("No content even though contentLength was specified to be " + ("greater than 0: " + dart.str(this.outbound.headers.contentLength) + "."), {uri: this.outbound[_uri$]});
>+        this[_doneCompleter$].completeError(error);
>+        return this[_closeFuture] = async.Future.error(error);
>+      }
>+    }
>+    if (this.contentLength != null) {
>+      if (dart.notNull(this[_bytesWritten]) < dart.notNull(this.contentLength)) {
>+        let error = new _http.HttpException.new("Content size below specified contentLength. " + (" " + dart.str(this[_bytesWritten]) + " bytes written but expected ") + (dart.str(this.contentLength) + "."), {uri: this.outbound[_uri$]});
>+        this[_doneCompleter$].completeError(error);
>+        return this[_closeFuture] = async.Future.error(error);
>+      }
>+    }
>+    const finalize = () => {
>+      if (dart.test(this.chunked)) {
>+        if (dart.test(this[_gzip])) {
>+          this[_gzipAdd] = dart.bind(this.socket, 'add');
>+          if (dart.notNull(this[_gzipBufferLength]) > 0) {
>+            this[_gzipSink].add(typed_data.Uint8List.view(this[_gzipBuffer][$buffer], 0, this[_gzipBufferLength]));
>+          }
>+          this[_gzipBuffer] = null;
>+          this[_gzipSink].close();
>+          this[_gzipAdd] = null;
>+        }
>+        this[_addChunk$](this[_chunkHeader](0), dart.bind(this.socket, 'add'));
>+      }
>+      if (dart.notNull(this[_length$3]) > 0) {
>+        this.socket.add(typed_data.Uint8List.view(this[_buffer$1][$buffer], 0, this[_length$3]));
>+      }
>+      this[_buffer$1] = null;
>+      return this.socket.flush().then(dart.dynamic, dart.fn(_ => {
>+        this[_doneCompleter$].complete(this.socket);
>+        return this.outbound;
>+      }, dynamicTo_HttpOutboundMessage()), {onError: dart.fn((error, stackTrace) => {
>+          this[_doneCompleter$].completeError(error, core.StackTrace._check(stackTrace));
>+          if (dart.test(this[_ignoreError](error))) {
>+            return this.outbound;
>+          } else {
>+            dart.throw(error);
>+          }
>+        }, dynamicAnddynamicTo_HttpOutboundMessage())});
>+    };
>+    dart.fn(finalize, VoidToFuture());
>+    let future = this.writeHeaders();
>+    if (future != null) {
>+      return this[_closeFuture] = future.whenComplete(finalize);
>+    }
>+    return this[_closeFuture] = finalize();
>+  }
>+  get done() {
>+    return this[_doneCompleter$].future;
>+  }
>+  setHeader(data, length) {
>+    if (!(this[_length$3] === 0)) dart.assertFailed(null, "dart:_http/http_impl.dart", 1459, 12, "_length == 0");
>+    this[_buffer$1] = typed_data.Uint8List._check(data);
>+    this[_length$3] = length;
>+  }
>+  set gzip(value) {
>+    this[_gzip] = value;
>+    if (dart.test(this[_gzip])) {
>+      this[_gzipBuffer] = typed_data.Uint8List.new(8192);
>+      if (!(this[_gzipSink] == null)) dart.assertFailed(null, "dart:_http/http_impl.dart", 1468, 14, "_gzipSink == null");
>+      this[_gzipSink] = new io.ZLibEncoder.new({gzip: true}).startChunkedConversion(new _http._HttpGZipSink.new(dart.fn(data => {
>+        if (this[_gzipAdd] == null) return;
>+        this[_addChunk$](this[_chunkHeader](data[$length]), this[_gzipAdd]);
>+        this[_pendingChunkedFooter] = 2;
>+        this[_addChunk$](data, this[_gzipAdd]);
>+      }, ListOfintToNull())));
>+    }
>+  }
>+  [_ignoreError](error) {
>+    return (io.SocketException.is(error) || io.TlsException.is(error)) && _http.HttpResponse.is(this.outbound);
>+  }
>+  [_addGZipChunk](chunk, add) {
>+    if (!dart.test(this.outbound.bufferOutput)) {
>+      add(chunk);
>+      return;
>+    }
>+    if (dart.notNull(chunk[$length]) > dart.notNull(this[_gzipBuffer][$length]) - dart.notNull(this[_gzipBufferLength])) {
>+      add(typed_data.Uint8List.view(this[_gzipBuffer][$buffer], 0, this[_gzipBufferLength]));
>+      this[_gzipBuffer] = typed_data.Uint8List.new(8192);
>+      this[_gzipBufferLength] = 0;
>+    }
>+    if (dart.notNull(chunk[$length]) > 8192) {
>+      add(chunk);
>+    } else {
>+      this[_gzipBuffer][$setRange](this[_gzipBufferLength], dart.notNull(this[_gzipBufferLength]) + dart.notNull(chunk[$length]), chunk);
>+      this[_gzipBufferLength] = dart.notNull(this[_gzipBufferLength]) + dart.notNull(chunk[$length]);
>+    }
>+  }
>+  [_addChunk$](chunk, add) {
>+    if (!dart.test(this.outbound.bufferOutput)) {
>+      if (this[_buffer$1] != null) {
>+        add(typed_data.Uint8List.view(this[_buffer$1][$buffer], 0, this[_length$3]));
>+        this[_buffer$1] = null;
>+        this[_length$3] = 0;
>+      }
>+      add(chunk);
>+      return;
>+    }
>+    if (dart.notNull(chunk[$length]) > dart.notNull(this[_buffer$1][$length]) - dart.notNull(this[_length$3])) {
>+      add(typed_data.Uint8List.view(this[_buffer$1][$buffer], 0, this[_length$3]));
>+      this[_buffer$1] = typed_data.Uint8List.new(8192);
>+      this[_length$3] = 0;
>+    }
>+    if (dart.notNull(chunk[$length]) > 8192) {
>+      add(chunk);
>+    } else {
>+      this[_buffer$1][$setRange](this[_length$3], dart.notNull(this[_length$3]) + dart.notNull(chunk[$length]), chunk);
>+      this[_length$3] = dart.notNull(this[_length$3]) + dart.notNull(chunk[$length]);
>+    }
>+  }
>+  [_chunkHeader](length) {
>+    let hexDigits = const$99 || (const$99 = dart.constList([48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70], core.int));
>+    if (length === 0) {
>+      if (this[_pendingChunkedFooter] === 2) return _http._HttpOutgoing._footerAndChunk0Length;
>+      return _http._HttpOutgoing._chunk0Length;
>+    }
>+    let size = this[_pendingChunkedFooter];
>+    let len = length;
>+    while (dart.notNull(len) > 0) {
>+      size = dart.notNull(size) + 1;
>+      len = len[$rightShift](4);
>+    }
>+    let footerAndHeader = typed_data.Uint8List.new(dart.notNull(size) + 2);
>+    if (this[_pendingChunkedFooter] === 2) {
>+      footerAndHeader[$_set](0, _http._CharCode.CR);
>+      footerAndHeader[$_set](1, _http._CharCode.LF);
>+    }
>+    let index = size;
>+    while (dart.notNull(index) > dart.notNull(this[_pendingChunkedFooter])) {
>+      footerAndHeader[$_set](index = dart.notNull(index) - 1, hexDigits[$_get](dart.notNull(length) & 15));
>+      length = length[$rightShift](4);
>+    }
>+    footerAndHeader[$_set](dart.notNull(size) + 0, _http._CharCode.CR);
>+    footerAndHeader[$_set](dart.notNull(size) + 1, _http._CharCode.LF);
>+    return footerAndHeader;
>+  }
>+};
>+(_http._HttpOutgoing.new = function(socket) {
>+  this[_doneCompleter$] = CompleterOfSocket().new();
>+  this.ignoreBody = false;
>+  this.headersWritten = false;
>+  this[_buffer$1] = null;
>+  this[_length$3] = 0;
>+  this[_closeFuture] = null;
>+  this.chunked = false;
>+  this[_pendingChunkedFooter] = 0;
>+  this.contentLength = null;
>+  this[_bytesWritten] = 0;
>+  this[_gzip] = false;
>+  this[_gzipSink] = null;
>+  this[_gzipAdd] = null;
>+  this[_gzipBuffer] = null;
>+  this[_gzipBufferLength] = 0;
>+  this[_socketError] = false;
>+  this.outbound = null;
>+  this.socket = socket;
>+}).prototype = _http._HttpOutgoing.prototype;
>+dart.addTypeTests(_http._HttpOutgoing);
>+_http._HttpOutgoing[dart.implements] = () => [StreamConsumerOfListOfint()];
>+dart.setMethodSignature(_http._HttpOutgoing, () => ({
>+  __proto__: dart.getMethods(_http._HttpOutgoing.__proto__),
>+  writeHeaders: dart.fnType(async.Future, [], {drainRequest: core.bool, setOutgoing: core.bool}),
>+  addStream: dart.fnType(async.Future, [core.Object]),
>+  close: dart.fnType(async.Future, []),
>+  setHeader: dart.fnType(dart.void, [core.List$(core.int), core.int]),
>+  [_ignoreError]: dart.fnType(core.bool, [dart.dynamic]),
>+  [_addGZipChunk]: dart.fnType(dart.void, [core.List$(core.int), dart.fnType(dart.void, [core.List$(core.int)])]),
>+  [_addChunk$]: dart.fnType(dart.void, [core.List$(core.int), dart.fnType(dart.void, [core.List$(core.int)])]),
>+  [_chunkHeader]: dart.fnType(core.List$(core.int), [core.int])
>+}));
>+dart.setGetterSignature(_http._HttpOutgoing, () => ({
>+  __proto__: dart.getGetters(_http._HttpOutgoing.__proto__),
>+  done: async.Future$(io.Socket)
>+}));
>+dart.setSetterSignature(_http._HttpOutgoing, () => ({
>+  __proto__: dart.getSetters(_http._HttpOutgoing.__proto__),
>+  gzip: core.bool
>+}));
>+dart.setLibraryUri(_http._HttpOutgoing, "dart:_http");
>+dart.setFieldSignature(_http._HttpOutgoing, () => ({
>+  __proto__: dart.getFields(_http._HttpOutgoing.__proto__),
>+  [_doneCompleter$]: dart.finalFieldType(CompleterOfSocket()),
>+  socket: dart.finalFieldType(io.Socket),
>+  ignoreBody: dart.fieldType(core.bool),
>+  headersWritten: dart.fieldType(core.bool),
>+  [_buffer$1]: dart.fieldType(typed_data.Uint8List),
>+  [_length$3]: dart.fieldType(core.int),
>+  [_closeFuture]: dart.fieldType(async.Future),
>+  chunked: dart.fieldType(core.bool),
>+  [_pendingChunkedFooter]: dart.fieldType(core.int),
>+  contentLength: dart.fieldType(core.int),
>+  [_bytesWritten]: dart.fieldType(core.int),
>+  [_gzip]: dart.fieldType(core.bool),
>+  [_gzipSink]: dart.fieldType(convert.ByteConversionSink),
>+  [_gzipAdd]: dart.fieldType(ListOfintTovoid()),
>+  [_gzipBuffer]: dart.fieldType(typed_data.Uint8List),
>+  [_gzipBufferLength]: dart.fieldType(core.int),
>+  [_socketError]: dart.fieldType(core.bool),
>+  outbound: dart.fieldType(_http._HttpOutboundMessage)
>+}));
>+dart.defineLazy(_http._HttpOutgoing, {
>+  /*_http._HttpOutgoing._footerAndChunk0Length*/get _footerAndChunk0Length() {
>+    return dart.constList([_http._CharCode.CR, _http._CharCode.LF, 48, _http._CharCode.CR, _http._CharCode.LF, _http._CharCode.CR, _http._CharCode.LF], core.int);
>+  },
>+  /*_http._HttpOutgoing._chunk0Length*/get _chunk0Length() {
>+    return dart.constList([48, _http._CharCode.CR, _http._CharCode.LF, _http._CharCode.CR, _http._CharCode.LF], core.int);
>+  }
>+});
>+const _context$ = dart.privateName(_http, "_context");
>+const _httpParser = dart.privateName(_http, "_httpParser");
>+const _subscription$0 = dart.privateName(_http, "_subscription");
>+const _dispose = dart.privateName(_http, "_dispose");
>+const _idleTimer = dart.privateName(_http, "_idleTimer");
>+const _currentUri = dart.privateName(_http, "_currentUri");
>+const _nextResponseCompleter = dart.privateName(_http, "_nextResponseCompleter");
>+const _streamFuture = dart.privateName(_http, "_streamFuture");
>+const _proxyCredentials = dart.privateName(_http, "_proxyCredentials");
>+const _returnConnection = dart.privateName(_http, "_returnConnection");
>+_http._HttpClientConnection = class _HttpClientConnection extends core.Object {
>+  send(uri, port, method, proxy) {
>+    if (dart.test(this.closed)) {
>+      dart.throw(new _http.HttpException.new("Socket closed before request was sent", {uri: uri}));
>+    }
>+    this[_currentUri] = uri;
>+    this[_subscription$0].pause();
>+    let proxyCreds = null;
>+    let creds = null;
>+    let outgoing = new _http._HttpOutgoing.new(this[_socket$]);
>+    let request = new _http._HttpClientRequest.new(outgoing, uri, method, proxy, this[_httpClient], this);
>+    let host = uri.host;
>+    if (host[$contains](":")) host = "[" + dart.str(host) + "]";
>+    request.headers.host = host;
>+    request.headers.port = port;
>+    request.headers[_add$2](_http.HttpHeaders.acceptEncodingHeader, "gzip");
>+    if (this[_httpClient].userAgent != null) {
>+      request.headers[_add$2]("user-agent", this[_httpClient].userAgent);
>+    }
>+    if (dart.test(proxy.isAuthenticated)) {
>+      let auth = _http._CryptoUtils.bytesToBase64(convert.utf8.encode(dart.str(proxy.username) + ":" + dart.str(proxy.password)));
>+      request.headers.set(_http.HttpHeaders.proxyAuthorizationHeader, "Basic " + dart.str(auth));
>+    } else if (!dart.test(proxy.isDirect) && dart.notNull(this[_httpClient][_proxyCredentials][$length]) > 0) {
>+      proxyCreds = this[_httpClient][_findProxyCredentials](proxy);
>+      if (proxyCreds != null) {
>+        proxyCreds.authorize(request);
>+      }
>+    }
>+    if (uri.userInfo != null && !uri.userInfo[$isEmpty]) {
>+      let auth = _http._CryptoUtils.bytesToBase64(convert.utf8.encode(uri.userInfo));
>+      request.headers.set(_http.HttpHeaders.authorizationHeader, "Basic " + dart.str(auth));
>+    } else {
>+      creds = this[_httpClient][_findCredentials](uri);
>+      if (creds != null) {
>+        creds.authorize(request);
>+      }
>+    }
>+    this[_httpParser].isHead = method === "HEAD";
>+    this[_streamFuture] = FutureOfSocket()._check(outgoing.done.then(io.Socket, dart.fn(s => {
>+      this[_nextResponseCompleter] = CompleterOf_HttpIncoming().new();
>+      FutureOfNull()._check(this[_nextResponseCompleter].future.then(core.Null, dart.fn(incoming => {
>+        this[_currentUri] = null;
>+        FutureOfNull()._check(incoming.dataDone.then(core.Null, dart.fn(closing => {
>+          if (dart.test(incoming.upgraded)) {
>+            this[_httpClient][_connectionClosed](this);
>+            this.startTimer();
>+            return;
>+          }
>+          if (dart.test(this.closed)) return;
>+          if (!dart.dtest(closing) && !dart.test(this[_dispose]) && dart.test(incoming.headers.persistentConnection) && dart.test(request.persistentConnection)) {
>+            this[_httpClient][_returnConnection](this);
>+            this[_subscription$0].resume();
>+          } else {
>+            this.destroy();
>+          }
>+        }, dynamicToNull())));
>+        if (proxyCreds != null && dart.equals(proxyCreds.scheme, _http._AuthenticationScheme.DIGEST)) {
>+          let authInfo = incoming.headers._get("proxy-authentication-info");
>+          if (authInfo != null && authInfo[$length] === 1) {
>+            let header = _http._HeaderValue.parse(authInfo[$_get](0), {parameterSeparator: ","});
>+            let nextnonce = header.parameters[$_get]("nextnonce");
>+            if (nextnonce != null) proxyCreds.nonce = nextnonce;
>+          }
>+        }
>+        if (creds != null && dart.equals(creds.scheme, _http._AuthenticationScheme.DIGEST)) {
>+          let authInfo = incoming.headers._get("authentication-info");
>+          if (authInfo != null && authInfo[$length] === 1) {
>+            let header = _http._HeaderValue.parse(authInfo[$_get](0), {parameterSeparator: ","});
>+            let nextnonce = header.parameters[$_get]("nextnonce");
>+            if (nextnonce != null) creds.nonce = nextnonce;
>+          }
>+        }
>+        request[_onIncoming](incoming);
>+      }, _HttpIncomingToNull()))).catchError(dart.fn(error => {
>+        dart.throw(new _http.HttpException.new("Connection closed before data was received", {uri: uri}));
>+      }, dynamicToNull()), {test: dart.fn(error => core.StateError.is(error), ObjectTobool())}).catchError(dart.fn((error, stackTrace) => {
>+        this.destroy();
>+        request[_onError$](error, core.StackTrace._check(stackTrace));
>+      }, dynamicAnddynamicToNull()));
>+      this[_subscription$0].resume();
>+      return s;
>+    }, SocketToSocket()), {onError: dart.fn(e => {
>+        this.destroy();
>+      }, dynamicToNull())}));
>+    return request;
>+  }
>+  detachSocket() {
>+    return FutureOfSocket()._check(this[_streamFuture].then(io.Socket, dart.fn(_ => new _http._DetachedSocket.new(this[_socket$], this[_httpParser].detachIncoming()), SocketTo_DetachedSocket())));
>+  }
>+  destroy() {
>+    this.closed = true;
>+    this[_httpClient][_connectionClosed](this);
>+    this[_socket$].destroy();
>+  }
>+  close() {
>+    this.closed = true;
>+    this[_httpClient][_connectionClosed](this);
>+    this[_streamFuture].timeout(this[_httpClient].idleTimeout).then(dart.void, dart.fn(_ => this[_socket$].destroy(), SocketTovoid()));
>+  }
>+  createProxyTunnel(host, port, proxy, callback) {
>+    let request = this.send(core.Uri.new({host: host, port: port}), port, "CONNECT", proxy);
>+    if (dart.test(proxy.isAuthenticated)) {
>+      let auth = _http._CryptoUtils.bytesToBase64(convert.utf8.encode(dart.str(proxy.username) + ":" + dart.str(proxy.password)));
>+      request.headers.set(_http.HttpHeaders.proxyAuthorizationHeader, "Basic " + dart.str(auth));
>+    }
>+    return FutureOf_HttpClientConnection()._check(FutureOfSecureSocket()._check(request.close().then(io.SecureSocket, dart.fn(response => {
>+      if (response.statusCode !== _internal.HttpStatus.ok) {
>+        dart.throw("Proxy failed to establish tunnel " + ("(" + dart.str(response.statusCode) + " " + dart.str(response.reasonPhrase) + ")"));
>+      }
>+      let socket = _http._HttpClientResponse.as(response)[_httpRequest][_httpClientConnection][_socket$];
>+      return io.SecureSocket.secure(socket, {host: host, context: this[_context$], onBadCertificate: callback});
>+    }, HttpClientResponseToFutureOfSecureSocket()))).then(_http._HttpClientConnection, dart.fn(secureSocket => {
>+      let key = core.String._check(_http._HttpClientConnection.makeKey(true, host, port));
>+      return new _http._HttpClientConnection.new(key, secureSocket, request[_httpClient], true);
>+    }, SecureSocketTo_HttpClientConnection())));
>+  }
>+  get connectionInfo() {
>+    return _http._HttpConnectionInfo.create(this[_socket$]);
>+  }
>+  static makeKey(isSecure, host, port) {
>+    return dart.test(isSecure) ? "ssh:" + dart.str(host) + ":" + dart.str(port) : dart.str(host) + ":" + dart.str(port);
>+  }
>+  stopTimer() {
>+    if (this[_idleTimer] != null) {
>+      this[_idleTimer].cancel();
>+      this[_idleTimer] = null;
>+    }
>+  }
>+  startTimer() {
>+    if (!(this[_idleTimer] == null)) dart.assertFailed(null, "dart:_http/http_impl.dart", 1825, 12, "_idleTimer == null");
>+    this[_idleTimer] = async.Timer.new(this[_httpClient].idleTimeout, dart.fn(() => {
>+      this[_idleTimer] = null;
>+      this.close();
>+    }, VoidToNull()));
>+  }
>+};
>+(_http._HttpClientConnection.new = function(key, socket, httpClient, proxyTunnel, context) {
>+  if (proxyTunnel === void 0) proxyTunnel = false;
>+  if (context === void 0) context = null;
>+  this[_subscription$0] = null;
>+  this[_dispose] = false;
>+  this[_idleTimer] = null;
>+  this.closed = false;
>+  this[_currentUri] = null;
>+  this[_nextResponseCompleter] = null;
>+  this[_streamFuture] = null;
>+  this.key = key;
>+  this[_socket$] = socket;
>+  this[_httpClient] = httpClient;
>+  this[_proxyTunnel] = proxyTunnel;
>+  this[_context$] = context;
>+  this[_httpParser] = _http._HttpParser.responseParser();
>+  this[_httpParser].listenToStream(this[_socket$]);
>+  this[_subscription$0] = this[_httpParser].listen(dart.fn(incoming => {
>+    this[_subscription$0].pause();
>+    if (this[_nextResponseCompleter] == null) {
>+      dart.throw(new _http.HttpException.new("Unexpected response (unsolicited response without request).", {uri: this[_currentUri]}));
>+    }
>+    if (incoming.statusCode === 100) {
>+      FutureOfNull()._check(incoming.drain(dart.dynamic).then(core.Null, dart.fn(_ => {
>+        this[_subscription$0].resume();
>+      }, dynamicToNull()))).catchError(dart.fn((error, stackTrace) => {
>+        if (stackTrace === void 0) stackTrace = null;
>+        this[_nextResponseCompleter].completeError(new _http.HttpException.new(core.String._check(dart.dload(error, 'message')), {uri: this[_currentUri]}), stackTrace);
>+        this[_nextResponseCompleter] = null;
>+      }, dynamic__ToNull()));
>+    } else {
>+      this[_nextResponseCompleter].complete(incoming);
>+      this[_nextResponseCompleter] = null;
>+    }
>+  }, _HttpIncomingToNull()), {onError: dart.fn((error, stackTrace) => {
>+      if (stackTrace === void 0) stackTrace = null;
>+      if (this[_nextResponseCompleter] != null) {
>+        this[_nextResponseCompleter].completeError(new _http.HttpException.new(core.String._check(dart.dload(error, 'message')), {uri: this[_currentUri]}), stackTrace);
>+        this[_nextResponseCompleter] = null;
>+      }
>+    }, dynamic__ToNull()), onDone: dart.fn(() => {
>+      if (this[_nextResponseCompleter] != null) {
>+        this[_nextResponseCompleter].completeError(new _http.HttpException.new("Connection closed before response was received", {uri: this[_currentUri]}));
>+        this[_nextResponseCompleter] = null;
>+      }
>+      this.close();
>+    }, VoidToNull())});
>+}).prototype = _http._HttpClientConnection.prototype;
>+dart.addTypeTests(_http._HttpClientConnection);
>+dart.setMethodSignature(_http._HttpClientConnection, () => ({
>+  __proto__: dart.getMethods(_http._HttpClientConnection.__proto__),
>+  send: dart.fnType(_http._HttpClientRequest, [core.Uri, core.int, core.String, _http._Proxy]),
>+  detachSocket: dart.fnType(async.Future$(io.Socket), []),
>+  destroy: dart.fnType(dart.void, []),
>+  close: dart.fnType(dart.void, []),
>+  createProxyTunnel: dart.fnType(async.Future$(_http._HttpClientConnection), [core.String, core.int, _http._Proxy, dart.fnType(core.bool, [io.X509Certificate])]),
>+  stopTimer: dart.fnType(dart.void, []),
>+  startTimer: dart.fnType(dart.void, [])
>+}));
>+dart.setGetterSignature(_http._HttpClientConnection, () => ({
>+  __proto__: dart.getGetters(_http._HttpClientConnection.__proto__),
>+  connectionInfo: _http.HttpConnectionInfo
>+}));
>+dart.setLibraryUri(_http._HttpClientConnection, "dart:_http");
>+dart.setFieldSignature(_http._HttpClientConnection, () => ({
>+  __proto__: dart.getFields(_http._HttpClientConnection.__proto__),
>+  key: dart.finalFieldType(core.String),
>+  [_socket$]: dart.finalFieldType(io.Socket),
>+  [_proxyTunnel]: dart.finalFieldType(core.bool),
>+  [_context$]: dart.finalFieldType(io.SecurityContext),
>+  [_httpParser]: dart.finalFieldType(_http._HttpParser),
>+  [_subscription$0]: dart.fieldType(async.StreamSubscription),
>+  [_httpClient]: dart.finalFieldType(_http._HttpClient),
>+  [_dispose]: dart.fieldType(core.bool),
>+  [_idleTimer]: dart.fieldType(async.Timer),
>+  closed: dart.fieldType(core.bool),
>+  [_currentUri]: dart.fieldType(core.Uri),
>+  [_nextResponseCompleter]: dart.fieldType(CompleterOf_HttpIncoming()),
>+  [_streamFuture]: dart.fieldType(FutureOfSocket())
>+}));
>+_http._ConnectionInfo = class _ConnectionInfo extends core.Object {};
>+(_http._ConnectionInfo.new = function(connection, proxy) {
>+  this.connection = connection;
>+  this.proxy = proxy;
>+}).prototype = _http._ConnectionInfo.prototype;
>+dart.addTypeTests(_http._ConnectionInfo);
>+dart.setLibraryUri(_http._ConnectionInfo, "dart:_http");
>+dart.setFieldSignature(_http._ConnectionInfo, () => ({
>+  __proto__: dart.getFields(_http._ConnectionInfo.__proto__),
>+  connection: dart.finalFieldType(_http._HttpClientConnection),
>+  proxy: dart.finalFieldType(_http._Proxy)
>+}));
>+const _idle = dart.privateName(_http, "_idle");
>+const _active = dart.privateName(_http, "_active");
>+const _socketTasks = dart.privateName(_http, "_socketTasks");
>+const _pending$ = dart.privateName(_http, "_pending");
>+const _connecting = dart.privateName(_http, "_connecting");
>+const _checkPending = dart.privateName(_http, "_checkPending");
>+const _connectionsChanged = dart.privateName(_http, "_connectionsChanged");
>+const _badCertificateCallback = dart.privateName(_http, "_badCertificateCallback");
>+const _getConnectionTarget = dart.privateName(_http, "_getConnectionTarget");
>+_http._ConnectionTarget = class _ConnectionTarget extends core.Object {
>+  get isEmpty() {
>+    return dart.test(this[_idle].isEmpty) && dart.test(this[_active].isEmpty) && this[_connecting] === 0;
>+  }
>+  get hasIdle() {
>+    return this[_idle].isNotEmpty;
>+  }
>+  get hasActive() {
>+    return dart.test(this[_active].isNotEmpty) || dart.notNull(this[_connecting]) > 0;
>+  }
>+  takeIdle() {
>+    if (!dart.test(this.hasIdle)) dart.assertFailed(null, "dart:_http/http_impl.dart", 1863, 12, "hasIdle");
>+    let connection = this[_idle].first;
>+    this[_idle].remove(connection);
>+    connection.stopTimer();
>+    this[_active].add(connection);
>+    return connection;
>+  }
>+  [_checkPending]() {
>+    if (dart.test(this[_pending$].isNotEmpty)) {
>+      dart.dcall(this[_pending$].removeFirst(), []);
>+    }
>+  }
>+  addNewActive(connection) {
>+    this[_active].add(connection);
>+  }
>+  returnConnection(connection) {
>+    if (!dart.test(this[_active].contains(connection))) dart.assertFailed(null, "dart:_http/http_impl.dart", 1882, 12, "_active.contains(connection)");
>+    this[_active].remove(connection);
>+    this[_idle].add(connection);
>+    connection.startTimer();
>+    this[_checkPending]();
>+  }
>+  connectionClosed(connection) {
>+    if (!(!dart.test(this[_active].contains(connection)) || !dart.test(this[_idle].contains(connection)))) dart.assertFailed(null, "dart:_http/http_impl.dart", 1890, 12, "!_active.contains(connection) || !_idle.contains(connection)");
>+    this[_active].remove(connection);
>+    this[_idle].remove(connection);
>+    this[_checkPending]();
>+  }
>+  close(force) {
>+    for (let t of this[_socketTasks].toList()) {
>+      FutureOfNull()._check(t.socket.then(core.Null, dart.fn(s => {
>+        dart.dsend(s, 'destroy', []);
>+      }, dynamicToNull()), {onError: dart.fn(e => {
>+        }, dynamicToNull())}));
>+      t.cancel();
>+    }
>+    if (dart.test(force)) {
>+      for (let c of this[_idle].toList()) {
>+        c.destroy();
>+      }
>+      for (let c of this[_active].toList()) {
>+        c.destroy();
>+      }
>+    } else {
>+      for (let c of this[_idle].toList()) {
>+        c.close();
>+      }
>+    }
>+  }
>+  connect(uriHost, uriPort, proxy, client) {
>+    if (dart.test(this.hasIdle)) {
>+      let connection = this.takeIdle();
>+      client[_connectionsChanged]();
>+      return FutureOf_ConnectionInfo().value(new _http._ConnectionInfo.new(connection, proxy));
>+    }
>+    if (client.maxConnectionsPerHost != null && dart.notNull(this[_active].length) + dart.notNull(this[_connecting]) >= dart.notNull(client.maxConnectionsPerHost)) {
>+      let completer = CompleterOf_ConnectionInfo().new();
>+      this[_pending$].add(dart.fn(() => {
>+        completer.complete(this.connect(uriHost, uriPort, proxy, client));
>+      }, VoidToNull()));
>+      return completer.future;
>+    }
>+    let currentBadCertificateCallback = client[_badCertificateCallback];
>+    function callback(certificate) {
>+      if (currentBadCertificateCallback == null) return false;
>+      return currentBadCertificateCallback(certificate, uriHost, uriPort);
>+    }
>+    dart.fn(callback, X509CertificateTobool());
>+    let connectionTask = dart.test(this.isSecure) && dart.test(proxy.isDirect) ? io.SecureSocket.startConnect(this.host, this.port, {context: this.context, onBadCertificate: callback}) : io.Socket.startConnect(this.host, this.port);
>+    this[_connecting] = dart.notNull(this[_connecting]) + 1;
>+    return FutureOf_ConnectionInfo()._check(connectionTask.then(_http._ConnectionInfo, dart.fn(task => {
>+      this[_socketTasks].add(task);
>+      let socketFuture = task.socket;
>+      if (client.connectionTimeout != null) {
>+        socketFuture = socketFuture.timeout(client.connectionTimeout, {onTimeout: dart.fn(() => {
>+            this[_socketTasks].remove(task);
>+            task.cancel();
>+          }, VoidToNull())});
>+      }
>+      return FutureOf_ConnectionInfo()._check(socketFuture.then(_http._ConnectionInfo, dart.fn(socket => {
>+        this[_connecting] = dart.notNull(this[_connecting]) - 1;
>+        dart.dsend(socket, 'setOption', [io.SocketOption.tcpNoDelay, true]);
>+        let connection = new _http._HttpClientConnection.new(this.key, io.Socket._check(socket), client, false, this.context);
>+        if (dart.test(this.isSecure) && !dart.test(proxy.isDirect)) {
>+          connection[_dispose] = true;
>+          return FutureOf_ConnectionInfo()._check(connection.createProxyTunnel(uriHost, uriPort, proxy, callback).then(_http._ConnectionInfo, dart.fn(tunnel => {
>+            client[_getConnectionTarget](uriHost, uriPort, true).addNewActive(tunnel);
>+            this[_socketTasks].remove(task);
>+            return new _http._ConnectionInfo.new(tunnel, proxy);
>+          }, _HttpClientConnectionTo_ConnectionInfo())));
>+        } else {
>+          this.addNewActive(connection);
>+          this[_socketTasks].remove(task);
>+          return new _http._ConnectionInfo.new(connection, proxy);
>+        }
>+      }, dynamicToFutureOrOf_ConnectionInfo()), {onError: dart.fn(error => {
>+          this[_connecting] = dart.notNull(this[_connecting]) - 1;
>+          this[_socketTasks].remove(task);
>+          this[_checkPending]();
>+          dart.throw(error);
>+        }, dynamicToNull())}));
>+    }, ConnectionTaskToFutureOf_ConnectionInfo())));
>+  }
>+};
>+(_http._ConnectionTarget.new = function(key, host, port, isSecure, context) {
>+  this[_idle] = new (_HashSetOf_HttpClientConnection()).new();
>+  this[_active] = new (_HashSetOf_HttpClientConnection()).new();
>+  this[_socketTasks] = new (_HashSetOfConnectionTask()).new();
>+  this[_pending$] = new collection.ListQueue.new();
>+  this[_connecting] = 0;
>+  this.key = key;
>+  this.host = host;
>+  this.port = port;
>+  this.isSecure = isSecure;
>+  this.context = context;
>+}).prototype = _http._ConnectionTarget.prototype;
>+dart.addTypeTests(_http._ConnectionTarget);
>+dart.setMethodSignature(_http._ConnectionTarget, () => ({
>+  __proto__: dart.getMethods(_http._ConnectionTarget.__proto__),
>+  takeIdle: dart.fnType(_http._HttpClientConnection, []),
>+  [_checkPending]: dart.fnType(dart.dynamic, []),
>+  addNewActive: dart.fnType(dart.void, [_http._HttpClientConnection]),
>+  returnConnection: dart.fnType(dart.void, [_http._HttpClientConnection]),
>+  connectionClosed: dart.fnType(dart.void, [_http._HttpClientConnection]),
>+  close: dart.fnType(dart.void, [core.bool]),
>+  connect: dart.fnType(async.Future$(_http._ConnectionInfo), [core.String, core.int, _http._Proxy, _http._HttpClient])
>+}));
>+dart.setGetterSignature(_http._ConnectionTarget, () => ({
>+  __proto__: dart.getGetters(_http._ConnectionTarget.__proto__),
>+  isEmpty: core.bool,
>+  hasIdle: core.bool,
>+  hasActive: core.bool
>+}));
>+dart.setLibraryUri(_http._ConnectionTarget, "dart:_http");
>+dart.setFieldSignature(_http._ConnectionTarget, () => ({
>+  __proto__: dart.getFields(_http._ConnectionTarget.__proto__),
>+  key: dart.finalFieldType(core.String),
>+  host: dart.finalFieldType(core.String),
>+  port: dart.finalFieldType(core.int),
>+  isSecure: dart.finalFieldType(core.bool),
>+  context: dart.finalFieldType(io.SecurityContext),
>+  [_idle]: dart.finalFieldType(SetOf_HttpClientConnection()),
>+  [_active]: dart.finalFieldType(SetOf_HttpClientConnection()),
>+  [_socketTasks]: dart.finalFieldType(SetOfConnectionTask()),
>+  [_pending$]: dart.finalFieldType(collection.Queue),
>+  [_connecting]: dart.fieldType(core.int)
>+}));
>+const _closing = dart.privateName(_http, "_closing");
>+const _closingForcefully = dart.privateName(_http, "_closingForcefully");
>+const _connectionTargets = dart.privateName(_http, "_connectionTargets");
>+const _credentials = dart.privateName(_http, "_credentials");
>+const _findProxy = dart.privateName(_http, "_findProxy");
>+const _idleTimeout = dart.privateName(_http, "_idleTimeout");
>+let const$100;
>+const _openUrl = dart.privateName(_http, "_openUrl");
>+const _closeConnections = dart.privateName(_http, "_closeConnections");
>+let const$101;
>+const _getConnection = dart.privateName(_http, "_getConnection");
>+_http._HttpClient = class _HttpClient extends core.Object {
>+  get idleTimeout() {
>+    return this[_idleTimeout];
>+  }
>+  set idleTimeout(timeout) {
>+    this[_idleTimeout] = timeout;
>+    for (let c of this[_connectionTargets][$values]) {
>+      for (let idle of c[_idle]) {
>+        idle.stopTimer();
>+        idle.startTimer();
>+      }
>+    }
>+  }
>+  set badCertificateCallback(callback) {
>+    this[_badCertificateCallback] = callback;
>+  }
>+  open(method, host, port, path) {
>+    let hashMark = 35;
>+    let questionMark = 63;
>+    let fragmentStart = path.length;
>+    let queryStart = path.length;
>+    for (let i = path.length - 1; i >= 0; i--) {
>+      let char = path[$codeUnitAt](i);
>+      if (char === hashMark) {
>+        fragmentStart = i;
>+        queryStart = i;
>+      } else if (char === questionMark) {
>+        queryStart = i;
>+      }
>+    }
>+    let query = null;
>+    if (queryStart < fragmentStart) {
>+      query = path[$substring](queryStart + 1, fragmentStart);
>+      path = path[$substring](0, queryStart);
>+    }
>+    let uri = core.Uri.new({scheme: "http", host: host, port: port, path: path, query: query});
>+    return this[_openUrl](method, uri);
>+  }
>+  openUrl(method, url) {
>+    return this[_openUrl](method, url);
>+  }
>+  get(host, port, path) {
>+    return this.open("get", host, port, path);
>+  }
>+  getUrl(url) {
>+    return this[_openUrl]("get", url);
>+  }
>+  post(host, port, path) {
>+    return this.open("post", host, port, path);
>+  }
>+  postUrl(url) {
>+    return this[_openUrl]("post", url);
>+  }
>+  put(host, port, path) {
>+    return this.open("put", host, port, path);
>+  }
>+  putUrl(url) {
>+    return this[_openUrl]("put", url);
>+  }
>+  delete(host, port, path) {
>+    return this.open("delete", host, port, path);
>+  }
>+  deleteUrl(url) {
>+    return this[_openUrl]("delete", url);
>+  }
>+  head(host, port, path) {
>+    return this.open("head", host, port, path);
>+  }
>+  headUrl(url) {
>+    return this[_openUrl]("head", url);
>+  }
>+  patch(host, port, path) {
>+    return this.open("patch", host, port, path);
>+  }
>+  patchUrl(url) {
>+    return this[_openUrl]("patch", url);
>+  }
>+  close(opts) {
>+    let force = opts && 'force' in opts ? opts.force : false;
>+    this[_closing] = true;
>+    this[_closingForcefully] = force;
>+    this[_closeConnections](this[_closingForcefully]);
>+    if (!!dart.test(this[_connectionTargets][$values][$any](dart.fn(s => s.hasIdle, _ConnectionTargetTobool())))) dart.assertFailed(null, "dart:_http/http_impl.dart", 2093, 12, "!_connectionTargets.values.any((s) => s.hasIdle)");
>+    if (!(!dart.test(force) || !dart.test(this[_connectionTargets][$values][$any](dart.fn(s => s[_active].isNotEmpty, _ConnectionTargetTobool()))))) dart.assertFailed(null, "dart:_http/http_impl.dart", 2095, 9, "!force || !_connectionTargets.values.any((s) => s._active.isNotEmpty)");
>+  }
>+  set authenticate(f) {
>+    this[_authenticate] = f;
>+  }
>+  addCredentials(url, realm, cr) {
>+    this[_credentials][$add](new _http._SiteCredentials.new(url, realm, _http._HttpClientCredentials._check(cr)));
>+  }
>+  set authenticateProxy(f) {
>+    this[_authenticateProxy] = f;
>+  }
>+  addProxyCredentials(host, port, realm, cr) {
>+    this[_proxyCredentials][$add](new _http._ProxyCredentials.new(host, port, realm, _http._HttpClientCredentials._check(cr)));
>+  }
>+  set findProxy(f) {
>+    return this[_findProxy] = f;
>+  }
>+  [_openUrl](method, uri) {
>+    if (dart.test(this[_closing])) {
>+      dart.throw(new core.StateError.new("Client is closed"));
>+    }
>+    uri = uri.removeFragment();
>+    if (method == null) {
>+      dart.throw(new core.ArgumentError.new(method));
>+    }
>+    if (method !== "CONNECT") {
>+      if (uri.host[$isEmpty]) {
>+        dart.throw(new core.ArgumentError.new("No host specified in URI " + dart.str(uri)));
>+      } else if (uri.scheme !== "http" && uri.scheme !== "https") {
>+        dart.throw(new core.ArgumentError.new("Unsupported scheme '" + dart.str(uri.scheme) + "' in URI " + dart.str(uri)));
>+      }
>+    }
>+    let isSecure = uri.scheme === "https";
>+    let port = uri.port;
>+    if (port === 0) {
>+      port = isSecure ? _http.HttpClient.defaultHttpsPort : _http.HttpClient.defaultHttpPort;
>+    }
>+    let proxyConf = const$101 || (const$101 = dart.const(new _http._ProxyConfiguration.direct()));
>+    if (this[_findProxy] != null) {
>+      try {
>+        proxyConf = new _http._ProxyConfiguration.new(core.String._check(dart.dcall(this[_findProxy], [uri])));
>+      } catch (e) {
>+        let error = dart.getThrown(e);
>+        let stackTrace = dart.stackTrace(e);
>+        return FutureOf_HttpClientRequest().error(error, stackTrace);
>+      }
>+    }
>+    return FutureOf_HttpClientRequest()._check(this[_getConnection](uri.host, port, proxyConf, isSecure).then(_http._HttpClientRequest, dart.fn(info => {
>+      function send(info) {
>+        return info.connection.send(uri, port, method[$toUpperCase](), info.proxy);
>+      }
>+      dart.fn(send, _ConnectionInfoTo_HttpClientRequest());
>+      if (dart.test(info.connection.closed)) {
>+        return FutureOf_HttpClientRequest()._check(this[_getConnection](uri.host, port, proxyConf, isSecure).then(_http._HttpClientRequest, send));
>+      }
>+      return send(info);
>+    }, _ConnectionInfoToFutureOrOf_HttpClientRequest())));
>+  }
>+  [_openUrlFromRequest](method, uri, previous) {
>+    let resolved = previous.uri.resolveUri(uri);
>+    return FutureOf_HttpClientRequest()._check(this[_openUrl](method, resolved).then(_http._HttpClientRequest, dart.fn(request => {
>+      request.followRedirects = previous.followRedirects;
>+      request.maxRedirects = previous.maxRedirects;
>+      for (let header of previous.headers[_headers][$keys]) {
>+        if (request.headers._get(header) == null) {
>+          request.headers.set(header, previous.headers._get(header));
>+        }
>+      }
>+      request.headers.chunkedTransferEncoding = false;
>+      request.contentLength = 0;
>+      return request;
>+    }, _HttpClientRequestTo_HttpClientRequest())));
>+  }
>+  [_returnConnection](connection) {
>+    this[_connectionTargets][$_get](connection.key).returnConnection(connection);
>+    this[_connectionsChanged]();
>+  }
>+  [_connectionClosed](connection) {
>+    connection.stopTimer();
>+    let connectionTarget = this[_connectionTargets][$_get](connection.key);
>+    if (connectionTarget != null) {
>+      connectionTarget.connectionClosed(connection);
>+      if (dart.test(connectionTarget.isEmpty)) {
>+        this[_connectionTargets][$remove](connection.key);
>+      }
>+      this[_connectionsChanged]();
>+    }
>+  }
>+  [_connectionsChanged]() {
>+    if (dart.test(this[_closing])) {
>+      this[_closeConnections](this[_closingForcefully]);
>+    }
>+  }
>+  [_closeConnections](force) {
>+    for (let connectionTarget of this[_connectionTargets][$values][$toList]()) {
>+      connectionTarget.close(force);
>+    }
>+  }
>+  [_getConnectionTarget](host, port, isSecure) {
>+    let key = core.String._check(_http._HttpClientConnection.makeKey(isSecure, host, port));
>+    return this[_connectionTargets][$putIfAbsent](key, dart.fn(() => new _http._ConnectionTarget.new(key, host, port, isSecure, this[_context$]), VoidTo_ConnectionTarget()));
>+  }
>+  [_getConnection](uriHost, uriPort, proxyConf, isSecure) {
>+    let proxies = proxyConf.proxies[$iterator];
>+    const connect = error => {
>+      if (!dart.test(proxies.moveNext())) return FutureOf_ConnectionInfo().error(error);
>+      let proxy = proxies.current;
>+      let host = dart.test(proxy.isDirect) ? uriHost : proxy.host;
>+      let port = dart.test(proxy.isDirect) ? uriPort : proxy.port;
>+      return this[_getConnectionTarget](host, port, isSecure).connect(uriHost, uriPort, proxy, this).catchError(connect);
>+    };
>+    dart.fn(connect, dynamicToFutureOf_ConnectionInfo());
>+    return connect(new _http.HttpException.new("No proxies given"));
>+  }
>+  [_findCredentials](url, scheme) {
>+    if (scheme === void 0) scheme = null;
>+    let cr = _http._SiteCredentials._check(this[_credentials][$fold](_http._SiteCredentials, null, dart.fn((prev, value) => {
>+      let siteCredentials = _http._SiteCredentials.as(value);
>+      if (dart.test(siteCredentials.applies(url, scheme))) {
>+        if (prev == null) return _http._SiteCredentials._check(value);
>+        return siteCredentials.uri.path.length > prev.uri.path.length ? siteCredentials : prev;
>+      } else {
>+        return prev;
>+      }
>+    }, _SiteCredentialsAnd_CredentialsTo_SiteCredentials())));
>+    return cr;
>+  }
>+  [_findProxyCredentials](proxy, scheme) {
>+    if (scheme === void 0) scheme = null;
>+    let it = this[_proxyCredentials][$iterator];
>+    while (dart.test(it.moveNext())) {
>+      if (dart.test(it.current.applies(proxy, scheme))) {
>+        return it.current;
>+      }
>+    }
>+    return null;
>+  }
>+  [_removeCredentials](cr) {
>+    let index = this[_credentials][$indexOf](cr);
>+    if (index !== -1) {
>+      this[_credentials][$removeAt](index);
>+    }
>+  }
>+  [_removeProxyCredentials](cr) {
>+    let index = this[_proxyCredentials][$indexOf](_http._ProxyCredentials._check(cr));
>+    if (index !== -1) {
>+      this[_proxyCredentials][$removeAt](index);
>+    }
>+  }
>+  static _findProxyFromEnvironment(url, environment) {
>+    function checkNoProxy(option) {
>+      if (option == null) return null;
>+      let names = IterableOfString()._check(option[$split](",")[$map](core.String, dart.fn(s => s[$trim](), StringToString())))[$iterator];
>+      while (dart.test(names.moveNext())) {
>+        let name = names.current;
>+        if (name[$startsWith]("[") && name[$endsWith]("]") && "[" + dart.str(url.host) + "]" === name || name[$isNotEmpty] && url.host[$endsWith](name)) {
>+          return "DIRECT";
>+        }
>+      }
>+      return null;
>+    }
>+    dart.fn(checkNoProxy, StringToString());
>+    function checkProxy(option) {
>+      if (option == null) return null;
>+      option = option[$trim]();
>+      if (option[$isEmpty]) return null;
>+      let pos = option[$indexOf]("://");
>+      if (pos >= 0) {
>+        option = option[$substring](pos + 3);
>+      }
>+      pos = option[$indexOf]("/");
>+      if (pos >= 0) {
>+        option = option[$substring](0, pos);
>+      }
>+      if (option[$indexOf]("[") === 0) {
>+        let pos = option[$lastIndexOf](":");
>+        if (option[$indexOf]("]") > pos) option = dart.str(option) + ":1080";
>+      } else {
>+        if (option[$indexOf](":") === -1) option = dart.str(option) + ":1080";
>+      }
>+      return "PROXY " + dart.str(option);
>+    }
>+    dart.fn(checkProxy, StringToString());
>+    if (environment == null) environment = _http._HttpClient._platformEnvironmentCache;
>+    let proxyCfg = null;
>+    let noProxy = environment[$_get]("no_proxy");
>+    if (noProxy == null) noProxy = environment[$_get]("NO_PROXY");
>+    if ((proxyCfg = checkNoProxy(noProxy)) != null) {
>+      return proxyCfg;
>+    }
>+    if (url.scheme === "http") {
>+      let proxy = environment[$_get]("http_proxy");
>+      if (proxy == null) proxy = environment[$_get]("HTTP_PROXY");
>+      if ((proxyCfg = checkProxy(proxy)) != null) {
>+        return proxyCfg;
>+      }
>+    } else if (url.scheme === "https") {
>+      let proxy = environment[$_get]("https_proxy");
>+      if (proxy == null) proxy = environment[$_get]("HTTPS_PROXY");
>+      if ((proxyCfg = checkProxy(proxy)) != null) {
>+        return proxyCfg;
>+      }
>+    }
>+    return "DIRECT";
>+  }
>+};
>+(_http._HttpClient.new = function(context) {
>+  this[_closing] = false;
>+  this[_closingForcefully] = false;
>+  this[_connectionTargets] = new (IdentityMapOfString$_ConnectionTarget()).new();
>+  this[_credentials] = JSArrayOf_Credentials().of([]);
>+  this[_proxyCredentials] = JSArrayOf_ProxyCredentials().of([]);
>+  this[_authenticate] = null;
>+  this[_authenticateProxy] = null;
>+  this[_findProxy] = dart.fn(_http.HttpClient.findProxyFromEnvironment, Uri__ToString());
>+  this[_idleTimeout] = const$100 || (const$100 = dart.const(new core.Duration.new({seconds: 15})));
>+  this[_badCertificateCallback] = null;
>+  this.connectionTimeout = null;
>+  this.maxConnectionsPerHost = null;
>+  this.autoUncompress = true;
>+  this.userAgent = _http._getHttpVersion();
>+  this[_context$] = context;
>+}).prototype = _http._HttpClient.prototype;
>+dart.addTypeTests(_http._HttpClient);
>+_http._HttpClient[dart.implements] = () => [_http.HttpClient];
>+dart.setMethodSignature(_http._HttpClient, () => ({
>+  __proto__: dart.getMethods(_http._HttpClient.__proto__),
>+  open: dart.fnType(async.Future$(_http.HttpClientRequest), [core.String, core.String, core.int, core.String]),
>+  openUrl: dart.fnType(async.Future$(_http.HttpClientRequest), [core.String, core.Uri]),
>+  get: dart.fnType(async.Future$(_http.HttpClientRequest), [core.String, core.int, core.String]),
>+  getUrl: dart.fnType(async.Future$(_http.HttpClientRequest), [core.Uri]),
>+  post: dart.fnType(async.Future$(_http.HttpClientRequest), [core.String, core.int, core.String]),
>+  postUrl: dart.fnType(async.Future$(_http.HttpClientRequest), [core.Uri]),
>+  put: dart.fnType(async.Future$(_http.HttpClientRequest), [core.String, core.int, core.String]),
>+  putUrl: dart.fnType(async.Future$(_http.HttpClientRequest), [core.Uri]),
>+  delete: dart.fnType(async.Future$(_http.HttpClientRequest), [core.String, core.int, core.String]),
>+  deleteUrl: dart.fnType(async.Future$(_http.HttpClientRequest), [core.Uri]),
>+  head: dart.fnType(async.Future$(_http.HttpClientRequest), [core.String, core.int, core.String]),
>+  headUrl: dart.fnType(async.Future$(_http.HttpClientRequest), [core.Uri]),
>+  patch: dart.fnType(async.Future$(_http.HttpClientRequest), [core.String, core.int, core.String]),
>+  patchUrl: dart.fnType(async.Future$(_http.HttpClientRequest), [core.Uri]),
>+  close: dart.fnType(dart.void, [], {force: core.bool}),
>+  addCredentials: dart.fnType(dart.void, [core.Uri, core.String, _http.HttpClientCredentials]),
>+  addProxyCredentials: dart.fnType(dart.void, [core.String, core.int, core.String, _http.HttpClientCredentials]),
>+  [_openUrl]: dart.fnType(async.Future$(_http._HttpClientRequest), [core.String, core.Uri]),
>+  [_openUrlFromRequest]: dart.fnType(async.Future$(_http._HttpClientRequest), [core.String, core.Uri, _http._HttpClientRequest]),
>+  [_returnConnection]: dart.fnType(dart.void, [_http._HttpClientConnection]),
>+  [_connectionClosed]: dart.fnType(dart.void, [_http._HttpClientConnection]),
>+  [_connectionsChanged]: dart.fnType(dart.void, []),
>+  [_closeConnections]: dart.fnType(dart.void, [core.bool]),
>+  [_getConnectionTarget]: dart.fnType(_http._ConnectionTarget, [core.String, core.int, core.bool]),
>+  [_getConnection]: dart.fnType(async.Future$(_http._ConnectionInfo), [core.String, core.int, _http._ProxyConfiguration, core.bool]),
>+  [_findCredentials]: dart.fnType(_http._SiteCredentials, [core.Uri], [_http._AuthenticationScheme]),
>+  [_findProxyCredentials]: dart.fnType(_http._ProxyCredentials, [_http._Proxy], [_http._AuthenticationScheme]),
>+  [_removeCredentials]: dart.fnType(dart.void, [_http._Credentials]),
>+  [_removeProxyCredentials]: dart.fnType(dart.void, [_http._Credentials])
>+}));
>+dart.setGetterSignature(_http._HttpClient, () => ({
>+  __proto__: dart.getGetters(_http._HttpClient.__proto__),
>+  idleTimeout: core.Duration
>+}));
>+dart.setSetterSignature(_http._HttpClient, () => ({
>+  __proto__: dart.getSetters(_http._HttpClient.__proto__),
>+  idleTimeout: core.Duration,
>+  badCertificateCallback: dart.fnType(core.bool, [io.X509Certificate, core.String, core.int]),
>+  authenticate: dart.fnType(async.Future$(core.bool), [core.Uri, core.String, core.String]),
>+  authenticateProxy: dart.fnType(async.Future$(core.bool), [core.String, core.int, core.String, core.String]),
>+  findProxy: dart.fnType(core.String, [core.Uri])
>+}));
>+dart.setLibraryUri(_http._HttpClient, "dart:_http");
>+dart.setFieldSignature(_http._HttpClient, () => ({
>+  __proto__: dart.getFields(_http._HttpClient.__proto__),
>+  [_closing]: dart.fieldType(core.bool),
>+  [_closingForcefully]: dart.fieldType(core.bool),
>+  [_connectionTargets]: dart.finalFieldType(MapOfString$_ConnectionTarget()),
>+  [_credentials]: dart.finalFieldType(ListOf_Credentials()),
>+  [_proxyCredentials]: dart.finalFieldType(ListOf_ProxyCredentials()),
>+  [_context$]: dart.finalFieldType(io.SecurityContext),
>+  [_authenticate]: dart.fieldType(core.Function),
>+  [_authenticateProxy]: dart.fieldType(core.Function),
>+  [_findProxy]: dart.fieldType(core.Function),
>+  [_idleTimeout]: dart.fieldType(core.Duration),
>+  [_badCertificateCallback]: dart.fieldType(X509CertificateAndStringAndintTobool()),
>+  connectionTimeout: dart.fieldType(core.Duration),
>+  maxConnectionsPerHost: dart.fieldType(core.int),
>+  autoUncompress: dart.fieldType(core.bool),
>+  userAgent: dart.fieldType(core.String)
>+}));
>+dart.defineLazy(_http._HttpClient, {
>+  /*_http._HttpClient._platformEnvironmentCache*/get _platformEnvironmentCache() {
>+    return io.Platform.environment;
>+  },
>+  set _platformEnvironmentCache(_) {}
>+});
>+const _state$1 = dart.privateName(_http, "_state");
>+const _idleMark = dart.privateName(_http, "_idleMark");
>+const _markActive = dart.privateName(_http, "_markActive");
>+const _markIdle = dart.privateName(_http, "_markIdle");
>+const _handleRequest = dart.privateName(_http, "_handleRequest");
>+const _isActive = dart.privateName(_http, "_isActive");
>+const _isIdle = dart.privateName(_http, "_isIdle");
>+const _isDetached = dart.privateName(_http, "_isDetached");
>+const _toJSON$ = dart.privateName(_http, "_toJSON");
>+const LinkedListEntry__ServiceObject$ = class LinkedListEntry__ServiceObject extends collection.LinkedListEntry {};
>+(LinkedListEntry__ServiceObject$.new = function() {
>+  _http._ServiceObject.new.call(this);
>+  LinkedListEntry__ServiceObject$.__proto__.new.call(this);
>+}).prototype = LinkedListEntry__ServiceObject$.prototype;
>+dart.applyMixin(LinkedListEntry__ServiceObject$, _http._ServiceObject);
>+_http._HttpConnection = class _HttpConnection extends LinkedListEntry__ServiceObject$ {
>+  markIdle() {
>+    this[_idleMark] = true;
>+  }
>+  get isMarkedIdle() {
>+    return this[_idleMark];
>+  }
>+  destroy() {
>+    if (this[_state$1] === 2 || this[_state$1] === 3) return;
>+    this[_state$1] = 2;
>+    dart.dsend(this[_socket$], 'destroy', []);
>+    this[_httpServer][_connectionClosed](this);
>+    _http._HttpConnection._connections[$remove](this[_serviceId$]);
>+  }
>+  detachSocket() {
>+    this[_state$1] = 3;
>+    this[_httpServer][_connectionClosed](this);
>+    let detachedIncoming = this[_httpParser].detachIncoming();
>+    return FutureOfSocket()._check(this[_streamFuture].then(io.Socket, dart.fn(_ => {
>+      _http._HttpConnection._connections[$remove](this[_serviceId$]);
>+      return new _http._DetachedSocket.new(io.Socket._check(this[_socket$]), detachedIncoming);
>+    }, dynamicTo_DetachedSocket())));
>+  }
>+  get connectionInfo() {
>+    return _http._HttpConnectionInfo.create(io.Socket._check(this[_socket$]));
>+  }
>+  get [_isActive]() {
>+    return this[_state$1] === 0;
>+  }
>+  get [_isIdle]() {
>+    return this[_state$1] === 1;
>+  }
>+  get [_isClosing]() {
>+    return this[_state$1] === 2;
>+  }
>+  get [_isDetached]() {
>+    return this[_state$1] === 3;
>+  }
>+  get [_serviceTypePath$]() {
>+    return "io/http/serverconnections";
>+  }
>+  get [_serviceTypeName$]() {
>+    return "HttpServerConnection";
>+  }
>+  [_toJSON$](ref) {
>+    let name = dart.str(dart.dload(dart.dload(this[_socket$], 'address'), 'host')) + ":" + dart.str(dart.dload(this[_socket$], 'port')) + " <-> " + (dart.str(dart.dload(dart.dload(this[_socket$], 'remoteAddress'), 'host')) + ":" + dart.str(dart.dload(this[_socket$], 'remotePort')));
>+    let r = new (IdentityMapOfString$dynamic()).from(["id", this[_servicePath$], "type", this[_serviceType$](ref), "name", name, "user_name", name]);
>+    if (dart.test(ref)) {
>+      return r;
>+    }
>+    r[$_set]("server", this[_httpServer][_toJSON$](true));
>+    try {
>+      r[$_set]("socket", dart.dsend(this[_socket$], _toJSON$, [true]));
>+    } catch (e) {
>+      let _ = dart.getThrown(e);
>+      r[$_set]("socket", new (IdentityMapOfString$String()).from(["id", this[_servicePath$], "type", "@Socket", "name", "UserSocket", "user_name", "UserSocket"]));
>+    }
>+    switch (this[_state$1]) {
>+      case 0:
>+      {
>+        r[$_set]("state", "Active");
>+        break;
>+      }
>+      case 1:
>+      {
>+        r[$_set]("state", "Idle");
>+        break;
>+      }
>+      case 2:
>+      {
>+        r[$_set]("state", "Closing");
>+        break;
>+      }
>+      case 3:
>+      {
>+        r[$_set]("state", "Detached");
>+        break;
>+      }
>+      default:
>+      {
>+        r[$_set]("state", "Unknown");
>+        break;
>+      }
>+    }
>+    return r;
>+  }
>+};
>+(_http._HttpConnection.new = function(socket, httpServer) {
>+  this[_state$1] = 1;
>+  this[_subscription$0] = null;
>+  this[_idleMark] = false;
>+  this[_streamFuture] = null;
>+  this[_socket$] = socket;
>+  this[_httpServer] = httpServer;
>+  this[_httpParser] = _http._HttpParser.requestParser();
>+  _http._HttpConnection.__proto__.new.call(this);
>+  _http._HttpConnection._connections[$_set](this[_serviceId$], this);
>+  this[_httpParser].listenToStream(StreamOfListOfint()._check(this[_socket$]));
>+  this[_subscription$0] = this[_httpParser].listen(dart.fn(incoming => {
>+    this[_httpServer][_markActive](this);
>+    FutureOfNull()._check(incoming.dataDone.then(core.Null, dart.fn(closing => {
>+      if (dart.dtest(closing)) this.destroy();
>+    }, dynamicToNull())));
>+    this[_subscription$0].pause();
>+    this[_state$1] = 0;
>+    let outgoing = new _http._HttpOutgoing.new(io.Socket._check(this[_socket$]));
>+    let response = new _http._HttpResponse.new(incoming.uri, incoming.headers.protocolVersion, outgoing, this[_httpServer].defaultResponseHeaders, this[_httpServer].serverHeader);
>+    let request = new _http._HttpRequest.new(response, incoming, this[_httpServer], this);
>+    this[_streamFuture] = outgoing.done.then(dart.dynamic, dart.fn(_ => {
>+      response.deadline = null;
>+      if (this[_state$1] === 3) return;
>+      if (dart.test(response.persistentConnection) && dart.test(request.persistentConnection) && dart.test(incoming.fullBodyRead) && !dart.test(this[_httpParser].upgrade) && !dart.test(this[_httpServer].closed)) {
>+        this[_state$1] = 1;
>+        this[_idleMark] = false;
>+        this[_httpServer][_markIdle](this);
>+        this[_subscription$0].resume();
>+      } else {
>+        this.destroy();
>+      }
>+    }, SocketToNull()), {onError: dart.fn(_ => {
>+        this.destroy();
>+      }, dynamicToNull())});
>+    outgoing.ignoreBody = request.method === "HEAD";
>+    response[_httpRequest] = request;
>+    this[_httpServer][_handleRequest](request);
>+  }, _HttpIncomingToNull()), {onDone: dart.fn(() => {
>+      this.destroy();
>+    }, VoidToNull()), onError: dart.fn(error => {
>+      this.destroy();
>+    }, dynamicToNull())});
>+}).prototype = _http._HttpConnection.prototype;
>+dart.addTypeTests(_http._HttpConnection);
>+dart.setMethodSignature(_http._HttpConnection, () => ({
>+  __proto__: dart.getMethods(_http._HttpConnection.__proto__),
>+  markIdle: dart.fnType(dart.void, []),
>+  destroy: dart.fnType(dart.void, []),
>+  detachSocket: dart.fnType(async.Future$(io.Socket), []),
>+  [_toJSON$]: dart.fnType(core.Map, [core.bool])
>+}));
>+dart.setGetterSignature(_http._HttpConnection, () => ({
>+  __proto__: dart.getGetters(_http._HttpConnection.__proto__),
>+  isMarkedIdle: core.bool,
>+  connectionInfo: _http.HttpConnectionInfo,
>+  [_isActive]: core.bool,
>+  [_isIdle]: core.bool,
>+  [_isClosing]: core.bool,
>+  [_isDetached]: core.bool,
>+  [_serviceTypePath$]: core.String,
>+  [_serviceTypeName$]: core.String
>+}));
>+dart.setLibraryUri(_http._HttpConnection, "dart:_http");
>+dart.setFieldSignature(_http._HttpConnection, () => ({
>+  __proto__: dart.getFields(_http._HttpConnection.__proto__),
>+  [_socket$]: dart.finalFieldType(dart.dynamic),
>+  [_httpServer]: dart.finalFieldType(_http._HttpServer),
>+  [_httpParser]: dart.finalFieldType(_http._HttpParser),
>+  [_state$1]: dart.fieldType(core.int),
>+  [_subscription$0]: dart.fieldType(async.StreamSubscription),
>+  [_idleMark]: dart.fieldType(core.bool),
>+  [_streamFuture]: dart.fieldType(async.Future)
>+}));
>+dart.defineLazy(_http._HttpConnection, {
>+  /*_http._HttpConnection._ACTIVE*/get _ACTIVE() {
>+    return 0;
>+  },
>+  /*_http._HttpConnection._IDLE*/get _IDLE() {
>+    return 1;
>+  },
>+  /*_http._HttpConnection._CLOSING*/get _CLOSING() {
>+    return 2;
>+  },
>+  /*_http._HttpConnection._DETACHED*/get _DETACHED() {
>+    return 3;
>+  },
>+  /*_http._HttpConnection._connections*/get _connections() {
>+    return new (IdentityMapOfint$_HttpConnection()).new();
>+  },
>+  set _connections(_) {}
>+});
>+const _serverSocket = dart.privateName(_http, "_serverSocket");
>+const _closeServer = dart.privateName(_http, "_closeServer");
>+const _activeConnections = dart.privateName(_http, "_activeConnections");
>+const _idleConnections = dart.privateName(_http, "_idleConnections");
>+let const$102;
>+let const$103;
>+const _maybePerformCleanup$ = dart.privateName(_http, "_maybePerformCleanup");
>+const Stream__ServiceObject$ = class Stream__ServiceObject extends async.Stream$(_http.HttpRequest) {};
>+(Stream__ServiceObject$.new = function() {
>+  _http._ServiceObject.new.call(this);
>+  Stream__ServiceObject$.__proto__.new.call(this);
>+}).prototype = Stream__ServiceObject$.prototype;
>+(Stream__ServiceObject$._internal = function() {
>+  _http._ServiceObject.new.call(this);
>+  Stream__ServiceObject$.__proto__._internal.call(this);
>+}).prototype = Stream__ServiceObject$.prototype;
>+(Stream__ServiceObject$.empty = function() {
>+  _http._ServiceObject.new.call(this);
>+  Stream__ServiceObject$.__proto__.empty.call(this);
>+}).prototype = Stream__ServiceObject$.prototype;
>+(Stream__ServiceObject$.fromFuture = function(future) {
>+  _http._ServiceObject.new.call(this);
>+  Stream__ServiceObject$.__proto__.fromFuture.call(this, future);
>+}).prototype = Stream__ServiceObject$.prototype;
>+(Stream__ServiceObject$.fromFutures = function(futures) {
>+  _http._ServiceObject.new.call(this);
>+  Stream__ServiceObject$.__proto__.fromFutures.call(this, futures);
>+}).prototype = Stream__ServiceObject$.prototype;
>+(Stream__ServiceObject$.fromIterable = function(elements) {
>+  _http._ServiceObject.new.call(this);
>+  Stream__ServiceObject$.__proto__.fromIterable.call(this, elements);
>+}).prototype = Stream__ServiceObject$.prototype;
>+(Stream__ServiceObject$.periodic = function(period, computation) {
>+  _http._ServiceObject.new.call(this);
>+  Stream__ServiceObject$.__proto__.periodic.call(this, period, computation);
>+}).prototype = Stream__ServiceObject$.prototype;
>+(Stream__ServiceObject$.eventTransformed = function(source, mapSink) {
>+  _http._ServiceObject.new.call(this);
>+  Stream__ServiceObject$.__proto__.eventTransformed.call(this, source, mapSink);
>+}).prototype = Stream__ServiceObject$.prototype;
>+dart.applyMixin(Stream__ServiceObject$, _http._ServiceObject);
>+_http._HttpServer = class _HttpServer extends Stream__ServiceObject$ {
>+  static bind(address, port, backlog, v6Only, shared) {
>+    return FutureOfHttpServer()._check(io.ServerSocket.bind(address, port, {backlog: backlog, v6Only: v6Only, shared: shared}).then(_http.HttpServer, dart.fn(socket => new _http._HttpServer.__(socket, true), ServerSocketTo_HttpServer())));
>+  }
>+  static bindSecure(address, port, context, backlog, v6Only, requestClientCertificate, shared) {
>+    return FutureOfHttpServer()._check(io.SecureServerSocket.bind(address, port, context, {backlog: backlog, v6Only: v6Only, requestClientCertificate: requestClientCertificate, shared: shared}).then(_http.HttpServer, dart.fn(socket => new _http._HttpServer.__(socket, true), SecureServerSocketTo_HttpServer())));
>+  }
>+  static _initDefaultResponseHeaders() {
>+    let defaultResponseHeaders = new _http._HttpHeaders.new("1.1");
>+    defaultResponseHeaders.contentType = _http.ContentType.text;
>+    defaultResponseHeaders.set("X-Frame-Options", "SAMEORIGIN");
>+    defaultResponseHeaders.set("X-Content-Type-Options", "nosniff");
>+    defaultResponseHeaders.set("X-XSS-Protection", "1; mode=block");
>+    return defaultResponseHeaders;
>+  }
>+  get idleTimeout() {
>+    return this[_idleTimeout];
>+  }
>+  set idleTimeout(duration) {
>+    if (this[_idleTimer] != null) {
>+      this[_idleTimer].cancel();
>+      this[_idleTimer] = null;
>+    }
>+    this[_idleTimeout] = duration;
>+    if (this[_idleTimeout] != null) {
>+      this[_idleTimer] = async.Timer.periodic(this[_idleTimeout], dart.fn(_ => {
>+        for (let idle of this[_idleConnections].toList()) {
>+          if (dart.test(idle.isMarkedIdle)) {
>+            idle.destroy();
>+          } else {
>+            idle.markIdle();
>+          }
>+        }
>+      }, TimerToNull()));
>+    }
>+  }
>+  listen(onData, opts) {
>+    let onError = opts && 'onError' in opts ? opts.onError : null;
>+    let onDone = opts && 'onDone' in opts ? opts.onDone : null;
>+    let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
>+    dart.dsend(this[_serverSocket], 'listen', [dart.fn(socket => {
>+        socket.setOption(io.SocketOption.tcpNoDelay, true);
>+        let connection = new _http._HttpConnection.new(socket, this);
>+        this[_idleConnections].add(connection);
>+      }, SocketToNull())], {onError: dart.fn((error, stackTrace) => {
>+        if (!io.HandshakeException.is(error)) {
>+          this[_controller$1].addError(error, core.StackTrace._check(stackTrace));
>+        }
>+      }, dynamicAnddynamicToNull()), onDone: dart.bind(this[_controller$1], 'close')});
>+    return this[_controller$1].stream.listen(onData, {onError: onError, onDone: onDone, cancelOnError: cancelOnError});
>+  }
>+  close(opts) {
>+    let force = opts && 'force' in opts ? opts.force : false;
>+    this.closed = true;
>+    let result = null;
>+    if (this[_serverSocket] != null && dart.test(this[_closeServer])) {
>+      result = async.Future._check(dart.dsend(this[_serverSocket], 'close', []));
>+    } else {
>+      result = async.Future.value();
>+    }
>+    this.idleTimeout = null;
>+    if (dart.test(force)) {
>+      for (let c of this[_activeConnections].toList()) {
>+        c.destroy();
>+      }
>+      if (!dart.test(this[_activeConnections].isEmpty)) dart.assertFailed(null, "dart:_http/http_impl.dart", 2634, 14, "_activeConnections.isEmpty");
>+    }
>+    for (let c of this[_idleConnections].toList()) {
>+      c.destroy();
>+    }
>+    this[_maybePerformCleanup$]();
>+    return result;
>+  }
>+  [_maybePerformCleanup$]() {
>+    if (dart.test(this.closed) && dart.test(this[_idleConnections].isEmpty) && dart.test(this[_activeConnections].isEmpty) && this[_sessionManagerInstance] != null) {
>+      this[_sessionManagerInstance].close();
>+      this[_sessionManagerInstance] = null;
>+      _http._HttpServer._servers[$remove](this[_serviceId$]);
>+    }
>+  }
>+  get port() {
>+    if (dart.test(this.closed)) dart.throw(new _http.HttpException.new("HttpServer is not bound to a socket"));
>+    return core.int._check(dart.dload(this[_serverSocket], 'port'));
>+  }
>+  get address() {
>+    if (dart.test(this.closed)) dart.throw(new _http.HttpException.new("HttpServer is not bound to a socket"));
>+    return io.InternetAddress._check(dart.dload(this[_serverSocket], 'address'));
>+  }
>+  set sessionTimeout(timeout) {
>+    this[_sessionManager].sessionTimeout = timeout;
>+  }
>+  [_handleRequest](request) {
>+    if (!dart.test(this.closed)) {
>+      this[_controller$1].add(request);
>+    } else {
>+      request[_httpConnection].destroy();
>+    }
>+  }
>+  [_connectionClosed](connection) {
>+    connection.unlink();
>+    this[_maybePerformCleanup$]();
>+  }
>+  [_markIdle](connection) {
>+    this[_activeConnections].remove(connection);
>+    this[_idleConnections].add(connection);
>+  }
>+  [_markActive](connection) {
>+    this[_idleConnections].remove(connection);
>+    this[_activeConnections].add(connection);
>+  }
>+  get [_sessionManager]() {
>+    if (this[_sessionManagerInstance] == null) {
>+      this[_sessionManagerInstance] = new _http._HttpSessionManager.new();
>+    }
>+    return this[_sessionManagerInstance];
>+  }
>+  connectionsInfo() {
>+    let result = new _http.HttpConnectionsInfo.new();
>+    result.total = dart.notNull(this[_activeConnections].length) + dart.notNull(this[_idleConnections].length);
>+    this[_activeConnections].forEach(dart.fn(conn => {
>+      if (dart.test(conn[_isActive])) {
>+        result.active = dart.notNull(result.active) + 1;
>+      } else {
>+        if (!dart.test(conn[_isClosing])) dart.assertFailed(null, "dart:_http/http_impl.dart", 2707, 16, "conn._isClosing");
>+        result.closing = dart.notNull(result.closing) + 1;
>+      }
>+    }, _HttpConnectionToNull()));
>+    this[_idleConnections].forEach(dart.fn(conn => {
>+      result.idle = dart.notNull(result.idle) + 1;
>+      if (!dart.test(conn[_isIdle])) dart.assertFailed(null, "dart:_http/http_impl.dart", 2713, 14, "conn._isIdle");
>+    }, _HttpConnectionToNull()));
>+    return result;
>+  }
>+  get [_serviceTypePath$]() {
>+    return "io/http/servers";
>+  }
>+  get [_serviceTypeName$]() {
>+    return "HttpServer";
>+  }
>+  [_toJSON$](ref) {
>+    let r = new (IdentityMapOfString$dynamic()).from(["id", this[_servicePath$], "type", this[_serviceType$](ref), "name", dart.str(this.address.host) + ":" + dart.str(this.port), "user_name", dart.str(this.address.host) + ":" + dart.str(this.port)]);
>+    if (dart.test(ref)) {
>+      return r;
>+    }
>+    try {
>+      r[$_set]("socket", dart.dsend(this[_serverSocket], _toJSON$, [true]));
>+    } catch (e) {
>+      let _ = dart.getThrown(e);
>+      r[$_set]("socket", new (IdentityMapOfString$String()).from(["id", this[_servicePath$], "type", "@Socket", "name", "UserSocket", "user_name", "UserSocket"]));
>+    }
>+    r[$_set]("port", this.port);
>+    r[$_set]("address", this.address.host);
>+    r[$_set]("active", IterableOfMap()._check(this[_activeConnections].map(core.Map, dart.fn(c => c[_toJSON$](true), _HttpConnectionToMap())))[$toList]());
>+    r[$_set]("idle", IterableOfMap()._check(this[_idleConnections].map(core.Map, dart.fn(c => c[_toJSON$](true), _HttpConnectionToMap())))[$toList]());
>+    r[$_set]("closed", this.closed);
>+    return r;
>+  }
>+};
>+(_http._HttpServer.__ = function(serverSocket, closeServer) {
>+  this.serverHeader = null;
>+  this.defaultResponseHeaders = _http._HttpServer._initDefaultResponseHeaders();
>+  this.autoCompress = false;
>+  this[_idleTimeout] = null;
>+  this[_idleTimer] = null;
>+  this[_sessionManagerInstance] = null;
>+  this.closed = false;
>+  this[_activeConnections] = new (LinkedListOf_HttpConnection()).new();
>+  this[_idleConnections] = new (LinkedListOf_HttpConnection()).new();
>+  this[_controller$1] = null;
>+  this[_serverSocket] = serverSocket;
>+  this[_closeServer] = closeServer;
>+  _http._HttpServer.__proto__.new.call(this);
>+  this[_controller$1] = StreamControllerOfHttpRequest().new({sync: true, onCancel: dart.bind(this, 'close')});
>+  this.idleTimeout = const$102 || (const$102 = dart.const(new core.Duration.new({seconds: 120})));
>+  _http._HttpServer._servers[$_set](this[_serviceId$], this);
>+}).prototype = _http._HttpServer.prototype;
>+(_http._HttpServer.listenOn = function(serverSocket) {
>+  this.serverHeader = null;
>+  this.defaultResponseHeaders = _http._HttpServer._initDefaultResponseHeaders();
>+  this.autoCompress = false;
>+  this[_idleTimeout] = null;
>+  this[_idleTimer] = null;
>+  this[_sessionManagerInstance] = null;
>+  this.closed = false;
>+  this[_activeConnections] = new (LinkedListOf_HttpConnection()).new();
>+  this[_idleConnections] = new (LinkedListOf_HttpConnection()).new();
>+  this[_controller$1] = null;
>+  this[_serverSocket] = serverSocket;
>+  this[_closeServer] = false;
>+  _http._HttpServer.__proto__.new.call(this);
>+  this[_controller$1] = StreamControllerOfHttpRequest().new({sync: true, onCancel: dart.bind(this, 'close')});
>+  this.idleTimeout = const$103 || (const$103 = dart.const(new core.Duration.new({seconds: 120})));
>+  _http._HttpServer._servers[$_set](this[_serviceId$], this);
>+}).prototype = _http._HttpServer.prototype;
>+dart.addTypeTests(_http._HttpServer);
>+_http._HttpServer[dart.implements] = () => [_http.HttpServer];
>+dart.setMethodSignature(_http._HttpServer, () => ({
>+  __proto__: dart.getMethods(_http._HttpServer.__proto__),
>+  listen: dart.fnType(async.StreamSubscription$(_http.HttpRequest), [dart.fnType(dart.void, [_http.HttpRequest])], {onError: core.Function, onDone: dart.fnType(dart.void, []), cancelOnError: core.bool}),
>+  close: dart.fnType(async.Future, [], {force: core.bool}),
>+  [_maybePerformCleanup$]: dart.fnType(dart.void, []),
>+  [_handleRequest]: dart.fnType(dart.void, [_http._HttpRequest]),
>+  [_connectionClosed]: dart.fnType(dart.void, [_http._HttpConnection]),
>+  [_markIdle]: dart.fnType(dart.void, [_http._HttpConnection]),
>+  [_markActive]: dart.fnType(dart.void, [_http._HttpConnection]),
>+  connectionsInfo: dart.fnType(_http.HttpConnectionsInfo, []),
>+  [_toJSON$]: dart.fnType(core.Map$(core.String, dart.dynamic), [core.bool])
>+}));
>+dart.setGetterSignature(_http._HttpServer, () => ({
>+  __proto__: dart.getGetters(_http._HttpServer.__proto__),
>+  idleTimeout: core.Duration,
>+  port: core.int,
>+  address: io.InternetAddress,
>+  [_sessionManager]: _http._HttpSessionManager,
>+  [_serviceTypePath$]: core.String,
>+  [_serviceTypeName$]: core.String
>+}));
>+dart.setSetterSignature(_http._HttpServer, () => ({
>+  __proto__: dart.getSetters(_http._HttpServer.__proto__),
>+  idleTimeout: core.Duration,
>+  sessionTimeout: core.int
>+}));
>+dart.setLibraryUri(_http._HttpServer, "dart:_http");
>+dart.setFieldSignature(_http._HttpServer, () => ({
>+  __proto__: dart.getFields(_http._HttpServer.__proto__),
>+  serverHeader: dart.fieldType(core.String),
>+  defaultResponseHeaders: dart.finalFieldType(_http.HttpHeaders),
>+  autoCompress: dart.fieldType(core.bool),
>+  [_idleTimeout]: dart.fieldType(core.Duration),
>+  [_idleTimer]: dart.fieldType(async.Timer),
>+  [_sessionManagerInstance]: dart.fieldType(_http._HttpSessionManager),
>+  closed: dart.fieldType(core.bool),
>+  [_serverSocket]: dart.finalFieldType(dart.dynamic),
>+  [_closeServer]: dart.finalFieldType(core.bool),
>+  [_activeConnections]: dart.finalFieldType(LinkedListOf_HttpConnection()),
>+  [_idleConnections]: dart.finalFieldType(LinkedListOf_HttpConnection()),
>+  [_controller$1]: dart.fieldType(StreamControllerOfHttpRequest())
>+}));
>+dart.defineLazy(_http._HttpServer, {
>+  /*_http._HttpServer._servers*/get _servers() {
>+    return new (IdentityMapOfint$_HttpServer()).new();
>+  },
>+  set _servers(_) {}
>+});
>+let const$104;
>+let const$105;
>+_http._ProxyConfiguration = class _ProxyConfiguration extends core.Object {};
>+(_http._ProxyConfiguration.new = function(configuration) {
>+  this.proxies = JSArrayOf_Proxy().of([]);
>+  if (configuration == null) {
>+    dart.throw(new _http.HttpException.new("Invalid proxy configuration " + dart.str(configuration)));
>+  }
>+  let list = configuration[$split](";");
>+  list[$forEach](dart.fn(proxy => {
>+    proxy = proxy[$trim]();
>+    if (!proxy[$isEmpty]) {
>+      if (proxy[$startsWith]("PROXY ")) {
>+        let username = null;
>+        let password = null;
>+        proxy = proxy[$substring]("PROXY ".length)[$trim]();
>+        let at = proxy[$indexOf]("@");
>+        if (at !== -1) {
>+          let userinfo = proxy[$substring](0, at)[$trim]();
>+          proxy = proxy[$substring](at + 1)[$trim]();
>+          let colon = userinfo[$indexOf](":");
>+          if (colon === -1 || colon === 0 || colon === proxy.length - 1) {
>+            dart.throw(new _http.HttpException.new("Invalid proxy configuration " + dart.str(configuration)));
>+          }
>+          username = userinfo[$substring](0, colon)[$trim]();
>+          password = userinfo[$substring](colon + 1)[$trim]();
>+        }
>+        let colon = proxy[$lastIndexOf](":");
>+        if (colon === -1 || colon === 0 || colon === proxy.length - 1) {
>+          dart.throw(new _http.HttpException.new("Invalid proxy configuration " + dart.str(configuration)));
>+        }
>+        let host = proxy[$substring](0, colon)[$trim]();
>+        if (host[$startsWith]("[") && host[$endsWith]("]")) {
>+          host = host[$substring](1, host.length - 1);
>+        }
>+        let portString = proxy[$substring](colon + 1)[$trim]();
>+        let port = null;
>+        try {
>+          port = core.int.parse(portString);
>+        } catch (e$) {
>+          let e = dart.getThrown(e$);
>+          if (core.FormatException.is(e)) {
>+            dart.throw(new _http.HttpException.new("Invalid proxy configuration " + dart.str(configuration) + ", " + ("invalid port '" + portString + "'")));
>+          } else
>+            throw e$;
>+        }
>+        this.proxies[$add](new _http._Proxy.new(host, port, username, password));
>+      } else if (proxy[$trim]() === "DIRECT") {
>+        this.proxies[$add](new _http._Proxy.direct());
>+      } else {
>+        dart.throw(new _http.HttpException.new("Invalid proxy configuration " + dart.str(configuration)));
>+      }
>+    }
>+  }, StringToNull()));
>+}).prototype = _http._ProxyConfiguration.prototype;
>+(_http._ProxyConfiguration.direct = function() {
>+  this.proxies = const$105 || (const$105 = dart.constList([const$104 || (const$104 = dart.const(new _http._Proxy.direct()))], _http._Proxy));
>+}).prototype = _http._ProxyConfiguration.prototype;
>+dart.addTypeTests(_http._ProxyConfiguration);
>+dart.setLibraryUri(_http._ProxyConfiguration, "dart:_http");
>+dart.setFieldSignature(_http._ProxyConfiguration, () => ({
>+  __proto__: dart.getFields(_http._ProxyConfiguration.__proto__),
>+  proxies: dart.finalFieldType(ListOf_Proxy())
>+}));
>+dart.defineLazy(_http._ProxyConfiguration, {
>+  /*_http._ProxyConfiguration.PROXY_PREFIX*/get PROXY_PREFIX() {
>+    return "PROXY ";
>+  },
>+  /*_http._ProxyConfiguration.DIRECT_PREFIX*/get DIRECT_PREFIX() {
>+    return "DIRECT";
>+  }
>+});
>+_http._Proxy = class _Proxy extends core.Object {
>+  get isAuthenticated() {
>+    return this.username != null;
>+  }
>+};
>+(_http._Proxy.new = function(host, port, username, password) {
>+  this.host = host;
>+  this.port = port;
>+  this.username = username;
>+  this.password = password;
>+  this.isDirect = false;
>+}).prototype = _http._Proxy.prototype;
>+(_http._Proxy.direct = function() {
>+  this.host = null;
>+  this.port = null;
>+  this.username = null;
>+  this.password = null;
>+  this.isDirect = true;
>+}).prototype = _http._Proxy.prototype;
>+dart.addTypeTests(_http._Proxy);
>+dart.setGetterSignature(_http._Proxy, () => ({
>+  __proto__: dart.getGetters(_http._Proxy.__proto__),
>+  isAuthenticated: core.bool
>+}));
>+dart.setLibraryUri(_http._Proxy, "dart:_http");
>+dart.setFieldSignature(_http._Proxy, () => ({
>+  __proto__: dart.getFields(_http._Proxy.__proto__),
>+  host: dart.finalFieldType(core.String),
>+  port: dart.finalFieldType(core.int),
>+  username: dart.finalFieldType(core.String),
>+  password: dart.finalFieldType(core.String),
>+  isDirect: dart.finalFieldType(core.bool)
>+}));
>+_http._HttpConnectionInfo = class _HttpConnectionInfo extends core.Object {
>+  static create(socket) {
>+    if (socket == null) return null;
>+    try {
>+      let info = new _http._HttpConnectionInfo.new();
>+      info.remoteAddress = socket.remoteAddress;
>+      info.remotePort = socket.remotePort;
>+      info.localPort = socket.port;
>+      return info;
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+    }
>+    return null;
>+  }
>+};
>+(_http._HttpConnectionInfo.new = function() {
>+  this.remoteAddress = null;
>+  this.remotePort = null;
>+  this.localPort = null;
>+}).prototype = _http._HttpConnectionInfo.prototype;
>+dart.addTypeTests(_http._HttpConnectionInfo);
>+_http._HttpConnectionInfo[dart.implements] = () => [_http.HttpConnectionInfo];
>+dart.setLibraryUri(_http._HttpConnectionInfo, "dart:_http");
>+dart.setFieldSignature(_http._HttpConnectionInfo, () => ({
>+  __proto__: dart.getFields(_http._HttpConnectionInfo.__proto__),
>+  remoteAddress: dart.fieldType(io.InternetAddress),
>+  remotePort: dart.fieldType(core.int),
>+  localPort: dart.fieldType(core.int)
>+}));
>+_http._DetachedSocket = class _DetachedSocket extends async.Stream$(core.List$(core.int)) {
>+  listen(onData, opts) {
>+    let onError = opts && 'onError' in opts ? opts.onError : null;
>+    let onDone = opts && 'onDone' in opts ? opts.onDone : null;
>+    let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
>+    return this[_incoming].listen(onData, {onError: onError, onDone: onDone, cancelOnError: cancelOnError});
>+  }
>+  get encoding() {
>+    return this[_socket$].encoding;
>+  }
>+  set encoding(value) {
>+    this[_socket$].encoding = value;
>+  }
>+  write(obj) {
>+    this[_socket$].write(obj);
>+  }
>+  writeln(obj) {
>+    if (obj === void 0) obj = "";
>+    this[_socket$].writeln(obj);
>+  }
>+  writeCharCode(charCode) {
>+    this[_socket$].writeCharCode(charCode);
>+  }
>+  writeAll(objects, separator) {
>+    if (separator === void 0) separator = "";
>+    this[_socket$].writeAll(objects, separator);
>+  }
>+  add(bytes) {
>+    ListOfint()._check(bytes);
>+    this[_socket$].add(bytes);
>+  }
>+  addError(error, stackTrace) {
>+    if (stackTrace === void 0) stackTrace = null;
>+    return this[_socket$].addError(error, stackTrace);
>+  }
>+  addStream(stream) {
>+    StreamOfListOfint()._check(stream);
>+    return this[_socket$].addStream(stream);
>+  }
>+  destroy() {
>+    this[_socket$].destroy();
>+  }
>+  flush() {
>+    return this[_socket$].flush();
>+  }
>+  close() {
>+    return this[_socket$].close();
>+  }
>+  get done() {
>+    return this[_socket$].done;
>+  }
>+  get port() {
>+    return this[_socket$].port;
>+  }
>+  get address() {
>+    return this[_socket$].address;
>+  }
>+  get remoteAddress() {
>+    return this[_socket$].remoteAddress;
>+  }
>+  get remotePort() {
>+    return this[_socket$].remotePort;
>+  }
>+  setOption(option, enabled) {
>+    return this[_socket$].setOption(option, enabled);
>+  }
>+  getRawOption(option) {
>+    return this[_socket$].getRawOption(option);
>+  }
>+  setRawOption(option) {
>+    this[_socket$].setRawOption(option);
>+  }
>+  [_toJSON$](ref) {
>+    return core.Map._check(dart.dsend(this[_socket$], _toJSON$, [ref]));
>+  }
>+};
>+(_http._DetachedSocket.new = function(socket, incoming) {
>+  this[_socket$] = socket;
>+  this[_incoming] = incoming;
>+  _http._DetachedSocket.__proto__.new.call(this);
>+}).prototype = _http._DetachedSocket.prototype;
>+dart.addTypeTests(_http._DetachedSocket);
>+_http._DetachedSocket[dart.implements] = () => [io.Socket];
>+dart.setMethodSignature(_http._DetachedSocket, () => ({
>+  __proto__: dart.getMethods(_http._DetachedSocket.__proto__),
>+  listen: dart.fnType(async.StreamSubscription$(core.List$(core.int)), [dart.fnType(dart.void, [core.List$(core.int)])], {onError: core.Function, onDone: dart.fnType(dart.void, []), cancelOnError: core.bool}),
>+  write: dart.fnType(dart.void, [core.Object]),
>+  writeln: dart.fnType(dart.void, [], [core.Object]),
>+  writeCharCode: dart.fnType(dart.void, [core.int]),
>+  writeAll: dart.fnType(dart.void, [core.Iterable], [core.String]),
>+  add: dart.fnType(dart.void, [core.Object]),
>+  addError: dart.fnType(dart.void, [core.Object], [core.StackTrace]),
>+  addStream: dart.fnType(async.Future, [core.Object]),
>+  destroy: dart.fnType(dart.void, []),
>+  flush: dart.fnType(async.Future, []),
>+  close: dart.fnType(async.Future, []),
>+  setOption: dart.fnType(core.bool, [io.SocketOption, core.bool]),
>+  getRawOption: dart.fnType(typed_data.Uint8List, [io.RawSocketOption]),
>+  setRawOption: dart.fnType(dart.void, [io.RawSocketOption]),
>+  [_toJSON$]: dart.fnType(core.Map, [core.bool])
>+}));
>+dart.setGetterSignature(_http._DetachedSocket, () => ({
>+  __proto__: dart.getGetters(_http._DetachedSocket.__proto__),
>+  encoding: convert.Encoding,
>+  done: async.Future,
>+  port: core.int,
>+  address: io.InternetAddress,
>+  remoteAddress: io.InternetAddress,
>+  remotePort: core.int
>+}));
>+dart.setSetterSignature(_http._DetachedSocket, () => ({
>+  __proto__: dart.getSetters(_http._DetachedSocket.__proto__),
>+  encoding: convert.Encoding
>+}));
>+dart.setLibraryUri(_http._DetachedSocket, "dart:_http");
>+dart.setFieldSignature(_http._DetachedSocket, () => ({
>+  __proto__: dart.getFields(_http._DetachedSocket.__proto__),
>+  [_incoming]: dart.finalFieldType(StreamOfListOfint()),
>+  [_socket$]: dart.finalFieldType(io.Socket)
>+}));
>+const _scheme = dart.privateName(_http, "_scheme");
>+_http._AuthenticationScheme = class _AuthenticationScheme extends core.Object {
>+  static fromString(scheme) {
>+    if (scheme[$toLowerCase]() === "basic") return _http._AuthenticationScheme.BASIC;
>+    if (scheme[$toLowerCase]() === "digest") return _http._AuthenticationScheme.DIGEST;
>+    return _http._AuthenticationScheme.UNKNOWN;
>+  }
>+  toString() {
>+    if (this._equals(_http._AuthenticationScheme.BASIC)) return "Basic";
>+    if (this._equals(_http._AuthenticationScheme.DIGEST)) return "Digest";
>+    return "Unknown";
>+  }
>+};
>+(_http._AuthenticationScheme.new = function(scheme) {
>+  this[_scheme] = scheme;
>+}).prototype = _http._AuthenticationScheme.prototype;
>+dart.addTypeTests(_http._AuthenticationScheme);
>+dart.setLibraryUri(_http._AuthenticationScheme, "dart:_http");
>+dart.setFieldSignature(_http._AuthenticationScheme, () => ({
>+  __proto__: dart.getFields(_http._AuthenticationScheme.__proto__),
>+  [_scheme]: dart.finalFieldType(core.int)
>+}));
>+dart.defineExtensionMethods(_http._AuthenticationScheme, ['toString']);
>+dart.defineLazy(_http._AuthenticationScheme, {
>+  /*_http._AuthenticationScheme.UNKNOWN*/get UNKNOWN() {
>+    return dart.const(new _http._AuthenticationScheme.new(-1));
>+  },
>+  /*_http._AuthenticationScheme.BASIC*/get BASIC() {
>+    return dart.const(new _http._AuthenticationScheme.new(0));
>+  },
>+  /*_http._AuthenticationScheme.DIGEST*/get DIGEST() {
>+    return dart.const(new _http._AuthenticationScheme.new(1));
>+  }
>+});
>+_http._Credentials = class _Credentials extends core.Object {
>+  get scheme() {
>+    return this.credentials.scheme;
>+  }
>+};
>+(_http._Credentials.new = function(credentials, realm) {
>+  this.used = false;
>+  this.ha1 = null;
>+  this.nonce = null;
>+  this.algorithm = null;
>+  this.qop = null;
>+  this.nonceCount = null;
>+  this.credentials = credentials;
>+  this.realm = realm;
>+  if (dart.equals(this.credentials.scheme, _http._AuthenticationScheme.DIGEST)) {
>+    let creds = _http._HttpClientDigestCredentials._check(this.credentials);
>+    let hasher = new _http._MD5.new();
>+    hasher.add(convert.utf8.encode(creds.username));
>+    hasher.add(JSArrayOfint().of([_http._CharCode.COLON]));
>+    hasher.add(this.realm[$codeUnits]);
>+    hasher.add(JSArrayOfint().of([_http._CharCode.COLON]));
>+    hasher.add(convert.utf8.encode(creds.password));
>+    this.ha1 = _http._CryptoUtils.bytesToHex(hasher.close());
>+  }
>+}).prototype = _http._Credentials.prototype;
>+dart.addTypeTests(_http._Credentials);
>+dart.setGetterSignature(_http._Credentials, () => ({
>+  __proto__: dart.getGetters(_http._Credentials.__proto__),
>+  scheme: _http._AuthenticationScheme
>+}));
>+dart.setLibraryUri(_http._Credentials, "dart:_http");
>+dart.setFieldSignature(_http._Credentials, () => ({
>+  __proto__: dart.getFields(_http._Credentials.__proto__),
>+  credentials: dart.fieldType(_http._HttpClientCredentials),
>+  realm: dart.fieldType(core.String),
>+  used: dart.fieldType(core.bool),
>+  ha1: dart.fieldType(core.String),
>+  nonce: dart.fieldType(core.String),
>+  algorithm: dart.fieldType(core.String),
>+  qop: dart.fieldType(core.String),
>+  nonceCount: dart.fieldType(core.int)
>+}));
>+_http._SiteCredentials = class _SiteCredentials extends _http._Credentials {
>+  applies(uri, scheme) {
>+    if (scheme != null && !dart.equals(this.credentials.scheme, scheme)) return false;
>+    if (uri.host != this.uri.host) return false;
>+    let thisPort = this.uri.port === 0 ? _http.HttpClient.defaultHttpPort : this.uri.port;
>+    let otherPort = uri.port === 0 ? _http.HttpClient.defaultHttpPort : uri.port;
>+    if (otherPort != thisPort) return false;
>+    return uri.path[$startsWith](this.uri.path);
>+  }
>+  authorize(request) {
>+    if (dart.equals(this.credentials.scheme, _http._AuthenticationScheme.DIGEST) && this.nonce == null) {
>+      return;
>+    }
>+    this.credentials.authorize(this, request);
>+    this.used = true;
>+  }
>+};
>+(_http._SiteCredentials.new = function(uri, realm, creds) {
>+  this.uri = uri;
>+  _http._SiteCredentials.__proto__.new.call(this, creds, core.String._check(realm));
>+}).prototype = _http._SiteCredentials.prototype;
>+dart.addTypeTests(_http._SiteCredentials);
>+dart.setMethodSignature(_http._SiteCredentials, () => ({
>+  __proto__: dart.getMethods(_http._SiteCredentials.__proto__),
>+  applies: dart.fnType(core.bool, [core.Uri, _http._AuthenticationScheme]),
>+  authorize: dart.fnType(dart.void, [_http.HttpClientRequest])
>+}));
>+dart.setLibraryUri(_http._SiteCredentials, "dart:_http");
>+dart.setFieldSignature(_http._SiteCredentials, () => ({
>+  __proto__: dart.getFields(_http._SiteCredentials.__proto__),
>+  uri: dart.fieldType(core.Uri)
>+}));
>+_http._ProxyCredentials = class _ProxyCredentials extends _http._Credentials {
>+  applies(proxy, scheme) {
>+    if (scheme != null && !dart.equals(this.credentials.scheme, scheme)) return false;
>+    return proxy.host == this.host && proxy.port == this.port;
>+  }
>+  authorize(request) {
>+    if (dart.equals(this.credentials.scheme, _http._AuthenticationScheme.DIGEST) && this.nonce == null) {
>+      return;
>+    }
>+    this.credentials.authorizeProxy(this, request);
>+  }
>+};
>+(_http._ProxyCredentials.new = function(host, port, realm, creds) {
>+  this.host = host;
>+  this.port = port;
>+  _http._ProxyCredentials.__proto__.new.call(this, creds, core.String._check(realm));
>+}).prototype = _http._ProxyCredentials.prototype;
>+dart.addTypeTests(_http._ProxyCredentials);
>+dart.setMethodSignature(_http._ProxyCredentials, () => ({
>+  __proto__: dart.getMethods(_http._ProxyCredentials.__proto__),
>+  applies: dart.fnType(core.bool, [_http._Proxy, _http._AuthenticationScheme]),
>+  authorize: dart.fnType(dart.void, [_http.HttpClientRequest])
>+}));
>+dart.setLibraryUri(_http._ProxyCredentials, "dart:_http");
>+dart.setFieldSignature(_http._ProxyCredentials, () => ({
>+  __proto__: dart.getFields(_http._ProxyCredentials.__proto__),
>+  host: dart.fieldType(core.String),
>+  port: dart.fieldType(core.int)
>+}));
>+_http._HttpClientCredentials = class _HttpClientCredentials extends core.Object {};
>+(_http._HttpClientCredentials.new = function() {
>+}).prototype = _http._HttpClientCredentials.prototype;
>+dart.addTypeTests(_http._HttpClientCredentials);
>+_http._HttpClientCredentials[dart.implements] = () => [_http.HttpClientCredentials];
>+dart.setLibraryUri(_http._HttpClientCredentials, "dart:_http");
>+_http._HttpClientBasicCredentials = class _HttpClientBasicCredentials extends _http._HttpClientCredentials {
>+  get scheme() {
>+    return _http._AuthenticationScheme.BASIC;
>+  }
>+  authorization() {
>+    let auth = _http._CryptoUtils.bytesToBase64(convert.utf8.encode(dart.str(this.username) + ":" + dart.str(this.password)));
>+    return "Basic " + dart.str(auth);
>+  }
>+  authorize(_, request) {
>+    request.headers.set(_http.HttpHeaders.authorizationHeader, this.authorization());
>+  }
>+  authorizeProxy(_, request) {
>+    request.headers.set(_http.HttpHeaders.proxyAuthorizationHeader, this.authorization());
>+  }
>+};
>+(_http._HttpClientBasicCredentials.new = function(username, password) {
>+  this.username = username;
>+  this.password = password;
>+}).prototype = _http._HttpClientBasicCredentials.prototype;
>+dart.addTypeTests(_http._HttpClientBasicCredentials);
>+_http._HttpClientBasicCredentials[dart.implements] = () => [_http.HttpClientBasicCredentials];
>+dart.setMethodSignature(_http._HttpClientBasicCredentials, () => ({
>+  __proto__: dart.getMethods(_http._HttpClientBasicCredentials.__proto__),
>+  authorization: dart.fnType(core.String, []),
>+  authorize: dart.fnType(dart.void, [_http._Credentials, _http.HttpClientRequest]),
>+  authorizeProxy: dart.fnType(dart.void, [_http._ProxyCredentials, _http.HttpClientRequest])
>+}));
>+dart.setGetterSignature(_http._HttpClientBasicCredentials, () => ({
>+  __proto__: dart.getGetters(_http._HttpClientBasicCredentials.__proto__),
>+  scheme: _http._AuthenticationScheme
>+}));
>+dart.setLibraryUri(_http._HttpClientBasicCredentials, "dart:_http");
>+dart.setFieldSignature(_http._HttpClientBasicCredentials, () => ({
>+  __proto__: dart.getFields(_http._HttpClientBasicCredentials.__proto__),
>+  username: dart.fieldType(core.String),
>+  password: dart.fieldType(core.String)
>+}));
>+_http._HttpClientDigestCredentials = class _HttpClientDigestCredentials extends _http._HttpClientCredentials {
>+  get scheme() {
>+    return _http._AuthenticationScheme.DIGEST;
>+  }
>+  authorization(credentials, request) {
>+    let requestUri = request[_requestUri]();
>+    let hasher = new _http._MD5.new();
>+    hasher.add(request.method[$codeUnits]);
>+    hasher.add(JSArrayOfint().of([_http._CharCode.COLON]));
>+    hasher.add(requestUri[$codeUnits]);
>+    let ha2 = _http._CryptoUtils.bytesToHex(hasher.close());
>+    let qop = null;
>+    let cnonce = null;
>+    let nc = null;
>+    let x = null;
>+    hasher = new _http._MD5.new();
>+    hasher.add(credentials.ha1[$codeUnits]);
>+    hasher.add(JSArrayOfint().of([_http._CharCode.COLON]));
>+    if (credentials.qop === "auth") {
>+      qop = credentials.qop;
>+      cnonce = _http._CryptoUtils.bytesToHex(_http._CryptoUtils.getRandomBytes(4));
>+      credentials.nonceCount = dart.notNull(credentials.nonceCount) + 1;
>+      nc = credentials.nonceCount[$toRadixString](16);
>+      nc = "00000000"[$substring](0, 8 - nc.length + 1) + dart.notNull(nc);
>+      hasher.add(credentials.nonce[$codeUnits]);
>+      hasher.add(JSArrayOfint().of([_http._CharCode.COLON]));
>+      hasher.add(nc[$codeUnits]);
>+      hasher.add(JSArrayOfint().of([_http._CharCode.COLON]));
>+      hasher.add(cnonce[$codeUnits]);
>+      hasher.add(JSArrayOfint().of([_http._CharCode.COLON]));
>+      hasher.add(credentials.qop[$codeUnits]);
>+      hasher.add(JSArrayOfint().of([_http._CharCode.COLON]));
>+      hasher.add(ha2[$codeUnits]);
>+    } else {
>+      hasher.add(credentials.nonce[$codeUnits]);
>+      hasher.add(JSArrayOfint().of([_http._CharCode.COLON]));
>+      hasher.add(ha2[$codeUnits]);
>+    }
>+    let response = _http._CryptoUtils.bytesToHex(hasher.close());
>+    let buffer = new core.StringBuffer.new();
>+    buffer.write("Digest ");
>+    buffer.write("username=\"" + dart.str(this.username) + "\"");
>+    buffer.write(", realm=\"" + dart.str(credentials.realm) + "\"");
>+    buffer.write(", nonce=\"" + dart.str(credentials.nonce) + "\"");
>+    buffer.write(", uri=\"" + dart.str(requestUri) + "\"");
>+    buffer.write(", algorithm=\"" + dart.str(credentials.algorithm) + "\"");
>+    if (qop === "auth") {
>+      buffer.write(", qop=\"" + dart.str(qop) + "\"");
>+      buffer.write(", cnonce=\"" + dart.str(cnonce) + "\"");
>+      buffer.write(", nc=\"" + dart.str(nc) + "\"");
>+    }
>+    buffer.write(", response=\"" + dart.str(response) + "\"");
>+    return buffer.toString();
>+  }
>+  authorize(credentials, request) {
>+    request.headers.set(_http.HttpHeaders.authorizationHeader, this.authorization(credentials, _http._HttpClientRequest._check(request)));
>+  }
>+  authorizeProxy(credentials, request) {
>+    request.headers.set(_http.HttpHeaders.proxyAuthorizationHeader, this.authorization(credentials, _http._HttpClientRequest._check(request)));
>+  }
>+};
>+(_http._HttpClientDigestCredentials.new = function(username, password) {
>+  this.username = username;
>+  this.password = password;
>+}).prototype = _http._HttpClientDigestCredentials.prototype;
>+dart.addTypeTests(_http._HttpClientDigestCredentials);
>+_http._HttpClientDigestCredentials[dart.implements] = () => [_http.HttpClientDigestCredentials];
>+dart.setMethodSignature(_http._HttpClientDigestCredentials, () => ({
>+  __proto__: dart.getMethods(_http._HttpClientDigestCredentials.__proto__),
>+  authorization: dart.fnType(core.String, [_http._Credentials, _http._HttpClientRequest]),
>+  authorize: dart.fnType(dart.void, [_http._Credentials, _http.HttpClientRequest]),
>+  authorizeProxy: dart.fnType(dart.void, [_http._ProxyCredentials, _http.HttpClientRequest])
>+}));
>+dart.setGetterSignature(_http._HttpClientDigestCredentials, () => ({
>+  __proto__: dart.getGetters(_http._HttpClientDigestCredentials.__proto__),
>+  scheme: _http._AuthenticationScheme
>+}));
>+dart.setLibraryUri(_http._HttpClientDigestCredentials, "dart:_http");
>+dart.setFieldSignature(_http._HttpClientDigestCredentials, () => ({
>+  __proto__: dart.getFields(_http._HttpClientDigestCredentials.__proto__),
>+  username: dart.fieldType(core.String),
>+  password: dart.fieldType(core.String)
>+}));
>+_http._RedirectInfo = class _RedirectInfo extends core.Object {};
>+(_http._RedirectInfo.new = function(statusCode, method, location) {
>+  this.statusCode = statusCode;
>+  this.method = method;
>+  this.location = location;
>+}).prototype = _http._RedirectInfo.prototype;
>+dart.addTypeTests(_http._RedirectInfo);
>+_http._RedirectInfo[dart.implements] = () => [_http.RedirectInfo];
>+dart.setLibraryUri(_http._RedirectInfo, "dart:_http");
>+dart.setFieldSignature(_http._RedirectInfo, () => ({
>+  __proto__: dart.getFields(_http._RedirectInfo.__proto__),
>+  statusCode: dart.finalFieldType(core.int),
>+  method: dart.finalFieldType(core.String),
>+  location: dart.finalFieldType(core.Uri)
>+}));
>+_http._getHttpVersion = function() {
>+  let version = io.Platform.version;
>+  let index = version[$indexOf](".", version[$indexOf](".") + 1);
>+  version = version[$substring](0, index);
>+  return "Dart/" + dart.str(version) + " (dart:io)";
>+};
>+_http._Const = class _Const extends core.Object {};
>+(_http._Const.new = function() {
>+}).prototype = _http._Const.prototype;
>+dart.addTypeTests(_http._Const);
>+dart.setLibraryUri(_http._Const, "dart:_http");
>+dart.defineLazy(_http._Const, {
>+  /*_http._Const.HTTP*/get HTTP() {
>+    return dart.constList([72, 84, 84, 80], core.int);
>+  },
>+  /*_http._Const.HTTP1DOT*/get HTTP1DOT() {
>+    return dart.constList([72, 84, 84, 80, 47, 49, 46], core.int);
>+  },
>+  /*_http._Const.HTTP10*/get HTTP10() {
>+    return dart.constList([72, 84, 84, 80, 47, 49, 46, 48], core.int);
>+  },
>+  /*_http._Const.HTTP11*/get HTTP11() {
>+    return dart.constList([72, 84, 84, 80, 47, 49, 46, 49], core.int);
>+  },
>+  /*_http._Const.T*/get T() {
>+    return true;
>+  },
>+  /*_http._Const.F*/get F() {
>+    return false;
>+  },
>+  /*_http._Const.SEPARATOR_MAP*/get SEPARATOR_MAP() {
>+    return dart.constList([false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, true, false, false, false, false, false, true, true, false, false, true, false, false, true, false, false, false, false, false, false, false, false, false, false, true, true, true, true, true, true, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, true, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false], core.bool);
>+  }
>+});
>+_http._CharCode = class _CharCode extends core.Object {};
>+(_http._CharCode.new = function() {
>+}).prototype = _http._CharCode.prototype;
>+dart.addTypeTests(_http._CharCode);
>+dart.setLibraryUri(_http._CharCode, "dart:_http");
>+dart.defineLazy(_http._CharCode, {
>+  /*_http._CharCode.HT*/get HT() {
>+    return 9;
>+  },
>+  /*_http._CharCode.LF*/get LF() {
>+    return 10;
>+  },
>+  /*_http._CharCode.CR*/get CR() {
>+    return 13;
>+  },
>+  /*_http._CharCode.SP*/get SP() {
>+    return 32;
>+  },
>+  /*_http._CharCode.AMPERSAND*/get AMPERSAND() {
>+    return 38;
>+  },
>+  /*_http._CharCode.COMMA*/get COMMA() {
>+    return 44;
>+  },
>+  /*_http._CharCode.DASH*/get DASH() {
>+    return 45;
>+  },
>+  /*_http._CharCode.SLASH*/get SLASH() {
>+    return 47;
>+  },
>+  /*_http._CharCode.ZERO*/get ZERO() {
>+    return 48;
>+  },
>+  /*_http._CharCode.ONE*/get ONE() {
>+    return 49;
>+  },
>+  /*_http._CharCode.COLON*/get COLON() {
>+    return 58;
>+  },
>+  /*_http._CharCode.SEMI_COLON*/get SEMI_COLON() {
>+    return 59;
>+  },
>+  /*_http._CharCode.EQUAL*/get EQUAL() {
>+    return 61;
>+  }
>+});
>+_http._State = class _State extends core.Object {};
>+(_http._State.new = function() {
>+}).prototype = _http._State.prototype;
>+dart.addTypeTests(_http._State);
>+dart.setLibraryUri(_http._State, "dart:_http");
>+dart.defineLazy(_http._State, {
>+  /*_http._State.START*/get START() {
>+    return 0;
>+  },
>+  /*_http._State.METHOD_OR_RESPONSE_HTTP_VERSION*/get METHOD_OR_RESPONSE_HTTP_VERSION() {
>+    return 1;
>+  },
>+  /*_http._State.RESPONSE_HTTP_VERSION*/get RESPONSE_HTTP_VERSION() {
>+    return 2;
>+  },
>+  /*_http._State.REQUEST_LINE_METHOD*/get REQUEST_LINE_METHOD() {
>+    return 3;
>+  },
>+  /*_http._State.REQUEST_LINE_URI*/get REQUEST_LINE_URI() {
>+    return 4;
>+  },
>+  /*_http._State.REQUEST_LINE_HTTP_VERSION*/get REQUEST_LINE_HTTP_VERSION() {
>+    return 5;
>+  },
>+  /*_http._State.REQUEST_LINE_ENDING*/get REQUEST_LINE_ENDING() {
>+    return 6;
>+  },
>+  /*_http._State.RESPONSE_LINE_STATUS_CODE*/get RESPONSE_LINE_STATUS_CODE() {
>+    return 7;
>+  },
>+  /*_http._State.RESPONSE_LINE_REASON_PHRASE*/get RESPONSE_LINE_REASON_PHRASE() {
>+    return 8;
>+  },
>+  /*_http._State.RESPONSE_LINE_ENDING*/get RESPONSE_LINE_ENDING() {
>+    return 9;
>+  },
>+  /*_http._State.HEADER_START*/get HEADER_START() {
>+    return 10;
>+  },
>+  /*_http._State.HEADER_FIELD*/get HEADER_FIELD() {
>+    return 11;
>+  },
>+  /*_http._State.HEADER_VALUE_START*/get HEADER_VALUE_START() {
>+    return 12;
>+  },
>+  /*_http._State.HEADER_VALUE*/get HEADER_VALUE() {
>+    return 13;
>+  },
>+  /*_http._State.HEADER_VALUE_FOLDING_OR_ENDING*/get HEADER_VALUE_FOLDING_OR_ENDING() {
>+    return 14;
>+  },
>+  /*_http._State.HEADER_VALUE_FOLD_OR_END*/get HEADER_VALUE_FOLD_OR_END() {
>+    return 15;
>+  },
>+  /*_http._State.HEADER_ENDING*/get HEADER_ENDING() {
>+    return 16;
>+  },
>+  /*_http._State.CHUNK_SIZE_STARTING_CR*/get CHUNK_SIZE_STARTING_CR() {
>+    return 17;
>+  },
>+  /*_http._State.CHUNK_SIZE_STARTING_LF*/get CHUNK_SIZE_STARTING_LF() {
>+    return 18;
>+  },
>+  /*_http._State.CHUNK_SIZE*/get CHUNK_SIZE() {
>+    return 19;
>+  },
>+  /*_http._State.CHUNK_SIZE_EXTENSION*/get CHUNK_SIZE_EXTENSION() {
>+    return 20;
>+  },
>+  /*_http._State.CHUNK_SIZE_ENDING*/get CHUNK_SIZE_ENDING() {
>+    return 21;
>+  },
>+  /*_http._State.CHUNKED_BODY_DONE_CR*/get CHUNKED_BODY_DONE_CR() {
>+    return 22;
>+  },
>+  /*_http._State.CHUNKED_BODY_DONE_LF*/get CHUNKED_BODY_DONE_LF() {
>+    return 23;
>+  },
>+  /*_http._State.BODY*/get BODY() {
>+    return 24;
>+  },
>+  /*_http._State.CLOSED*/get CLOSED() {
>+    return 25;
>+  },
>+  /*_http._State.UPGRADED*/get UPGRADED() {
>+    return 26;
>+  },
>+  /*_http._State.FAILURE*/get FAILURE() {
>+    return 27;
>+  },
>+  /*_http._State.FIRST_BODY_STATE*/get FIRST_BODY_STATE() {
>+    return 17;
>+  }
>+});
>+_http._HttpVersion = class _HttpVersion extends core.Object {};
>+(_http._HttpVersion.new = function() {
>+}).prototype = _http._HttpVersion.prototype;
>+dart.addTypeTests(_http._HttpVersion);
>+dart.setLibraryUri(_http._HttpVersion, "dart:_http");
>+dart.defineLazy(_http._HttpVersion, {
>+  /*_http._HttpVersion.UNDETERMINED*/get UNDETERMINED() {
>+    return 0;
>+  },
>+  /*_http._HttpVersion.HTTP10*/get HTTP10() {
>+    return 1;
>+  },
>+  /*_http._HttpVersion.HTTP11*/get HTTP11() {
>+    return 2;
>+  }
>+});
>+_http._MessageType = class _MessageType extends core.Object {};
>+(_http._MessageType.new = function() {
>+}).prototype = _http._MessageType.prototype;
>+dart.addTypeTests(_http._MessageType);
>+dart.setLibraryUri(_http._MessageType, "dart:_http");
>+dart.defineLazy(_http._MessageType, {
>+  /*_http._MessageType.UNDETERMINED*/get UNDETERMINED() {
>+    return 0;
>+  },
>+  /*_http._MessageType.REQUEST*/get REQUEST() {
>+    return 1;
>+  },
>+  /*_http._MessageType.RESPONSE*/get RESPONSE() {
>+    return 0;
>+  }
>+});
>+const _injectData = dart.privateName(_http, "_injectData");
>+const _userOnData = dart.privateName(_http, "_userOnData");
>+const _isCanceled$ = dart.privateName(_http, "_isCanceled");
>+const _pauseCount$0 = dart.privateName(_http, "_pauseCount");
>+const _scheduled = dart.privateName(_http, "_scheduled");
>+const _maybeScheduleData = dart.privateName(_http, "_maybeScheduleData");
>+_http._HttpDetachedStreamSubscription = class _HttpDetachedStreamSubscription extends core.Object {
>+  get isPaused() {
>+    return this[_subscription$0].isPaused;
>+  }
>+  asFuture(T, futureValue) {
>+    if (futureValue === void 0) futureValue = null;
>+    return async.Future$(T)._check(this[_subscription$0].asFuture(T, futureValue));
>+  }
>+  cancel() {
>+    this[_isCanceled$] = true;
>+    this[_injectData] = null;
>+    return this[_subscription$0].cancel();
>+  }
>+  onData(handleData) {
>+    this[_userOnData] = handleData;
>+    this[_subscription$0].onData(handleData);
>+  }
>+  onDone(handleDone) {
>+    this[_subscription$0].onDone(handleDone);
>+  }
>+  onError(handleError) {
>+    this[_subscription$0].onError(handleError);
>+  }
>+  pause(resumeSignal) {
>+    if (resumeSignal === void 0) resumeSignal = null;
>+    if (this[_injectData] == null) {
>+      this[_subscription$0].pause(resumeSignal);
>+    } else {
>+      this[_pauseCount$0] = dart.notNull(this[_pauseCount$0]) + 1;
>+      if (resumeSignal != null) {
>+        resumeSignal.whenComplete(dart.bind(this, 'resume'));
>+      }
>+    }
>+  }
>+  resume() {
>+    if (this[_injectData] == null) {
>+      this[_subscription$0].resume();
>+    } else {
>+      this[_pauseCount$0] = dart.notNull(this[_pauseCount$0]) - 1;
>+      this[_maybeScheduleData]();
>+    }
>+  }
>+  [_maybeScheduleData]() {
>+    if (dart.test(this[_scheduled])) return;
>+    if (this[_pauseCount$0] !== 0) return;
>+    this[_scheduled] = true;
>+    async.scheduleMicrotask(dart.fn(() => {
>+      this[_scheduled] = false;
>+      if (dart.notNull(this[_pauseCount$0]) > 0 || dart.test(this[_isCanceled$])) return;
>+      let data = this[_injectData];
>+      this[_injectData] = null;
>+      this[_subscription$0].resume();
>+      if (this[_userOnData] != null) {
>+        dart.dcall(this[_userOnData], [data]);
>+      }
>+    }, VoidToNull()));
>+  }
>+};
>+(_http._HttpDetachedStreamSubscription.new = function(subscription, injectData, userOnData) {
>+  this[_isCanceled$] = false;
>+  this[_pauseCount$0] = 1;
>+  this[_scheduled] = false;
>+  this[_subscription$0] = subscription;
>+  this[_injectData] = injectData;
>+  this[_userOnData] = userOnData;
>+}).prototype = _http._HttpDetachedStreamSubscription.prototype;
>+_http._HttpDetachedStreamSubscription.prototype[dart.isStreamSubscription] = true;
>+dart.addTypeTests(_http._HttpDetachedStreamSubscription);
>+_http._HttpDetachedStreamSubscription[dart.implements] = () => [StreamSubscriptionOfListOfint()];
>+dart.setMethodSignature(_http._HttpDetachedStreamSubscription, () => ({
>+  __proto__: dart.getMethods(_http._HttpDetachedStreamSubscription.__proto__),
>+  asFuture: dart.gFnType(T => [async.Future$(T), [], [T]]),
>+  cancel: dart.fnType(async.Future, []),
>+  onData: dart.fnType(dart.void, [dart.fnType(dart.void, [core.List$(core.int)])]),
>+  onDone: dart.fnType(dart.void, [dart.fnType(dart.void, [])]),
>+  onError: dart.fnType(dart.void, [core.Function]),
>+  pause: dart.fnType(dart.void, [], [async.Future]),
>+  resume: dart.fnType(dart.void, []),
>+  [_maybeScheduleData]: dart.fnType(dart.void, [])
>+}));
>+dart.setGetterSignature(_http._HttpDetachedStreamSubscription, () => ({
>+  __proto__: dart.getGetters(_http._HttpDetachedStreamSubscription.__proto__),
>+  isPaused: core.bool
>+}));
>+dart.setLibraryUri(_http._HttpDetachedStreamSubscription, "dart:_http");
>+dart.setFieldSignature(_http._HttpDetachedStreamSubscription, () => ({
>+  __proto__: dart.getFields(_http._HttpDetachedStreamSubscription.__proto__),
>+  [_subscription$0]: dart.fieldType(StreamSubscriptionOfListOfint()),
>+  [_injectData]: dart.fieldType(ListOfint()),
>+  [_isCanceled$]: dart.fieldType(core.bool),
>+  [_pauseCount$0]: dart.fieldType(core.int),
>+  [_userOnData]: dart.fieldType(core.Function),
>+  [_scheduled]: dart.fieldType(core.bool)
>+}));
>+_http._HttpDetachedIncoming = class _HttpDetachedIncoming extends async.Stream$(core.List$(core.int)) {
>+  listen(onData, opts) {
>+    let onError = opts && 'onError' in opts ? opts.onError : null;
>+    let onDone = opts && 'onDone' in opts ? opts.onDone : null;
>+    let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
>+    if (this.subscription != null) {
>+      this.subscription.onData(onData);
>+      this.subscription.onError(onError);
>+      this.subscription.onDone(onDone);
>+      if (this.bufferedData == null) {
>+        this.subscription.resume();
>+        return this.subscription;
>+      }
>+      let _ = new _http._HttpDetachedStreamSubscription.new(this.subscription, this.bufferedData, onData);
>+      _.resume();
>+      return _;
>+    } else {
>+      return StreamOfListOfint().fromIterable(JSArrayOfListOfint().of([this.bufferedData])).listen(onData, {onError: onError, onDone: onDone, cancelOnError: cancelOnError});
>+    }
>+  }
>+};
>+(_http._HttpDetachedIncoming.new = function(subscription, bufferedData) {
>+  this.subscription = subscription;
>+  this.bufferedData = bufferedData;
>+  _http._HttpDetachedIncoming.__proto__.new.call(this);
>+}).prototype = _http._HttpDetachedIncoming.prototype;
>+dart.addTypeTests(_http._HttpDetachedIncoming);
>+dart.setMethodSignature(_http._HttpDetachedIncoming, () => ({
>+  __proto__: dart.getMethods(_http._HttpDetachedIncoming.__proto__),
>+  listen: dart.fnType(async.StreamSubscription$(core.List$(core.int)), [dart.fnType(dart.void, [core.List$(core.int)])], {onError: core.Function, onDone: dart.fnType(dart.void, []), cancelOnError: core.bool})
>+}));
>+dart.setLibraryUri(_http._HttpDetachedIncoming, "dart:_http");
>+dart.setFieldSignature(_http._HttpDetachedIncoming, () => ({
>+  __proto__: dart.getFields(_http._HttpDetachedIncoming.__proto__),
>+  subscription: dart.finalFieldType(StreamSubscriptionOfListOfint()),
>+  bufferedData: dart.finalFieldType(ListOfint())
>+}));
>+const _requestParser = dart.privateName(_http, "_requestParser");
>+const _parserCalled = dart.privateName(_http, "_parserCalled");
>+const _index$1 = dart.privateName(_http, "_index");
>+const _httpVersionIndex = dart.privateName(_http, "_httpVersionIndex");
>+const _messageType = dart.privateName(_http, "_messageType");
>+const _statusCodeLength = dart.privateName(_http, "_statusCodeLength");
>+const _method$ = dart.privateName(_http, "_method");
>+const _uri_or_reason_phrase = dart.privateName(_http, "_uri_or_reason_phrase");
>+const _headerField = dart.privateName(_http, "_headerField");
>+const _headerValue = dart.privateName(_http, "_headerValue");
>+const _httpVersion = dart.privateName(_http, "_httpVersion");
>+const _connectionUpgrade = dart.privateName(_http, "_connectionUpgrade");
>+const _chunked = dart.privateName(_http, "_chunked");
>+const _noMessageBody = dart.privateName(_http, "_noMessageBody");
>+const _remainingContent = dart.privateName(_http, "_remainingContent");
>+const _socketSubscription$ = dart.privateName(_http, "_socketSubscription");
>+const _paused = dart.privateName(_http, "_paused");
>+const _bodyPaused = dart.privateName(_http, "_bodyPaused");
>+const _bodyController = dart.privateName(_http, "_bodyController");
>+const _pauseStateChanged = dart.privateName(_http, "_pauseStateChanged");
>+const _reset = dart.privateName(_http, "_reset");
>+const _onData$2 = dart.privateName(_http, "_onData");
>+const _onDone$ = dart.privateName(_http, "_onDone");
>+const _doParse = dart.privateName(_http, "_doParse");
>+const _reportError$ = dart.privateName(_http, "_reportError");
>+const _createIncoming = dart.privateName(_http, "_createIncoming");
>+const _closeIncoming = dart.privateName(_http, "_closeIncoming");
>+const _headersEnd = dart.privateName(_http, "_headersEnd");
>+const _expect = dart.privateName(_http, "_expect");
>+const _caseInsensitiveCompare = dart.privateName(_http, "_caseInsensitiveCompare");
>+const _expectHexDigit = dart.privateName(_http, "_expectHexDigit");
>+const _releaseBuffer = dart.privateName(_http, "_releaseBuffer");
>+_http._HttpParser = class _HttpParser extends async.Stream$(_http._HttpIncoming) {
>+  static requestParser() {
>+    return new _http._HttpParser.__(true);
>+  }
>+  static responseParser() {
>+    return new _http._HttpParser.__(false);
>+  }
>+  listen(onData, opts) {
>+    let onError = opts && 'onError' in opts ? opts.onError : null;
>+    let onDone = opts && 'onDone' in opts ? opts.onDone : null;
>+    let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
>+    return this[_controller$1].stream.listen(onData, {onError: onError, onDone: onDone, cancelOnError: cancelOnError});
>+  }
>+  listenToStream(stream) {
>+    this[_socketSubscription$] = stream.listen(dart.bind(this, _onData$2), {onError: dart.bind(this[_controller$1], 'addError'), onDone: dart.bind(this, _onDone$)});
>+  }
>+  [_parse]() {
>+    try {
>+      this[_doParse]();
>+    } catch (e$) {
>+      let e = dart.getThrown(e$);
>+      let s = dart.stackTrace(e$);
>+      this[_state$1] = _http._State.FAILURE;
>+      this[_reportError$](e, s);
>+    }
>+  }
>+  [_headersEnd]() {
>+    this[_headers][_mutable] = false;
>+    this[_transferLength] = this[_headers].contentLength;
>+    if (dart.test(this[_chunked])) this[_transferLength] = -1;
>+    if (this[_messageType] === _http._MessageType.REQUEST && dart.notNull(this[_transferLength]) < 0 && this[_chunked] === false) {
>+      this[_transferLength] = 0;
>+    }
>+    if (dart.test(this[_connectionUpgrade])) {
>+      this[_state$1] = _http._State.UPGRADED;
>+      this[_transferLength] = 0;
>+    }
>+    this[_createIncoming](this[_transferLength]);
>+    if (dart.test(this[_requestParser])) {
>+      this[_incoming].method = core.String.fromCharCodes(this[_method$]);
>+      this[_incoming].uri = core.Uri.parse(core.String.fromCharCodes(this[_uri_or_reason_phrase]));
>+    } else {
>+      this[_incoming].statusCode = this[_statusCode];
>+      this[_incoming].reasonPhrase = core.String.fromCharCodes(this[_uri_or_reason_phrase]);
>+    }
>+    this[_method$][$clear]();
>+    this[_uri_or_reason_phrase][$clear]();
>+    if (dart.test(this[_connectionUpgrade])) {
>+      this[_incoming].upgraded = true;
>+      this[_parserCalled] = false;
>+      let tmp = this[_incoming];
>+      this[_closeIncoming]();
>+      this[_controller$1].add(tmp);
>+      return true;
>+    }
>+    if (this[_transferLength] === 0 || this[_messageType] === _http._MessageType.RESPONSE && dart.test(this[_noMessageBody])) {
>+      this[_reset]();
>+      let tmp = this[_incoming];
>+      this[_closeIncoming]();
>+      this[_controller$1].add(tmp);
>+      return false;
>+    } else if (dart.test(this[_chunked])) {
>+      this[_state$1] = _http._State.CHUNK_SIZE;
>+      this[_remainingContent] = 0;
>+    } else if (dart.notNull(this[_transferLength]) > 0) {
>+      this[_remainingContent] = this[_transferLength];
>+      this[_state$1] = _http._State.BODY;
>+    } else {
>+      this[_state$1] = _http._State.BODY;
>+    }
>+    this[_parserCalled] = false;
>+    this[_controller$1].add(this[_incoming]);
>+    return true;
>+  }
>+  [_doParse]() {
>+    if (!!dart.test(this[_parserCalled])) dart.assertFailed(null, "dart:_http/http_parser.dart", 400, 12, "!_parserCalled");
>+    this[_parserCalled] = true;
>+    if (this[_state$1] === _http._State.CLOSED) {
>+      dart.throw(new _http.HttpException.new("Data on closed connection"));
>+    }
>+    if (this[_state$1] === _http._State.FAILURE) {
>+      dart.throw(new _http.HttpException.new("Data on failed connection"));
>+    }
>+    while (this[_buffer$1] != null && dart.notNull(this[_index$1]) < dart.notNull(this[_buffer$1][$length]) && this[_state$1] !== _http._State.FAILURE && this[_state$1] !== _http._State.UPGRADED) {
>+      if (this[_incoming] != null && dart.test(this[_bodyPaused]) || this[_incoming] == null && dart.test(this[_paused])) {
>+        this[_parserCalled] = false;
>+        return;
>+      }
>+      let byte = this[_buffer$1][$_get]((() => {
>+        let x = this[_index$1];
>+        this[_index$1] = dart.notNull(x) + 1;
>+        return x;
>+      })());
>+      switch (this[_state$1]) {
>+        case _http._State.START:
>+        {
>+          if (byte == _http._Const.HTTP[$_get](0)) {
>+            this[_httpVersionIndex] = 1;
>+            this[_state$1] = _http._State.METHOD_OR_RESPONSE_HTTP_VERSION;
>+          } else {
>+            if (!dart.test(_http._HttpParser._isTokenChar(byte))) {
>+              dart.throw(new _http.HttpException.new("Invalid request method"));
>+            }
>+            this[_method$][$add](byte);
>+            if (!dart.test(this[_requestParser])) {
>+              dart.throw(new _http.HttpException.new("Invalid response line"));
>+            }
>+            this[_state$1] = _http._State.REQUEST_LINE_METHOD;
>+          }
>+          break;
>+        }
>+        case _http._State.METHOD_OR_RESPONSE_HTTP_VERSION:
>+        {
>+          if (dart.notNull(this[_httpVersionIndex]) < dart.notNull(_http._Const.HTTP[$length]) && byte == _http._Const.HTTP[$_get](this[_httpVersionIndex])) {
>+            this[_httpVersionIndex] = dart.notNull(this[_httpVersionIndex]) + 1;
>+          } else if (this[_httpVersionIndex] == _http._Const.HTTP[$length] && byte === _http._CharCode.SLASH) {
>+            this[_httpVersionIndex] = dart.notNull(this[_httpVersionIndex]) + 1;
>+            if (dart.test(this[_requestParser])) {
>+              dart.throw(new _http.HttpException.new("Invalid request line"));
>+            }
>+            this[_state$1] = _http._State.RESPONSE_HTTP_VERSION;
>+          } else {
>+            for (let i = 0; i < dart.notNull(this[_httpVersionIndex]); i++) {
>+              this[_method$][$add](_http._Const.HTTP[$_get](i));
>+            }
>+            if (byte === _http._CharCode.SP) {
>+              this[_state$1] = _http._State.REQUEST_LINE_URI;
>+            } else {
>+              this[_method$][$add](byte);
>+              this[_httpVersion] = _http._HttpVersion.UNDETERMINED;
>+              if (!dart.test(this[_requestParser])) {
>+                dart.throw(new _http.HttpException.new("Invalid response line"));
>+              }
>+              this[_state$1] = _http._State.REQUEST_LINE_METHOD;
>+            }
>+          }
>+          break;
>+        }
>+        case _http._State.RESPONSE_HTTP_VERSION:
>+        {
>+          if (dart.notNull(this[_httpVersionIndex]) < dart.notNull(_http._Const.HTTP1DOT[$length])) {
>+            this[_expect](byte, _http._Const.HTTP1DOT[$_get](this[_httpVersionIndex]));
>+            this[_httpVersionIndex] = dart.notNull(this[_httpVersionIndex]) + 1;
>+          } else if (this[_httpVersionIndex] == _http._Const.HTTP1DOT[$length] && byte === _http._CharCode.ONE) {
>+            this[_httpVersion] = _http._HttpVersion.HTTP11;
>+            this[_persistentConnection] = true;
>+            this[_httpVersionIndex] = dart.notNull(this[_httpVersionIndex]) + 1;
>+          } else if (this[_httpVersionIndex] == _http._Const.HTTP1DOT[$length] && byte === _http._CharCode.ZERO) {
>+            this[_httpVersion] = _http._HttpVersion.HTTP10;
>+            this[_persistentConnection] = false;
>+            this[_httpVersionIndex] = dart.notNull(this[_httpVersionIndex]) + 1;
>+          } else if (this[_httpVersionIndex] === dart.notNull(_http._Const.HTTP1DOT[$length]) + 1) {
>+            this[_expect](byte, _http._CharCode.SP);
>+            this[_state$1] = _http._State.RESPONSE_LINE_STATUS_CODE;
>+          } else {
>+            dart.throw(new _http.HttpException.new("Invalid response line"));
>+          }
>+          break;
>+        }
>+        case _http._State.REQUEST_LINE_METHOD:
>+        {
>+          if (byte === _http._CharCode.SP) {
>+            this[_state$1] = _http._State.REQUEST_LINE_URI;
>+          } else {
>+            if (dart.test(_http._Const.SEPARATOR_MAP[$_get](byte)) || byte === _http._CharCode.CR || byte === _http._CharCode.LF) {
>+              dart.throw(new _http.HttpException.new("Invalid request method"));
>+            }
>+            this[_method$][$add](byte);
>+          }
>+          break;
>+        }
>+        case _http._State.REQUEST_LINE_URI:
>+        {
>+          if (byte === _http._CharCode.SP) {
>+            if (this[_uri_or_reason_phrase][$length] === 0) {
>+              dart.throw(new _http.HttpException.new("Invalid request URI"));
>+            }
>+            this[_state$1] = _http._State.REQUEST_LINE_HTTP_VERSION;
>+            this[_httpVersionIndex] = 0;
>+          } else {
>+            if (byte === _http._CharCode.CR || byte === _http._CharCode.LF) {
>+              dart.throw(new _http.HttpException.new("Invalid request URI"));
>+            }
>+            this[_uri_or_reason_phrase][$add](byte);
>+          }
>+          break;
>+        }
>+        case _http._State.REQUEST_LINE_HTTP_VERSION:
>+        {
>+          if (dart.notNull(this[_httpVersionIndex]) < dart.notNull(_http._Const.HTTP1DOT[$length])) {
>+            this[_expect](byte, _http._Const.HTTP11[$_get](this[_httpVersionIndex]));
>+            this[_httpVersionIndex] = dart.notNull(this[_httpVersionIndex]) + 1;
>+          } else if (this[_httpVersionIndex] == _http._Const.HTTP1DOT[$length]) {
>+            if (byte === _http._CharCode.ONE) {
>+              this[_httpVersion] = _http._HttpVersion.HTTP11;
>+              this[_persistentConnection] = true;
>+              this[_httpVersionIndex] = dart.notNull(this[_httpVersionIndex]) + 1;
>+            } else if (byte === _http._CharCode.ZERO) {
>+              this[_httpVersion] = _http._HttpVersion.HTTP10;
>+              this[_persistentConnection] = false;
>+              this[_httpVersionIndex] = dart.notNull(this[_httpVersionIndex]) + 1;
>+            } else {
>+              dart.throw(new _http.HttpException.new("Invalid response line"));
>+            }
>+          } else {
>+            if (byte === _http._CharCode.CR) {
>+              this[_state$1] = _http._State.REQUEST_LINE_ENDING;
>+            } else {
>+              this[_expect](byte, _http._CharCode.LF);
>+              this[_messageType] = _http._MessageType.REQUEST;
>+              this[_state$1] = _http._State.HEADER_START;
>+            }
>+          }
>+          break;
>+        }
>+        case _http._State.REQUEST_LINE_ENDING:
>+        {
>+          this[_expect](byte, _http._CharCode.LF);
>+          this[_messageType] = _http._MessageType.REQUEST;
>+          this[_state$1] = _http._State.HEADER_START;
>+          break;
>+        }
>+        case _http._State.RESPONSE_LINE_STATUS_CODE:
>+        {
>+          if (byte === _http._CharCode.SP) {
>+            this[_state$1] = _http._State.RESPONSE_LINE_REASON_PHRASE;
>+          } else if (byte === _http._CharCode.CR) {
>+            this[_state$1] = _http._State.RESPONSE_LINE_ENDING;
>+          } else {
>+            this[_statusCodeLength] = dart.notNull(this[_statusCodeLength]) + 1;
>+            if (dart.notNull(byte) < 48 && 57 < dart.notNull(byte) || dart.notNull(this[_statusCodeLength]) > 3) {
>+              dart.throw(new _http.HttpException.new("Invalid response status code"));
>+            } else {
>+              this[_statusCode] = dart.notNull(this[_statusCode]) * 10 + dart.notNull(byte) - 48;
>+            }
>+          }
>+          break;
>+        }
>+        case _http._State.RESPONSE_LINE_REASON_PHRASE:
>+        {
>+          if (byte === _http._CharCode.CR) {
>+            this[_state$1] = _http._State.RESPONSE_LINE_ENDING;
>+          } else {
>+            if (byte === _http._CharCode.CR || byte === _http._CharCode.LF) {
>+              dart.throw(new _http.HttpException.new("Invalid response reason phrase"));
>+            }
>+            this[_uri_or_reason_phrase][$add](byte);
>+          }
>+          break;
>+        }
>+        case _http._State.RESPONSE_LINE_ENDING:
>+        {
>+          this[_expect](byte, _http._CharCode.LF);
>+          this[_messageType] === _http._MessageType.RESPONSE;
>+          if (dart.notNull(this[_statusCode]) < 100 || dart.notNull(this[_statusCode]) > 599) {
>+            dart.throw(new _http.HttpException.new("Invalid response status code"));
>+          } else {
>+            if (dart.notNull(this[_statusCode]) <= 199 || this[_statusCode] === 204 || this[_statusCode] === 304) {
>+              this[_noMessageBody] = true;
>+            }
>+          }
>+          this[_state$1] = _http._State.HEADER_START;
>+          break;
>+        }
>+        case _http._State.HEADER_START:
>+        {
>+          this[_headers] = new _http._HttpHeaders.new(this.version);
>+          if (byte === _http._CharCode.CR) {
>+            this[_state$1] = _http._State.HEADER_ENDING;
>+          } else if (byte === _http._CharCode.LF) {
>+            this[_state$1] = _http._State.HEADER_ENDING;
>+            this[_index$1] = dart.notNull(this[_index$1]) - 1;
>+          } else {
>+            this[_headerField][$add](_http._HttpParser._toLowerCaseByte(byte));
>+            this[_state$1] = _http._State.HEADER_FIELD;
>+          }
>+          break;
>+        }
>+        case _http._State.HEADER_FIELD:
>+        {
>+          if (byte === _http._CharCode.COLON) {
>+            this[_state$1] = _http._State.HEADER_VALUE_START;
>+          } else {
>+            if (!dart.test(_http._HttpParser._isTokenChar(byte))) {
>+              dart.throw(new _http.HttpException.new("Invalid header field name"));
>+            }
>+            this[_headerField][$add](_http._HttpParser._toLowerCaseByte(byte));
>+          }
>+          break;
>+        }
>+        case _http._State.HEADER_VALUE_START:
>+        {
>+          if (byte === _http._CharCode.CR) {
>+            this[_state$1] = _http._State.HEADER_VALUE_FOLDING_OR_ENDING;
>+          } else if (byte === _http._CharCode.LF) {
>+            this[_state$1] = _http._State.HEADER_VALUE_FOLD_OR_END;
>+          } else if (byte !== _http._CharCode.SP && byte !== _http._CharCode.HT) {
>+            this[_headerValue][$add](byte);
>+            this[_state$1] = _http._State.HEADER_VALUE;
>+          }
>+          break;
>+        }
>+        case _http._State.HEADER_VALUE:
>+        {
>+          if (byte === _http._CharCode.CR) {
>+            this[_state$1] = _http._State.HEADER_VALUE_FOLDING_OR_ENDING;
>+          } else if (byte === _http._CharCode.LF) {
>+            this[_state$1] = _http._State.HEADER_VALUE_FOLD_OR_END;
>+          } else {
>+            this[_headerValue][$add](byte);
>+          }
>+          break;
>+        }
>+        case _http._State.HEADER_VALUE_FOLDING_OR_ENDING:
>+        {
>+          this[_expect](byte, _http._CharCode.LF);
>+          this[_state$1] = _http._State.HEADER_VALUE_FOLD_OR_END;
>+          break;
>+        }
>+        case _http._State.HEADER_VALUE_FOLD_OR_END:
>+        {
>+          if (byte === _http._CharCode.SP || byte === _http._CharCode.HT) {
>+            this[_state$1] = _http._State.HEADER_VALUE_START;
>+          } else {
>+            let headerField = core.String.fromCharCodes(this[_headerField]);
>+            let headerValue = core.String.fromCharCodes(this[_headerValue]);
>+            if (headerField === "transfer-encoding" && dart.test(this[_caseInsensitiveCompare]("chunked"[$codeUnits], this[_headerValue]))) {
>+              this[_chunked] = true;
>+            }
>+            if (headerField === "connection") {
>+              let tokens = _http._HttpParser._tokenizeFieldValue(headerValue);
>+              let isResponse = this[_messageType] === _http._MessageType.RESPONSE;
>+              let isUpgradeCode = this[_statusCode] === _internal.HttpStatus.upgradeRequired || this[_statusCode] === _internal.HttpStatus.switchingProtocols;
>+              for (let i = 0; i < dart.notNull(tokens[$length]); i++) {
>+                let isUpgrade = this[_caseInsensitiveCompare]("upgrade"[$codeUnits], tokens[$_get](i)[$codeUnits]);
>+                if (dart.test(isUpgrade) && !isResponse || dart.test(isUpgrade) && isResponse && isUpgradeCode) {
>+                  this[_connectionUpgrade] = true;
>+                }
>+                this[_headers][_add$2](headerField, tokens[$_get](i));
>+              }
>+            } else {
>+              this[_headers][_add$2](headerField, headerValue);
>+            }
>+            this[_headerField][$clear]();
>+            this[_headerValue][$clear]();
>+            if (byte === _http._CharCode.CR) {
>+              this[_state$1] = _http._State.HEADER_ENDING;
>+            } else if (byte === _http._CharCode.LF) {
>+              this[_state$1] = _http._State.HEADER_ENDING;
>+              this[_index$1] = dart.notNull(this[_index$1]) - 1;
>+            } else {
>+              this[_headerField][$add](_http._HttpParser._toLowerCaseByte(byte));
>+              this[_state$1] = _http._State.HEADER_FIELD;
>+            }
>+          }
>+          break;
>+        }
>+        case _http._State.HEADER_ENDING:
>+        {
>+          this[_expect](byte, _http._CharCode.LF);
>+          if (dart.test(this[_headersEnd]())) {
>+            return;
>+          } else {
>+            break;
>+          }
>+          return;
>+        }
>+        case _http._State.CHUNK_SIZE_STARTING_CR:
>+        {
>+          this[_expect](byte, _http._CharCode.CR);
>+          this[_state$1] = _http._State.CHUNK_SIZE_STARTING_LF;
>+          break;
>+        }
>+        case _http._State.CHUNK_SIZE_STARTING_LF:
>+        {
>+          this[_expect](byte, _http._CharCode.LF);
>+          this[_state$1] = _http._State.CHUNK_SIZE;
>+          break;
>+        }
>+        case _http._State.CHUNK_SIZE:
>+        {
>+          if (byte === _http._CharCode.CR) {
>+            this[_state$1] = _http._State.CHUNK_SIZE_ENDING;
>+          } else if (byte === _http._CharCode.SEMI_COLON) {
>+            this[_state$1] = _http._State.CHUNK_SIZE_EXTENSION;
>+          } else {
>+            let value = this[_expectHexDigit](byte);
>+            this[_remainingContent] = dart.notNull(this[_remainingContent]) * 16 + dart.notNull(value);
>+          }
>+          break;
>+        }
>+        case _http._State.CHUNK_SIZE_EXTENSION:
>+        {
>+          if (byte === _http._CharCode.CR) {
>+            this[_state$1] = _http._State.CHUNK_SIZE_ENDING;
>+          }
>+          break;
>+        }
>+        case _http._State.CHUNK_SIZE_ENDING:
>+        {
>+          this[_expect](byte, _http._CharCode.LF);
>+          if (dart.notNull(this[_remainingContent]) > 0) {
>+            this[_state$1] = _http._State.BODY;
>+          } else {
>+            this[_state$1] = _http._State.CHUNKED_BODY_DONE_CR;
>+          }
>+          break;
>+        }
>+        case _http._State.CHUNKED_BODY_DONE_CR:
>+        {
>+          this[_expect](byte, _http._CharCode.CR);
>+          this[_state$1] = _http._State.CHUNKED_BODY_DONE_LF;
>+          break;
>+        }
>+        case _http._State.CHUNKED_BODY_DONE_LF:
>+        {
>+          this[_expect](byte, _http._CharCode.LF);
>+          this[_reset]();
>+          this[_closeIncoming]();
>+          break;
>+        }
>+        case _http._State.BODY:
>+        {
>+          this[_index$1] = dart.notNull(this[_index$1]) - 1;
>+          let dataAvailable = dart.notNull(this[_buffer$1][$length]) - dart.notNull(this[_index$1]);
>+          if (dart.notNull(this[_remainingContent]) >= 0 && dart.notNull(dataAvailable) > dart.notNull(this[_remainingContent])) {
>+            dataAvailable = this[_remainingContent];
>+          }
>+          let data = typed_data.Uint8List.view(this[_buffer$1][$buffer], dart.notNull(this[_buffer$1][$offsetInBytes]) + dart.notNull(this[_index$1]), dataAvailable);
>+          this[_bodyController].add(data);
>+          if (this[_remainingContent] !== -1) {
>+            this[_remainingContent] = dart.notNull(this[_remainingContent]) - dart.notNull(data[$length]);
>+          }
>+          this[_index$1] = dart.notNull(this[_index$1]) + dart.notNull(data[$length]);
>+          if (this[_remainingContent] === 0) {
>+            if (!dart.test(this[_chunked])) {
>+              this[_reset]();
>+              this[_closeIncoming]();
>+            } else {
>+              this[_state$1] = _http._State.CHUNK_SIZE_STARTING_CR;
>+            }
>+          }
>+          break;
>+        }
>+        case _http._State.FAILURE:
>+        {
>+          if (!false) dart.assertFailed(null, "dart:_http/http_parser.dart", 784, 18, "false");
>+          break;
>+        }
>+        default:
>+        {
>+          if (!false) dart.assertFailed(null, "dart:_http/http_parser.dart", 789, 18, "false");
>+          break;
>+        }
>+      }
>+    }
>+    this[_parserCalled] = false;
>+    if (this[_buffer$1] != null && this[_index$1] == this[_buffer$1][$length]) {
>+      this[_releaseBuffer]();
>+      if (this[_state$1] !== _http._State.UPGRADED && this[_state$1] !== _http._State.FAILURE) {
>+        this[_socketSubscription$].resume();
>+      }
>+    }
>+  }
>+  [_onData$2](buffer) {
>+    this[_socketSubscription$].pause();
>+    if (!(this[_buffer$1] == null)) dart.assertFailed(null, "dart:_http/http_parser.dart", 807, 12, "_buffer == null");
>+    this[_buffer$1] = typed_data.Uint8List._check(buffer);
>+    this[_index$1] = 0;
>+    this[_parse]();
>+  }
>+  [_onDone$]() {
>+    this[_socketSubscription$] = null;
>+    if (this[_state$1] === _http._State.CLOSED || this[_state$1] === _http._State.FAILURE) return;
>+    if (this[_incoming] != null) {
>+      if (this[_state$1] !== _http._State.UPGRADED && !(this[_state$1] === _http._State.START && !dart.test(this[_requestParser])) && !(this[_state$1] === _http._State.BODY && !dart.test(this[_chunked]) && this[_transferLength] === -1)) {
>+        this[_bodyController].addError(new _http.HttpException.new("Connection closed while receiving data"));
>+      }
>+      this[_closeIncoming](true);
>+      this[_controller$1].close();
>+      return;
>+    }
>+    if (this[_state$1] === _http._State.START) {
>+      if (!dart.test(this[_requestParser])) {
>+        this[_reportError$](new _http.HttpException.new("Connection closed before full header was received"));
>+      }
>+      this[_controller$1].close();
>+      return;
>+    }
>+    if (this[_state$1] === _http._State.UPGRADED) {
>+      this[_controller$1].close();
>+      return;
>+    }
>+    if (dart.notNull(this[_state$1]) < _http._State.FIRST_BODY_STATE) {
>+      this[_state$1] = _http._State.FAILURE;
>+      this[_reportError$](new _http.HttpException.new("Connection closed before full header was received"));
>+      this[_controller$1].close();
>+      return;
>+    }
>+    if (!dart.test(this[_chunked]) && this[_transferLength] === -1) {
>+      this[_state$1] = _http._State.CLOSED;
>+    } else {
>+      this[_state$1] = _http._State.FAILURE;
>+      this[_reportError$](new _http.HttpException.new("Connection closed before full body was received"));
>+    }
>+    this[_controller$1].close();
>+  }
>+  get version() {
>+    switch (this[_httpVersion]) {
>+      case _http._HttpVersion.HTTP10:
>+      {
>+        return "1.0";
>+      }
>+      case _http._HttpVersion.HTTP11:
>+      {
>+        return "1.1";
>+      }
>+    }
>+    return null;
>+  }
>+  get messageType() {
>+    return this[_messageType];
>+  }
>+  get transferLength() {
>+    return this[_transferLength];
>+  }
>+  get upgrade() {
>+    return dart.test(this[_connectionUpgrade]) && this[_state$1] === _http._State.UPGRADED;
>+  }
>+  get persistentConnection() {
>+    return this[_persistentConnection];
>+  }
>+  set isHead(value) {
>+    if (dart.test(value)) this[_noMessageBody] = true;
>+  }
>+  detachIncoming() {
>+    this[_state$1] = _http._State.UPGRADED;
>+    return new _http._HttpDetachedIncoming.new(this[_socketSubscription$], this.readUnparsedData());
>+  }
>+  readUnparsedData() {
>+    if (this[_buffer$1] == null) return null;
>+    if (this[_index$1] == this[_buffer$1][$length]) return null;
>+    let result = this[_buffer$1][$sublist](this[_index$1]);
>+    this[_releaseBuffer]();
>+    return result;
>+  }
>+  [_reset]() {
>+    if (this[_state$1] === _http._State.UPGRADED) return;
>+    this[_state$1] = _http._State.START;
>+    this[_messageType] = _http._MessageType.UNDETERMINED;
>+    this[_headerField][$clear]();
>+    this[_headerValue][$clear]();
>+    this[_method$][$clear]();
>+    this[_uri_or_reason_phrase][$clear]();
>+    this[_statusCode] = 0;
>+    this[_statusCodeLength] = 0;
>+    this[_httpVersion] = _http._HttpVersion.UNDETERMINED;
>+    this[_transferLength] = -1;
>+    this[_persistentConnection] = false;
>+    this[_connectionUpgrade] = false;
>+    this[_chunked] = false;
>+    this[_noMessageBody] = false;
>+    this[_remainingContent] = -1;
>+    this[_headers] = null;
>+  }
>+  [_releaseBuffer]() {
>+    this[_buffer$1] = null;
>+    this[_index$1] = null;
>+  }
>+  static _isTokenChar(byte) {
>+    return dart.notNull(byte) > 31 && dart.notNull(byte) < 128 && !dart.test(_http._Const.SEPARATOR_MAP[$_get](byte));
>+  }
>+  static _isValueChar(byte) {
>+    return dart.notNull(byte) > 31 && dart.notNull(byte) < 128 || byte === _http._CharCode.SP || byte === _http._CharCode.HT;
>+  }
>+  static _tokenizeFieldValue(headerValue) {
>+    let tokens = JSArrayOfString().of([]);
>+    let start = 0;
>+    let index = 0;
>+    while (index < headerValue.length) {
>+      if (headerValue[$_get](index) === ",") {
>+        tokens[$add](headerValue[$substring](start, index));
>+        start = index + 1;
>+      } else if (headerValue[$_get](index) === " " || headerValue[$_get](index) === "\t") {
>+        start++;
>+      }
>+      index++;
>+    }
>+    tokens[$add](headerValue[$substring](start, index));
>+    return tokens;
>+  }
>+  static _toLowerCaseByte(x) {
>+    return (dart.notNull(x) - 65 & 127) < 26 ? (dart.notNull(x) | 32) >>> 0 : x;
>+  }
>+  [_caseInsensitiveCompare](expected, value) {
>+    if (expected[$length] != value[$length]) return false;
>+    for (let i = 0; i < dart.notNull(expected[$length]); i++) {
>+      if (expected[$_get](i) != _http._HttpParser._toLowerCaseByte(value[$_get](i))) return false;
>+    }
>+    return true;
>+  }
>+  [_expect](val1, val2) {
>+    if (val1 != val2) {
>+      dart.throw(new _http.HttpException.new("Failed to parse HTTP"));
>+    }
>+  }
>+  [_expectHexDigit](byte) {
>+    if (48 <= dart.notNull(byte) && dart.notNull(byte) <= 57) {
>+      return dart.notNull(byte) - 48;
>+    } else if (65 <= dart.notNull(byte) && dart.notNull(byte) <= 70) {
>+      return dart.notNull(byte) - 65 + 10;
>+    } else if (97 <= dart.notNull(byte) && dart.notNull(byte) <= 102) {
>+      return dart.notNull(byte) - 97 + 10;
>+    } else {
>+      dart.throw(new _http.HttpException.new("Failed to parse HTTP"));
>+    }
>+  }
>+  [_createIncoming](transferLength) {
>+    if (!(this[_incoming] == null)) dart.assertFailed(null, "dart:_http/http_parser.dart", 992, 12, "_incoming == null");
>+    if (!(this[_bodyController] == null)) dart.assertFailed(null, "dart:_http/http_parser.dart", 993, 12, "_bodyController == null");
>+    if (!!dart.test(this[_bodyPaused])) dart.assertFailed(null, "dart:_http/http_parser.dart", 994, 12, "!_bodyPaused");
>+    let incoming = null;
>+    this[_bodyController] = StreamControllerOfListOfint().new({sync: true, onListen: dart.fn(() => {
>+        if (!dart.equals(incoming, this[_incoming])) return;
>+        if (!dart.test(this[_bodyPaused])) dart.assertFailed(null, "dart:_http/http_parser.dart", 1000, 18, "_bodyPaused");
>+        this[_bodyPaused] = false;
>+        this[_pauseStateChanged]();
>+      }, VoidToNull()), onPause: dart.fn(() => {
>+        if (!dart.equals(incoming, this[_incoming])) return;
>+        if (!!dart.test(this[_bodyPaused])) dart.assertFailed(null, "dart:_http/http_parser.dart", 1006, 18, "!_bodyPaused");
>+        this[_bodyPaused] = true;
>+        this[_pauseStateChanged]();
>+      }, VoidToNull()), onResume: dart.fn(() => {
>+        if (!dart.equals(incoming, this[_incoming])) return;
>+        if (!dart.test(this[_bodyPaused])) dart.assertFailed(null, "dart:_http/http_parser.dart", 1012, 18, "_bodyPaused");
>+        this[_bodyPaused] = false;
>+        this[_pauseStateChanged]();
>+      }, VoidToNull()), onCancel: dart.fn(() => {
>+        if (!dart.equals(incoming, this[_incoming])) return;
>+        if (this[_socketSubscription$] != null) {
>+          this[_socketSubscription$].cancel();
>+        }
>+        this[_closeIncoming](true);
>+        this[_controller$1].close();
>+      }, VoidToNull())});
>+    incoming = this[_incoming] = new _http._HttpIncoming.new(this[_headers], transferLength, this[_bodyController].stream);
>+    this[_bodyPaused] = true;
>+    this[_pauseStateChanged]();
>+  }
>+  [_closeIncoming](closing) {
>+    if (closing === void 0) closing = false;
>+    if (this[_incoming] == null) return;
>+    let tmp = this[_incoming];
>+    tmp.close(closing);
>+    this[_incoming] = null;
>+    if (this[_bodyController] != null) {
>+      this[_bodyController].close();
>+      this[_bodyController] = null;
>+    }
>+    this[_bodyPaused] = false;
>+    this[_pauseStateChanged]();
>+  }
>+  [_pauseStateChanged]() {
>+    if (this[_incoming] != null) {
>+      if (!dart.test(this[_bodyPaused]) && !dart.test(this[_parserCalled])) {
>+        this[_parse]();
>+      }
>+    } else {
>+      if (!dart.test(this[_paused]) && !dart.test(this[_parserCalled])) {
>+        this[_parse]();
>+      }
>+    }
>+  }
>+  [_reportError$](error, stackTrace) {
>+    if (stackTrace === void 0) stackTrace = null;
>+    if (this[_socketSubscription$] != null) this[_socketSubscription$].cancel();
>+    this[_state$1] = _http._State.FAILURE;
>+    this[_controller$1].addError(error, core.StackTrace._check(stackTrace));
>+    this[_controller$1].close();
>+  }
>+};
>+(_http._HttpParser.__ = function(requestParser) {
>+  this[_parserCalled] = false;
>+  this[_buffer$1] = null;
>+  this[_index$1] = null;
>+  this[_state$1] = null;
>+  this[_httpVersionIndex] = null;
>+  this[_messageType] = null;
>+  this[_statusCode] = 0;
>+  this[_statusCodeLength] = 0;
>+  this[_method$] = JSArrayOfint().of([]);
>+  this[_uri_or_reason_phrase] = JSArrayOfint().of([]);
>+  this[_headerField] = JSArrayOfint().of([]);
>+  this[_headerValue] = JSArrayOfint().of([]);
>+  this[_httpVersion] = null;
>+  this[_transferLength] = -1;
>+  this[_persistentConnection] = null;
>+  this[_connectionUpgrade] = null;
>+  this[_chunked] = null;
>+  this[_noMessageBody] = false;
>+  this[_remainingContent] = -1;
>+  this[_headers] = null;
>+  this[_incoming] = null;
>+  this[_socketSubscription$] = null;
>+  this[_paused] = true;
>+  this[_bodyPaused] = false;
>+  this[_controller$1] = null;
>+  this[_bodyController] = null;
>+  this[_requestParser] = requestParser;
>+  _http._HttpParser.__proto__.new.call(this);
>+  this[_controller$1] = StreamControllerOf_HttpIncoming().new({sync: true, onListen: dart.fn(() => {
>+      this[_paused] = false;
>+    }, VoidToNull()), onPause: dart.fn(() => {
>+      this[_paused] = true;
>+      this[_pauseStateChanged]();
>+    }, VoidToNull()), onResume: dart.fn(() => {
>+      this[_paused] = false;
>+      this[_pauseStateChanged]();
>+    }, VoidToNull()), onCancel: dart.fn(() => {
>+      if (this[_socketSubscription$] != null) {
>+        this[_socketSubscription$].cancel();
>+      }
>+    }, VoidToNull())});
>+  this[_reset]();
>+}).prototype = _http._HttpParser.prototype;
>+dart.addTypeTests(_http._HttpParser);
>+dart.setMethodSignature(_http._HttpParser, () => ({
>+  __proto__: dart.getMethods(_http._HttpParser.__proto__),
>+  listen: dart.fnType(async.StreamSubscription$(_http._HttpIncoming), [dart.fnType(dart.void, [_http._HttpIncoming])], {onError: core.Function, onDone: dart.fnType(dart.void, []), cancelOnError: core.bool}),
>+  listenToStream: dart.fnType(dart.void, [async.Stream$(core.List$(core.int))]),
>+  [_parse]: dart.fnType(dart.void, []),
>+  [_headersEnd]: dart.fnType(core.bool, []),
>+  [_doParse]: dart.fnType(dart.void, []),
>+  [_onData$2]: dart.fnType(dart.void, [core.List$(core.int)]),
>+  [_onDone$]: dart.fnType(dart.void, []),
>+  detachIncoming: dart.fnType(_http._HttpDetachedIncoming, []),
>+  readUnparsedData: dart.fnType(core.List$(core.int), []),
>+  [_reset]: dart.fnType(dart.void, []),
>+  [_releaseBuffer]: dart.fnType(dart.void, []),
>+  [_caseInsensitiveCompare]: dart.fnType(core.bool, [core.List$(core.int), core.List$(core.int)]),
>+  [_expect]: dart.fnType(core.int, [core.int, core.int]),
>+  [_expectHexDigit]: dart.fnType(core.int, [core.int]),
>+  [_createIncoming]: dart.fnType(dart.void, [core.int]),
>+  [_closeIncoming]: dart.fnType(dart.void, [], [core.bool]),
>+  [_pauseStateChanged]: dart.fnType(dart.void, []),
>+  [_reportError$]: dart.fnType(dart.void, [dart.dynamic], [dart.dynamic])
>+}));
>+dart.setGetterSignature(_http._HttpParser, () => ({
>+  __proto__: dart.getGetters(_http._HttpParser.__proto__),
>+  version: core.String,
>+  messageType: core.int,
>+  transferLength: core.int,
>+  upgrade: core.bool,
>+  persistentConnection: core.bool
>+}));
>+dart.setSetterSignature(_http._HttpParser, () => ({
>+  __proto__: dart.getSetters(_http._HttpParser.__proto__),
>+  isHead: core.bool
>+}));
>+dart.setLibraryUri(_http._HttpParser, "dart:_http");
>+dart.setFieldSignature(_http._HttpParser, () => ({
>+  __proto__: dart.getFields(_http._HttpParser.__proto__),
>+  [_parserCalled]: dart.fieldType(core.bool),
>+  [_buffer$1]: dart.fieldType(typed_data.Uint8List),
>+  [_index$1]: dart.fieldType(core.int),
>+  [_requestParser]: dart.finalFieldType(core.bool),
>+  [_state$1]: dart.fieldType(core.int),
>+  [_httpVersionIndex]: dart.fieldType(core.int),
>+  [_messageType]: dart.fieldType(core.int),
>+  [_statusCode]: dart.fieldType(core.int),
>+  [_statusCodeLength]: dart.fieldType(core.int),
>+  [_method$]: dart.finalFieldType(ListOfint()),
>+  [_uri_or_reason_phrase]: dart.finalFieldType(ListOfint()),
>+  [_headerField]: dart.finalFieldType(ListOfint()),
>+  [_headerValue]: dart.finalFieldType(ListOfint()),
>+  [_httpVersion]: dart.fieldType(core.int),
>+  [_transferLength]: dart.fieldType(core.int),
>+  [_persistentConnection]: dart.fieldType(core.bool),
>+  [_connectionUpgrade]: dart.fieldType(core.bool),
>+  [_chunked]: dart.fieldType(core.bool),
>+  [_noMessageBody]: dart.fieldType(core.bool),
>+  [_remainingContent]: dart.fieldType(core.int),
>+  [_headers]: dart.fieldType(_http._HttpHeaders),
>+  [_incoming]: dart.fieldType(_http._HttpIncoming),
>+  [_socketSubscription$]: dart.fieldType(StreamSubscriptionOfListOfint()),
>+  [_paused]: dart.fieldType(core.bool),
>+  [_bodyPaused]: dart.fieldType(core.bool),
>+  [_controller$1]: dart.fieldType(StreamControllerOf_HttpIncoming()),
>+  [_bodyController]: dart.fieldType(StreamControllerOfListOfint())
>+}));
>+dart.defineLazy(_http, {
>+  /*_http._DART_SESSION_ID*/get _DART_SESSION_ID() {
>+    return "DARTSESSID";
>+  }
>+});
>+const _lastSeen = dart.privateName(_http, "_lastSeen");
>+const _timeoutCallback = dart.privateName(_http, "_timeoutCallback");
>+const _prev = dart.privateName(_http, "_prev");
>+const _next$1 = dart.privateName(_http, "_next");
>+const _data$1 = dart.privateName(_http, "_data");
>+const _removeFromTimeoutQueue = dart.privateName(_http, "_removeFromTimeoutQueue");
>+const _sessions = dart.privateName(_http, "_sessions");
>+const _bumpToEnd = dart.privateName(_http, "_bumpToEnd");
>+_http._HttpSession = class _HttpSession extends core.Object {
>+  destroy() {
>+    this[_destroyed] = true;
>+    this[_sessionManager][_removeFromTimeoutQueue](this);
>+    this[_sessionManager][_sessions][$remove](this.id);
>+  }
>+  [_markSeen]() {
>+    this[_lastSeen] = new core.DateTime.now();
>+    this[_sessionManager][_bumpToEnd](this);
>+  }
>+  get lastSeen() {
>+    return this[_lastSeen];
>+  }
>+  get isNew() {
>+    return this[_isNew];
>+  }
>+  set onTimeout(callback) {
>+    this[_timeoutCallback] = callback;
>+  }
>+  containsValue(value) {
>+    return this[_data$1][$containsValue](value);
>+  }
>+  containsKey(key) {
>+    return this[_data$1][$containsKey](key);
>+  }
>+  _get(key) {
>+    return this[_data$1][$_get](key);
>+  }
>+  _set(key, value) {
>+    this[_data$1][$_set](key, value);
>+    return value;
>+  }
>+  putIfAbsent(key, ifAbsent) {
>+    return this[_data$1][$putIfAbsent](key, ifAbsent);
>+  }
>+  addAll(other) {
>+    return this[_data$1][$addAll](other);
>+  }
>+  remove(key) {
>+    return this[_data$1][$remove](key);
>+  }
>+  clear() {
>+    this[_data$1][$clear]();
>+  }
>+  forEach(f) {
>+    this[_data$1][$forEach](f);
>+  }
>+  get entries() {
>+    return this[_data$1][$entries];
>+  }
>+  addEntries(entries) {
>+    this[_data$1][$addEntries](entries);
>+  }
>+  map(K, V, transform) {
>+    return core.Map$(K, V)._check(this[_data$1][$map](K, V, transform));
>+  }
>+  removeWhere(test) {
>+    this[_data$1][$removeWhere](test);
>+  }
>+  cast(K, V) {
>+    return core.Map$(K, V)._check(this[_data$1][$cast](K, V));
>+  }
>+  update(key, update, opts) {
>+    let ifAbsent = opts && 'ifAbsent' in opts ? opts.ifAbsent : null;
>+    return this[_data$1][$update](key, update, {ifAbsent: ifAbsent});
>+  }
>+  updateAll(update) {
>+    this[_data$1][$updateAll](update);
>+  }
>+  get keys() {
>+    return this[_data$1][$keys];
>+  }
>+  get values() {
>+    return this[_data$1][$values];
>+  }
>+  get length() {
>+    return this[_data$1][$length];
>+  }
>+  get isEmpty() {
>+    return this[_data$1][$isEmpty];
>+  }
>+  get isNotEmpty() {
>+    return this[_data$1][$isNotEmpty];
>+  }
>+  toString() {
>+    return "HttpSession id:" + dart.str(this.id) + " " + dart.str(this[_data$1]);
>+  }
>+};
>+(_http._HttpSession.new = function(sessionManager, id) {
>+  this[_destroyed] = false;
>+  this[_isNew] = true;
>+  this[_timeoutCallback] = null;
>+  this[_prev] = null;
>+  this[_next$1] = null;
>+  this[_data$1] = new _js_helper.LinkedMap.new();
>+  this[_sessionManager] = sessionManager;
>+  this.id = id;
>+  this[_lastSeen] = new core.DateTime.now();
>+}).prototype = _http._HttpSession.prototype;
>+dart.addTypeTests(_http._HttpSession);
>+_http._HttpSession[dart.implements] = () => [_http.HttpSession];
>+dart.setMethodSignature(_http._HttpSession, () => ({
>+  __proto__: dart.getMethods(_http._HttpSession.__proto__),
>+  destroy: dart.fnType(dart.void, []),
>+  [_markSeen]: dart.fnType(dart.void, []),
>+  containsValue: dart.fnType(core.bool, [core.Object]),
>+  [$containsValue]: dart.fnType(core.bool, [core.Object]),
>+  containsKey: dart.fnType(core.bool, [core.Object]),
>+  [$containsKey]: dart.fnType(core.bool, [core.Object]),
>+  _get: dart.fnType(dart.dynamic, [core.Object]),
>+  [$_get]: dart.fnType(dart.dynamic, [core.Object]),
>+  _set: dart.fnType(dart.void, [dart.dynamic, dart.dynamic]),
>+  [$_set]: dart.fnType(dart.void, [dart.dynamic, dart.dynamic]),
>+  putIfAbsent: dart.fnType(dart.dynamic, [dart.dynamic, dart.fnType(dart.dynamic, [])]),
>+  [$putIfAbsent]: dart.fnType(dart.dynamic, [dart.dynamic, dart.fnType(dart.dynamic, [])]),
>+  addAll: dart.fnType(dart.void, [core.Map]),
>+  [$addAll]: dart.fnType(dart.void, [core.Map]),
>+  remove: dart.fnType(dart.dynamic, [core.Object]),
>+  [$remove]: dart.fnType(dart.dynamic, [core.Object]),
>+  clear: dart.fnType(dart.void, []),
>+  [$clear]: dart.fnType(dart.void, []),
>+  forEach: dart.fnType(dart.void, [dart.fnType(dart.void, [dart.dynamic, dart.dynamic])]),
>+  [$forEach]: dart.fnType(dart.void, [dart.fnType(dart.void, [dart.dynamic, dart.dynamic])]),
>+  addEntries: dart.fnType(dart.void, [core.Iterable$(core.MapEntry)]),
>+  [$addEntries]: dart.fnType(dart.void, [core.Iterable$(core.MapEntry)]),
>+  map: dart.gFnType((K, V) => [core.Map$(K, V), [dart.fnType(core.MapEntry$(K, V), [dart.dynamic, dart.dynamic])]]),
>+  [$map]: dart.gFnType((K, V) => [core.Map$(K, V), [dart.fnType(core.MapEntry$(K, V), [dart.dynamic, dart.dynamic])]]),
>+  removeWhere: dart.fnType(dart.void, [dart.fnType(core.bool, [dart.dynamic, dart.dynamic])]),
>+  [$removeWhere]: dart.fnType(dart.void, [dart.fnType(core.bool, [dart.dynamic, dart.dynamic])]),
>+  cast: dart.gFnType((K, V) => [core.Map$(K, V), []]),
>+  [$cast]: dart.gFnType((K, V) => [core.Map$(K, V), []]),
>+  update: dart.fnType(dart.dynamic, [dart.dynamic, dart.fnType(dart.dynamic, [dart.dynamic])], {ifAbsent: dart.fnType(dart.dynamic, [])}),
>+  [$update]: dart.fnType(dart.dynamic, [dart.dynamic, dart.fnType(dart.dynamic, [dart.dynamic])], {ifAbsent: dart.fnType(dart.dynamic, [])}),
>+  updateAll: dart.fnType(dart.void, [dart.fnType(dart.dynamic, [dart.dynamic, dart.dynamic])]),
>+  [$updateAll]: dart.fnType(dart.void, [dart.fnType(dart.dynamic, [dart.dynamic, dart.dynamic])])
>+}));
>+dart.setGetterSignature(_http._HttpSession, () => ({
>+  __proto__: dart.getGetters(_http._HttpSession.__proto__),
>+  lastSeen: core.DateTime,
>+  isNew: core.bool,
>+  entries: core.Iterable$(core.MapEntry),
>+  [$entries]: core.Iterable$(core.MapEntry),
>+  keys: core.Iterable,
>+  [$keys]: core.Iterable,
>+  values: core.Iterable,
>+  [$values]: core.Iterable,
>+  length: core.int,
>+  [$length]: core.int,
>+  isEmpty: core.bool,
>+  [$isEmpty]: core.bool,
>+  isNotEmpty: core.bool,
>+  [$isNotEmpty]: core.bool
>+}));
>+dart.setSetterSignature(_http._HttpSession, () => ({
>+  __proto__: dart.getSetters(_http._HttpSession.__proto__),
>+  onTimeout: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(_http._HttpSession, "dart:_http");
>+dart.setFieldSignature(_http._HttpSession, () => ({
>+  __proto__: dart.getFields(_http._HttpSession.__proto__),
>+  [_destroyed]: dart.fieldType(core.bool),
>+  [_isNew]: dart.fieldType(core.bool),
>+  [_lastSeen]: dart.fieldType(core.DateTime),
>+  [_timeoutCallback]: dart.fieldType(core.Function),
>+  [_sessionManager]: dart.fieldType(_http._HttpSessionManager),
>+  [_prev]: dart.fieldType(_http._HttpSession),
>+  [_next$1]: dart.fieldType(_http._HttpSession),
>+  id: dart.finalFieldType(core.String),
>+  [_data$1]: dart.finalFieldType(core.Map)
>+}));
>+dart.defineExtensionMethods(_http._HttpSession, [
>+  'containsValue',
>+  'containsKey',
>+  '_get',
>+  '_set',
>+  'putIfAbsent',
>+  'addAll',
>+  'remove',
>+  'clear',
>+  'forEach',
>+  'addEntries',
>+  'map',
>+  'removeWhere',
>+  'cast',
>+  'update',
>+  'updateAll',
>+  'toString'
>+]);
>+dart.defineExtensionAccessors(_http._HttpSession, [
>+  'entries',
>+  'keys',
>+  'values',
>+  'length',
>+  'isEmpty',
>+  'isNotEmpty'
>+]);
>+const _sessionTimeout = dart.privateName(_http, "_sessionTimeout");
>+const _head$0 = dart.privateName(_http, "_head");
>+const _tail$ = dart.privateName(_http, "_tail");
>+const _timer = dart.privateName(_http, "_timer");
>+const _addToTimeoutQueue = dart.privateName(_http, "_addToTimeoutQueue");
>+const _stopTimer = dart.privateName(_http, "_stopTimer");
>+const _startTimer = dart.privateName(_http, "_startTimer");
>+const _timerTimeout = dart.privateName(_http, "_timerTimeout");
>+_http._HttpSessionManager = class _HttpSessionManager extends core.Object {
>+  createSessionId() {
>+    let _KEY_LENGTH = 16;
>+    let data = _http._CryptoUtils.getRandomBytes(_KEY_LENGTH);
>+    return _http._CryptoUtils.bytesToHex(data);
>+  }
>+  getSession(id) {
>+    return this[_sessions][$_get](id);
>+  }
>+  createSession() {
>+    let id = this.createSessionId();
>+    while (dart.test(this[_sessions][$containsKey](id))) {
>+      id = this.createSessionId();
>+    }
>+    let session = this[_sessions][$_set](id, new _http._HttpSession.new(this, id));
>+    this[_addToTimeoutQueue](session);
>+    return session;
>+  }
>+  set sessionTimeout(timeout) {
>+    this[_sessionTimeout] = timeout;
>+    this[_stopTimer]();
>+    this[_startTimer]();
>+  }
>+  close() {
>+    this[_stopTimer]();
>+  }
>+  [_bumpToEnd](session) {
>+    this[_removeFromTimeoutQueue](session);
>+    this[_addToTimeoutQueue](session);
>+  }
>+  [_addToTimeoutQueue](session) {
>+    if (this[_head$0] == null) {
>+      if (!(this[_tail$] == null)) dart.assertFailed(null, "dart:_http/http_session.dart", 148, 14, "_tail == null");
>+      this[_tail$] = this[_head$0] = session;
>+      this[_startTimer]();
>+    } else {
>+      if (!(this[_timer] != null)) dart.assertFailed(null, "dart:_http/http_session.dart", 152, 14, "_timer != null");
>+      if (!(this[_tail$] != null)) dart.assertFailed(null, "dart:_http/http_session.dart", 153, 14, "_tail != null");
>+      this[_tail$][_next$1] = session;
>+      session[_prev] = this[_tail$];
>+      this[_tail$] = session;
>+    }
>+  }
>+  [_removeFromTimeoutQueue](session) {
>+    if (session[_next$1] != null) {
>+      session[_next$1][_prev] = session[_prev];
>+    }
>+    if (session[_prev] != null) {
>+      session[_prev][_next$1] = session[_next$1];
>+    }
>+    if (dart.equals(this[_head$0], session)) {
>+      this[_head$0] = session[_next$1];
>+      this[_stopTimer]();
>+      this[_startTimer]();
>+    }
>+    if (dart.equals(this[_tail$], session)) {
>+      this[_tail$] = session[_prev];
>+    }
>+    session[_next$1] = session[_prev] = null;
>+  }
>+  [_timerTimeout]() {
>+    this[_stopTimer]();
>+    if (!(this[_head$0] != null)) dart.assertFailed(null, "dart:_http/http_session.dart", 182, 12, "_head != null");
>+    let session = this[_head$0];
>+    session.destroy();
>+    if (session[_timeoutCallback] != null) {
>+      dart.dsend(session, _timeoutCallback, []);
>+    }
>+  }
>+  [_startTimer]() {
>+    if (!(this[_timer] == null)) dart.assertFailed(null, "dart:_http/http_session.dart", 191, 12, "_timer == null");
>+    if (this[_head$0] != null) {
>+      let seconds = new core.DateTime.now().difference(this[_head$0].lastSeen).inSeconds;
>+      this[_timer] = async.Timer.new(new core.Duration.new({seconds: dart.notNull(this[_sessionTimeout]) - dart.notNull(seconds)}), dart.bind(this, _timerTimeout));
>+    }
>+  }
>+  [_stopTimer]() {
>+    if (this[_timer] != null) {
>+      this[_timer].cancel();
>+      this[_timer] = null;
>+    }
>+  }
>+};
>+(_http._HttpSessionManager.new = function() {
>+  this[_sessionTimeout] = 20 * 60;
>+  this[_head$0] = null;
>+  this[_tail$] = null;
>+  this[_timer] = null;
>+  this[_sessions] = new (IdentityMapOfString$_HttpSession()).new();
>+}).prototype = _http._HttpSessionManager.prototype;
>+dart.addTypeTests(_http._HttpSessionManager);
>+dart.setMethodSignature(_http._HttpSessionManager, () => ({
>+  __proto__: dart.getMethods(_http._HttpSessionManager.__proto__),
>+  createSessionId: dart.fnType(core.String, []),
>+  getSession: dart.fnType(_http._HttpSession, [core.String]),
>+  createSession: dart.fnType(_http._HttpSession, []),
>+  close: dart.fnType(dart.void, []),
>+  [_bumpToEnd]: dart.fnType(dart.void, [_http._HttpSession]),
>+  [_addToTimeoutQueue]: dart.fnType(dart.void, [_http._HttpSession]),
>+  [_removeFromTimeoutQueue]: dart.fnType(dart.void, [_http._HttpSession]),
>+  [_timerTimeout]: dart.fnType(dart.void, []),
>+  [_startTimer]: dart.fnType(dart.void, []),
>+  [_stopTimer]: dart.fnType(dart.void, [])
>+}));
>+dart.setSetterSignature(_http._HttpSessionManager, () => ({
>+  __proto__: dart.getSetters(_http._HttpSessionManager.__proto__),
>+  sessionTimeout: core.int
>+}));
>+dart.setLibraryUri(_http._HttpSessionManager, "dart:_http");
>+dart.setFieldSignature(_http._HttpSessionManager, () => ({
>+  __proto__: dart.getFields(_http._HttpSessionManager.__proto__),
>+  [_sessions]: dart.fieldType(MapOfString$_HttpSession()),
>+  [_sessionTimeout]: dart.fieldType(core.int),
>+  [_head$0]: dart.fieldType(_http._HttpSession),
>+  [_tail$]: dart.fieldType(_http._HttpSession),
>+  [_timer]: dart.fieldType(async.Timer)
>+}));
>+dart.defineLazy(_http, {
>+  /*_http._httpOverridesToken*/get _httpOverridesToken() {
>+    return new core.Object.new();
>+  },
>+  /*_http._asyncRunZoned*/get _asyncRunZoned() {
>+    return dart.fn(async.runZoned, Fn__ToR());
>+  }
>+});
>+_http.HttpOverrides = class HttpOverrides extends core.Object {
>+  static get current() {
>+    return _http.HttpOverrides._check((() => {
>+      let l = async.Zone.current._get(_http._httpOverridesToken);
>+      return l != null ? l : _http.HttpOverrides._global;
>+    })());
>+  }
>+  static set global(overrides) {
>+    _http.HttpOverrides._global = overrides;
>+  }
>+  static runZoned(R, body, opts) {
>+    let createHttpClient = opts && 'createHttpClient' in opts ? opts.createHttpClient : null;
>+    let findProxyFromEnvironment = opts && 'findProxyFromEnvironment' in opts ? opts.findProxyFromEnvironment : null;
>+    let zoneSpecification = opts && 'zoneSpecification' in opts ? opts.zoneSpecification : null;
>+    let onError = opts && 'onError' in opts ? opts.onError : null;
>+    let overrides = new _http._HttpOverridesScope.new(createHttpClient, findProxyFromEnvironment);
>+    return _http._asyncRunZoned(R, body, {zoneValues: new _js_helper.LinkedMap.from([_http._httpOverridesToken, overrides]), zoneSpecification: zoneSpecification, onError: onError});
>+  }
>+  static runWithHttpOverrides(R, body, overrides, opts) {
>+    let zoneSpecification = opts && 'zoneSpecification' in opts ? opts.zoneSpecification : null;
>+    let onError = opts && 'onError' in opts ? opts.onError : null;
>+    return _http._asyncRunZoned(R, body, {zoneValues: new _js_helper.LinkedMap.from([_http._httpOverridesToken, overrides]), zoneSpecification: zoneSpecification, onError: onError});
>+  }
>+  createHttpClient(context) {
>+    return new _http._HttpClient.new(context);
>+  }
>+  findProxyFromEnvironment(url, environment) {
>+    return _http._HttpClient._findProxyFromEnvironment(url, environment);
>+  }
>+};
>+(_http.HttpOverrides.new = function() {
>+}).prototype = _http.HttpOverrides.prototype;
>+dart.addTypeTests(_http.HttpOverrides);
>+dart.setMethodSignature(_http.HttpOverrides, () => ({
>+  __proto__: dart.getMethods(_http.HttpOverrides.__proto__),
>+  createHttpClient: dart.fnType(_http.HttpClient, [io.SecurityContext]),
>+  findProxyFromEnvironment: dart.fnType(core.String, [core.Uri, core.Map$(core.String, core.String)])
>+}));
>+dart.setLibraryUri(_http.HttpOverrides, "dart:_http");
>+dart.defineLazy(_http.HttpOverrides, {
>+  /*_http.HttpOverrides._global*/get _global() {
>+    return null;
>+  },
>+  set _global(_) {}
>+});
>+const _createHttpClient = dart.privateName(_http, "_createHttpClient");
>+const _findProxyFromEnvironment = dart.privateName(_http, "_findProxyFromEnvironment");
>+const _previous$2 = dart.privateName(_http, "_previous");
>+_http._HttpOverridesScope = class _HttpOverridesScope extends _http.HttpOverrides {
>+  createHttpClient(context) {
>+    if (this[_createHttpClient] != null) return this[_createHttpClient](context);
>+    if (this[_previous$2] != null) return this[_previous$2].createHttpClient(context);
>+    return super.createHttpClient(context);
>+  }
>+  findProxyFromEnvironment(url, environment) {
>+    if (this[_findProxyFromEnvironment] != null) {
>+      return this[_findProxyFromEnvironment](url, environment);
>+    }
>+    if (this[_previous$2] != null) {
>+      return this[_previous$2].findProxyFromEnvironment(url, environment);
>+    }
>+    return super.findProxyFromEnvironment(url, environment);
>+  }
>+};
>+(_http._HttpOverridesScope.new = function(createHttpClient, findProxyFromEnvironment) {
>+  this[_previous$2] = _http.HttpOverrides.current;
>+  this[_createHttpClient] = createHttpClient;
>+  this[_findProxyFromEnvironment] = findProxyFromEnvironment;
>+}).prototype = _http._HttpOverridesScope.prototype;
>+dart.addTypeTests(_http._HttpOverridesScope);
>+dart.setLibraryUri(_http._HttpOverridesScope, "dart:_http");
>+dart.setFieldSignature(_http._HttpOverridesScope, () => ({
>+  __proto__: dart.getFields(_http._HttpOverridesScope.__proto__),
>+  [_previous$2]: dart.finalFieldType(_http.HttpOverrides),
>+  [_createHttpClient]: dart.finalFieldType(SecurityContextToHttpClient()),
>+  [_findProxyFromEnvironment]: dart.finalFieldType(UriAndMapOfString$StringToString())
>+}));
>+_http.WebSocketStatus = class WebSocketStatus extends core.Object {};
>+(_http.WebSocketStatus.new = function() {
>+}).prototype = _http.WebSocketStatus.prototype;
>+dart.addTypeTests(_http.WebSocketStatus);
>+dart.setLibraryUri(_http.WebSocketStatus, "dart:_http");
>+dart.defineLazy(_http.WebSocketStatus, {
>+  /*_http.WebSocketStatus.normalClosure*/get normalClosure() {
>+    return 1000;
>+  },
>+  /*_http.WebSocketStatus.goingAway*/get goingAway() {
>+    return 1001;
>+  },
>+  /*_http.WebSocketStatus.protocolError*/get protocolError() {
>+    return 1002;
>+  },
>+  /*_http.WebSocketStatus.unsupportedData*/get unsupportedData() {
>+    return 1003;
>+  },
>+  /*_http.WebSocketStatus.reserved1004*/get reserved1004() {
>+    return 1004;
>+  },
>+  /*_http.WebSocketStatus.noStatusReceived*/get noStatusReceived() {
>+    return 1005;
>+  },
>+  /*_http.WebSocketStatus.abnormalClosure*/get abnormalClosure() {
>+    return 1006;
>+  },
>+  /*_http.WebSocketStatus.invalidFramePayloadData*/get invalidFramePayloadData() {
>+    return 1007;
>+  },
>+  /*_http.WebSocketStatus.policyViolation*/get policyViolation() {
>+    return 1008;
>+  },
>+  /*_http.WebSocketStatus.messageTooBig*/get messageTooBig() {
>+    return 1009;
>+  },
>+  /*_http.WebSocketStatus.missingMandatoryExtension*/get missingMandatoryExtension() {
>+    return 1010;
>+  },
>+  /*_http.WebSocketStatus.internalServerError*/get internalServerError() {
>+    return 1011;
>+  },
>+  /*_http.WebSocketStatus.reserved1015*/get reserved1015() {
>+    return 1015;
>+  },
>+  /*_http.WebSocketStatus.NORMAL_CLOSURE*/get NORMAL_CLOSURE() {
>+    return 1000;
>+  },
>+  /*_http.WebSocketStatus.GOING_AWAY*/get GOING_AWAY() {
>+    return 1001;
>+  },
>+  /*_http.WebSocketStatus.PROTOCOL_ERROR*/get PROTOCOL_ERROR() {
>+    return 1002;
>+  },
>+  /*_http.WebSocketStatus.UNSUPPORTED_DATA*/get UNSUPPORTED_DATA() {
>+    return 1003;
>+  },
>+  /*_http.WebSocketStatus.RESERVED_1004*/get RESERVED_1004() {
>+    return 1004;
>+  },
>+  /*_http.WebSocketStatus.NO_STATUS_RECEIVED*/get NO_STATUS_RECEIVED() {
>+    return 1005;
>+  },
>+  /*_http.WebSocketStatus.ABNORMAL_CLOSURE*/get ABNORMAL_CLOSURE() {
>+    return 1006;
>+  },
>+  /*_http.WebSocketStatus.INVALID_FRAME_PAYLOAD_DATA*/get INVALID_FRAME_PAYLOAD_DATA() {
>+    return 1007;
>+  },
>+  /*_http.WebSocketStatus.POLICY_VIOLATION*/get POLICY_VIOLATION() {
>+    return 1008;
>+  },
>+  /*_http.WebSocketStatus.MESSAGE_TOO_BIG*/get MESSAGE_TOO_BIG() {
>+    return 1009;
>+  },
>+  /*_http.WebSocketStatus.MISSING_MANDATORY_EXTENSION*/get MISSING_MANDATORY_EXTENSION() {
>+    return 1010;
>+  },
>+  /*_http.WebSocketStatus.INTERNAL_SERVER_ERROR*/get INTERNAL_SERVER_ERROR() {
>+    return 1011;
>+  },
>+  /*_http.WebSocketStatus.RESERVED_1015*/get RESERVED_1015() {
>+    return 1015;
>+  }
>+});
>+const _createServerResponseHeader = dart.privateName(_http, "_createServerResponseHeader");
>+const _createClientRequestHeader = dart.privateName(_http, "_createClientRequestHeader");
>+const _createHeader = dart.privateName(_http, "_createHeader");
>+_http.CompressionOptions = class CompressionOptions extends core.Object {
>+  [_createServerResponseHeader](requested) {
>+    let info = new _http._CompressionMaxWindowBits.new();
>+    let mwb = null;
>+    let part = null;
>+    if ((requested == null ? null : requested.parameters) != null) {
>+      part = requested.parameters[$_get]("server_max_window_bits");
>+    }
>+    if (part != null) {
>+      if (part.length >= 2 && part[$startsWith]("0")) {
>+        dart.throw(new core.ArgumentError.new("Illegal 0 padding on value."));
>+      } else {
>+        mwb = this.serverMaxWindowBits == null ? core.int.parse(part, {onError: dart.fn(source => _http._WebSocketImpl.DEFAULT_WINDOW_BITS, StringToint())}) : this.serverMaxWindowBits;
>+        info.headerValue = "; server_max_window_bits=" + dart.str(mwb);
>+        info.maxWindowBits = mwb;
>+      }
>+    } else {
>+      info.headerValue = "";
>+      info.maxWindowBits = _http._WebSocketImpl.DEFAULT_WINDOW_BITS;
>+    }
>+    return info;
>+  }
>+  [_createClientRequestHeader](requested, size) {
>+    let info = "";
>+    if (requested != null) {
>+      info = "; client_max_window_bits=" + dart.str(size);
>+    } else {
>+      if (this.clientMaxWindowBits == null) {
>+        info = "; client_max_window_bits";
>+      } else {
>+        info = "; client_max_window_bits=" + dart.str(this.clientMaxWindowBits);
>+      }
>+      if (this.serverMaxWindowBits != null) {
>+        info = info + ("; server_max_window_bits=" + dart.str(this.serverMaxWindowBits));
>+      }
>+    }
>+    return info;
>+  }
>+  [_createHeader](requested) {
>+    if (requested === void 0) requested = null;
>+    let info = new _http._CompressionMaxWindowBits.new("", 0);
>+    if (!dart.test(this.enabled)) {
>+      return info;
>+    }
>+    info.headerValue = _http._WebSocketImpl.PER_MESSAGE_DEFLATE;
>+    if (dart.test(this.clientNoContextTakeover) && (requested == null || requested != null && dart.test(requested.parameters[$containsKey]("client_no_context_takeover")))) {
>+      info.headerValue = dart.notNull(info.headerValue) + "; client_no_context_takeover";
>+    }
>+    if (dart.test(this.serverNoContextTakeover) && (requested == null || requested != null && dart.test(requested.parameters[$containsKey]("server_no_context_takeover")))) {
>+      info.headerValue = dart.notNull(info.headerValue) + "; server_no_context_takeover";
>+    }
>+    let headerList = this[_createServerResponseHeader](requested);
>+    info.headerValue = dart.notNull(info.headerValue) + dart.notNull(headerList.headerValue);
>+    info.maxWindowBits = headerList.maxWindowBits;
>+    info.headerValue = dart.notNull(info.headerValue) + dart.notNull(this[_createClientRequestHeader](requested, info.maxWindowBits));
>+    return info;
>+  }
>+};
>+(_http.CompressionOptions.new = function(opts) {
>+  let clientNoContextTakeover = opts && 'clientNoContextTakeover' in opts ? opts.clientNoContextTakeover : false;
>+  let serverNoContextTakeover = opts && 'serverNoContextTakeover' in opts ? opts.serverNoContextTakeover : false;
>+  let clientMaxWindowBits = opts && 'clientMaxWindowBits' in opts ? opts.clientMaxWindowBits : null;
>+  let serverMaxWindowBits = opts && 'serverMaxWindowBits' in opts ? opts.serverMaxWindowBits : null;
>+  let enabled = opts && 'enabled' in opts ? opts.enabled : true;
>+  this.clientNoContextTakeover = clientNoContextTakeover;
>+  this.serverNoContextTakeover = serverNoContextTakeover;
>+  this.clientMaxWindowBits = clientMaxWindowBits;
>+  this.serverMaxWindowBits = serverMaxWindowBits;
>+  this.enabled = enabled;
>+}).prototype = _http.CompressionOptions.prototype;
>+dart.addTypeTests(_http.CompressionOptions);
>+dart.setMethodSignature(_http.CompressionOptions, () => ({
>+  __proto__: dart.getMethods(_http.CompressionOptions.__proto__),
>+  [_createServerResponseHeader]: dart.fnType(_http._CompressionMaxWindowBits, [_http.HeaderValue]),
>+  [_createClientRequestHeader]: dart.fnType(core.String, [_http.HeaderValue, core.int]),
>+  [_createHeader]: dart.fnType(_http._CompressionMaxWindowBits, [], [_http.HeaderValue])
>+}));
>+dart.setLibraryUri(_http.CompressionOptions, "dart:_http");
>+dart.setFieldSignature(_http.CompressionOptions, () => ({
>+  __proto__: dart.getFields(_http.CompressionOptions.__proto__),
>+  clientNoContextTakeover: dart.finalFieldType(core.bool),
>+  serverNoContextTakeover: dart.finalFieldType(core.bool),
>+  clientMaxWindowBits: dart.finalFieldType(core.int),
>+  serverMaxWindowBits: dart.finalFieldType(core.int),
>+  enabled: dart.finalFieldType(core.bool)
>+}));
>+dart.defineLazy(_http.CompressionOptions, {
>+  /*_http.CompressionOptions.compressionDefault*/get compressionDefault() {
>+    return dart.const(new _http.CompressionOptions.new());
>+  },
>+  /*_http.CompressionOptions.DEFAULT*/get DEFAULT() {
>+    return _http.CompressionOptions.compressionDefault;
>+  },
>+  /*_http.CompressionOptions.compressionOff*/get compressionOff() {
>+    return dart.const(new _http.CompressionOptions.new({enabled: false}));
>+  },
>+  /*_http.CompressionOptions.OFF*/get OFF() {
>+    return _http.CompressionOptions.compressionOff;
>+  }
>+});
>+_http.WebSocketTransformer = class WebSocketTransformer extends core.Object {
>+  static new(opts) {
>+    let protocolSelector = opts && 'protocolSelector' in opts ? opts.protocolSelector : null;
>+    let compression = opts && 'compression' in opts ? opts.compression : _http.CompressionOptions.compressionDefault;
>+    return new _http._WebSocketTransformerImpl.new(protocolSelector, compression);
>+  }
>+  static upgrade(request, opts) {
>+    let protocolSelector = opts && 'protocolSelector' in opts ? opts.protocolSelector : null;
>+    let compression = opts && 'compression' in opts ? opts.compression : _http.CompressionOptions.compressionDefault;
>+    return _http._WebSocketTransformerImpl._upgrade(request, protocolSelector, compression);
>+  }
>+  static isUpgradeRequest(request) {
>+    return _http._WebSocketTransformerImpl._isUpgradeRequest(request);
>+  }
>+};
>+(_http.WebSocketTransformer[dart.mixinNew] = function() {
>+}).prototype = _http.WebSocketTransformer.prototype;
>+dart.addTypeTests(_http.WebSocketTransformer);
>+_http.WebSocketTransformer[dart.implements] = () => [StreamTransformerOfHttpRequest$WebSocket()];
>+dart.setLibraryUri(_http.WebSocketTransformer, "dart:_http");
>+_http.WebSocket = class WebSocket extends core.Object {
>+  static connect(url, opts) {
>+    let protocols = opts && 'protocols' in opts ? opts.protocols : null;
>+    let headers = opts && 'headers' in opts ? opts.headers : null;
>+    let compression = opts && 'compression' in opts ? opts.compression : _http.CompressionOptions.compressionDefault;
>+    return _http._WebSocketImpl.connect(url, protocols, headers, {compression: compression});
>+  }
>+  static fromUpgradedSocket(socket, opts) {
>+    let protocol = opts && 'protocol' in opts ? opts.protocol : null;
>+    let serverSide = opts && 'serverSide' in opts ? opts.serverSide : null;
>+    let compression = opts && 'compression' in opts ? opts.compression : _http.CompressionOptions.compressionDefault;
>+    if (serverSide == null) {
>+      dart.throw(new core.ArgumentError.new("The serverSide argument must be passed " + "explicitly to WebSocket.fromUpgradedSocket."));
>+    }
>+    return new _http._WebSocketImpl._fromSocket(socket, protocol, compression, serverSide);
>+  }
>+  static get userAgent() {
>+    return _http._WebSocketImpl.userAgent;
>+  }
>+  static set userAgent(userAgent) {
>+    _http._WebSocketImpl.userAgent = userAgent;
>+  }
>+};
>+(_http.WebSocket.new = function() {
>+  this.pingInterval = null;
>+}).prototype = _http.WebSocket.prototype;
>+_http.WebSocket.prototype[dart.isStream] = true;
>+dart.addTypeTests(_http.WebSocket);
>+_http.WebSocket[dart.implements] = () => [async.Stream, async.StreamSink];
>+dart.setLibraryUri(_http.WebSocket, "dart:_http");
>+dart.setFieldSignature(_http.WebSocket, () => ({
>+  __proto__: dart.getFields(_http.WebSocket.__proto__),
>+  pingInterval: dart.fieldType(core.Duration)
>+}));
>+dart.defineLazy(_http.WebSocket, {
>+  /*_http.WebSocket.connecting*/get connecting() {
>+    return 0;
>+  },
>+  /*_http.WebSocket.open*/get open() {
>+    return 1;
>+  },
>+  /*_http.WebSocket.closing*/get closing() {
>+    return 2;
>+  },
>+  /*_http.WebSocket.closed*/get closed() {
>+    return 3;
>+  },
>+  /*_http.WebSocket.CONNECTING*/get CONNECTING() {
>+    return 0;
>+  },
>+  /*_http.WebSocket.OPEN*/get OPEN() {
>+    return 1;
>+  },
>+  /*_http.WebSocket.CLOSING*/get CLOSING() {
>+    return 2;
>+  },
>+  /*_http.WebSocket.CLOSED*/get CLOSED() {
>+    return 3;
>+  }
>+});
>+_http.WebSocketException = class WebSocketException extends core.Object {
>+  toString() {
>+    return "WebSocketException: " + dart.str(this.message);
>+  }
>+};
>+(_http.WebSocketException.new = function(message) {
>+  if (message === void 0) message = "";
>+  this.message = message;
>+}).prototype = _http.WebSocketException.prototype;
>+dart.addTypeTests(_http.WebSocketException);
>+_http.WebSocketException[dart.implements] = () => [io.IOException];
>+dart.setLibraryUri(_http.WebSocketException, "dart:_http");
>+dart.setFieldSignature(_http.WebSocketException, () => ({
>+  __proto__: dart.getFields(_http.WebSocketException.__proto__),
>+  message: dart.finalFieldType(core.String)
>+}));
>+dart.defineExtensionMethods(_http.WebSocketException, ['toString']);
>+dart.defineLazy(_http, {
>+  /*_http._webSocketGUID*/get _webSocketGUID() {
>+    return "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
>+  },
>+  /*_http._clientNoContextTakeover*/get _clientNoContextTakeover() {
>+    return "client_no_context_takeover";
>+  },
>+  /*_http._serverNoContextTakeover*/get _serverNoContextTakeover() {
>+    return "server_no_context_takeover";
>+  },
>+  /*_http._clientMaxWindowBits*/get _clientMaxWindowBits() {
>+    return "client_max_window_bits";
>+  },
>+  /*_http._serverMaxWindowBits*/get _serverMaxWindowBits() {
>+    return "server_max_window_bits";
>+  }
>+});
>+_http._WebSocketMessageType = class _WebSocketMessageType extends core.Object {};
>+(_http._WebSocketMessageType.new = function() {
>+}).prototype = _http._WebSocketMessageType.prototype;
>+dart.addTypeTests(_http._WebSocketMessageType);
>+dart.setLibraryUri(_http._WebSocketMessageType, "dart:_http");
>+dart.defineLazy(_http._WebSocketMessageType, {
>+  /*_http._WebSocketMessageType.NONE*/get NONE() {
>+    return 0;
>+  },
>+  /*_http._WebSocketMessageType.TEXT*/get TEXT() {
>+    return 1;
>+  },
>+  /*_http._WebSocketMessageType.BINARY*/get BINARY() {
>+    return 2;
>+  }
>+});
>+_http._WebSocketOpcode = class _WebSocketOpcode extends core.Object {};
>+(_http._WebSocketOpcode.new = function() {
>+}).prototype = _http._WebSocketOpcode.prototype;
>+dart.addTypeTests(_http._WebSocketOpcode);
>+dart.setLibraryUri(_http._WebSocketOpcode, "dart:_http");
>+dart.defineLazy(_http._WebSocketOpcode, {
>+  /*_http._WebSocketOpcode.CONTINUATION*/get CONTINUATION() {
>+    return 0;
>+  },
>+  /*_http._WebSocketOpcode.TEXT*/get TEXT() {
>+    return 1;
>+  },
>+  /*_http._WebSocketOpcode.BINARY*/get BINARY() {
>+    return 2;
>+  },
>+  /*_http._WebSocketOpcode.RESERVED_3*/get RESERVED_3() {
>+    return 3;
>+  },
>+  /*_http._WebSocketOpcode.RESERVED_4*/get RESERVED_4() {
>+    return 4;
>+  },
>+  /*_http._WebSocketOpcode.RESERVED_5*/get RESERVED_5() {
>+    return 5;
>+  },
>+  /*_http._WebSocketOpcode.RESERVED_6*/get RESERVED_6() {
>+    return 6;
>+  },
>+  /*_http._WebSocketOpcode.RESERVED_7*/get RESERVED_7() {
>+    return 7;
>+  },
>+  /*_http._WebSocketOpcode.CLOSE*/get CLOSE() {
>+    return 8;
>+  },
>+  /*_http._WebSocketOpcode.PING*/get PING() {
>+    return 9;
>+  },
>+  /*_http._WebSocketOpcode.PONG*/get PONG() {
>+    return 10;
>+  },
>+  /*_http._WebSocketOpcode.RESERVED_B*/get RESERVED_B() {
>+    return 11;
>+  },
>+  /*_http._WebSocketOpcode.RESERVED_C*/get RESERVED_C() {
>+    return 12;
>+  },
>+  /*_http._WebSocketOpcode.RESERVED_D*/get RESERVED_D() {
>+    return 13;
>+  },
>+  /*_http._WebSocketOpcode.RESERVED_E*/get RESERVED_E() {
>+    return 14;
>+  },
>+  /*_http._WebSocketOpcode.RESERVED_F*/get RESERVED_F() {
>+    return 15;
>+  }
>+});
>+_http._EncodedString = class _EncodedString extends core.Object {};
>+(_http._EncodedString.new = function(bytes) {
>+  this.bytes = bytes;
>+}).prototype = _http._EncodedString.prototype;
>+dart.addTypeTests(_http._EncodedString);
>+dart.setLibraryUri(_http._EncodedString, "dart:_http");
>+dart.setFieldSignature(_http._EncodedString, () => ({
>+  __proto__: dart.getFields(_http._EncodedString.__proto__),
>+  bytes: dart.finalFieldType(ListOfint())
>+}));
>+_http._CompressionMaxWindowBits = class _CompressionMaxWindowBits extends core.Object {
>+  toString() {
>+    return this.headerValue;
>+  }
>+};
>+(_http._CompressionMaxWindowBits.new = function(headerValue, maxWindowBits) {
>+  if (headerValue === void 0) headerValue = null;
>+  if (maxWindowBits === void 0) maxWindowBits = null;
>+  this.headerValue = headerValue;
>+  this.maxWindowBits = maxWindowBits;
>+}).prototype = _http._CompressionMaxWindowBits.prototype;
>+dart.addTypeTests(_http._CompressionMaxWindowBits);
>+dart.setLibraryUri(_http._CompressionMaxWindowBits, "dart:_http");
>+dart.setFieldSignature(_http._CompressionMaxWindowBits, () => ({
>+  __proto__: dart.getFields(_http._CompressionMaxWindowBits.__proto__),
>+  headerValue: dart.fieldType(core.String),
>+  maxWindowBits: dart.fieldType(core.int)
>+}));
>+dart.defineExtensionMethods(_http._CompressionMaxWindowBits, ['toString']);
>+const _serverSide = dart.privateName(_http, "_serverSide");
>+const _deflate = dart.privateName(_http, "_deflate");
>+const _fin = dart.privateName(_http, "_fin");
>+const _compressed = dart.privateName(_http, "_compressed");
>+const _opcode = dart.privateName(_http, "_opcode");
>+const _len = dart.privateName(_http, "_len");
>+const _masked = dart.privateName(_http, "_masked");
>+const _remainingLenBytes = dart.privateName(_http, "_remainingLenBytes");
>+const _remainingMaskingKeyBytes = dart.privateName(_http, "_remainingMaskingKeyBytes");
>+const _remainingPayloadBytes = dart.privateName(_http, "_remainingPayloadBytes");
>+const _unmaskingIndex = dart.privateName(_http, "_unmaskingIndex");
>+const _currentMessageType = dart.privateName(_http, "_currentMessageType");
>+const _eventSink$ = dart.privateName(_http, "_eventSink");
>+const _maskingBytes = dart.privateName(_http, "_maskingBytes");
>+const _payload = dart.privateName(_http, "_payload");
>+const _isControlFrame = dart.privateName(_http, "_isControlFrame");
>+const _lengthDone = dart.privateName(_http, "_lengthDone");
>+const _maskDone = dart.privateName(_http, "_maskDone");
>+const _unmask = dart.privateName(_http, "_unmask");
>+const _controlFrameEnd = dart.privateName(_http, "_controlFrameEnd");
>+const _messageFrameEnd = dart.privateName(_http, "_messageFrameEnd");
>+const _startPayload = dart.privateName(_http, "_startPayload");
>+const _prepareForNextFrame = dart.privateName(_http, "_prepareForNextFrame");
>+_http._WebSocketProtocolTransformer = class _WebSocketProtocolTransformer extends async.StreamTransformerBase$(core.List$(core.int), dart.dynamic) {
>+  bind(stream) {
>+    StreamOfListOfint()._check(stream);
>+    return async.Stream.eventTransformed(stream, dart.fn(eventSink => {
>+      if (this[_eventSink$] != null) {
>+        dart.throw(new core.StateError.new("WebSocket transformer already used."));
>+      }
>+      this[_eventSink$] = eventSink;
>+      return this;
>+    }, EventSinkTo_WebSocketProtocolTransformer()));
>+  }
>+  addError(error, stackTrace) {
>+    if (stackTrace === void 0) stackTrace = null;
>+    this[_eventSink$].addError(error, stackTrace);
>+  }
>+  close() {
>+    this[_eventSink$].close();
>+  }
>+  add(bytes) {
>+    ListOfint()._check(bytes);
>+    let buffer = typed_data.Uint8List.is(bytes) ? bytes : typed_data.Uint8List.fromList(bytes);
>+    let index = 0;
>+    let lastIndex = buffer[$length];
>+    if (this[_state$1] === 5) {
>+      dart.throw(new _http.WebSocketException.new("Data on closed connection"));
>+    }
>+    if (this[_state$1] === 6) {
>+      dart.throw(new _http.WebSocketException.new("Data on failed connection"));
>+    }
>+    while (index < dart.notNull(lastIndex) && this[_state$1] !== 5 && this[_state$1] !== 6) {
>+      let byte = buffer[$_get](index);
>+      if (dart.notNull(this[_state$1]) <= 2) {
>+        if (this[_state$1] === 0) {
>+          this[_fin] = (dart.notNull(byte) & 128) !== 0;
>+          if ((dart.notNull(byte) & (32 | 16)) !== 0) {
>+            dart.throw(new _http.WebSocketException.new("Protocol error"));
>+          }
>+          this[_opcode] = dart.notNull(byte) & 15;
>+          if (this[_opcode] !== _http._WebSocketOpcode.CONTINUATION) {
>+            if ((dart.notNull(byte) & 64) !== 0) {
>+              this[_compressed] = true;
>+            } else {
>+              this[_compressed] = false;
>+            }
>+          }
>+          if (dart.notNull(this[_opcode]) <= _http._WebSocketOpcode.BINARY) {
>+            if (this[_opcode] === _http._WebSocketOpcode.CONTINUATION) {
>+              if (this[_currentMessageType] === _http._WebSocketMessageType.NONE) {
>+                dart.throw(new _http.WebSocketException.new("Protocol error"));
>+              }
>+            } else {
>+              if (!(this[_opcode] === _http._WebSocketOpcode.TEXT || this[_opcode] === _http._WebSocketOpcode.BINARY)) dart.assertFailed(null, "dart:_http/websocket_impl.dart", 163, 22, "_opcode == _WebSocketOpcode.TEXT || _opcode == _WebSocketOpcode.BINARY");
>+              if (this[_currentMessageType] !== _http._WebSocketMessageType.NONE) {
>+                dart.throw(new _http.WebSocketException.new("Protocol error"));
>+              }
>+              this[_currentMessageType] = this[_opcode];
>+            }
>+          } else if (dart.notNull(this[_opcode]) >= _http._WebSocketOpcode.CLOSE && dart.notNull(this[_opcode]) <= _http._WebSocketOpcode.PONG) {
>+            if (!dart.test(this[_fin])) dart.throw(new _http.WebSocketException.new("Protocol error"));
>+          } else {
>+            dart.throw(new _http.WebSocketException.new("Protocol error"));
>+          }
>+          this[_state$1] = 1;
>+        } else if (this[_state$1] === 1) {
>+          this[_masked] = (dart.notNull(byte) & 128) !== 0;
>+          this[_len] = dart.notNull(byte) & 127;
>+          if (dart.test(this[_isControlFrame]()) && dart.notNull(this[_len]) > 125) {
>+            dart.throw(new _http.WebSocketException.new("Protocol error"));
>+          }
>+          if (this[_len] === 126) {
>+            this[_len] = 0;
>+            this[_remainingLenBytes] = 2;
>+            this[_state$1] = 2;
>+          } else if (this[_len] === 127) {
>+            this[_len] = 0;
>+            this[_remainingLenBytes] = 8;
>+            this[_state$1] = 2;
>+          } else {
>+            if (!(dart.notNull(this[_len]) < 126)) dart.assertFailed(null, "dart:_http/websocket_impl.dart", 193, 20, "_len < 126");
>+            this[_lengthDone]();
>+          }
>+        } else {
>+          if (!(this[_state$1] === 2)) dart.assertFailed(null, "dart:_http/websocket_impl.dart", 197, 18, "_state == LEN_REST");
>+          this[_len] = (dart.notNull(this[_len]) << 8 | dart.notNull(byte)) >>> 0;
>+          this[_remainingLenBytes] = dart.notNull(this[_remainingLenBytes]) - 1;
>+          if (this[_remainingLenBytes] === 0) {
>+            this[_lengthDone]();
>+          }
>+        }
>+      } else {
>+        if (this[_state$1] === 3) {
>+          this[_maskingBytes][$_set](4 - (() => {
>+            let x = this[_remainingMaskingKeyBytes];
>+            this[_remainingMaskingKeyBytes] = dart.notNull(x) - 1;
>+            return x;
>+          })(), byte);
>+          if (this[_remainingMaskingKeyBytes] === 0) {
>+            this[_maskDone]();
>+          }
>+        } else {
>+          if (!(this[_state$1] === 4)) dart.assertFailed(null, "dart:_http/websocket_impl.dart", 211, 18, "_state == PAYLOAD");
>+          let payloadLength = math.min(core.int, dart.notNull(lastIndex) - index, this[_remainingPayloadBytes]);
>+          this[_remainingPayloadBytes] = dart.notNull(this[_remainingPayloadBytes]) - payloadLength;
>+          if (dart.test(this[_masked])) {
>+            this[_unmask](index, payloadLength, buffer);
>+          }
>+          this[_payload].add(typed_data.Uint8List.view(buffer[$buffer], index, payloadLength));
>+          index = index + payloadLength;
>+          if (dart.test(this[_isControlFrame]())) {
>+            if (this[_remainingPayloadBytes] === 0) this[_controlFrameEnd]();
>+          } else {
>+            if (this[_currentMessageType] !== _http._WebSocketMessageType.TEXT && this[_currentMessageType] !== _http._WebSocketMessageType.BINARY) {
>+              dart.throw(new _http.WebSocketException.new("Protocol error"));
>+            }
>+            if (this[_remainingPayloadBytes] === 0) this[_messageFrameEnd]();
>+          }
>+          index--;
>+        }
>+      }
>+      index++;
>+    }
>+  }
>+  [_unmask](index, length, buffer) {
>+    let BLOCK_SIZE = 16;
>+    if (dart.notNull(length) >= BLOCK_SIZE) {
>+      let startOffset = BLOCK_SIZE - (dart.notNull(index) & 15);
>+      let end = dart.notNull(index) + startOffset;
>+      for (let i = index; dart.notNull(i) < end; i = dart.notNull(i) + 1) {
>+        buffer[$_set](i, (dart.notNull(buffer[$_get](i)) ^ dart.notNull(core.int._check(this[_maskingBytes][$_get]((() => {
>+          let x = this[_unmaskingIndex];
>+          this[_unmaskingIndex] = dart.notNull(x) + 1;
>+          return x;
>+        })() & 3)))) >>> 0);
>+      }
>+      index = dart.notNull(index) + startOffset;
>+      length = dart.notNull(length) - startOffset;
>+      let blockCount = (dart.notNull(length) / BLOCK_SIZE)[$truncate]();
>+      if (blockCount > 0) {
>+        let mask = 0;
>+        for (let i = 3; i >= 0; i--) {
>+          mask = (mask << 8 | dart.notNull(core.int._check(this[_maskingBytes][$_get](dart.notNull(this[_unmaskingIndex]) + i & 3)))) >>> 0;
>+        }
>+        let blockMask = typed_data.Int32x4.new(mask, mask, mask, mask);
>+        let blockBuffer = typed_data.Int32x4List.view(buffer[$buffer], index, blockCount);
>+        for (let i = 0; i < dart.notNull(blockBuffer.length); i++) {
>+          blockBuffer._set(i, blockBuffer._get(i)['^'](blockMask));
>+        }
>+        let bytes = blockCount * BLOCK_SIZE;
>+        index = dart.notNull(index) + bytes;
>+        length = dart.notNull(length) - bytes;
>+      }
>+    }
>+    let end = dart.notNull(index) + dart.notNull(length);
>+    for (let i = index; dart.notNull(i) < end; i = dart.notNull(i) + 1) {
>+      buffer[$_set](i, (dart.notNull(buffer[$_get](i)) ^ dart.notNull(core.int._check(this[_maskingBytes][$_get]((() => {
>+        let x = this[_unmaskingIndex];
>+        this[_unmaskingIndex] = dart.notNull(x) + 1;
>+        return x;
>+      })() & 3)))) >>> 0);
>+    }
>+  }
>+  [_lengthDone]() {
>+    if (dart.test(this[_masked])) {
>+      if (!dart.test(this[_serverSide])) {
>+        dart.throw(new _http.WebSocketException.new("Received masked frame from server"));
>+      }
>+      this[_state$1] = 3;
>+    } else {
>+      if (dart.test(this[_serverSide])) {
>+        dart.throw(new _http.WebSocketException.new("Received unmasked frame from client"));
>+      }
>+      this[_remainingPayloadBytes] = this[_len];
>+      this[_startPayload]();
>+    }
>+  }
>+  [_maskDone]() {
>+    this[_remainingPayloadBytes] = this[_len];
>+    this[_startPayload]();
>+  }
>+  [_startPayload]() {
>+    if (this[_remainingPayloadBytes] === 0) {
>+      if (dart.test(this[_isControlFrame]())) {
>+        switch (this[_opcode]) {
>+          case _http._WebSocketOpcode.CLOSE:
>+          {
>+            this[_state$1] = 5;
>+            this[_eventSink$].close();
>+            break;
>+          }
>+          case _http._WebSocketOpcode.PING:
>+          {
>+            this[_eventSink$].add(new _http._WebSocketPing.new());
>+            break;
>+          }
>+          case _http._WebSocketOpcode.PONG:
>+          {
>+            this[_eventSink$].add(new _http._WebSocketPong.new());
>+            break;
>+          }
>+        }
>+        this[_prepareForNextFrame]();
>+      } else {
>+        this[_messageFrameEnd]();
>+      }
>+    } else {
>+      this[_state$1] = 4;
>+    }
>+  }
>+  [_messageFrameEnd]() {
>+    if (dart.test(this[_fin])) {
>+      let bytes = this[_payload].takeBytes();
>+      if (this[_deflate] != null && dart.test(this[_compressed])) {
>+        bytes = this[_deflate].processIncomingMessage(bytes);
>+      }
>+      switch (this[_currentMessageType]) {
>+        case _http._WebSocketMessageType.TEXT:
>+        {
>+          this[_eventSink$].add(convert.utf8.decode(bytes));
>+          break;
>+        }
>+        case _http._WebSocketMessageType.BINARY:
>+        {
>+          this[_eventSink$].add(bytes);
>+          break;
>+        }
>+      }
>+      this[_currentMessageType] = _http._WebSocketMessageType.NONE;
>+    }
>+    this[_prepareForNextFrame]();
>+  }
>+  [_controlFrameEnd]() {
>+    switch (this[_opcode]) {
>+      case _http._WebSocketOpcode.CLOSE:
>+      {
>+        this.closeCode = _http.WebSocketStatus.NO_STATUS_RECEIVED;
>+        let payload = this[_payload].takeBytes();
>+        if (dart.notNull(payload[$length]) > 0) {
>+          if (payload[$length] === 1) {
>+            dart.throw(new _http.WebSocketException.new("Protocol error"));
>+          }
>+          this.closeCode = (dart.notNull(payload[$_get](0)) << 8 | dart.notNull(payload[$_get](1))) >>> 0;
>+          if (this.closeCode === _http.WebSocketStatus.NO_STATUS_RECEIVED) {
>+            dart.throw(new _http.WebSocketException.new("Protocol error"));
>+          }
>+          if (dart.notNull(payload[$length]) > 2) {
>+            this.closeReason = convert.utf8.decode(payload[$sublist](2));
>+          }
>+        }
>+        this[_state$1] = 5;
>+        this[_eventSink$].close();
>+        break;
>+      }
>+      case _http._WebSocketOpcode.PING:
>+      {
>+        this[_eventSink$].add(new _http._WebSocketPing.new(this[_payload].takeBytes()));
>+        break;
>+      }
>+      case _http._WebSocketOpcode.PONG:
>+      {
>+        this[_eventSink$].add(new _http._WebSocketPong.new(this[_payload].takeBytes()));
>+        break;
>+      }
>+    }
>+    this[_prepareForNextFrame]();
>+  }
>+  [_isControlFrame]() {
>+    return this[_opcode] === _http._WebSocketOpcode.CLOSE || this[_opcode] === _http._WebSocketOpcode.PING || this[_opcode] === _http._WebSocketOpcode.PONG;
>+  }
>+  [_prepareForNextFrame]() {
>+    if (this[_state$1] !== 5 && this[_state$1] !== 6) this[_state$1] = 0;
>+    this[_fin] = false;
>+    this[_opcode] = -1;
>+    this[_len] = -1;
>+    this[_remainingLenBytes] = -1;
>+    this[_remainingMaskingKeyBytes] = 4;
>+    this[_remainingPayloadBytes] = -1;
>+    this[_unmaskingIndex] = 0;
>+  }
>+};
>+(_http._WebSocketProtocolTransformer.new = function(serverSide, deflate) {
>+  if (serverSide === void 0) serverSide = false;
>+  if (deflate === void 0) deflate = null;
>+  this[_state$1] = 0;
>+  this[_fin] = false;
>+  this[_compressed] = false;
>+  this[_opcode] = -1;
>+  this[_len] = -1;
>+  this[_masked] = false;
>+  this[_remainingLenBytes] = -1;
>+  this[_remainingMaskingKeyBytes] = 4;
>+  this[_remainingPayloadBytes] = -1;
>+  this[_unmaskingIndex] = 0;
>+  this[_currentMessageType] = _http._WebSocketMessageType.NONE;
>+  this.closeCode = _http.WebSocketStatus.NO_STATUS_RECEIVED;
>+  this.closeReason = "";
>+  this[_eventSink$] = null;
>+  this[_maskingBytes] = core.List.new(4);
>+  this[_payload] = io.BytesBuilder.new({copy: false});
>+  this[_serverSide] = serverSide;
>+  this[_deflate] = deflate;
>+  _http._WebSocketProtocolTransformer.__proto__.new.call(this);
>+}).prototype = _http._WebSocketProtocolTransformer.prototype;
>+dart.addTypeTests(_http._WebSocketProtocolTransformer);
>+_http._WebSocketProtocolTransformer[dart.implements] = () => [EventSinkOfListOfint()];
>+dart.setMethodSignature(_http._WebSocketProtocolTransformer, () => ({
>+  __proto__: dart.getMethods(_http._WebSocketProtocolTransformer.__proto__),
>+  bind: dart.fnType(async.Stream, [core.Object]),
>+  addError: dart.fnType(dart.void, [core.Object], [core.StackTrace]),
>+  close: dart.fnType(dart.void, []),
>+  add: dart.fnType(dart.void, [core.Object]),
>+  [_unmask]: dart.fnType(dart.void, [core.int, core.int, typed_data.Uint8List]),
>+  [_lengthDone]: dart.fnType(dart.void, []),
>+  [_maskDone]: dart.fnType(dart.void, []),
>+  [_startPayload]: dart.fnType(dart.void, []),
>+  [_messageFrameEnd]: dart.fnType(dart.void, []),
>+  [_controlFrameEnd]: dart.fnType(dart.void, []),
>+  [_isControlFrame]: dart.fnType(core.bool, []),
>+  [_prepareForNextFrame]: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(_http._WebSocketProtocolTransformer, "dart:_http");
>+dart.setFieldSignature(_http._WebSocketProtocolTransformer, () => ({
>+  __proto__: dart.getFields(_http._WebSocketProtocolTransformer.__proto__),
>+  [_state$1]: dart.fieldType(core.int),
>+  [_fin]: dart.fieldType(core.bool),
>+  [_compressed]: dart.fieldType(core.bool),
>+  [_opcode]: dart.fieldType(core.int),
>+  [_len]: dart.fieldType(core.int),
>+  [_masked]: dart.fieldType(core.bool),
>+  [_remainingLenBytes]: dart.fieldType(core.int),
>+  [_remainingMaskingKeyBytes]: dart.fieldType(core.int),
>+  [_remainingPayloadBytes]: dart.fieldType(core.int),
>+  [_unmaskingIndex]: dart.fieldType(core.int),
>+  [_currentMessageType]: dart.fieldType(core.int),
>+  closeCode: dart.fieldType(core.int),
>+  closeReason: dart.fieldType(core.String),
>+  [_eventSink$]: dart.fieldType(async.EventSink),
>+  [_serverSide]: dart.finalFieldType(core.bool),
>+  [_maskingBytes]: dart.finalFieldType(core.List),
>+  [_payload]: dart.finalFieldType(io.BytesBuilder),
>+  [_deflate]: dart.fieldType(_http._WebSocketPerMessageDeflate)
>+}));
>+dart.defineLazy(_http._WebSocketProtocolTransformer, {
>+  /*_http._WebSocketProtocolTransformer.START*/get START() {
>+    return 0;
>+  },
>+  /*_http._WebSocketProtocolTransformer.LEN_FIRST*/get LEN_FIRST() {
>+    return 1;
>+  },
>+  /*_http._WebSocketProtocolTransformer.LEN_REST*/get LEN_REST() {
>+    return 2;
>+  },
>+  /*_http._WebSocketProtocolTransformer.MASK*/get MASK() {
>+    return 3;
>+  },
>+  /*_http._WebSocketProtocolTransformer.PAYLOAD*/get PAYLOAD() {
>+    return 4;
>+  },
>+  /*_http._WebSocketProtocolTransformer.CLOSED*/get CLOSED() {
>+    return 5;
>+  },
>+  /*_http._WebSocketProtocolTransformer.FAILURE*/get FAILURE() {
>+    return 6;
>+  },
>+  /*_http._WebSocketProtocolTransformer.FIN*/get FIN() {
>+    return 128;
>+  },
>+  /*_http._WebSocketProtocolTransformer.RSV1*/get RSV1() {
>+    return 64;
>+  },
>+  /*_http._WebSocketProtocolTransformer.RSV2*/get RSV2() {
>+    return 32;
>+  },
>+  /*_http._WebSocketProtocolTransformer.RSV3*/get RSV3() {
>+    return 16;
>+  },
>+  /*_http._WebSocketProtocolTransformer.OPCODE*/get OPCODE() {
>+    return 15;
>+  }
>+});
>+_http._WebSocketPing = class _WebSocketPing extends core.Object {};
>+(_http._WebSocketPing.new = function(payload) {
>+  if (payload === void 0) payload = null;
>+  this.payload = payload;
>+}).prototype = _http._WebSocketPing.prototype;
>+dart.addTypeTests(_http._WebSocketPing);
>+dart.setLibraryUri(_http._WebSocketPing, "dart:_http");
>+dart.setFieldSignature(_http._WebSocketPing, () => ({
>+  __proto__: dart.getFields(_http._WebSocketPing.__proto__),
>+  payload: dart.finalFieldType(ListOfint())
>+}));
>+_http._WebSocketPong = class _WebSocketPong extends core.Object {};
>+(_http._WebSocketPong.new = function(payload) {
>+  if (payload === void 0) payload = null;
>+  this.payload = payload;
>+}).prototype = _http._WebSocketPong.prototype;
>+dart.addTypeTests(_http._WebSocketPong);
>+dart.setLibraryUri(_http._WebSocketPong, "dart:_http");
>+dart.setFieldSignature(_http._WebSocketPong, () => ({
>+  __proto__: dart.getFields(_http._WebSocketPong.__proto__),
>+  payload: dart.finalFieldType(ListOfint())
>+}));
>+const _protocolSelector = dart.privateName(_http, "_protocolSelector");
>+const _compression = dart.privateName(_http, "_compression");
>+_http._WebSocketTransformerImpl = class _WebSocketTransformerImpl extends async.StreamTransformerBase$(_http.HttpRequest, _http.WebSocket) {
>+  bind(stream) {
>+    StreamOfHttpRequest()._check(stream);
>+    stream.listen(dart.fn(request => {
>+      _http._WebSocketTransformerImpl._upgrade(request, this[_protocolSelector], this[_compression]).then(dart.void, dart.fn(webSocket => this[_controller$1].add(webSocket), WebSocketTovoid())).catchError(dart.bind(this[_controller$1], 'addError'));
>+    }, HttpRequestToNull()), {onDone: dart.fn(() => {
>+        this[_controller$1].close();
>+      }, VoidToNull())});
>+    return this[_controller$1].stream;
>+  }
>+  static _tokenizeFieldValue(headerValue) {
>+    let tokens = JSArrayOfString().of([]);
>+    let start = 0;
>+    let index = 0;
>+    while (index < headerValue.length) {
>+      if (headerValue[$_get](index) === ",") {
>+        tokens[$add](headerValue[$substring](start, index));
>+        start = index + 1;
>+      } else if (headerValue[$_get](index) === " " || headerValue[$_get](index) === "\t") {
>+        start++;
>+      }
>+      index++;
>+    }
>+    tokens[$add](headerValue[$substring](start, index));
>+    return tokens;
>+  }
>+  static _upgrade(request, _protocolSelector, compression) {
>+    let response = request.response;
>+    if (!dart.test(_http._WebSocketTransformerImpl._isUpgradeRequest(request))) {
>+      response.statusCode = _internal.HttpStatus.badRequest;
>+      response.close();
>+      return FutureOfWebSocket().error(new _http.WebSocketException.new("Invalid WebSocket upgrade request"));
>+    }
>+    function upgrade(protocol) {
>+      response.statusCode = _internal.HttpStatus.switchingProtocols;
>+      response.headers.add(_http.HttpHeaders.connectionHeader, "Upgrade");
>+      response.headers.add(_http.HttpHeaders.upgradeHeader, "websocket");
>+      let key = request.headers.value("Sec-WebSocket-Key");
>+      let sha1 = new _http._SHA1.new();
>+      sha1.add((dart.str(key) + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11")[$codeUnits]);
>+      let accept = _http._CryptoUtils.bytesToBase64(sha1.close());
>+      response.headers.add("Sec-WebSocket-Accept", accept);
>+      if (protocol != null) {
>+        response.headers.add("Sec-WebSocket-Protocol", protocol);
>+      }
>+      let deflate = _http._WebSocketTransformerImpl._negotiateCompression(request, response, compression);
>+      response.headers.contentLength = 0;
>+      return FutureOfWebSocket()._check(response.detachSocket().then(_http.WebSocket, dart.fn(socket => new _http._WebSocketImpl._fromSocket(socket, protocol, compression, true, deflate), SocketTo_WebSocketImpl())));
>+    }
>+    dart.fn(upgrade, StringToFutureOfWebSocket());
>+    let protocols = request.headers._get("Sec-WebSocket-Protocol");
>+    if (protocols != null && _protocolSelector != null) {
>+      protocols = _http._WebSocketTransformerImpl._tokenizeFieldValue(protocols[$join](", "));
>+      return FutureOfWebSocket()._check(FutureOfString()._check(FutureOfString().new(dart.fn(() => FutureOrOfString()._check(_protocolSelector(protocols)), VoidToFutureOrOfString())).then(core.String, dart.fn(protocol => {
>+        if (dart.notNull(protocols[$indexOf](protocol)) < 0) {
>+          dart.throw(new _http.WebSocketException.new("Selected protocol is not in the list of available protocols"));
>+        }
>+        return protocol;
>+      }, StringToString()))).catchError(dart.fn(error => {
>+        response.statusCode = _internal.HttpStatus.internalServerError;
>+        response.close();
>+        dart.throw(error);
>+      }, dynamicToNull())).then(_http.WebSocket, upgrade));
>+    } else {
>+      return upgrade(null);
>+    }
>+  }
>+  static _negotiateCompression(request, response, compression) {
>+    let extensionHeader = request.headers.value("Sec-WebSocket-Extensions");
>+    let t = extensionHeader;
>+    t == null ? extensionHeader = "" : t;
>+    let hv = _http.HeaderValue.parse(extensionHeader, {valueSeparator: ","});
>+    if (dart.test(compression.enabled) && hv.value === _http._WebSocketImpl.PER_MESSAGE_DEFLATE) {
>+      let info = compression[_createHeader](hv);
>+      response.headers.add("Sec-WebSocket-Extensions", info.headerValue);
>+      let serverNoContextTakeover = dart.test(hv.parameters[$containsKey]("server_no_context_takeover")) && dart.test(compression.serverNoContextTakeover);
>+      let clientNoContextTakeover = dart.test(hv.parameters[$containsKey]("client_no_context_takeover")) && dart.test(compression.clientNoContextTakeover);
>+      let deflate = new _http._WebSocketPerMessageDeflate.new({serverNoContextTakeover: serverNoContextTakeover, clientNoContextTakeover: clientNoContextTakeover, serverMaxWindowBits: info.maxWindowBits, clientMaxWindowBits: info.maxWindowBits, serverSide: true});
>+      return deflate;
>+    }
>+    return null;
>+  }
>+  static _isUpgradeRequest(request) {
>+    if (request.method !== "GET") {
>+      return false;
>+    }
>+    if (request.headers._get(_http.HttpHeaders.connectionHeader) == null) {
>+      return false;
>+    }
>+    let isUpgrade = false;
>+    request.headers._get(_http.HttpHeaders.connectionHeader)[$forEach](dart.fn(value => {
>+      if (value[$toLowerCase]() === "upgrade") isUpgrade = true;
>+    }, StringToNull()));
>+    if (!isUpgrade) return false;
>+    let upgrade = request.headers.value(_http.HttpHeaders.upgradeHeader);
>+    if (upgrade == null || upgrade[$toLowerCase]() !== "websocket") {
>+      return false;
>+    }
>+    let version = request.headers.value("Sec-WebSocket-Version");
>+    if (version == null || version !== "13") {
>+      return false;
>+    }
>+    let key = request.headers.value("Sec-WebSocket-Key");
>+    if (key == null) {
>+      return false;
>+    }
>+    return true;
>+  }
>+};
>+(_http._WebSocketTransformerImpl.new = function(protocolSelector, compression) {
>+  this[_controller$1] = StreamControllerOfWebSocket().new({sync: true});
>+  this[_protocolSelector] = protocolSelector;
>+  this[_compression] = compression;
>+  _http._WebSocketTransformerImpl.__proto__.new.call(this);
>+}).prototype = _http._WebSocketTransformerImpl.prototype;
>+dart.addTypeTests(_http._WebSocketTransformerImpl);
>+_http._WebSocketTransformerImpl[dart.implements] = () => [_http.WebSocketTransformer];
>+dart.setMethodSignature(_http._WebSocketTransformerImpl, () => ({
>+  __proto__: dart.getMethods(_http._WebSocketTransformerImpl.__proto__),
>+  bind: dart.fnType(async.Stream$(_http.WebSocket), [core.Object])
>+}));
>+dart.setLibraryUri(_http._WebSocketTransformerImpl, "dart:_http");
>+dart.setFieldSignature(_http._WebSocketTransformerImpl, () => ({
>+  __proto__: dart.getFields(_http._WebSocketTransformerImpl.__proto__),
>+  [_controller$1]: dart.finalFieldType(StreamControllerOfWebSocket()),
>+  [_protocolSelector]: dart.finalFieldType(ListOfStringTodynamic()),
>+  [_compression]: dart.finalFieldType(_http.CompressionOptions)
>+}));
>+const _ensureDecoder = dart.privateName(_http, "_ensureDecoder");
>+const _ensureEncoder = dart.privateName(_http, "_ensureEncoder");
>+let const$106;
>+_http._WebSocketPerMessageDeflate = class _WebSocketPerMessageDeflate extends core.Object {
>+  [_ensureDecoder]() {
>+    if (this.decoder == null) {
>+      this.decoder = io.RawZLibFilter.inflateFilter({windowBits: dart.test(this.serverSide) ? this.clientMaxWindowBits : this.serverMaxWindowBits, raw: true});
>+    }
>+  }
>+  [_ensureEncoder]() {
>+    if (this.encoder == null) {
>+      this.encoder = io.RawZLibFilter.deflateFilter({windowBits: dart.test(this.serverSide) ? this.serverMaxWindowBits : this.clientMaxWindowBits, raw: true});
>+    }
>+  }
>+  processIncomingMessage(msg) {
>+    this[_ensureDecoder]();
>+    let data = JSArrayOfint().of([]);
>+    data[$addAll](msg);
>+    data[$addAll](const$106 || (const$106 = dart.constList([0, 0, 255, 255], core.int)));
>+    this.decoder.process(data, 0, data[$length]);
>+    let result = JSArrayOfint().of([]);
>+    let out = null;
>+    while ((out = this.decoder.processed()) != null) {
>+      result[$addAll](out);
>+    }
>+    if (dart.test(this.serverSide) && dart.test(this.clientNoContextTakeover) || !dart.test(this.serverSide) && dart.test(this.serverNoContextTakeover)) {
>+      this.decoder = null;
>+    }
>+    return typed_data.Uint8List.fromList(result);
>+  }
>+  processOutgoingMessage(msg) {
>+    this[_ensureEncoder]();
>+    let result = JSArrayOfint().of([]);
>+    let buffer = null;
>+    if (!typed_data.Uint8List.is(msg)) {
>+      for (let i = 0; i < dart.notNull(msg[$length]); i++) {
>+        if (dart.notNull(msg[$_get](i)) < 0 || 255 < dart.notNull(msg[$_get](i))) {
>+          dart.throw(new core.ArgumentError.new("List element is not a byte value " + ("(value " + dart.str(msg[$_get](i)) + " at index " + dart.str(i) + ")")));
>+        }
>+      }
>+      buffer = typed_data.Uint8List.fromList(msg);
>+    } else {
>+      buffer = typed_data.Uint8List._check(msg);
>+    }
>+    this.encoder.process(buffer, 0, buffer[$length]);
>+    let out = null;
>+    while ((out = this.encoder.processed()) != null) {
>+      result[$addAll](out);
>+    }
>+    if (!dart.test(this.serverSide) && dart.test(this.clientNoContextTakeover) || dart.test(this.serverSide) && dart.test(this.serverNoContextTakeover)) {
>+      this.encoder = null;
>+    }
>+    if (dart.notNull(result[$length]) > 4) {
>+      result = result[$sublist](0, dart.notNull(result[$length]) - 4);
>+    }
>+    if (result[$length] === 0) {
>+      return JSArrayOfint().of([0]);
>+    }
>+    return result;
>+  }
>+};
>+(_http._WebSocketPerMessageDeflate.new = function(opts) {
>+  let clientMaxWindowBits = opts && 'clientMaxWindowBits' in opts ? opts.clientMaxWindowBits : _http._WebSocketImpl.DEFAULT_WINDOW_BITS;
>+  let serverMaxWindowBits = opts && 'serverMaxWindowBits' in opts ? opts.serverMaxWindowBits : _http._WebSocketImpl.DEFAULT_WINDOW_BITS;
>+  let serverNoContextTakeover = opts && 'serverNoContextTakeover' in opts ? opts.serverNoContextTakeover : false;
>+  let clientNoContextTakeover = opts && 'clientNoContextTakeover' in opts ? opts.clientNoContextTakeover : false;
>+  let serverSide = opts && 'serverSide' in opts ? opts.serverSide : false;
>+  this.decoder = null;
>+  this.encoder = null;
>+  this.clientMaxWindowBits = clientMaxWindowBits;
>+  this.serverMaxWindowBits = serverMaxWindowBits;
>+  this.serverNoContextTakeover = serverNoContextTakeover;
>+  this.clientNoContextTakeover = clientNoContextTakeover;
>+  this.serverSide = serverSide;
>+}).prototype = _http._WebSocketPerMessageDeflate.prototype;
>+dart.addTypeTests(_http._WebSocketPerMessageDeflate);
>+dart.setMethodSignature(_http._WebSocketPerMessageDeflate, () => ({
>+  __proto__: dart.getMethods(_http._WebSocketPerMessageDeflate.__proto__),
>+  [_ensureDecoder]: dart.fnType(dart.void, []),
>+  [_ensureEncoder]: dart.fnType(dart.void, []),
>+  processIncomingMessage: dart.fnType(typed_data.Uint8List, [core.List$(core.int)]),
>+  processOutgoingMessage: dart.fnType(core.List$(core.int), [core.List$(core.int)])
>+}));
>+dart.setLibraryUri(_http._WebSocketPerMessageDeflate, "dart:_http");
>+dart.setFieldSignature(_http._WebSocketPerMessageDeflate, () => ({
>+  __proto__: dart.getFields(_http._WebSocketPerMessageDeflate.__proto__),
>+  serverNoContextTakeover: dart.fieldType(core.bool),
>+  clientNoContextTakeover: dart.fieldType(core.bool),
>+  clientMaxWindowBits: dart.fieldType(core.int),
>+  serverMaxWindowBits: dart.fieldType(core.int),
>+  serverSide: dart.fieldType(core.bool),
>+  decoder: dart.fieldType(io.RawZLibFilter),
>+  encoder: dart.fieldType(io.RawZLibFilter)
>+}));
>+const _deflateHelper = dart.privateName(_http, "_deflateHelper");
>+const _outCloseCode = dart.privateName(_http, "_outCloseCode");
>+const _outCloseReason = dart.privateName(_http, "_outCloseReason");
>+_http._WebSocketOutgoingTransformer = class _WebSocketOutgoingTransformer extends async.StreamTransformerBase$(dart.dynamic, core.List$(core.int)) {
>+  bind(stream) {
>+    return StreamOfListOfint().eventTransformed(stream, dart.fn(eventSink => {
>+      if (this[_eventSink$] != null) {
>+        dart.throw(new core.StateError.new("WebSocket transformer already used"));
>+      }
>+      this[_eventSink$] = eventSink;
>+      return this;
>+    }, EventSinkOfListOfintTo_WebSocketOutgoingTransformer()));
>+  }
>+  add(message) {
>+    if (_http._WebSocketPong.is(message)) {
>+      this.addFrame(_http._WebSocketOpcode.PONG, message.payload);
>+      return;
>+    }
>+    if (_http._WebSocketPing.is(message)) {
>+      this.addFrame(_http._WebSocketOpcode.PING, message.payload);
>+      return;
>+    }
>+    let data = null;
>+    let opcode = null;
>+    if (message != null) {
>+      if (typeof message == 'string') {
>+        opcode = _http._WebSocketOpcode.TEXT;
>+        data = convert.utf8.encode(message);
>+      } else if (ListOfint().is(message)) {
>+        opcode = _http._WebSocketOpcode.BINARY;
>+        data = message;
>+      } else if (_http._EncodedString.is(message)) {
>+        opcode = _http._WebSocketOpcode.TEXT;
>+        data = message.bytes;
>+      } else {
>+        dart.throw(new core.ArgumentError.new(message));
>+      }
>+      if (this[_deflateHelper] != null) {
>+        data = this[_deflateHelper].processOutgoingMessage(data);
>+      }
>+    } else {
>+      opcode = _http._WebSocketOpcode.TEXT;
>+    }
>+    this.addFrame(opcode, data);
>+  }
>+  addError(error, stackTrace) {
>+    if (stackTrace === void 0) stackTrace = null;
>+    this[_eventSink$].addError(error, stackTrace);
>+  }
>+  close() {
>+    let code = this.webSocket[_outCloseCode];
>+    let reason = this.webSocket[_outCloseReason];
>+    let data = null;
>+    if (code != null) {
>+      data = JSArrayOfint().of([]);
>+      data[$add](dart.notNull(code) >> 8 & 255);
>+      data[$add](dart.notNull(code) & 255);
>+      if (reason != null) {
>+        data[$addAll](convert.utf8.encode(reason));
>+      }
>+    }
>+    this.addFrame(_http._WebSocketOpcode.CLOSE, data);
>+    this[_eventSink$].close();
>+  }
>+  addFrame(opcode, data) {
>+    _http._WebSocketOutgoingTransformer.createFrame(opcode, data, this.webSocket[_serverSide], this[_deflateHelper] != null && (opcode === _http._WebSocketOpcode.TEXT || opcode === _http._WebSocketOpcode.BINARY))[$forEach](dart.fn(e => {
>+      this[_eventSink$].add(e);
>+    }, ListOfintToNull()));
>+  }
>+  static createFrame(opcode, data, serverSide, compressed) {
>+    let mask = !dart.test(serverSide);
>+    let dataLength = data == null ? 0 : data[$length];
>+    let headerSize = mask ? 6 : 2;
>+    if (dart.notNull(dataLength) > 65535) {
>+      headerSize = headerSize + 8;
>+    } else if (dart.notNull(dataLength) > 125) {
>+      headerSize = headerSize + 2;
>+    }
>+    let header = typed_data.Uint8List.new(headerSize);
>+    let index = 0;
>+    let hoc = (_http._WebSocketProtocolTransformer.FIN | (dart.test(compressed) ? _http._WebSocketProtocolTransformer.RSV1 : 0) | dart.notNull(opcode) & _http._WebSocketProtocolTransformer.OPCODE) >>> 0;
>+    header[$_set](index++, hoc);
>+    let lengthBytes = 1;
>+    if (dart.notNull(dataLength) > 65535) {
>+      header[$_set](index++, 127);
>+      lengthBytes = 8;
>+    } else if (dart.notNull(dataLength) > 125) {
>+      header[$_set](index++, 126);
>+      lengthBytes = 2;
>+    }
>+    for (let i = 0; i < lengthBytes; i++) {
>+      header[$_set](index++, dataLength[$rightShift]((lengthBytes - 1 - i) * 8) & 255);
>+    }
>+    if (mask) {
>+      let i$ = 1;
>+      header[$_set](i$, (dart.notNull(header[$_get](i$)) | 1 << 7) >>> 0);
>+      let maskBytes = _http._CryptoUtils.getRandomBytes(4);
>+      header[$setRange](index, index + 4, maskBytes);
>+      index = index + 4;
>+      if (data != null) {
>+        let list = null;
>+        if (opcode === _http._WebSocketOpcode.TEXT && typed_data.Uint8List.is(data)) {
>+          list = data;
>+        } else {
>+          if (typed_data.Uint8List.is(data)) {
>+            list = typed_data.Uint8List.fromList(data);
>+          } else {
>+            list = typed_data.Uint8List.new(data[$length]);
>+            for (let i = 0; i < dart.notNull(data[$length]); i++) {
>+              if (dart.notNull(data[$_get](i)) < 0 || 255 < dart.notNull(data[$_get](i))) {
>+                dart.throw(new core.ArgumentError.new("List element is not a byte value " + ("(value " + dart.str(data[$_get](i)) + " at index " + dart.str(i) + ")")));
>+              }
>+              list[$_set](i, data[$_get](i));
>+            }
>+          }
>+        }
>+        let BLOCK_SIZE = 16;
>+        let blockCount = (dart.notNull(list[$length]) / BLOCK_SIZE)[$truncate]();
>+        if (blockCount > 0) {
>+          let mask = 0;
>+          for (let i = 3; i >= 0; i--) {
>+            mask = (mask << 8 | dart.notNull(maskBytes[$_get](i))) >>> 0;
>+          }
>+          let blockMask = typed_data.Int32x4.new(mask, mask, mask, mask);
>+          let blockBuffer = typed_data.Int32x4List.view(list[$buffer], 0, blockCount);
>+          for (let i = 0; i < dart.notNull(blockBuffer.length); i++) {
>+            blockBuffer._set(i, blockBuffer._get(i)['^'](blockMask));
>+          }
>+        }
>+        for (let i = blockCount * BLOCK_SIZE; i < dart.notNull(list[$length]); i++) {
>+          list[$_set](i, (dart.notNull(list[$_get](i)) ^ dart.notNull(maskBytes[$_get](i & 3))) >>> 0);
>+        }
>+        data = list;
>+      }
>+    }
>+    if (!(index === headerSize)) dart.assertFailed(null, "dart:_http/websocket_impl.dart", 835, 12, "index == headerSize");
>+    if (data == null) {
>+      return JSArrayOfListOfint().of([header]);
>+    } else {
>+      return JSArrayOfListOfint().of([header, data]);
>+    }
>+  }
>+};
>+(_http._WebSocketOutgoingTransformer.new = function(webSocket) {
>+  this[_eventSink$] = null;
>+  this[_deflateHelper] = null;
>+  this.webSocket = webSocket;
>+  _http._WebSocketOutgoingTransformer.__proto__.new.call(this);
>+  this[_deflateHelper] = this.webSocket[_deflate];
>+}).prototype = _http._WebSocketOutgoingTransformer.prototype;
>+dart.addTypeTests(_http._WebSocketOutgoingTransformer);
>+_http._WebSocketOutgoingTransformer[dart.implements] = () => [async.EventSink];
>+dart.setMethodSignature(_http._WebSocketOutgoingTransformer, () => ({
>+  __proto__: dart.getMethods(_http._WebSocketOutgoingTransformer.__proto__),
>+  bind: dart.fnType(async.Stream$(core.List$(core.int)), [async.Stream]),
>+  add: dart.fnType(dart.void, [dart.dynamic]),
>+  addError: dart.fnType(dart.void, [core.Object], [core.StackTrace]),
>+  close: dart.fnType(dart.void, []),
>+  addFrame: dart.fnType(dart.void, [core.int, core.List$(core.int)])
>+}));
>+dart.setLibraryUri(_http._WebSocketOutgoingTransformer, "dart:_http");
>+dart.setFieldSignature(_http._WebSocketOutgoingTransformer, () => ({
>+  __proto__: dart.getFields(_http._WebSocketOutgoingTransformer.__proto__),
>+  webSocket: dart.finalFieldType(_http._WebSocketImpl),
>+  [_eventSink$]: dart.fieldType(EventSinkOfListOfint()),
>+  [_deflateHelper]: dart.fieldType(_http._WebSocketPerMessageDeflate)
>+}));
>+const _issuedPause = dart.privateName(_http, "_issuedPause");
>+const _closed$ = dart.privateName(_http, "_closed");
>+const _closeCompleter$ = dart.privateName(_http, "_closeCompleter");
>+const _completer = dart.privateName(_http, "_completer");
>+const _onListen$ = dart.privateName(_http, "_onListen");
>+const _onPause$ = dart.privateName(_http, "_onPause");
>+const _onResume$ = dart.privateName(_http, "_onResume");
>+const _cancel$ = dart.privateName(_http, "_cancel");
>+const _done = dart.privateName(_http, "_done");
>+const _ensureController = dart.privateName(_http, "_ensureController");
>+_http._WebSocketConsumer = class _WebSocketConsumer extends core.Object {
>+  [_onListen$]() {
>+    if (this[_subscription$0] != null) {
>+      this[_subscription$0].cancel();
>+    }
>+  }
>+  [_onPause$]() {
>+    if (this[_subscription$0] != null) {
>+      this[_subscription$0].pause();
>+    } else {
>+      this[_issuedPause] = true;
>+    }
>+  }
>+  [_onResume$]() {
>+    if (this[_subscription$0] != null) {
>+      this[_subscription$0].resume();
>+    } else {
>+      this[_issuedPause] = false;
>+    }
>+  }
>+  [_cancel$]() {
>+    if (this[_subscription$0] != null) {
>+      let subscription = this[_subscription$0];
>+      this[_subscription$0] = null;
>+      subscription.cancel();
>+    }
>+  }
>+  [_ensureController]() {
>+    if (this[_controller$1] != null) return;
>+    this[_controller$1] = async.StreamController.new({sync: true, onPause: dart.bind(this, _onPause$), onResume: dart.bind(this, _onResume$), onCancel: dart.bind(this, _onListen$)});
>+    let stream = StreamOfListOfint()._check(this[_controller$1].stream.transform(ListOfint(), new _http._WebSocketOutgoingTransformer.new(this.webSocket)));
>+    FutureOfNull()._check(this.socket.addStream(stream).then(core.Null, dart.fn(_ => {
>+      this[_done]();
>+      this[_closeCompleter$].complete(this.webSocket);
>+    }, dynamicToNull()), {onError: dart.fn((error, stackTrace) => {
>+        this[_closed$] = true;
>+        this[_cancel$]();
>+        if (core.ArgumentError.is(error)) {
>+          if (!dart.test(this[_done](error, stackTrace))) {
>+            this[_closeCompleter$].completeError(error, stackTrace);
>+          }
>+        } else {
>+          this[_done]();
>+          this[_closeCompleter$].complete(this.webSocket);
>+        }
>+      }, dynamicAndStackTraceToNull())}));
>+  }
>+  [_done](error, stackTrace) {
>+    if (error === void 0) error = null;
>+    if (stackTrace === void 0) stackTrace = null;
>+    if (this[_completer] == null) return false;
>+    if (error != null) {
>+      this[_completer].completeError(error, stackTrace);
>+    } else {
>+      this[_completer].complete(this.webSocket);
>+    }
>+    this[_completer] = null;
>+    return true;
>+  }
>+  addStream(stream) {
>+    if (dart.test(this[_closed$])) {
>+      stream.listen(null).cancel();
>+      return async.Future.value(this.webSocket);
>+    }
>+    this[_ensureController]();
>+    this[_completer] = async.Completer.new();
>+    this[_subscription$0] = stream.listen(dart.fn(data => {
>+      this[_controller$1].add(data);
>+    }, dynamicToNull()), {onDone: dart.bind(this, _done), onError: dart.bind(this, _done), cancelOnError: true});
>+    if (dart.test(this[_issuedPause])) {
>+      this[_subscription$0].pause();
>+      this[_issuedPause] = false;
>+    }
>+    return this[_completer].future;
>+  }
>+  close() {
>+    this[_ensureController]();
>+    const closeSocket = () => {
>+      return this.socket.close().catchError(dart.fn(_ => {
>+      }, dynamicToNull())).then(dart.dynamic, dart.fn(_ => this.webSocket, dynamicTo_WebSocketImpl()));
>+    };
>+    dart.fn(closeSocket, VoidToFuture());
>+    this[_controller$1].close();
>+    return this[_closeCompleter$].future.then(dart.dynamic, dart.fn(_ => closeSocket(), dynamicToFuture()));
>+  }
>+  add(data) {
>+    if (dart.test(this[_closed$])) return;
>+    this[_ensureController]();
>+    this[_controller$1].add(data);
>+  }
>+  closeSocket() {
>+    this[_closed$] = true;
>+    this[_cancel$]();
>+    this.close();
>+  }
>+};
>+(_http._WebSocketConsumer.new = function(webSocket, socket) {
>+  this[_controller$1] = null;
>+  this[_subscription$0] = null;
>+  this[_issuedPause] = false;
>+  this[_closed$] = false;
>+  this[_closeCompleter$] = CompleterOfWebSocket().new();
>+  this[_completer] = null;
>+  this.webSocket = webSocket;
>+  this.socket = socket;
>+}).prototype = _http._WebSocketConsumer.prototype;
>+dart.addTypeTests(_http._WebSocketConsumer);
>+_http._WebSocketConsumer[dart.implements] = () => [async.StreamConsumer];
>+dart.setMethodSignature(_http._WebSocketConsumer, () => ({
>+  __proto__: dart.getMethods(_http._WebSocketConsumer.__proto__),
>+  [_onListen$]: dart.fnType(dart.void, []),
>+  [_onPause$]: dart.fnType(dart.void, []),
>+  [_onResume$]: dart.fnType(dart.void, []),
>+  [_cancel$]: dart.fnType(dart.void, []),
>+  [_ensureController]: dart.fnType(dart.dynamic, []),
>+  [_done]: dart.fnType(core.bool, [], [dart.dynamic, core.StackTrace]),
>+  addStream: dart.fnType(async.Future, [async.Stream]),
>+  close: dart.fnType(async.Future, []),
>+  add: dart.fnType(dart.void, [dart.dynamic]),
>+  closeSocket: dart.fnType(dart.void, [])
>+}));
>+dart.setLibraryUri(_http._WebSocketConsumer, "dart:_http");
>+dart.setFieldSignature(_http._WebSocketConsumer, () => ({
>+  __proto__: dart.getFields(_http._WebSocketConsumer.__proto__),
>+  webSocket: dart.finalFieldType(_http._WebSocketImpl),
>+  socket: dart.finalFieldType(io.Socket),
>+  [_controller$1]: dart.fieldType(async.StreamController),
>+  [_subscription$0]: dart.fieldType(async.StreamSubscription),
>+  [_issuedPause]: dart.fieldType(core.bool),
>+  [_closed$]: dart.fieldType(core.bool),
>+  [_closeCompleter$]: dart.fieldType(async.Completer),
>+  [_completer]: dart.fieldType(async.Completer)
>+}));
>+const _sink$1 = dart.privateName(_http, "_sink");
>+const _readyState = dart.privateName(_http, "_readyState");
>+const _writeClosed = dart.privateName(_http, "_writeClosed");
>+const _closeCode = dart.privateName(_http, "_closeCode");
>+const _closeReason = dart.privateName(_http, "_closeReason");
>+const _pingInterval = dart.privateName(_http, "_pingInterval");
>+const _pingTimer = dart.privateName(_http, "_pingTimer");
>+const _consumer = dart.privateName(_http, "_consumer");
>+const _closeTimer = dart.privateName(_http, "_closeTimer");
>+const _close$0 = dart.privateName(_http, "_close");
>+let const$107;
>+const Stream__ServiceObject$$ = class Stream__ServiceObject extends async.Stream {};
>+(Stream__ServiceObject$$.new = function() {
>+  _http._ServiceObject.new.call(this);
>+  Stream__ServiceObject$$.__proto__.new.call(this);
>+}).prototype = Stream__ServiceObject$$.prototype;
>+(Stream__ServiceObject$$._internal = function() {
>+  _http._ServiceObject.new.call(this);
>+  Stream__ServiceObject$$.__proto__._internal.call(this);
>+}).prototype = Stream__ServiceObject$$.prototype;
>+(Stream__ServiceObject$$.empty = function() {
>+  _http._ServiceObject.new.call(this);
>+  Stream__ServiceObject$$.__proto__.empty.call(this);
>+}).prototype = Stream__ServiceObject$$.prototype;
>+(Stream__ServiceObject$$.fromFuture = function(future) {
>+  _http._ServiceObject.new.call(this);
>+  Stream__ServiceObject$$.__proto__.fromFuture.call(this, future);
>+}).prototype = Stream__ServiceObject$$.prototype;
>+(Stream__ServiceObject$$.fromFutures = function(futures) {
>+  _http._ServiceObject.new.call(this);
>+  Stream__ServiceObject$$.__proto__.fromFutures.call(this, futures);
>+}).prototype = Stream__ServiceObject$$.prototype;
>+(Stream__ServiceObject$$.fromIterable = function(elements) {
>+  _http._ServiceObject.new.call(this);
>+  Stream__ServiceObject$$.__proto__.fromIterable.call(this, elements);
>+}).prototype = Stream__ServiceObject$$.prototype;
>+(Stream__ServiceObject$$.periodic = function(period, computation) {
>+  _http._ServiceObject.new.call(this);
>+  Stream__ServiceObject$$.__proto__.periodic.call(this, period, computation);
>+}).prototype = Stream__ServiceObject$$.prototype;
>+(Stream__ServiceObject$$.eventTransformed = function(source, mapSink) {
>+  _http._ServiceObject.new.call(this);
>+  Stream__ServiceObject$$.__proto__.eventTransformed.call(this, source, mapSink);
>+}).prototype = Stream__ServiceObject$$.prototype;
>+dart.applyMixin(Stream__ServiceObject$$, _http._ServiceObject);
>+_http._WebSocketImpl = class _WebSocketImpl extends Stream__ServiceObject$$ {
>+  static connect(url, protocols, headers, opts) {
>+    let compression = opts && 'compression' in opts ? opts.compression : _http.CompressionOptions.compressionDefault;
>+    let uri = core.Uri.parse(url);
>+    if (uri.scheme !== "ws" && uri.scheme !== "wss") {
>+      dart.throw(new _http.WebSocketException.new("Unsupported URL scheme '" + dart.str(uri.scheme) + "'"));
>+    }
>+    let random = math.Random.new();
>+    let nonceData = typed_data.Uint8List.new(16);
>+    for (let i = 0; i < 16; i++) {
>+      nonceData[$_set](i, random.nextInt(256));
>+    }
>+    let nonce = _http._CryptoUtils.bytesToBase64(nonceData);
>+    uri = core.Uri.new({scheme: uri.scheme === "wss" ? "https" : "http", userInfo: uri.userInfo, host: uri.host, port: uri.port, path: uri.path, query: uri.query, fragment: uri.fragment});
>+    return FutureOfWebSocket()._check(FutureOfHttpClientResponse()._check(_http._WebSocketImpl._httpClient.openUrl("GET", uri).then(_http.HttpClientResponse, dart.fn(request => {
>+      if (uri.userInfo != null && !uri.userInfo[$isEmpty]) {
>+        let auth = _http._CryptoUtils.bytesToBase64(convert.utf8.encode(uri.userInfo));
>+        request.headers.set(_http.HttpHeaders.authorizationHeader, "Basic " + dart.str(auth));
>+      }
>+      if (headers != null) {
>+        headers[$forEach](dart.fn((field, value) => request.headers.add(field, value), StringAnddynamicTovoid()));
>+      }
>+      let _ = request.headers;
>+      _.set(_http.HttpHeaders.connectionHeader, "Upgrade");
>+      _.set(_http.HttpHeaders.upgradeHeader, "websocket");
>+      _.set("Sec-WebSocket-Key", nonce);
>+      _.set("Cache-Control", "no-cache");
>+      _.set("Sec-WebSocket-Version", "13");
>+      if (protocols != null) {
>+        request.headers.add("Sec-WebSocket-Protocol", protocols[$toList]());
>+      }
>+      if (dart.test(compression.enabled)) {
>+        request.headers.add("Sec-WebSocket-Extensions", compression[_createHeader]());
>+      }
>+      return request.close();
>+    }, HttpClientRequestToFutureOfHttpClientResponse()))).then(_http.WebSocket, dart.fn(response => {
>+      function error(message) {
>+        FutureOfNull()._check(response.detachSocket().then(core.Null, dart.fn(socket => {
>+          socket.destroy();
>+        }, SocketToNull())));
>+        dart.throw(new _http.WebSocketException.new(message));
>+      }
>+      dart.fn(error, StringTovoid());
>+      if (response.statusCode !== _internal.HttpStatus.switchingProtocols || response.headers._get(_http.HttpHeaders.connectionHeader) == null || !dart.test(response.headers._get(_http.HttpHeaders.connectionHeader)[$any](dart.fn(value => value[$toLowerCase]() === "upgrade", StringTobool()))) || response.headers.value(_http.HttpHeaders.upgradeHeader)[$toLowerCase]() !== "websocket") {
>+        error("Connection to '" + dart.str(uri) + "' was not upgraded to websocket");
>+      }
>+      let accept = response.headers.value("Sec-WebSocket-Accept");
>+      if (accept == null) {
>+        error("Response did not contain a 'Sec-WebSocket-Accept' header");
>+      }
>+      let sha1 = new _http._SHA1.new();
>+      sha1.add((dart.str(nonce) + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11")[$codeUnits]);
>+      let expectedAccept = sha1.close();
>+      let receivedAccept = _http._CryptoUtils.base64StringToBytes(accept);
>+      if (expectedAccept[$length] != receivedAccept[$length]) {
>+        error("Reasponse header 'Sec-WebSocket-Accept' is the wrong length");
>+      }
>+      for (let i = 0; i < dart.notNull(expectedAccept[$length]); i++) {
>+        if (expectedAccept[$_get](i) != receivedAccept[$_get](i)) {
>+          error("Bad response 'Sec-WebSocket-Accept' header");
>+        }
>+      }
>+      let protocol = response.headers.value("Sec-WebSocket-Protocol");
>+      let deflate = _http._WebSocketImpl.negotiateClientCompression(response, compression);
>+      return FutureOfWebSocket()._check(response.detachSocket().then(_http.WebSocket, dart.fn(socket => new _http._WebSocketImpl._fromSocket(socket, protocol, compression, false, deflate), SocketTo_WebSocketImpl())));
>+    }, HttpClientResponseToFutureOfWebSocket())));
>+  }
>+  static negotiateClientCompression(response, compression) {
>+    let extensionHeader = response.headers.value("Sec-WebSocket-Extensions");
>+    if (extensionHeader == null) {
>+      extensionHeader = "";
>+    }
>+    let hv = _http.HeaderValue.parse(extensionHeader, {valueSeparator: ","});
>+    if (dart.test(compression.enabled) && hv.value === "permessage-deflate") {
>+      let serverNoContextTakeover = hv.parameters[$containsKey]("server_no_context_takeover");
>+      let clientNoContextTakeover = hv.parameters[$containsKey]("client_no_context_takeover");
>+      function getWindowBits(type) {
>+        let o = hv.parameters[$_get](type);
>+        if (o == null) {
>+          return 15;
>+        }
>+        return core.int.parse(o, {onError: dart.fn(s => 15, StringToint())});
>+      }
>+      dart.fn(getWindowBits, StringToint());
>+      return new _http._WebSocketPerMessageDeflate.new({clientMaxWindowBits: getWindowBits("client_max_window_bits"), serverMaxWindowBits: getWindowBits("server_max_window_bits"), clientNoContextTakeover: clientNoContextTakeover, serverNoContextTakeover: serverNoContextTakeover});
>+    }
>+    return null;
>+  }
>+  listen(onData, opts) {
>+    let onError = opts && 'onError' in opts ? opts.onError : null;
>+    let onDone = opts && 'onDone' in opts ? opts.onDone : null;
>+    let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
>+    return this[_controller$1].stream.listen(onData, {onError: onError, onDone: onDone, cancelOnError: cancelOnError});
>+  }
>+  get pingInterval() {
>+    return this[_pingInterval];
>+  }
>+  set pingInterval(interval) {
>+    if (dart.test(this[_writeClosed])) return;
>+    if (this[_pingTimer] != null) this[_pingTimer].cancel();
>+    this[_pingInterval] = interval;
>+    if (this[_pingInterval] == null) return;
>+    this[_pingTimer] = async.Timer.new(this[_pingInterval], dart.fn(() => {
>+      if (dart.test(this[_writeClosed])) return;
>+      this[_consumer].add(new _http._WebSocketPing.new());
>+      this[_pingTimer] = async.Timer.new(this[_pingInterval], dart.fn(() => {
>+        this[_close$0](_http.WebSocketStatus.GOING_AWAY);
>+      }, VoidToNull()));
>+    }, VoidToNull()));
>+  }
>+  get readyState() {
>+    return this[_readyState];
>+  }
>+  get extensions() {
>+    return null;
>+  }
>+  get closeCode() {
>+    return this[_closeCode];
>+  }
>+  get closeReason() {
>+    return this[_closeReason];
>+  }
>+  add(data) {
>+    this[_sink$1].add(data);
>+  }
>+  addUtf8Text(bytes) {
>+    core.ArgumentError.checkNotNull(bytes, "bytes");
>+    this[_sink$1].add(new _http._EncodedString.new(bytes));
>+  }
>+  addError(error, stackTrace) {
>+    if (stackTrace === void 0) stackTrace = null;
>+    this[_sink$1].addError(error, stackTrace);
>+  }
>+  addStream(stream) {
>+    return this[_sink$1].addStream(stream);
>+  }
>+  get done() {
>+    return this[_sink$1].done;
>+  }
>+  close(code, reason) {
>+    if (code === void 0) code = null;
>+    if (reason === void 0) reason = null;
>+    if (dart.test(_http._WebSocketImpl._isReservedStatusCode(code))) {
>+      dart.throw(new _http.WebSocketException.new("Reserved status code " + dart.str(code)));
>+    }
>+    if (this[_outCloseCode] == null) {
>+      this[_outCloseCode] = code;
>+      this[_outCloseReason] = reason;
>+    }
>+    if (!dart.test(this[_controller$1].isClosed)) {
>+      if (!dart.test(this[_controller$1].hasListener) && this[_subscription$0] != null) {
>+        this[_controller$1].stream.drain(dart.dynamic).catchError(dart.fn(_ => new _js_helper.LinkedMap.new(), dynamicToMap()));
>+      }
>+      if (this[_closeTimer] == null) {
>+        this[_closeTimer] = async.Timer.new(const$107 || (const$107 = dart.const(new core.Duration.new({seconds: 5}))), dart.fn(() => {
>+          this[_closeCode] = this[_outCloseCode];
>+          this[_closeReason] = this[_outCloseReason];
>+          if (this[_subscription$0] != null) this[_subscription$0].cancel();
>+          this[_controller$1].close();
>+          _http._WebSocketImpl._webSockets[$remove](this[_serviceId$]);
>+        }, VoidToNull()));
>+      }
>+    }
>+    return this[_sink$1].close();
>+  }
>+  static get userAgent() {
>+    return _http._WebSocketImpl._httpClient.userAgent;
>+  }
>+  static set userAgent(userAgent) {
>+    _http._WebSocketImpl._httpClient.userAgent = userAgent;
>+  }
>+  [_close$0](code, reason) {
>+    if (code === void 0) code = null;
>+    if (reason === void 0) reason = null;
>+    if (dart.test(this[_writeClosed])) return;
>+    if (this[_outCloseCode] == null) {
>+      this[_outCloseCode] = code;
>+      this[_outCloseReason] = reason;
>+    }
>+    this[_writeClosed] = true;
>+    this[_consumer].closeSocket();
>+    _http._WebSocketImpl._webSockets[$remove](this[_serviceId$]);
>+  }
>+  get [_serviceTypePath$]() {
>+    return "io/websockets";
>+  }
>+  get [_serviceTypeName$]() {
>+    return "WebSocket";
>+  }
>+  [_toJSON$](ref) {
>+    let name = dart.str(dart.dload(dart.dload(this[_socket$], 'address'), 'host')) + ":" + dart.str(dart.dload(this[_socket$], 'port'));
>+    let r = new (IdentityMapOfString$dynamic()).from(["id", this[_servicePath$], "type", this[_serviceType$](ref), "name", name, "user_name", name]);
>+    if (dart.test(ref)) {
>+      return r;
>+    }
>+    try {
>+      r[$_set]("socket", dart.dsend(this[_socket$], _toJSON$, [true]));
>+    } catch (e) {
>+      let _ = dart.getThrown(e);
>+      r[$_set]("socket", new (IdentityMapOfString$String()).from(["id", this[_servicePath$], "type", "@Socket", "name", "UserSocket", "user_name", "UserSocket"]));
>+    }
>+    return r;
>+  }
>+  static _isReservedStatusCode(code) {
>+    return code != null && (dart.notNull(code) < _http.WebSocketStatus.NORMAL_CLOSURE || code === _http.WebSocketStatus.RESERVED_1004 || code === _http.WebSocketStatus.NO_STATUS_RECEIVED || code === _http.WebSocketStatus.ABNORMAL_CLOSURE || dart.notNull(code) > _http.WebSocketStatus.INTERNAL_SERVER_ERROR && dart.notNull(code) < _http.WebSocketStatus.RESERVED_1015 || dart.notNull(code) >= _http.WebSocketStatus.RESERVED_1015 && dart.notNull(code) < 3000);
>+  }
>+};
>+(_http._WebSocketImpl._fromSocket = function(socket, protocol, compression, serverSide, deflate) {
>+  if (serverSide === void 0) serverSide = false;
>+  if (deflate === void 0) deflate = null;
>+  this[_controller$1] = null;
>+  this[_subscription$0] = null;
>+  this[_sink$1] = null;
>+  this[_readyState] = _http.WebSocket.connecting;
>+  this[_writeClosed] = false;
>+  this[_closeCode] = null;
>+  this[_closeReason] = null;
>+  this[_pingInterval] = null;
>+  this[_pingTimer] = null;
>+  this[_consumer] = null;
>+  this[_outCloseCode] = null;
>+  this[_outCloseReason] = null;
>+  this[_closeTimer] = null;
>+  this[_deflate] = null;
>+  this[_socket$] = socket;
>+  this.protocol = protocol;
>+  this[_serverSide] = serverSide;
>+  _http._WebSocketImpl.__proto__.new.call(this);
>+  this[_consumer] = new _http._WebSocketConsumer.new(this, io.Socket._check(this[_socket$]));
>+  this[_sink$1] = new _http._StreamSinkImpl.new(this[_consumer]);
>+  this[_readyState] = _http.WebSocket.open;
>+  this[_deflate] = deflate;
>+  let transformer = new _http._WebSocketProtocolTransformer.new(this[_serverSide], this[_deflate]);
>+  this[_subscription$0] = async.StreamSubscription._check(dart.dsend(dart.dsend(this[_socket$], 'transform', [transformer]), 'listen', [dart.fn(data => {
>+      if (_http._WebSocketPing.is(data)) {
>+        if (!dart.test(this[_writeClosed])) this[_consumer].add(new _http._WebSocketPong.new(data.payload));
>+      } else if (_http._WebSocketPong.is(data)) {
>+        this.pingInterval = this[_pingInterval];
>+      } else {
>+        this[_controller$1].add(data);
>+      }
>+    }, dynamicToNull())], {onError: dart.fn((error, stackTrace) => {
>+      if (this[_closeTimer] != null) this[_closeTimer].cancel();
>+      if (core.FormatException.is(error)) {
>+        this[_close$0](_http.WebSocketStatus.INVALID_FRAME_PAYLOAD_DATA);
>+      } else {
>+        this[_close$0](_http.WebSocketStatus.PROTOCOL_ERROR);
>+      }
>+      this[_closeCode] = this[_outCloseCode];
>+      this[_closeReason] = this[_outCloseReason];
>+      this[_controller$1].close();
>+    }, dynamicAnddynamicToNull()), onDone: dart.fn(() => {
>+      if (this[_closeTimer] != null) this[_closeTimer].cancel();
>+      if (this[_readyState] === _http.WebSocket.open) {
>+        this[_readyState] = _http.WebSocket.closing;
>+        if (!dart.test(_http._WebSocketImpl._isReservedStatusCode(transformer.closeCode))) {
>+          this[_close$0](transformer.closeCode, transformer.closeReason);
>+        } else {
>+          this[_close$0]();
>+        }
>+        this[_readyState] = _http.WebSocket.closed;
>+      }
>+      this[_closeCode] = transformer.closeCode;
>+      this[_closeReason] = transformer.closeReason;
>+      this[_controller$1].close();
>+    }, VoidToNull()), cancelOnError: true}));
>+  this[_subscription$0].pause();
>+  this[_controller$1] = async.StreamController.new({sync: true, onListen: dart.bind(this[_subscription$0], 'resume'), onCancel: dart.fn(() => {
>+      this[_subscription$0].cancel();
>+      this[_subscription$0] = null;
>+    }, VoidToNull()), onPause: dart.bind(this[_subscription$0], 'pause'), onResume: dart.bind(this[_subscription$0], 'resume')});
>+  _http._WebSocketImpl._webSockets[$_set](this[_serviceId$], this);
>+}).prototype = _http._WebSocketImpl.prototype;
>+dart.addTypeTests(_http._WebSocketImpl);
>+_http._WebSocketImpl[dart.implements] = () => [_http.WebSocket];
>+dart.setMethodSignature(_http._WebSocketImpl, () => ({
>+  __proto__: dart.getMethods(_http._WebSocketImpl.__proto__),
>+  listen: dart.fnType(async.StreamSubscription, [dart.fnType(dart.void, [dart.dynamic])], {onError: core.Function, onDone: dart.fnType(dart.void, []), cancelOnError: core.bool}),
>+  add: dart.fnType(dart.void, [dart.dynamic]),
>+  addUtf8Text: dart.fnType(dart.void, [core.List$(core.int)]),
>+  addError: dart.fnType(dart.void, [core.Object], [core.StackTrace]),
>+  addStream: dart.fnType(async.Future, [async.Stream]),
>+  close: dart.fnType(async.Future, [], [core.int, core.String]),
>+  [_close$0]: dart.fnType(dart.void, [], [core.int, core.String]),
>+  [_toJSON$]: dart.fnType(core.Map$(core.String, dart.dynamic), [core.bool])
>+}));
>+dart.setGetterSignature(_http._WebSocketImpl, () => ({
>+  __proto__: dart.getGetters(_http._WebSocketImpl.__proto__),
>+  pingInterval: core.Duration,
>+  readyState: core.int,
>+  extensions: core.String,
>+  closeCode: core.int,
>+  closeReason: core.String,
>+  done: async.Future,
>+  [_serviceTypePath$]: core.String,
>+  [_serviceTypeName$]: core.String
>+}));
>+dart.setSetterSignature(_http._WebSocketImpl, () => ({
>+  __proto__: dart.getSetters(_http._WebSocketImpl.__proto__),
>+  pingInterval: core.Duration
>+}));
>+dart.setLibraryUri(_http._WebSocketImpl, "dart:_http");
>+dart.setFieldSignature(_http._WebSocketImpl, () => ({
>+  __proto__: dart.getFields(_http._WebSocketImpl.__proto__),
>+  protocol: dart.finalFieldType(core.String),
>+  [_controller$1]: dart.fieldType(async.StreamController),
>+  [_subscription$0]: dart.fieldType(async.StreamSubscription),
>+  [_sink$1]: dart.fieldType(async.StreamSink),
>+  [_socket$]: dart.finalFieldType(dart.dynamic),
>+  [_serverSide]: dart.finalFieldType(core.bool),
>+  [_readyState]: dart.fieldType(core.int),
>+  [_writeClosed]: dart.fieldType(core.bool),
>+  [_closeCode]: dart.fieldType(core.int),
>+  [_closeReason]: dart.fieldType(core.String),
>+  [_pingInterval]: dart.fieldType(core.Duration),
>+  [_pingTimer]: dart.fieldType(async.Timer),
>+  [_consumer]: dart.fieldType(_http._WebSocketConsumer),
>+  [_outCloseCode]: dart.fieldType(core.int),
>+  [_outCloseReason]: dart.fieldType(core.String),
>+  [_closeTimer]: dart.fieldType(async.Timer),
>+  [_deflate]: dart.fieldType(_http._WebSocketPerMessageDeflate)
>+}));
>+dart.defineLazy(_http._WebSocketImpl, {
>+  /*_http._WebSocketImpl._webSockets*/get _webSockets() {
>+    return new (IdentityMapOfint$_WebSocketImpl()).new();
>+  },
>+  set _webSockets(_) {},
>+  /*_http._WebSocketImpl.DEFAULT_WINDOW_BITS*/get DEFAULT_WINDOW_BITS() {
>+    return 15;
>+  },
>+  /*_http._WebSocketImpl.PER_MESSAGE_DEFLATE*/get PER_MESSAGE_DEFLATE() {
>+    return "permessage-deflate";
>+  },
>+  /*_http._WebSocketImpl._httpClient*/get _httpClient() {
>+    return _http.HttpClient.new();
>+  }
>+});
>+dart.setBaseClass(_http._HttpConnection.__proto__, collection.LinkedListEntry$(_http._HttpConnection));
>+dart.trackLibraries("dart_sdk", {
>+  "dart:_runtime": dart,
>+  "dart:_debugger": _debugger,
>+  "dart:_foreign_helper": _foreign_helper,
>+  "dart:_interceptors": _interceptors,
>+  "dart:_internal": _internal,
>+  "dart:_isolate_helper": _isolate_helper,
>+  "dart:_js_helper": _js_helper,
>+  "dart:_js_mirrors": _js_mirrors,
>+  "dart:_js_primitives": _js_primitives,
>+  "dart:_metadata": _metadata,
>+  "dart:_native_typed_data": _native_typed_data,
>+  "dart:async": async,
>+  "dart:collection": collection,
>+  "dart:convert": convert,
>+  "dart:core": core,
>+  "dart:developer": developer,
>+  "dart:io": io,
>+  "dart:isolate": isolate,
>+  "dart:js": js,
>+  "dart:js_util": js_util,
>+  "dart:math": math,
>+  "dart:mirrors": mirrors,
>+  "dart:typed_data": typed_data,
>+  "dart:indexed_db": indexed_db,
>+  "dart:html": html$,
>+  "dart:html_common": html_common,
>+  "dart:svg": svg$,
>+  "dart:web_audio": web_audio,
>+  "dart:web_gl": web_gl,
>+  "dart:web_sql": web_sql,
>+  "dart:_http": _http
>+}, {
>+  "dart:_runtime": ["utils.dart", "classes.dart", "rtti.dart", "types.dart", "errors.dart", "operations.dart"],
>+  "dart:_debugger": ["profile.dart"],
>+  "dart:_interceptors": ["js_array.dart", "js_number.dart", "js_string.dart"],
>+  "dart:_internal": ["async_cast.dart", "cast.dart", "iterable.dart", "list.dart", "print.dart", "sort.dart", "symbol.dart", "linked_list.dart"],
>+  "dart:_js_helper": ["annotations.dart", "linked_hash_map.dart", "identity_hash_map.dart", "custom_hash_map.dart", "native_helper.dart", "regexp_helper.dart", "string_helper.dart", "js_rti.dart"],
>+  "dart:async": ["async_error.dart", "broadcast_stream_controller.dart", "deferred_load.dart", "future.dart", "future_impl.dart", "schedule_microtask.dart", "stream.dart", "stream_controller.dart", "stream_impl.dart", "stream_pipe.dart", "stream_transformers.dart", "timer.dart", "zone.dart"],
>+  "dart:collection": ["collections.dart", "hash_map.dart", "hash_set.dart", "iterable.dart", "iterator.dart", "linked_hash_map.dart", "linked_hash_set.dart", "linked_list.dart", "list.dart", "maps.dart", "queue.dart", "set.dart", "splay_tree.dart"],
>+  "dart:convert": ["ascii.dart", "base64.dart", "byte_conversion.dart", "chunked_conversion.dart", "codec.dart", "converter.dart", "encoding.dart", "html_escape.dart", "json.dart", "latin1.dart", "line_splitter.dart", "string_conversion.dart", "utf.dart"],
>+  "dart:core": ["annotations.dart", "bigint.dart", "bool.dart", "comparable.dart", "date_time.dart", "double.dart", "duration.dart", "errors.dart", "exceptions.dart", "expando.dart", "function.dart", "identical.dart", "int.dart", "invocation.dart", "iterable.dart", "iterator.dart", "list.dart", "map.dart", "null.dart", "num.dart", "object.dart", "pattern.dart", "print.dart", "regexp.dart", "set.dart", "sink.dart", "stacktrace.dart", "stopwatch.dart", "string.dart", "string_buffer.dart", "string_sink.dart", "symbol.dart", "type.dart", "uri.dart"],
>+  "dart:developer": ["extension.dart", "profiler.dart", "service.dart", "timeline.dart"],
>+  "dart:io": ["bytes_builder.dart", "common.dart", "data_transformer.dart", "directory.dart", "directory_impl.dart", "embedder_config.dart", "eventhandler.dart", "file.dart", "file_impl.dart", "file_system_entity.dart", "io_resource_info.dart", "io_sink.dart", "io_service.dart", "link.dart", "namespace_impl.dart", "overrides.dart", "platform.dart", "platform_impl.dart", "process.dart", "secure_server_socket.dart", "secure_socket.dart", "security_context.dart", "service_object.dart", "socket.dart", "stdio.dart", "string_transformer.dart", "sync_socket.dart"],
>+  "dart:isolate": ["capability.dart"],
>+  "dart:math": ["jenkins_smi_hash.dart", "point.dart", "random.dart", "rectangle.dart"],
>+  "dart:typed_data": ["unmodifiable_typed_data.dart"],
>+  "dart:html_common": ["css_class_set.dart", "conversions.dart", "conversions_dart2js.dart", "device.dart", "filtered_element_list.dart", "lists.dart"],
>+  "dart:_http": ["crypto.dart", "http_date.dart", "http_headers.dart", "http_impl.dart", "http_parser.dart", "http_session.dart", "overrides.dart", "websocket.dart", "websocket_impl.dart"]
>+}, null);
>+
>+console.log('done!');
>+}
>+
>+let start = Date.now();
>+try {
>+foo();
>+} catch { }
>+// print(Date.now() - start);
>Index: JSTests/stress/lexical-let-tdz.js
>===================================================================
>--- JSTests/stress/lexical-let-tdz.js	(revision 268822)
>+++ JSTests/stress/lexical-let-tdz.js	(working copy)
>@@ -58,8 +58,8 @@ function foo() {
> }
> function bar() {
>     captureX();
>-    let x = 20;
>-    function captureX() { return x; }
>+    let fooBar = 20;
>+    function captureX() { return fooBar; }
> }
> 
> for (var i = 0; i < NUM_LOOPS; i++) {
>Index: JSTests/stress/tagged-template-tdz.js
>===================================================================
>--- JSTests/stress/tagged-template-tdz.js	(revision 268822)
>+++ JSTests/stress/tagged-template-tdz.js	(working copy)
>@@ -1,4 +1,6 @@
> function shouldThrowTDZ(func) {
>+    print(func);
>+    print("-------------------")
>     let hasThrown = false;
>     try {
>         func();
>Index: Source/JavaScriptCore/ChangeLog
>===================================================================
>--- Source/JavaScriptCore/ChangeLog	(revision 268822)
>+++ Source/JavaScriptCore/ChangeLog	(working copy)
>@@ -1,3 +1,139 @@
>+2020-10-23  Saam Barati  <sbarati@apple.com>
>+
>+        Better cache our serialization of the outer TDZ environment when creating FunctionExecutables during bytecode generation
>+        https://bugs.webkit.org/show_bug.cgi?id=199866
>+        <rdar://problem/53333108>
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        This patch removes performance pathologies regarding programs with
>+        many variables under TDZ (let/const). We had an algorithm for caching
>+        the results of gathering all variables under TDZ, but that algorithm
>+        wasn't nearly aggressive enough in its caching. This lead us to worst
>+        case quadratic runtime, which could happens in practice for large functions.
>+        
>+        There are a few fixes here:
>+        - Instead of flattening the entire TDZ stack, and caching that result,
>+        we now cache each stack entry individually. So as you push/pop to the
>+        TDZ environment stack, we no longer invalidate everything. Instead, we
>+        will just need to cache the newly pushed entry. We also no longer invalidate
>+        the cache for lifting a TDZ check. The compromise here is we may emit
>+        more runtime TDZ checks for closure variables. This is better than N^2
>+        bytecode compile time perf, since a well predicted branch for a TDZ
>+        check is essentially free.
>+        - We no longer transform the CompactTDZEnvironment (formerly CompactVariableEnvironment)
>+        from a Vector into a HashSet each time we generate code for an inner function. Instead,
>+        CompactTDZEnvironment can be in two modes: compact and inflated. It starts life off in
>+        compact mode (a vector), and will turn into an inflated mode if it's ever needed. Once
>+        inflated, it'll stay this way until it's destructed. This improves our algorithm from being 
>+        O(EnvSize * NumFunctions) to O(EnvSize) at the cost of using more space in a HashTable versus a 
>+        Vector. In the future, we could consider just binary searching through this Vector, and never using
>+        a hash table.
>+
>+        * bytecode/UnlinkedFunctionExecutable.cpp:
>+        (JSC::generateUnlinkedFunctionCodeBlock):
>+        (JSC::UnlinkedFunctionExecutable::UnlinkedFunctionExecutable):
>+        * bytecode/UnlinkedFunctionExecutable.h:
>+        * bytecompiler/BytecodeGenerator.cpp:
>+        (JSC::BytecodeGenerator::BytecodeGenerator):
>+        (JSC::BytecodeGenerator::popLexicalScopeInternal):
>+        (JSC::BytecodeGenerator::needsTDZCheck):
>+        (JSC::BytecodeGenerator::liftTDZCheckIfPossible):
>+        (JSC::BytecodeGenerator::pushTDZVariables):
>+        (JSC::BytecodeGenerator::getVariablesUnderTDZ):
>+        (JSC::BytecodeGenerator::preserveTDZStack):
>+        (JSC::BytecodeGenerator::restoreTDZStack):
>+        (JSC::BytecodeGenerator::emitNewInstanceFieldInitializerFunction):
>+        * bytecompiler/BytecodeGenerator.h:
>+        (JSC::BytecodeGenerator::generate):
>+        (JSC::BytecodeGenerator::makeFunction):
>+        * debugger/DebuggerCallFrame.cpp:
>+        (JSC::DebuggerCallFrame::evaluateWithScopeExtension):
>+        * interpreter/Interpreter.cpp:
>+        (JSC::eval):
>+        * parser/Parser.h:
>+        (JSC::Parser<LexerType>::parse):
>+        (JSC::parse):
>+        * parser/VariableEnvironment.cpp:
>+        (JSC::CompactTDZEnvironment::sortCompact):
>+        (JSC::CompactTDZEnvironment::CompactTDZEnvironment):
>+        (JSC::CompactTDZEnvironment::operator== const):
>+        (JSC::CompactTDZEnvironment::toTDZEnvironmentSlow const):
>+        (JSC::CompactTDZEnvironmentMap::get):
>+        (JSC::CompactTDZEnvironmentMap::Handle::~Handle):
>+        (JSC::CompactTDZEnvironmentMap::Handle::Handle):
>+        (JSC::CompactVariableEnvironment::CompactVariableEnvironment): Deleted.
>+        (JSC::CompactVariableEnvironment::operator== const): Deleted.
>+        (JSC::CompactVariableEnvironment::toVariableEnvironment const): Deleted.
>+        (JSC::CompactVariableMap::get): Deleted.
>+        (JSC::CompactVariableMap::Handle::~Handle): Deleted.
>+        (JSC::CompactVariableMap::Handle::Handle): Deleted.
>+        * parser/VariableEnvironment.h:
>+        (JSC::CompactTDZEnvironment::toTDZEnvironment const):
>+        (JSC::CompactTDZEnvironmentKey::CompactTDZEnvironmentKey):
>+        (JSC::CompactTDZEnvironmentKey::hash):
>+        (JSC::CompactTDZEnvironmentKey::equal):
>+        (JSC::CompactTDZEnvironmentKey::makeDeletedValue):
>+        (JSC::CompactTDZEnvironmentKey::isHashTableDeletedValue const):
>+        (JSC::CompactTDZEnvironmentKey::environment):
>+        (WTF::HashTraits<JSC::CompactTDZEnvironmentKey>::emptyValue):
>+        (WTF::HashTraits<JSC::CompactTDZEnvironmentKey>::isEmptyValue):
>+        (WTF::HashTraits<JSC::CompactTDZEnvironmentKey>::constructDeletedValue):
>+        (WTF::HashTraits<JSC::CompactTDZEnvironmentKey>::isDeletedValue):
>+        (JSC::CompactTDZEnvironmentMap::Handle::environment const):
>+        (JSC::CompactVariableEnvironment::hash const): Deleted.
>+        (JSC::CompactVariableMapKey::CompactVariableMapKey): Deleted.
>+        (JSC::CompactVariableMapKey::hash): Deleted.
>+        (JSC::CompactVariableMapKey::equal): Deleted.
>+        (JSC::CompactVariableMapKey::makeDeletedValue): Deleted.
>+        (JSC::CompactVariableMapKey::isHashTableDeletedValue const): Deleted.
>+        (JSC::CompactVariableMapKey::isHashTableEmptyValue const): Deleted.
>+        (JSC::CompactVariableMapKey::environment): Deleted.
>+        (WTF::HashTraits<JSC::CompactVariableMapKey>::emptyValue): Deleted.
>+        (WTF::HashTraits<JSC::CompactVariableMapKey>::isEmptyValue): Deleted.
>+        (WTF::HashTraits<JSC::CompactVariableMapKey>::constructDeletedValue): Deleted.
>+        (WTF::HashTraits<JSC::CompactVariableMapKey>::isDeletedValue): Deleted.
>+        (JSC::CompactVariableMap::Handle::Handle): Deleted.
>+        (JSC::CompactVariableMap::Handle::operator=): Deleted.
>+        (JSC::CompactVariableMap::Handle::operator bool const): Deleted.
>+        (JSC::CompactVariableMap::Handle::environment const): Deleted.
>+        (JSC::CompactVariableMap::Handle::swap): Deleted.
>+        * runtime/CachedTypes.cpp:
>+        (JSC::Decoder::handleForTDZEnvironment const):
>+        (JSC::Decoder::setHandleForTDZEnvironment):
>+        (JSC::CachedCompactTDZEnvironment::encode):
>+        (JSC::CachedCompactTDZEnvironment::decode const):
>+        (JSC::CachedCompactTDZEnvironmentMapHandle::encode):
>+        (JSC::CachedCompactTDZEnvironmentMapHandle::decode const):
>+        (JSC::CachedFunctionExecutableRareData::decode const):
>+        (JSC::Decoder::handleForEnvironment const): Deleted.
>+        (JSC::Decoder::setHandleForEnvironment): Deleted.
>+        (JSC::CachedCompactVariableEnvironment::encode): Deleted.
>+        (JSC::CachedCompactVariableEnvironment::decode const): Deleted.
>+        (JSC::CachedCompactVariableMapHandle::encode): Deleted.
>+        (JSC::CachedCompactVariableMapHandle::decode const): Deleted.
>+        * runtime/CachedTypes.h:
>+        * runtime/CodeCache.cpp:
>+        (JSC::generateUnlinkedCodeBlockImpl):
>+        (JSC::generateUnlinkedCodeBlock):
>+        (JSC::generateUnlinkedCodeBlockForDirectEval):
>+        (JSC::recursivelyGenerateUnlinkedCodeBlockForProgram):
>+        (JSC::recursivelyGenerateUnlinkedCodeBlockForModuleProgram):
>+        (JSC::CodeCache::getUnlinkedGlobalCodeBlock):
>+        * runtime/CodeCache.h:
>+        * runtime/Completion.cpp:
>+        (JSC::generateProgramBytecode):
>+        (JSC::generateModuleBytecode):
>+        * runtime/DirectEvalExecutable.cpp:
>+        (JSC::DirectEvalExecutable::create):
>+        * runtime/DirectEvalExecutable.h:
>+        * runtime/JSScope.cpp:
>+        (JSC::JSScope::collectClosureVariablesUnderTDZ):
>+        * runtime/JSScope.h:
>+        * runtime/VM.cpp:
>+        (JSC::VM::VM):
>+        * runtime/VM.h:
>+
> 2020-10-21  Caitlin Potter  <caitp@igalia.com>
> 
>         [JSC] support op_get_private_name in DFG and FTL
>Index: Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.cpp
>===================================================================
>--- Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.cpp	(revision 268822)
>+++ Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.cpp	(working copy)
>@@ -72,9 +72,9 @@ static UnlinkedFunctionCodeBlock* genera
> 
>     UnlinkedFunctionCodeBlock* result = UnlinkedFunctionCodeBlock::create(vm, FunctionCode, ExecutableInfo(function->usesEval(), kind == CodeForConstruct, functionKind == UnlinkedBuiltinFunction, executable->constructorKind(), scriptMode, executable->superBinding(), parseMode, executable->derivedContextType(), executable->needsClassFieldInitializer(), false, isClassContext, EvalContextType::FunctionEvalContext), codeGenerationMode);
> 
>-    VariableEnvironment parentScopeTDZVariables = executable->parentScopeTDZVariables();
>+    auto parentScopeTDZVariables = executable->parentScopeTDZVariables();
>     ECMAMode ecmaMode = executable->isInStrictContext() ? ECMAMode::strict() : ECMAMode::sloppy();
>-    error = BytecodeGenerator::generate(vm, function.get(), source, result, codeGenerationMode, &parentScopeTDZVariables, ecmaMode);
>+    error = BytecodeGenerator::generate(vm, function.get(), source, result, codeGenerationMode, parentScopeTDZVariables, ecmaMode);
> 
>     if (error.isValid())
>         return nullptr;
>@@ -82,7 +82,7 @@ static UnlinkedFunctionCodeBlock* genera
>     return result;
> }
> 
>-UnlinkedFunctionExecutable::UnlinkedFunctionExecutable(VM& vm, Structure* structure, const SourceCode& parentSource, FunctionMetadataNode* node, UnlinkedFunctionKind kind, ConstructAbility constructAbility, JSParserScriptMode scriptMode, Optional<CompactVariableMap::Handle> parentScopeTDZVariables, DerivedContextType derivedContextType, NeedsClassFieldInitializer needsClassFieldInitializer, bool isBuiltinDefaultClassConstructor)
>+UnlinkedFunctionExecutable::UnlinkedFunctionExecutable(VM& vm, Structure* structure, const SourceCode& parentSource, FunctionMetadataNode* node, UnlinkedFunctionKind kind, ConstructAbility constructAbility, JSParserScriptMode scriptMode, Optional<Vector<CompactTDZEnvironmentMap::Handle>> parentScopeTDZVariables, DerivedContextType derivedContextType, NeedsClassFieldInitializer needsClassFieldInitializer, bool isBuiltinDefaultClassConstructor)
>     : Base(vm, structure)
>     , m_firstLineOffset(node->firstLine() - parentSource.firstLine().oneBasedInt())
>     , m_isInStrictContext(node->isInStrictContext())
>Index: Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.h
>===================================================================
>--- Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.h	(revision 268822)
>+++ Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.h	(working copy)
>@@ -70,7 +70,7 @@ public:
>         return &vm.unlinkedFunctionExecutableSpace.space;
>     }
> 
>-    static UnlinkedFunctionExecutable* create(VM& vm, const SourceCode& source, FunctionMetadataNode* node, UnlinkedFunctionKind unlinkedFunctionKind, ConstructAbility constructAbility, JSParserScriptMode scriptMode, Optional<CompactVariableMap::Handle> parentScopeTDZVariables, DerivedContextType derivedContextType, NeedsClassFieldInitializer needsClassFieldInitializer, bool isBuiltinDefaultClassConstructor = false)
>+    static UnlinkedFunctionExecutable* create(VM& vm, const SourceCode& source, FunctionMetadataNode* node, UnlinkedFunctionKind unlinkedFunctionKind, ConstructAbility constructAbility, JSParserScriptMode scriptMode, Optional<Vector<CompactTDZEnvironmentMap::Handle>> parentScopeTDZVariables, DerivedContextType derivedContextType, NeedsClassFieldInitializer needsClassFieldInitializer, bool isBuiltinDefaultClassConstructor = false)
>     {
>         UnlinkedFunctionExecutable* instance = new (NotNull, allocateCell<UnlinkedFunctionExecutable>(vm.heap))
>             UnlinkedFunctionExecutable(vm, vm.unlinkedFunctionExecutableStructure.get(), source, node, unlinkedFunctionKind, constructAbility, scriptMode, WTFMove(parentScopeTDZVariables), derivedContextType, needsClassFieldInitializer, isBuiltinDefaultClassConstructor);
>@@ -168,11 +168,11 @@ public:
>         return !m_rareData->m_classSource.isNull();
>     }
> 
>-    VariableEnvironment parentScopeTDZVariables() const
>+    Vector<CompactTDZEnvironmentMap::Handle> parentScopeTDZVariables() const
>     {
>-        if (!m_rareData || !m_rareData->m_parentScopeTDZVariables)
>-            return VariableEnvironment();
>-        return m_rareData->m_parentScopeTDZVariables.environment().toVariableEnvironment();
>+        if (!m_rareData || m_rareData->m_parentScopeTDZVariables.isEmpty())
>+            return { };
>+        return m_rareData->m_parentScopeTDZVariables;
>     }
>     
>     bool isArrowFunction() const { return isArrowFunctionParseMode(parseMode()); }
>@@ -208,7 +208,7 @@ public:
>         SourceCode m_classSource;
>         String m_sourceURLDirective;
>         String m_sourceMappingURLDirective;
>-        CompactVariableMap::Handle m_parentScopeTDZVariables;
>+        Vector<CompactTDZEnvironmentMap::Handle> m_parentScopeTDZVariables;
>         Vector<JSTextPosition> m_instanceFieldLocations;
>     };
> 
>@@ -229,7 +229,7 @@ public:
>     }
> 
> private:
>-    UnlinkedFunctionExecutable(VM&, Structure*, const SourceCode&, FunctionMetadataNode*, UnlinkedFunctionKind, ConstructAbility, JSParserScriptMode, Optional<CompactVariableMap::Handle>,  JSC::DerivedContextType, JSC::NeedsClassFieldInitializer, bool isBuiltinDefaultClassConstructor);
>+    UnlinkedFunctionExecutable(VM&, Structure*, const SourceCode&, FunctionMetadataNode*, UnlinkedFunctionKind, ConstructAbility, JSParserScriptMode, Optional<Vector<CompactTDZEnvironmentMap::Handle>>,  JSC::DerivedContextType, JSC::NeedsClassFieldInitializer, bool isBuiltinDefaultClassConstructor);
>     UnlinkedFunctionExecutable(Decoder&, const CachedFunctionExecutable&);
> 
>     static void visitChildren(JSCell*, SlotVisitor&);
>Index: Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp
>===================================================================
>--- Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp	(revision 268822)
>+++ Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp	(working copy)
>@@ -48,6 +48,7 @@
> #include "Options.h"
> #include "PrivateFieldPutKind.h"
> #include "StrongInlines.h"
>+#include "SuperSampler.h"
> #include "UnlinkedCodeBlock.h"
> #include "UnlinkedEvalCodeBlock.h"
> #include "UnlinkedFunctionCodeBlock.h"
>@@ -288,7 +289,7 @@ ParserError BytecodeGenerator::generate(
>     return ParserError(ParserError::ErrorNone);
> }
> 
>-BytecodeGenerator::BytecodeGenerator(VM& vm, ProgramNode* programNode, UnlinkedProgramCodeBlock* codeBlock, OptionSet<CodeGenerationMode> codeGenerationMode, const VariableEnvironment* parentScopeTDZVariables, ECMAMode ecmaMode)
>+BytecodeGenerator::BytecodeGenerator(VM& vm, ProgramNode* programNode, UnlinkedProgramCodeBlock* codeBlock, OptionSet<CodeGenerationMode> codeGenerationMode, const CachedTDZStack& parentScopeTDZVariables, ECMAMode ecmaMode)
>     : BytecodeGeneratorBase(makeUnique<UnlinkedCodeBlockGenerator>(vm, codeBlock), CodeBlock::llintBaselineCalleeSaveSpaceAsVirtualRegisters())
>     , m_codeGenerationMode(codeGenerationMode)
>     , m_scopeNode(programNode)
>@@ -300,11 +301,10 @@ BytecodeGenerator::BytecodeGenerator(VM&
>     , m_isBuiltinFunction(false)
>     , m_usesNonStrictEval(false)
>     , m_inTailPosition(false)
>-    , m_hasCachedVariablesUnderTDZ(false)
>     , m_needsToUpdateArrowFunctionContext(programNode->usesArrowFunction() || programNode->usesEval())
>     , m_ecmaMode(ecmaMode)
> {
>-    ASSERT_UNUSED(parentScopeTDZVariables, !parentScopeTDZVariables->size());
>+    ASSERT_UNUSED(parentScopeTDZVariables, !parentScopeTDZVariables.size());
> 
>     m_codeBlock->setNumParameters(1); // Allocate space for "this"
> 
>@@ -336,7 +336,7 @@ BytecodeGenerator::BytecodeGenerator(VM&
>     }
> }
> 
>-BytecodeGenerator::BytecodeGenerator(VM& vm, FunctionNode* functionNode, UnlinkedFunctionCodeBlock* codeBlock, OptionSet<CodeGenerationMode> codeGenerationMode, const VariableEnvironment* parentScopeTDZVariables, ECMAMode ecmaMode)
>+BytecodeGenerator::BytecodeGenerator(VM& vm, FunctionNode* functionNode, UnlinkedFunctionCodeBlock* codeBlock, OptionSet<CodeGenerationMode> codeGenerationMode, const CachedTDZStack& parentScopeTDZVariables, ECMAMode ecmaMode)
>     : BytecodeGeneratorBase(makeUnique<UnlinkedCodeBlockGenerator>(vm, codeBlock), CodeBlock::llintBaselineCalleeSaveSpaceAsVirtualRegisters())
>     , m_codeGenerationMode(codeGenerationMode)
>     , m_scopeNode(functionNode)
>@@ -355,7 +355,6 @@ BytecodeGenerator::BytecodeGenerator(VM&
>     //
>     // Note that we intentionally enable tail call for naked constructors since it does not have special code for "return".
>     , m_inTailPosition(Options::useTailCalls() && !isConstructor() && constructorKind() == ConstructorKind::None && ecmaMode.isStrict())
>-    , m_hasCachedVariablesUnderTDZ(false)
>     , m_needsToUpdateArrowFunctionContext(functionNode->usesArrowFunction() || functionNode->usesEval())
>     , m_ecmaMode(ecmaMode)
>     , m_derivedContextType(codeBlock->derivedContextType())
>@@ -364,6 +363,9 @@ BytecodeGenerator::BytecodeGenerator(VM&
>     functionSymbolTable->setUsesNonStrictEval(m_usesNonStrictEval);
>     int symbolTableConstantIndex = 0;
> 
>+    m_parentScopeTDZVariables = parentScopeTDZVariables;
>+    m_cachedVariablesUnderTDZ = m_parentScopeTDZVariables;
>+
>     FunctionParameters& parameters = *functionNode->parameters(); 
>     // http://www.ecma-international.org/ecma-262/6.0/index.html#sec-functiondeclarationinstantiation
>     // This implements IsSimpleParameterList in the Ecma 2015 spec.
>@@ -770,10 +772,6 @@ BytecodeGenerator::BytecodeGenerator(VM&
>         emitPutDerivedConstructorToArrowFunctionContextScope();
>     }
> 
>-    // All "addVar()"s needs to happen before "initializeDefaultParameterValuesAndSetupFunctionScopeStack()" is called
>-    // because a function's default parameter ExpressionNodes will use temporary registers.
>-    pushTDZVariables(*parentScopeTDZVariables, TDZCheckOptimization::DoNotOptimize, TDZRequirement::UnderTDZ);
>-
>     Ref<Label> catchLabel = newLabel();
>     TryData* tryFormalParametersData = nullptr;
>     bool needTryCatch = isAsyncFunctionWrapperParseMode(parseMode) && !isSimpleParameterList;
>@@ -782,6 +780,8 @@ BytecodeGenerator::BytecodeGenerator(VM&
>         tryFormalParametersData = pushTry(tryFormalParametersStart.get(), catchLabel.get(), HandlerType::SynthesizedCatch);
>     }
> 
>+    // All "addVar()"s needs to happen before "initializeDefaultParameterValuesAndSetupFunctionScopeStack()" is called
>+    // because a function's default parameter ExpressionNodes will use temporary registers.
>     initializeDefaultParameterValuesAndSetupFunctionScopeStack(parameters, isSimpleParameterList, functionNode, functionSymbolTable, symbolTableConstantIndex, captures, shouldCreateArgumentsVariableInParameterScope);
> 
>     if (needTryCatch) {
>@@ -840,7 +840,7 @@ BytecodeGenerator::BytecodeGenerator(VM&
>     pushLexicalScope(m_scopeNode, TDZCheckOptimization::Optimize, NestedScopeType::IsNotNested, nullptr, shouldInitializeBlockScopedFunctions);
> }
> 
>-BytecodeGenerator::BytecodeGenerator(VM& vm, EvalNode* evalNode, UnlinkedEvalCodeBlock* codeBlock, OptionSet<CodeGenerationMode> codeGenerationMode, const VariableEnvironment* parentScopeTDZVariables, ECMAMode ecmaMode)
>+BytecodeGenerator::BytecodeGenerator(VM& vm, EvalNode* evalNode, UnlinkedEvalCodeBlock* codeBlock, OptionSet<CodeGenerationMode> codeGenerationMode, const CachedTDZStack& parentScopeTDZVariables, ECMAMode ecmaMode)
>     : BytecodeGeneratorBase(makeUnique<UnlinkedCodeBlockGenerator>(vm, codeBlock), CodeBlock::llintBaselineCalleeSaveSpaceAsVirtualRegisters())
>     , m_codeGenerationMode(codeGenerationMode)
>     , m_scopeNode(evalNode)
>@@ -852,14 +852,14 @@ BytecodeGenerator::BytecodeGenerator(VM&
>     , m_isBuiltinFunction(false)
>     , m_usesNonStrictEval(codeBlock->usesEval() && !ecmaMode.isStrict())
>     , m_inTailPosition(false)
>-    , m_hasCachedVariablesUnderTDZ(false)
>     , m_needsToUpdateArrowFunctionContext(evalNode->usesArrowFunction() || evalNode->usesEval())
>     , m_ecmaMode(ecmaMode)
>     , m_derivedContextType(codeBlock->derivedContextType())
> {
>     m_codeBlock->setNumParameters(1);
> 
>-    pushTDZVariables(*parentScopeTDZVariables, TDZCheckOptimization::DoNotOptimize, TDZRequirement::UnderTDZ);
>+    m_parentScopeTDZVariables = parentScopeTDZVariables;
>+    m_cachedVariablesUnderTDZ = m_parentScopeTDZVariables;
> 
>     emitEnter();
> 
>@@ -904,7 +904,7 @@ BytecodeGenerator::BytecodeGenerator(VM&
>     pushLexicalScope(m_scopeNode, TDZCheckOptimization::Optimize, NestedScopeType::IsNotNested, nullptr, shouldInitializeBlockScopedFunctions);
> }
> 
>-BytecodeGenerator::BytecodeGenerator(VM& vm, ModuleProgramNode* moduleProgramNode, UnlinkedModuleProgramCodeBlock* codeBlock, OptionSet<CodeGenerationMode> codeGenerationMode, const VariableEnvironment* parentScopeTDZVariables, ECMAMode ecmaMode)
>+BytecodeGenerator::BytecodeGenerator(VM& vm, ModuleProgramNode* moduleProgramNode, UnlinkedModuleProgramCodeBlock* codeBlock, OptionSet<CodeGenerationMode> codeGenerationMode, const CachedTDZStack& parentScopeTDZVariables, ECMAMode ecmaMode)
>     : BytecodeGeneratorBase(makeUnique<UnlinkedCodeBlockGenerator>(vm, codeBlock), CodeBlock::llintBaselineCalleeSaveSpaceAsVirtualRegisters())
>     , m_codeGenerationMode(codeGenerationMode)
>     , m_scopeNode(moduleProgramNode)
>@@ -916,11 +916,10 @@ BytecodeGenerator::BytecodeGenerator(VM&
>     , m_isBuiltinFunction(false)
>     , m_usesNonStrictEval(false)
>     , m_inTailPosition(false)
>-    , m_hasCachedVariablesUnderTDZ(false)
>     , m_needsToUpdateArrowFunctionContext(moduleProgramNode->usesArrowFunction() || moduleProgramNode->usesEval())
>     , m_ecmaMode(ecmaMode)
> {
>-    ASSERT_UNUSED(parentScopeTDZVariables, !parentScopeTDZVariables->size());
>+    ASSERT_UNUSED(parentScopeTDZVariables, !parentScopeTDZVariables.size());
> 
>     SymbolTable* moduleEnvironmentSymbolTable = SymbolTable::create(m_vm);
>     moduleEnvironmentSymbolTable->setUsesNonStrictEval(m_usesNonStrictEval);
>@@ -2170,7 +2169,7 @@ void BytecodeGenerator::popLexicalScopeI
>     }
> 
>     m_TDZStack.removeLast();
>-    m_cachedVariablesUnderTDZ = { };
>+    m_cachedVariablesUnderTDZ.removeLast();
> }
> 
> void BytecodeGenerator::prepareLexicalScopeForNextForLoopIteration(VariableEnvironmentNode* node, RegisterID* loopSymbolTable)
>@@ -2858,6 +2857,11 @@ bool BytecodeGenerator::needsTDZCheck(co
>         return iter->value != TDZNecessityLevel::NotNeeded;
>     }
> 
>+    for (unsigned i = m_parentScopeTDZVariables.size(); i--;) {
>+        if (m_parentScopeTDZVariables[i].environment().toTDZEnvironment().contains(variable.ident().impl()))
>+            return true;
>+    }
>+
>     return false;
> }
> 
>@@ -2880,10 +2884,8 @@ void BytecodeGenerator::liftTDZCheckIfPo
>     for (unsigned i = m_TDZStack.size(); i--;) {
>         auto iter = m_TDZStack[i].find(identifier);
>         if (iter != m_TDZStack[i].end()) {
>-            if (iter->value == TDZNecessityLevel::Optimize) {
>-                m_cachedVariablesUnderTDZ = { };
>+            if (iter->value == TDZNecessityLevel::Optimize)
>                 iter->value = TDZNecessityLevel::NotNeeded;
>-            }
>             break;
>         }
>     }
>@@ -2908,59 +2910,55 @@ void BytecodeGenerator::pushTDZVariables
>         map.add(entry.key, entry.value.isFunction() ? TDZNecessityLevel::NotNeeded : level);
> 
>     m_TDZStack.append(WTFMove(map));
>-    m_cachedVariablesUnderTDZ = { };
>+    m_cachedVariablesUnderTDZ.append({ });
> }
> 
>-Optional<CompactVariableMap::Handle> BytecodeGenerator::getVariablesUnderTDZ()
>+Optional<BytecodeGenerator::CachedTDZStack> BytecodeGenerator::getVariablesUnderTDZ()
> {
>-    if (m_cachedVariablesUnderTDZ) {
>-        if (!m_hasCachedVariablesUnderTDZ) {
>-            ASSERT(m_cachedVariablesUnderTDZ.environment().toVariableEnvironment().isEmpty());
>-            return WTF::nullopt;
>-        }
>+    auto assertCacheIsCoherent = [&] {
>+#if ASSERT_ENABLED
>+        for (size_t i = 0; i < m_cachedVariablesUnderTDZ.size(); ++i)
>+            ASSERT(!!m_cachedVariablesUnderTDZ[i]);
>+#endif
>+    };
>+
>+    RELEASE_ASSERT(m_TDZStack.size() + m_parentScopeTDZVariables.size() == m_cachedVariablesUnderTDZ.size());
>+
>+    if (m_cachedVariablesUnderTDZ.isEmpty())
>+        return WTF::nullopt;
>+
>+    if (m_cachedVariablesUnderTDZ.last()) {
>+        assertCacheIsCoherent();
>         return m_cachedVariablesUnderTDZ;
>     }
> 
>-    // We keep track of variablesThatDontNeedTDZ in this algorithm to prevent
>-    // reporting that "x" is under TDZ if this function is called at "...".
>-    //
>-    //     {
>-    //         {
>-    //             let x;
>-    //             ...
>-    //         }
>-    //         let x;
>-    //     }
>-    SmallPtrSet<UniquedStringImpl*, 16> variablesThatDontNeedTDZ;
>-    VariableEnvironment environment;
>-    for (unsigned i = m_TDZStack.size(); i--; ) {
>+    for (size_t i = m_TDZStack.size(); i--;) {
>+        if (m_cachedVariablesUnderTDZ[i + m_parentScopeTDZVariables.size()])
>+            break;
>+
>         auto& map = m_TDZStack[i];
>-        for (auto& entry : map)  {
>-            if (entry.value != TDZNecessityLevel::NotNeeded) {
>-                if (!variablesThatDontNeedTDZ.contains(entry.key.get()))
>-                    environment.add(entry.key.get());
>-            } else
>-                variablesThatDontNeedTDZ.add(entry.key.get());
>+        TDZEnvironment environment;
>+        for (auto& entry : map) {
>+            if (entry.value != TDZNecessityLevel::NotNeeded)
>+                environment.add(entry.key.get());
>         }
>+        m_cachedVariablesUnderTDZ[i + m_parentScopeTDZVariables.size()] = m_vm.m_compactVariableMap->get(environment);
>     }
> 
>-    m_cachedVariablesUnderTDZ = m_vm.m_compactVariableMap->get(environment);
>-    m_hasCachedVariablesUnderTDZ = !environment.isEmpty();
>-    if (!m_hasCachedVariablesUnderTDZ)
>-        return WTF::nullopt;
>-
>+    assertCacheIsCoherent();
>     return m_cachedVariablesUnderTDZ;
> }
> 
> void BytecodeGenerator::preserveTDZStack(BytecodeGenerator::PreservedTDZStack& preservedStack)
> {
>     preservedStack.m_preservedTDZStack = m_TDZStack;
>+    preservedStack.m_cachedTDZStack = m_cachedVariablesUnderTDZ;
> }
> 
> void BytecodeGenerator::restoreTDZStack(const BytecodeGenerator::PreservedTDZStack& preservedStack)
> {
>     m_TDZStack = preservedStack.m_preservedTDZStack;
>-    m_cachedVariablesUnderTDZ = { };
>+    m_cachedVariablesUnderTDZ = preservedStack.m_cachedTDZStack;
> }
> 
> RegisterID* BytecodeGenerator::emitNewObject(RegisterID* dst)
>@@ -3147,7 +3145,7 @@ RegisterID* BytecodeGenerator::emitNewIn
>         superBinding = SuperBinding::Needed;
>     }
> 
>-    Optional<CompactVariableMap::Handle> variablesUnderTDZ = getVariablesUnderTDZ();
>+    auto variablesUnderTDZ = getVariablesUnderTDZ();
>     SourceParseMode parseMode = SourceParseMode::InstanceFieldInitializerMode;
>     ConstructAbility constructAbility = ConstructAbility::CannotConstruct;
> 
>Index: Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h
>===================================================================
>--- Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h	(revision 268822)
>+++ Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h	(working copy)
>@@ -407,11 +407,12 @@ namespace JSC {
> 
>     public:
>         typedef DeclarationStacks::FunctionStack FunctionStack;
>+        using CachedTDZStack = Vector<CompactTDZEnvironmentMap::Handle>;
> 
>-        BytecodeGenerator(VM&, ProgramNode*, UnlinkedProgramCodeBlock*, OptionSet<CodeGenerationMode>, const VariableEnvironment*, ECMAMode);
>-        BytecodeGenerator(VM&, FunctionNode*, UnlinkedFunctionCodeBlock*, OptionSet<CodeGenerationMode>, const VariableEnvironment*, ECMAMode);
>-        BytecodeGenerator(VM&, EvalNode*, UnlinkedEvalCodeBlock*, OptionSet<CodeGenerationMode>, const VariableEnvironment*, ECMAMode);
>-        BytecodeGenerator(VM&, ModuleProgramNode*, UnlinkedModuleProgramCodeBlock*, OptionSet<CodeGenerationMode>, const VariableEnvironment*, ECMAMode);
>+        BytecodeGenerator(VM&, ProgramNode*, UnlinkedProgramCodeBlock*, OptionSet<CodeGenerationMode>, const CachedTDZStack&, ECMAMode);
>+        BytecodeGenerator(VM&, FunctionNode*, UnlinkedFunctionCodeBlock*, OptionSet<CodeGenerationMode>, const CachedTDZStack&, ECMAMode);
>+        BytecodeGenerator(VM&, EvalNode*, UnlinkedEvalCodeBlock*, OptionSet<CodeGenerationMode>, const CachedTDZStack&, ECMAMode);
>+        BytecodeGenerator(VM&, ModuleProgramNode*, UnlinkedModuleProgramCodeBlock*, OptionSet<CodeGenerationMode>, const CachedTDZStack&, ECMAMode);
> 
>         ~BytecodeGenerator();
>         
>@@ -431,14 +432,14 @@ namespace JSC {
>         NeedsClassFieldInitializer needsClassFieldInitializer() const { return m_codeBlock->needsClassFieldInitializer(); }
> 
>         template<typename Node, typename UnlinkedCodeBlock>
>-        static ParserError generate(VM& vm, Node* node, const SourceCode& sourceCode, UnlinkedCodeBlock* unlinkedCodeBlock, OptionSet<CodeGenerationMode> codeGenerationMode, const VariableEnvironment* environment, ECMAMode ecmaMode)
>+        static ParserError generate(VM& vm, Node* node, const SourceCode& sourceCode, UnlinkedCodeBlock* unlinkedCodeBlock, OptionSet<CodeGenerationMode> codeGenerationMode, const CachedTDZStack& parentScopeTDZVariables, ECMAMode ecmaMode)
>         {
>             MonotonicTime before;
>             if (UNLIKELY(Options::reportBytecodeCompileTimes()))
>                 before = MonotonicTime::now();
> 
>             DeferGC deferGC(vm.heap);
>-            auto bytecodeGenerator = makeUnique<BytecodeGenerator>(vm, node, unlinkedCodeBlock, codeGenerationMode, environment, ecmaMode);
>+            auto bytecodeGenerator = makeUnique<BytecodeGenerator>(vm, node, unlinkedCodeBlock, codeGenerationMode, parentScopeTDZVariables, ecmaMode);
>             auto result = bytecodeGenerator->generate();
> 
>             if (UNLIKELY(Options::reportBytecodeCompileTimes())) {
>@@ -1185,7 +1186,7 @@ namespace JSC {
>                     newDerivedContextType = DerivedContextType::DerivedMethodContext;
>             }
> 
>-            Optional<CompactVariableMap::Handle> optionalVariablesUnderTDZ = getVariablesUnderTDZ();
>+            auto optionalVariablesUnderTDZ = getVariablesUnderTDZ();
> 
>             // FIXME: These flags, ParserModes and propagation to XXXCodeBlocks should be reorganized.
>             // https://bugs.webkit.org/show_bug.cgi?id=151547
>@@ -1197,7 +1198,7 @@ namespace JSC {
>             return UnlinkedFunctionExecutable::create(m_vm, m_scopeNode->source(), metadata, isBuiltinFunction() ? UnlinkedBuiltinFunction : UnlinkedNormalFunction, constructAbility, scriptMode(), WTFMove(optionalVariablesUnderTDZ), newDerivedContextType, needsClassFieldInitializer);
>         }
> 
>-        Optional<CompactVariableMap::Handle> getVariablesUnderTDZ();
>+        Optional<CachedTDZStack> getVariablesUnderTDZ();
> 
>         RegisterID* emitConstructVarargs(RegisterID* dst, RegisterID* func, RegisterID* thisRegister, RegisterID* arguments, RegisterID* firstFreeRegister, int32_t firstVarArgOffset, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd, DebuggableCall);
>         template<typename CallOp>
>@@ -1231,6 +1232,7 @@ namespace JSC {
>         class PreservedTDZStack {
>         private:
>             Vector<TDZMap> m_preservedTDZStack;
>+            CachedTDZStack m_cachedTDZStack;
>             friend class BytecodeGenerator;
>         };
> 
>@@ -1262,7 +1264,9 @@ namespace JSC {
>         };
>         Vector<LexicalScopeStackEntry> m_lexicalScopeStack;
> 
>+        CachedTDZStack m_parentScopeTDZVariables;
>         Vector<TDZMap> m_TDZStack;
>+        CachedTDZStack m_cachedVariablesUnderTDZ;
>         Optional<size_t> m_varScopeLexicalScopeStackIndex;
>         void pushTDZVariables(const VariableEnvironment&, TDZCheckOptimization, TDZRequirement);
> 
>@@ -1344,13 +1348,10 @@ namespace JSC {
>         bool m_isBuiltinFunction { false };
>         bool m_usesNonStrictEval { false };
>         bool m_inTailPosition { false };
>-        bool m_hasCachedVariablesUnderTDZ { false };
>         bool m_needsToUpdateArrowFunctionContext : 1;
>         ECMAMode m_ecmaMode;
>         DerivedContextType m_derivedContextType { DerivedContextType::None };
> 
>-        CompactVariableMap::Handle m_cachedVariablesUnderTDZ;
>-
>         struct CatchEntry {
>             TryData* tryData;
>             VirtualRegister exceptionRegister;
>Index: Source/JavaScriptCore/debugger/DebuggerCallFrame.cpp
>===================================================================
>--- Source/JavaScriptCore/debugger/DebuggerCallFrame.cpp	(revision 268822)
>+++ Source/JavaScriptCore/debugger/DebuggerCallFrame.cpp	(working copy)
>@@ -258,11 +258,12 @@ JSValue DebuggerCallFrame::evaluateWithS
>     else 
>         evalContextType = EvalContextType::None;
> 
>-    VariableEnvironment variablesUnderTDZ;
>-    JSScope::collectClosureVariablesUnderTDZ(scope()->jsScope(), variablesUnderTDZ);
>+    TDZEnvironment variablesUnderTDZ;
>+    VariableEnvironment privateNames;
>+    JSScope::collectClosureVariablesUnderTDZ(scope()->jsScope(), variablesUnderTDZ, privateNames);
> 
>     ECMAMode ecmaMode = codeBlock->ownerExecutable()->isInStrictContext() ? ECMAMode::strict() : ECMAMode::sloppy();
>-    auto* eval = DirectEvalExecutable::create(globalObject, makeSource(script, callFrame->callerSourceOrigin(vm)), codeBlock->unlinkedCodeBlock()->derivedContextType(), codeBlock->unlinkedCodeBlock()->needsClassFieldInitializer(), codeBlock->unlinkedCodeBlock()->isArrowFunction(), codeBlock->ownerExecutable()->isInsideOrdinaryFunction(), evalContextType, &variablesUnderTDZ, ecmaMode);
>+    auto* eval = DirectEvalExecutable::create(globalObject, makeSource(script, callFrame->callerSourceOrigin(vm)), codeBlock->unlinkedCodeBlock()->derivedContextType(), codeBlock->unlinkedCodeBlock()->needsClassFieldInitializer(), codeBlock->unlinkedCodeBlock()->isArrowFunction(), codeBlock->ownerExecutable()->isInsideOrdinaryFunction(), evalContextType, &variablesUnderTDZ, &privateNames, ecmaMode);
>     if (UNLIKELY(catchScope.exception())) {
>         exception = catchScope.exception();
>         catchScope.clearException();
>Index: Source/JavaScriptCore/interpreter/Interpreter.cpp
>===================================================================
>--- Source/JavaScriptCore/interpreter/Interpreter.cpp	(revision 268822)
>+++ Source/JavaScriptCore/interpreter/Interpreter.cpp	(working copy)
>@@ -143,9 +143,10 @@ JSValue eval(JSGlobalObject* globalObjec
>             RETURN_IF_EXCEPTION(scope, JSValue());
>         }
>         
>-        VariableEnvironment variablesUnderTDZ;
>-        JSScope::collectClosureVariablesUnderTDZ(callerScopeChain, variablesUnderTDZ);
>-        eval = DirectEvalExecutable::create(globalObject, makeSource(programSource, callerCodeBlock->source().provider()->sourceOrigin()), derivedContextType, callerUnlinkedCodeBlock->needsClassFieldInitializer(), isArrowFunctionContext, callerCodeBlock->ownerExecutable()->isInsideOrdinaryFunction(), evalContextType, &variablesUnderTDZ, ecmaMode);
>+        TDZEnvironment variablesUnderTDZ;
>+        VariableEnvironment privateNames;
>+        JSScope::collectClosureVariablesUnderTDZ(callerScopeChain, variablesUnderTDZ, privateNames);
>+        eval = DirectEvalExecutable::create(globalObject, makeSource(programSource, callerCodeBlock->source().provider()->sourceOrigin()), derivedContextType, callerUnlinkedCodeBlock->needsClassFieldInitializer(), isArrowFunctionContext, callerCodeBlock->ownerExecutable()->isInsideOrdinaryFunction(), evalContextType, &variablesUnderTDZ, &privateNames, ecmaMode);
>         EXCEPTION_ASSERT(!!scope.exception() == !eval);
>         if (!eval)
>             return jsUndefined();
>Index: Source/JavaScriptCore/parser/Parser.h
>===================================================================
>--- Source/JavaScriptCore/parser/Parser.h	(revision 268822)
>+++ Source/JavaScriptCore/parser/Parser.h	(working copy)
>@@ -2053,7 +2053,7 @@ private:
> 
> template <typename LexerType>
> template <class ParsedNode>
>-std::unique_ptr<ParsedNode> Parser<LexerType>::parse(ParserError& error, const Identifier& calleeName, SourceParseMode parseMode, ParsingContext parsingContext, Optional<int> functionConstructorParametersEndPosition, const VariableEnvironment* variablesUnderTDZ, const Vector<JSTextPosition>* instanceFieldLocations)
>+std::unique_ptr<ParsedNode> Parser<LexerType>::parse(ParserError& error, const Identifier& calleeName, SourceParseMode parseMode, ParsingContext parsingContext, Optional<int> functionConstructorParametersEndPosition, const VariableEnvironment* parentScopePrivateNames, const Vector<JSTextPosition>* instanceFieldLocations)
> {
>     int errLine;
>     String errMsg;
>@@ -2068,9 +2068,9 @@ std::unique_ptr<ParsedNode> Parser<Lexer
>     ASSERT(m_source->startColumn() > OrdinalNumber::beforeFirst());
>     unsigned startColumn = m_source->startColumn().zeroBasedInt();
> 
>-    if (isEvalNode<ParsedNode>() && variablesUnderTDZ && variablesUnderTDZ->privateNamesSize()) {
>+    if (isEvalNode<ParsedNode>() && parentScopePrivateNames && parentScopePrivateNames->privateNamesSize()) {
>         currentScope()->setIsPrivateNameScope();
>-        variablesUnderTDZ->copyPrivateNamesTo(currentScope()->lexicalVariables());
>+        parentScopePrivateNames->copyPrivateNamesTo(currentScope()->lexicalVariables());
>     }
> 
>     auto parseResult = parseInner(calleeName, parseMode, parsingContext, functionConstructorParametersEndPosition, instanceFieldLocations);
>@@ -2157,7 +2157,7 @@ std::unique_ptr<ParsedNode> parse(
>     DerivedContextType derivedContextType = DerivedContextType::None,
>     EvalContextType evalContextType = EvalContextType::None,
>     DebuggerParseData* debuggerParseData = nullptr,
>-    const VariableEnvironment* variablesUnderTDZ = nullptr,
>+    const VariableEnvironment* parentScopePrivateNames = nullptr,
>     const Vector<JSTextPosition>* instanceFieldLocations = nullptr,
>     bool isInsideOrdinaryFunction = false)
> {
>@@ -2170,7 +2170,7 @@ std::unique_ptr<ParsedNode> parse(
>     std::unique_ptr<ParsedNode> result;
>     if (source.provider()->source().is8Bit()) {
>         Parser<Lexer<LChar>> parser(vm, source, builtinMode, strictMode, scriptMode, parseMode, superBinding, defaultConstructorKindForTopLevelFunction, derivedContextType, isEvalNode<ParsedNode>(), evalContextType, debuggerParseData, isInsideOrdinaryFunction);
>-        result = parser.parse<ParsedNode>(error, name, parseMode, isEvalNode<ParsedNode>() ? ParsingContext::Eval : ParsingContext::Program, WTF::nullopt, variablesUnderTDZ, instanceFieldLocations);
>+        result = parser.parse<ParsedNode>(error, name, parseMode, isEvalNode<ParsedNode>() ? ParsingContext::Eval : ParsingContext::Program, WTF::nullopt, parentScopePrivateNames, instanceFieldLocations);
>         if (positionBeforeLastNewline)
>             *positionBeforeLastNewline = parser.positionBeforeLastNewline();
>         if (builtinMode == JSParserBuiltinMode::Builtin) {
>@@ -2183,7 +2183,7 @@ std::unique_ptr<ParsedNode> parse(
>     } else {
>         ASSERT_WITH_MESSAGE(defaultConstructorKindForTopLevelFunction == ConstructorKind::None, "BuiltinExecutables's special constructors should always use a 8-bit string");
>         Parser<Lexer<UChar>> parser(vm, source, builtinMode, strictMode, scriptMode, parseMode, superBinding, defaultConstructorKindForTopLevelFunction, derivedContextType, isEvalNode<ParsedNode>(), evalContextType, debuggerParseData, isInsideOrdinaryFunction);
>-        result = parser.parse<ParsedNode>(error, name, parseMode, isEvalNode<ParsedNode>() ? ParsingContext::Eval : ParsingContext::Program, WTF::nullopt, variablesUnderTDZ, instanceFieldLocations);
>+        result = parser.parse<ParsedNode>(error, name, parseMode, isEvalNode<ParsedNode>() ? ParsingContext::Eval : ParsingContext::Program, WTF::nullopt, parentScopePrivateNames, instanceFieldLocations);
>         if (positionBeforeLastNewline)
>             *positionBeforeLastNewline = parser.positionBeforeLastNewline();
>     }
>Index: Source/JavaScriptCore/parser/VariableEnvironment.cpp
>===================================================================
>--- Source/JavaScriptCore/parser/VariableEnvironment.cpp	(revision 268822)
>+++ Source/JavaScriptCore/parser/VariableEnvironment.cpp	(working copy)
>@@ -104,64 +104,88 @@ void VariableEnvironment::markVariableAs
>     findResult->value.setIsExported();
> }
> 
>-CompactVariableEnvironment::CompactVariableEnvironment(const VariableEnvironment& env)
>-    : m_isEverythingCaptured(env.isEverythingCaptured())
>-{
>-    Vector<std::pair<UniquedStringImpl*, VariableEnvironmentEntry>, 32> sortedEntries;
>-    sortedEntries.reserveInitialCapacity(env.mapSize());
>-    for (auto& pair : env)
>-        sortedEntries.append({ pair.key.get(), pair.value });
> 
>-    std::sort(sortedEntries.begin(), sortedEntries.end(), [] (const auto& a, const auto& b) {
>-        return a.first < b.first;
>+void CompactTDZEnvironment::sortCompact(Compact& compact)
>+{
>+    std::sort(compact.begin(), compact.end(), [] (auto& a, auto& b) {
>+        return a.get() < b.get();
>     });
>+}
>+
>+CompactTDZEnvironment::CompactTDZEnvironment(const TDZEnvironment& env)
>+{
>+    Compact compactVariables;
>+    compactVariables.reserveCapacity(env.size());
> 
>-    m_hash = 0;
>-    m_variables.reserveInitialCapacity(sortedEntries.size());
>-    m_variableMetadata.reserveInitialCapacity(sortedEntries.size());
>-    for (const auto& pair : sortedEntries) {
>-        m_variables.append(pair.first);
>-        m_variableMetadata.append(pair.second);
>-        m_hash ^= pair.first->hash();
>-        m_hash += pair.second.bits();
>+    m_hash = 0; // Note: XOR is commutative so order doesn't matter here.
>+    for (auto& key : env) {
>+        compactVariables.append(key.get());
>+        m_hash ^= key->hash();
>     }
> 
>-    if (m_isEverythingCaptured)
>-        m_hash *= 2;
>+    sortCompact(compactVariables);
>+    m_variables = WTFMove(compactVariables);
> }
> 
>-bool CompactVariableEnvironment::operator==(const CompactVariableEnvironment& other) const
>+bool CompactTDZEnvironment::operator==(const CompactTDZEnvironment& other) const
> {
>     if (this == &other)
>         return true;
>-    if (m_isEverythingCaptured != other.m_isEverythingCaptured)
>-        return false;
>-    if (m_variables != other.m_variables)
>-        return false;
>-    if (m_variableMetadata != other.m_variableMetadata)
>+
>+    if (m_hash != other.m_hash)
>         return false;
>-    return true;
>-}
> 
>-VariableEnvironment CompactVariableEnvironment::toVariableEnvironment() const
>-{
>-    VariableEnvironment result;
>-    ASSERT(m_variables.size() == m_variableMetadata.size());
>-    for (size_t i = 0; i < m_variables.size(); ++i) {
>-        auto addResult = result.add(m_variables[i]);
>-        ASSERT(addResult.isNewEntry);
>-        addResult.iterator->value = m_variableMetadata[i];
>-    }
>+    auto equal = [&] (const Compact& compact, const Inflated& inflated) {
>+        if (compact.size() != inflated.size())
>+            return false;
>+        for (auto& ident : compact) {
>+            if (!inflated.contains(ident))
>+                return false;
>+        }
>+        return true;
>+    };
> 
>-    if (m_isEverythingCaptured)
>-        result.markAllVariablesAsCaptured();
>+    bool result;
>+    WTF::switchOn(m_variables,
>+        [&] (const Compact& compact) {
>+            WTF::switchOn(other.m_variables,
>+                [&] (const Compact& otherCompact) {
>+                    result = compact == otherCompact;
>+                },
>+                [&] (const Inflated& otherInflated) {
>+                    result = equal(compact, otherInflated);
>+                });
>+        },
>+        [&] (const Inflated& inflated) {
>+            WTF::switchOn(other.m_variables,
>+                [&] (const Compact& otherCompact) {
>+                    result = equal(otherCompact, inflated);
>+                },
>+                [&] (const Inflated& otherInflated) {
>+                    result = inflated == otherInflated;
>+                });
>+        });
> 
>     return result;
> }
> 
>-CompactVariableMap::Handle CompactVariableMap::get(const VariableEnvironment& env)
>+TDZEnvironment& CompactTDZEnvironment::toTDZEnvironmentSlow() const
>+{
>+    Inflated inflated;
>+    {
>+        auto& compact = WTF::get<Compact>(m_variables);
>+        for (size_t i = 0; i < compact.size(); ++i) {
>+            auto addResult = inflated.add(compact[i]);
>+            ASSERT_UNUSED(addResult, addResult.isNewEntry);
>+        }
>+    }
>+    m_variables = Variables(WTFMove(inflated));
>+    return const_cast<Inflated&>(WTF::get<Inflated>(m_variables));
>+}
>+
>+CompactTDZEnvironmentMap::Handle CompactTDZEnvironmentMap::get(const TDZEnvironment& env)
> {
>-    auto* environment = new CompactVariableEnvironment(env);
>+    auto* environment = new CompactTDZEnvironment(env);
>     bool isNewEntry;
>     auto handle = get(environment, isNewEntry);
>     if (!isNewEntry)
>@@ -169,19 +193,19 @@ CompactVariableMap::Handle CompactVariab
>     return handle;
> }
> 
>-CompactVariableMap::Handle CompactVariableMap::get(CompactVariableEnvironment* environment, bool& isNewEntry)
>+CompactTDZEnvironmentMap::Handle CompactTDZEnvironmentMap::get(CompactTDZEnvironment* environment, bool& isNewEntry)
> {
>-    CompactVariableMapKey key { *environment };
>+    CompactTDZEnvironmentKey key { *environment };
>     auto addResult = m_map.add(key, 1);
>     isNewEntry = addResult.isNewEntry;
>     if (addResult.isNewEntry)
>-        return CompactVariableMap::Handle(*environment, *this);
>+        return CompactTDZEnvironmentMap::Handle(*environment, *this);
> 
>     ++addResult.iterator->value;
>-    return CompactVariableMap::Handle(addResult.iterator->key.environment(), *this);
>+    return CompactTDZEnvironmentMap::Handle(addResult.iterator->key.environment(), *this);
> }
> 
>-CompactVariableMap::Handle::~Handle()
>+CompactTDZEnvironmentMap::Handle::~Handle()
> {
>     if (!m_map) {
>         ASSERT(!m_environment);
>@@ -190,7 +214,7 @@ CompactVariableMap::Handle::~Handle()
>     }
> 
>     RELEASE_ASSERT(m_environment);
>-    auto iter = m_map->m_map.find(CompactVariableMapKey { *m_environment });
>+    auto iter = m_map->m_map.find(CompactTDZEnvironmentKey { *m_environment });
>     RELEASE_ASSERT(iter != m_map->m_map.end());
>     --iter->value;
>     if (!iter->value) {
>@@ -200,18 +224,18 @@ CompactVariableMap::Handle::~Handle()
>     }
> }
> 
>-CompactVariableMap::Handle::Handle(const CompactVariableMap::Handle& other)
>+CompactTDZEnvironmentMap::Handle::Handle(const CompactTDZEnvironmentMap::Handle& other)
>     : m_environment(other.m_environment)
>     , m_map(other.m_map)
> {
>     if (m_map) {
>-        auto iter = m_map->m_map.find(CompactVariableMapKey { *m_environment });
>+        auto iter = m_map->m_map.find(CompactTDZEnvironmentKey { *m_environment });
>         RELEASE_ASSERT(iter != m_map->m_map.end());
>         ++iter->value;
>     }
> }
> 
>-CompactVariableMap::Handle::Handle(CompactVariableEnvironment& environment, CompactVariableMap& map)
>+CompactTDZEnvironmentMap::Handle::Handle(CompactTDZEnvironment& environment, CompactTDZEnvironmentMap& map)
>     : m_environment(&environment)
>     , m_map(&map)
> { 
>Index: Source/JavaScriptCore/parser/VariableEnvironment.h
>===================================================================
>--- Source/JavaScriptCore/parser/VariableEnvironment.h	(revision 268822)
>+++ Source/JavaScriptCore/parser/VariableEnvironment.h	(working copy)
>@@ -29,6 +29,7 @@
> #include <wtf/HashMap.h>
> #include <wtf/HashSet.h>
> #include <wtf/IteratorRange.h>
>+#include <wtf/Variant.h>
> 
> namespace JSC {
> 
>@@ -119,6 +120,7 @@ struct PrivateNameEntryHashTraits : Hash
> };
> 
> class VariableEnvironment {
>+    WTF_MAKE_FAST_ALLOCATED;
> private:
>     typedef HashMap<PackedRefPtr<UniquedStringImpl>, VariableEnvironmentEntry, IdentifierRepHash, HashTraits<RefPtr<UniquedStringImpl>>, VariableEnvironmentEntryHashTraits> Map;
>     typedef HashMap<PackedRefPtr<UniquedStringImpl>, PrivateNameEntry, IdentifierRepHash, HashTraits<RefPtr<UniquedStringImpl>>, PrivateNameEntryHashTraits> PrivateNames;
>@@ -262,56 +264,69 @@ private:
>     std::unique_ptr<VariableEnvironment::RareData> m_rareData;
> };
> 
>-class CompactVariableEnvironment {
>+using TDZEnvironment = HashSet<RefPtr<UniquedStringImpl>, IdentifierRepHash>;
>+
>+class CompactTDZEnvironment {
>     WTF_MAKE_FAST_ALLOCATED;
>-    WTF_MAKE_NONCOPYABLE(CompactVariableEnvironment);
>+    WTF_MAKE_NONCOPYABLE(CompactTDZEnvironment);
> 
>-    friend class CachedCompactVariableEnvironment;
>+    friend class CachedCompactTDZEnvironment;
>+
>+    using Compact = Vector<PackedRefPtr<UniquedStringImpl>>;
>+    using Inflated = TDZEnvironment;
>+    using Variables = Variant<Compact, Inflated>;
> 
> public:
>-    CompactVariableEnvironment(const VariableEnvironment&);
>-    VariableEnvironment toVariableEnvironment() const;
>+    CompactTDZEnvironment(const TDZEnvironment&);
> 
>-    bool operator==(const CompactVariableEnvironment&) const;
>+    bool operator==(const CompactTDZEnvironment&) const;
>     unsigned hash() const { return m_hash; }
> 
>+    static void sortCompact(Compact&);
>+
>+    TDZEnvironment& toTDZEnvironment() const
>+    {
>+        if (WTF::holds_alternative<Inflated>(m_variables))
>+            return const_cast<TDZEnvironment&>(WTF::get<Inflated>(m_variables));
>+        return toTDZEnvironmentSlow();
>+    }
>+
> private:
>-    CompactVariableEnvironment() = default;
>+    CompactTDZEnvironment() = default;
>+    TDZEnvironment& toTDZEnvironmentSlow() const;
> 
>-    Vector<PackedRefPtr<UniquedStringImpl>> m_variables;
>-    Vector<VariableEnvironmentEntry> m_variableMetadata;
>+    mutable Variables m_variables;
>     unsigned m_hash;
>-    bool m_isEverythingCaptured;
> };
> 
>-struct CompactVariableMapKey {
>-    CompactVariableMapKey()
>+struct CompactTDZEnvironmentKey {
>+    CompactTDZEnvironmentKey()
>         : m_environment(nullptr)
>     {
>         ASSERT(isHashTableEmptyValue());
>     }
> 
>-    CompactVariableMapKey(CompactVariableEnvironment& environment)
>+    CompactTDZEnvironmentKey(CompactTDZEnvironment& environment)
>         : m_environment(&environment)
>     { }
> 
>-    static unsigned hash(const CompactVariableMapKey& key) { return key.m_environment->hash(); }
>-    static bool equal(const CompactVariableMapKey& a, const CompactVariableMapKey& b) { return *a.m_environment == *b.m_environment; }
>+    static unsigned hash(const CompactTDZEnvironmentKey& key) { return key.m_environment->hash(); }
>+    static bool equal(const CompactTDZEnvironmentKey& a, const CompactTDZEnvironmentKey& b) { return *a.m_environment == *b.m_environment; }
>     static constexpr bool safeToCompareToEmptyOrDeleted = false;
>-    static void makeDeletedValue(CompactVariableMapKey& key)
>+    static void makeDeletedValue(CompactTDZEnvironmentKey& key)
>     {
>-        key.m_environment = reinterpret_cast<CompactVariableEnvironment*>(1);
>+        key.m_environment = reinterpret_cast<CompactTDZEnvironment*>(1);
>     }
>     bool isHashTableDeletedValue() const
>     {
>-        return m_environment == reinterpret_cast<CompactVariableEnvironment*>(1);
>+        return m_environment == reinterpret_cast<CompactTDZEnvironment*>(1);
>     }
>     bool isHashTableEmptyValue() const
>     {
>         return !m_environment;
>     }
> 
>-    CompactVariableEnvironment& environment()
>+    CompactTDZEnvironment& environment()
>     {
>         RELEASE_ASSERT(!isHashTableDeletedValue());
>         RELEASE_ASSERT(!isHashTableEmptyValue());
>@@ -319,7 +334,7 @@ struct CompactVariableMapKey {
>     }
> 
> private:
>-    CompactVariableEnvironment* m_environment;
>+    CompactTDZEnvironment* m_environment;
> };
> 
> } // namespace JSC
>@@ -327,32 +342,32 @@ private:
> namespace WTF {
> 
> template<typename T> struct DefaultHash;
>-template<> struct DefaultHash<JSC::CompactVariableMapKey> : JSC::CompactVariableMapKey { };
>+template<> struct DefaultHash<JSC::CompactTDZEnvironmentKey> : JSC::CompactTDZEnvironmentKey { };
> 
>-template<> struct HashTraits<JSC::CompactVariableMapKey> : GenericHashTraits<JSC::CompactVariableMapKey> {
>+template<> struct HashTraits<JSC::CompactTDZEnvironmentKey> : GenericHashTraits<JSC::CompactTDZEnvironmentKey> {
>     static constexpr bool emptyValueIsZero = true;
>-    static JSC::CompactVariableMapKey emptyValue() { return JSC::CompactVariableMapKey(); }
>+    static JSC::CompactTDZEnvironmentKey emptyValue() { return JSC::CompactTDZEnvironmentKey(); }
> 
>     static constexpr bool hasIsEmptyValueFunction = true;
>-    static bool isEmptyValue(JSC::CompactVariableMapKey key) { return key.isHashTableEmptyValue(); }
>+    static bool isEmptyValue(JSC::CompactTDZEnvironmentKey key) { return key.isHashTableEmptyValue(); }
> 
>-    static void constructDeletedValue(JSC::CompactVariableMapKey& key) { JSC::CompactVariableMapKey::makeDeletedValue(key); }
>-    static bool isDeletedValue(JSC::CompactVariableMapKey key) { return key.isHashTableDeletedValue(); }
>+    static void constructDeletedValue(JSC::CompactTDZEnvironmentKey& key) { JSC::CompactTDZEnvironmentKey::makeDeletedValue(key); }
>+    static bool isDeletedValue(JSC::CompactTDZEnvironmentKey key) { return key.isHashTableDeletedValue(); }
> };
> 
> } // namespace WTF
> 
> namespace JSC {
> 
>-class CompactVariableMap : public RefCounted<CompactVariableMap> {
>+class CompactTDZEnvironmentMap : public RefCounted<CompactTDZEnvironmentMap> {
> public:
>     class Handle {
>-        friend class CachedCompactVariableMapHandle;
>+        friend class CachedCompactTDZEnvironmentMapHandle;
> 
>     public:
>         Handle() = default;
> 
>-        Handle(CompactVariableEnvironment&, CompactVariableMap&);
>+        Handle(CompactTDZEnvironment&, CompactTDZEnvironmentMap&);
> 
>         Handle(Handle&& other)
>         {
>@@ -377,7 +392,7 @@ public:
> 
>         explicit operator bool() const { return !!m_map; }
> 
>-        const CompactVariableEnvironment& environment() const
>+        const CompactTDZEnvironment& environment() const
>         {
>             return *m_environment;
>         }
>@@ -389,19 +404,19 @@ public:
>             std::swap(other.m_map, m_map);
>         }
> 
>-        CompactVariableEnvironment* m_environment { nullptr };
>-        RefPtr<CompactVariableMap> m_map;
>+        CompactTDZEnvironment* m_environment { nullptr };
>+        RefPtr<CompactTDZEnvironmentMap> m_map;
>     };
> 
>-    Handle get(const VariableEnvironment&);
>+    Handle get(const TDZEnvironment&);
> 
> private:
>     friend class Handle;
>-    friend class CachedCompactVariableMapHandle;
>+    friend class CachedCompactTDZEnvironmentMapHandle;
> 
>-    Handle get(CompactVariableEnvironment*, bool& isNewEntry);
>+    Handle get(CompactTDZEnvironment*, bool& isNewEntry);
> 
>-    HashMap<CompactVariableMapKey, unsigned> m_map;
>+    HashMap<CompactTDZEnvironmentKey, unsigned> m_map;
> };
> 
> } // namespace JSC
>Index: Source/JavaScriptCore/runtime/CachedTypes.cpp
>===================================================================
>--- Source/JavaScriptCore/runtime/CachedTypes.cpp	(revision 268822)
>+++ Source/JavaScriptCore/runtime/CachedTypes.cpp	(working copy)
>@@ -327,14 +327,14 @@ const void* Decoder::ptrForOffsetFromBas
>     return m_cachedBytecode->data() + offset;
> }
> 
>-CompactVariableMap::Handle Decoder::handleForEnvironment(CompactVariableEnvironment* environment) const
>+CompactTDZEnvironmentMap::Handle Decoder::handleForTDZEnvironment(CompactTDZEnvironment* environment) const
> {
>     auto it = m_environmentToHandleMap.find(environment);
>     RELEASE_ASSERT(it != m_environmentToHandleMap.end());
>     return it->value;
> }
> 
>-void Decoder::setHandleForEnvironment(CompactVariableEnvironment* environment, const CompactVariableMap::Handle& handle)
>+void Decoder::setHandleForTDZEnvironment(CompactTDZEnvironment* environment, const CompactTDZEnvironmentMap::Handle& handle)
> {
>     auto addResult = m_environmentToHandleMap.add(environment, handle);
>     RELEASE_ASSERT(addResult.isNewEntry);
>@@ -1050,69 +1050,80 @@ private:
>     CachedPtr<CachedVariableEnvironmentRareData> m_rareData;
> };
> 
>-class CachedCompactVariableEnvironment : public CachedObject<CompactVariableEnvironment> {
>+class CachedCompactTDZEnvironment : public CachedObject<CompactTDZEnvironment> {
> public:
>-    void encode(Encoder& encoder, const CompactVariableEnvironment& env)
>+    void encode(Encoder& encoder, const CompactTDZEnvironment& env)
>     {
>-        m_variables.encode(encoder, env.m_variables);
>-        m_variableMetadata.encode(encoder, env.m_variableMetadata);
>+        if (WTF::holds_alternative<CompactTDZEnvironment::Compact>(env.m_variables))
>+            m_variables.encode(encoder, WTF::get<CompactTDZEnvironment::Compact>(env.m_variables));
>+        else {
>+            CompactTDZEnvironment::Compact compact;
>+            for (auto& key : WTF::get<CompactTDZEnvironment::Inflated>(env.m_variables))
>+                compact.append(key);
>+            m_variables.encode(encoder, compact);
>+        }
>         m_hash = env.m_hash;
>-        m_isEverythingCaptured = env.m_isEverythingCaptured;
>     }
> 
>-    void decode(Decoder& decoder, CompactVariableEnvironment& env) const
>+    void decode(Decoder& decoder, CompactTDZEnvironment& env) const
>     {
>-        m_variables.decode(decoder, env.m_variables);
>-        m_variableMetadata.decode(decoder, env.m_variableMetadata);
>+        {
>+            CompactTDZEnvironment::Compact compact;
>+            m_variables.decode(decoder, compact);
>+            CompactTDZEnvironment::sortCompact(compact);
>+            env.m_variables = CompactTDZEnvironment::Variables(WTFMove(compact));
>+        }
>         env.m_hash = m_hash;
>-        env.m_isEverythingCaptured = m_isEverythingCaptured;
>     }
> 
>-    CompactVariableEnvironment* decode(Decoder& decoder) const
>+    CompactTDZEnvironment* decode(Decoder& decoder) const
>     {
>-        CompactVariableEnvironment* env = new CompactVariableEnvironment;
>+        CompactTDZEnvironment* env = new CompactTDZEnvironment;
>         decode(decoder, *env);
>         return env;
>     }
> 
> private:
>     CachedVector<CachedRefPtr<CachedUniquedStringImpl, UniquedStringImpl, WTF::PackedPtrTraits<UniquedStringImpl>>> m_variables;
>-    CachedVector<VariableEnvironmentEntry> m_variableMetadata;
>     unsigned m_hash;
>-    bool m_isEverythingCaptured;
> };
> 
>-class CachedCompactVariableMapHandle : public CachedObject<CompactVariableMap::Handle> {
>+class CachedCompactTDZEnvironmentMapHandle : public CachedObject<CompactTDZEnvironmentMap::Handle> {
> public:
>-    void encode(Encoder& encoder, const CompactVariableMap::Handle& handle)
>+    void encode(Encoder& encoder, const CompactTDZEnvironmentMap::Handle& handle)
>     {
>         m_environment.encode(encoder, handle.m_environment);
>     }
> 
>-    CompactVariableMap::Handle decode(Decoder& decoder) const
>+    CompactTDZEnvironmentMap::Handle decode(Decoder& decoder) const
>     {
>         bool isNewAllocation;
>-        CompactVariableEnvironment* environment = m_environment.decode(decoder, isNewAllocation);
>+        CompactTDZEnvironment* environment = m_environment.decode(decoder, isNewAllocation);
>         if (!environment) {
>             ASSERT(!isNewAllocation);
>-            return CompactVariableMap::Handle();
>+            return CompactTDZEnvironmentMap::Handle();
>         }
> 
>         if (!isNewAllocation)
>-            return decoder.handleForEnvironment(environment);
>+            return decoder.handleForTDZEnvironment(environment);
>         bool isNewEntry;
>-        CompactVariableMap::Handle handle = decoder.vm().m_compactVariableMap->get(environment, isNewEntry);
>+        CompactTDZEnvironmentMap::Handle handle = decoder.vm().m_compactVariableMap->get(environment, isNewEntry);
>         if (!isNewEntry) {
>             decoder.addFinalizer([=] {
>                 delete environment;
>             });
>         }
>-        decoder.setHandleForEnvironment(environment, handle);
>+        decoder.setHandleForTDZEnvironment(environment, handle);
>         return handle;
>     }
> 
>+    void decode(Decoder& decoder, CompactTDZEnvironmentMap::Handle& handle) const
>+    {
>+        handle = decode(decoder);
>+    }
>+
> private:
>-    CachedPtr<CachedCompactVariableEnvironment> m_environment;
>+    CachedPtr<CachedCompactTDZEnvironment> m_environment;
> };
> 
> template<typename T, typename Source = SourceType<T>>
>@@ -1751,14 +1762,13 @@ public:
>     {
>         UnlinkedFunctionExecutable::RareData* rareData = new UnlinkedFunctionExecutable::RareData { };
>         m_classSource.decode(decoder, rareData->m_classSource);
>-        auto parentScopeTDZVariables = m_parentScopeTDZVariables.decode(decoder);
>-        rareData->m_parentScopeTDZVariables = WTFMove(parentScopeTDZVariables);
>+        m_parentScopeTDZVariables.decode(decoder, rareData->m_parentScopeTDZVariables);
>         return rareData;
>     }
> 
> private:
>     CachedSourceCodeWithoutProvider m_classSource;
>-    CachedCompactVariableMapHandle m_parentScopeTDZVariables;
>+    CachedVector<CachedCompactTDZEnvironmentMapHandle> m_parentScopeTDZVariables;
> };
> 
> class CachedFunctionExecutable : public CachedObject<UnlinkedFunctionExecutable> {
>Index: Source/JavaScriptCore/runtime/CachedTypes.h
>===================================================================
>--- Source/JavaScriptCore/runtime/CachedTypes.h	(revision 268822)
>+++ Source/JavaScriptCore/runtime/CachedTypes.h	(working copy)
>@@ -90,8 +90,8 @@ public:
>     void cacheOffset(ptrdiff_t, void*);
>     WTF::Optional<void*> cachedPtrForOffset(ptrdiff_t);
>     const void* ptrForOffsetFromBase(ptrdiff_t);
>-    CompactVariableMap::Handle handleForEnvironment(CompactVariableEnvironment*) const;
>-    void setHandleForEnvironment(CompactVariableEnvironment*, const CompactVariableMap::Handle&);
>+    CompactTDZEnvironmentMap::Handle handleForTDZEnvironment(CompactTDZEnvironment*) const;
>+    void setHandleForTDZEnvironment(CompactTDZEnvironment*, const CompactTDZEnvironmentMap::Handle&);
>     void addLeafExecutable(const UnlinkedFunctionExecutable*, ptrdiff_t);
>     RefPtr<SourceProvider> provider() const;
> 
>@@ -105,7 +105,7 @@ private:
>     Ref<CachedBytecode> m_cachedBytecode;
>     HashMap<ptrdiff_t, void*> m_offsetToPtrMap;
>     Vector<std::function<void()>> m_finalizers;
>-    HashMap<CompactVariableEnvironment*, CompactVariableMap::Handle> m_environmentToHandleMap;
>+    HashMap<CompactTDZEnvironment*, CompactTDZEnvironmentMap::Handle> m_environmentToHandleMap;
>     RefPtr<SourceProvider> m_provider;
> };
> 
>Index: Source/JavaScriptCore/runtime/CodeCache.cpp
>===================================================================
>--- Source/JavaScriptCore/runtime/CodeCache.cpp	(revision 268822)
>+++ Source/JavaScriptCore/runtime/CodeCache.cpp	(working copy)
>@@ -71,12 +71,14 @@ static void generateUnlinkedCodeBlockFor
> }
> 
> template <class UnlinkedCodeBlockType, class ExecutableType = ScriptExecutable>
>-UnlinkedCodeBlockType* generateUnlinkedCodeBlockImpl(VM& vm, const SourceCode& source, JSParserStrictMode strictMode, JSParserScriptMode scriptMode, OptionSet<CodeGenerationMode> codeGenerationMode, ParserError& error, EvalContextType evalContextType, DerivedContextType derivedContextType, bool isArrowFunctionContext, const VariableEnvironment* variablesUnderTDZ, ExecutableType* executable = nullptr)
>+UnlinkedCodeBlockType* generateUnlinkedCodeBlockImpl(VM& vm, const SourceCode& source, JSParserStrictMode strictMode, JSParserScriptMode scriptMode, OptionSet<CodeGenerationMode> codeGenerationMode, ParserError& error, EvalContextType evalContextType, DerivedContextType derivedContextType, bool isArrowFunctionContext, const TDZEnvironment* variablesUnderTDZ = nullptr, const VariableEnvironment* parentScopePrivateNames = nullptr, ExecutableType* executable = nullptr)
> {
>     typedef typename CacheTypes<UnlinkedCodeBlockType>::RootNode RootNode;
>     bool isInsideOrdinaryFunction = executable && executable->isInsideOrdinaryFunction();
>+
>     std::unique_ptr<RootNode> rootNode = parse<RootNode>(
>-        vm, source, Identifier(), JSParserBuiltinMode::NotBuiltin, strictMode, scriptMode, CacheTypes<UnlinkedCodeBlockType>::parseMode, SuperBinding::NotNeeded, error, nullptr, ConstructorKind::None, derivedContextType, evalContextType, nullptr, variablesUnderTDZ, nullptr, isInsideOrdinaryFunction);
>+        vm, source, Identifier(), JSParserBuiltinMode::NotBuiltin, strictMode, scriptMode, CacheTypes<UnlinkedCodeBlockType>::parseMode, SuperBinding::NotNeeded, error, nullptr, ConstructorKind::None, derivedContextType, evalContextType, nullptr, parentScopePrivateNames, nullptr, isInsideOrdinaryFunction);
>+
>     if (!rootNode)
>         return nullptr;
> 
>@@ -103,7 +105,10 @@ UnlinkedCodeBlockType* generateUnlinkedC
>     if (!source.provider()->sourceMappingURLDirective().isNull())
>         unlinkedCodeBlock->setSourceMappingURLDirective(source.provider()->sourceMappingURLDirective());
> 
>-    error = BytecodeGenerator::generate(vm, rootNode.get(), source, unlinkedCodeBlock, codeGenerationMode, variablesUnderTDZ, ecmaMode);
>+    Vector<CompactTDZEnvironmentMap::Handle> parentVariablesUnderTDZ;
>+    if (variablesUnderTDZ)
>+        parentVariablesUnderTDZ.append(vm.m_compactVariableMap->get(*variablesUnderTDZ));
>+    error = BytecodeGenerator::generate(vm, rootNode.get(), source, unlinkedCodeBlock, codeGenerationMode, parentVariablesUnderTDZ, ecmaMode);
> 
>     if (error.isValid())
>         return nullptr;
>@@ -112,22 +117,22 @@ UnlinkedCodeBlockType* generateUnlinkedC
> }
> 
> template <class UnlinkedCodeBlockType, class ExecutableType>
>-UnlinkedCodeBlockType* generateUnlinkedCodeBlock(VM& vm, ExecutableType* executable, const SourceCode& source, JSParserStrictMode strictMode, JSParserScriptMode scriptMode, OptionSet<CodeGenerationMode> codeGenerationMode, ParserError& error, EvalContextType evalContextType, const VariableEnvironment* variablesUnderTDZ)
>+UnlinkedCodeBlockType* generateUnlinkedCodeBlock(VM& vm, ExecutableType* executable, const SourceCode& source, JSParserStrictMode strictMode, JSParserScriptMode scriptMode, OptionSet<CodeGenerationMode> codeGenerationMode, ParserError& error, EvalContextType evalContextType, const TDZEnvironment* variablesUnderTDZ = nullptr, const VariableEnvironment* parentScopePrivateNames = nullptr)
> {
>-    return generateUnlinkedCodeBlockImpl<UnlinkedCodeBlockType, ExecutableType>(vm, source, strictMode, scriptMode, codeGenerationMode, error, evalContextType, executable->derivedContextType(), executable->isArrowFunctionContext(), variablesUnderTDZ, executable);
>+    return generateUnlinkedCodeBlockImpl<UnlinkedCodeBlockType, ExecutableType>(vm, source, strictMode, scriptMode, codeGenerationMode, error, evalContextType, executable->derivedContextType(), executable->isArrowFunctionContext(), variablesUnderTDZ, parentScopePrivateNames, executable);
> }
> 
>-UnlinkedEvalCodeBlock* generateUnlinkedCodeBlockForDirectEval(VM& vm, DirectEvalExecutable* executable, const SourceCode& source, JSParserStrictMode strictMode, JSParserScriptMode scriptMode, OptionSet<CodeGenerationMode> codeGenerationMode, ParserError& error, EvalContextType evalContextType, const VariableEnvironment* variablesUnderTDZ)
>+UnlinkedEvalCodeBlock* generateUnlinkedCodeBlockForDirectEval(VM& vm, DirectEvalExecutable* executable, const SourceCode& source, JSParserStrictMode strictMode, JSParserScriptMode scriptMode, OptionSet<CodeGenerationMode> codeGenerationMode, ParserError& error, EvalContextType evalContextType, const TDZEnvironment* variablesUnderTDZ, const VariableEnvironment* parentScopePrivateNames)
> {
>-    return generateUnlinkedCodeBlock<UnlinkedEvalCodeBlock>(vm, executable, source, strictMode, scriptMode, codeGenerationMode, error, evalContextType, variablesUnderTDZ);
>+    return generateUnlinkedCodeBlock<UnlinkedEvalCodeBlock>(vm, executable, source, strictMode, scriptMode, codeGenerationMode, error, evalContextType, variablesUnderTDZ, parentScopePrivateNames);
> }
> 
> template <class UnlinkedCodeBlockType>
> std::enable_if_t<!std::is_same<UnlinkedCodeBlockType, UnlinkedEvalCodeBlock>::value, UnlinkedCodeBlockType*>
>-recursivelyGenerateUnlinkedCodeBlock(VM& vm, const SourceCode& source, JSParserStrictMode strictMode, JSParserScriptMode scriptMode, OptionSet<CodeGenerationMode> codeGenerationMode, ParserError& error, EvalContextType evalContextType, const VariableEnvironment* variablesUnderTDZ)
>+recursivelyGenerateUnlinkedCodeBlock(VM& vm, const SourceCode& source, JSParserStrictMode strictMode, JSParserScriptMode scriptMode, OptionSet<CodeGenerationMode> codeGenerationMode, ParserError& error, EvalContextType evalContextType)
> {
>     bool isArrowFunctionContext = false;
>-    UnlinkedCodeBlockType* unlinkedCodeBlock = generateUnlinkedCodeBlockImpl<UnlinkedCodeBlockType>(vm, source, strictMode, scriptMode, codeGenerationMode, error, evalContextType, DerivedContextType::None, isArrowFunctionContext, variablesUnderTDZ);
>+    UnlinkedCodeBlockType* unlinkedCodeBlock = generateUnlinkedCodeBlockImpl<UnlinkedCodeBlockType>(vm, source, strictMode, scriptMode, codeGenerationMode, error, evalContextType, DerivedContextType::None, isArrowFunctionContext);
>     if (!unlinkedCodeBlock)
>         return nullptr;
> 
>@@ -135,14 +140,14 @@ recursivelyGenerateUnlinkedCodeBlock(VM&
>     return unlinkedCodeBlock;
> }
> 
>-UnlinkedProgramCodeBlock* recursivelyGenerateUnlinkedCodeBlockForProgram(VM& vm, const SourceCode& source, JSParserStrictMode strictMode, JSParserScriptMode scriptMode, OptionSet<CodeGenerationMode> codeGenerationMode, ParserError& error, EvalContextType evalContextType, const VariableEnvironment* variablesUnderTDZ)
>+UnlinkedProgramCodeBlock* recursivelyGenerateUnlinkedCodeBlockForProgram(VM& vm, const SourceCode& source, JSParserStrictMode strictMode, JSParserScriptMode scriptMode, OptionSet<CodeGenerationMode> codeGenerationMode, ParserError& error, EvalContextType evalContextType)
> {
>-    return recursivelyGenerateUnlinkedCodeBlock<UnlinkedProgramCodeBlock>(vm, source, strictMode, scriptMode, codeGenerationMode, error, evalContextType, variablesUnderTDZ);
>+    return recursivelyGenerateUnlinkedCodeBlock<UnlinkedProgramCodeBlock>(vm, source, strictMode, scriptMode, codeGenerationMode, error, evalContextType);
> }
> 
>-UnlinkedModuleProgramCodeBlock* recursivelyGenerateUnlinkedCodeBlockForModuleProgram(VM& vm, const SourceCode& source, JSParserStrictMode strictMode, JSParserScriptMode scriptMode, OptionSet<CodeGenerationMode> codeGenerationMode, ParserError& error, EvalContextType evalContextType, const VariableEnvironment* variablesUnderTDZ)
>+UnlinkedModuleProgramCodeBlock* recursivelyGenerateUnlinkedCodeBlockForModuleProgram(VM& vm, const SourceCode& source, JSParserStrictMode strictMode, JSParserScriptMode scriptMode, OptionSet<CodeGenerationMode> codeGenerationMode, ParserError& error, EvalContextType evalContextType)
> {
>-    return recursivelyGenerateUnlinkedCodeBlock<UnlinkedModuleProgramCodeBlock>(vm, source, strictMode, scriptMode, codeGenerationMode, error, evalContextType, variablesUnderTDZ);
>+    return recursivelyGenerateUnlinkedCodeBlock<UnlinkedModuleProgramCodeBlock>(vm, source, strictMode, scriptMode, codeGenerationMode, error, evalContextType);
> }
> 
> template <class UnlinkedCodeBlockType, class ExecutableType>
>@@ -168,8 +173,7 @@ UnlinkedCodeBlockType* CodeCache::getUnl
>         return unlinkedCodeBlock;
>     }
> 
>-    VariableEnvironment variablesUnderTDZ;
>-    unlinkedCodeBlock = generateUnlinkedCodeBlock<UnlinkedCodeBlockType, ExecutableType>(vm, executable, source, strictMode, scriptMode, codeGenerationMode, error, evalContextType, &variablesUnderTDZ);
>+    unlinkedCodeBlock = generateUnlinkedCodeBlock<UnlinkedCodeBlockType, ExecutableType>(vm, executable, source, strictMode, scriptMode, codeGenerationMode, error, evalContextType);
> 
>     if (unlinkedCodeBlock && Options::useCodeCache()) {
>         m_sourceCode.addCache(key, SourceCodeValue(vm, unlinkedCodeBlock, m_sourceCode.age()));
>Index: Source/JavaScriptCore/runtime/CodeCache.h
>===================================================================
>--- Source/JavaScriptCore/runtime/CodeCache.h	(revision 268822)
>+++ Source/JavaScriptCore/runtime/CodeCache.h	(working copy)
>@@ -50,7 +50,8 @@ class ParserError;
> class ProgramExecutable;
> class SourceCode;
> class VM;
>-class VariableEnvironment;
>+
>+using TDZEnvironment = HashSet<RefPtr<UniquedStringImpl>, IdentifierRepHash>;
> 
> namespace CodeCacheInternal {
> static constexpr bool verbose = false;
>@@ -253,9 +254,9 @@ template <> struct CacheTypes<UnlinkedMo
>     static constexpr SourceParseMode parseMode = SourceParseMode::ModuleEvaluateMode;
> };
> 
>-UnlinkedEvalCodeBlock* generateUnlinkedCodeBlockForDirectEval(VM&, DirectEvalExecutable*, const SourceCode&, JSParserStrictMode, JSParserScriptMode, OptionSet<CodeGenerationMode>, ParserError&, EvalContextType, const VariableEnvironment* variablesUnderTDZ);
>-UnlinkedProgramCodeBlock* recursivelyGenerateUnlinkedCodeBlockForProgram(VM&, const SourceCode&, JSParserStrictMode, JSParserScriptMode, OptionSet<CodeGenerationMode>, ParserError&, EvalContextType, const VariableEnvironment* variablesUnderTDZ);
>-UnlinkedModuleProgramCodeBlock* recursivelyGenerateUnlinkedCodeBlockForModuleProgram(VM&, const SourceCode&, JSParserStrictMode, JSParserScriptMode, OptionSet<CodeGenerationMode>, ParserError&, EvalContextType, const VariableEnvironment* variablesUnderTDZ);
>+UnlinkedEvalCodeBlock* generateUnlinkedCodeBlockForDirectEval(VM&, DirectEvalExecutable*, const SourceCode&, JSParserStrictMode, JSParserScriptMode, OptionSet<CodeGenerationMode>, ParserError&, EvalContextType, const TDZEnvironment* variablesUnderTDZ, const VariableEnvironment* parentScopePrivateNames);
>+UnlinkedProgramCodeBlock* recursivelyGenerateUnlinkedCodeBlockForProgram(VM&, const SourceCode&, JSParserStrictMode, JSParserScriptMode, OptionSet<CodeGenerationMode>, ParserError&, EvalContextType);
>+UnlinkedModuleProgramCodeBlock* recursivelyGenerateUnlinkedCodeBlockForModuleProgram(VM&, const SourceCode&, JSParserStrictMode, JSParserScriptMode, OptionSet<CodeGenerationMode>, ParserError&, EvalContextType);
> 
> void writeCodeBlock(VM&, const SourceCodeKey&, const SourceCodeValue&);
> RefPtr<CachedBytecode> serializeBytecode(VM&, UnlinkedCodeBlock*, const SourceCode&, SourceCodeType, JSParserStrictMode, JSParserScriptMode, FileSystem::PlatformFileHandle fd, BytecodeCacheError&, OptionSet<CodeGenerationMode>);
>Index: Source/JavaScriptCore/runtime/Completion.cpp
>===================================================================
>--- Source/JavaScriptCore/runtime/Completion.cpp	(revision 268822)
>+++ Source/JavaScriptCore/runtime/Completion.cpp	(working copy)
>@@ -91,13 +91,12 @@ RefPtr<CachedBytecode> generateProgramBy
>     JSLockHolder lock(vm);
>     RELEASE_ASSERT(vm.atomStringTable() == Thread::current().atomStringTable());
> 
>-    VariableEnvironment variablesUnderTDZ;
>     JSParserStrictMode strictMode = JSParserStrictMode::NotStrict;
>     JSParserScriptMode scriptMode = JSParserScriptMode::Classic;
>     EvalContextType evalContextType = EvalContextType::None;
> 
>     ParserError parserError;
>-    UnlinkedCodeBlock* unlinkedCodeBlock = recursivelyGenerateUnlinkedCodeBlockForProgram(vm, source, strictMode, scriptMode, { }, parserError, evalContextType, &variablesUnderTDZ);
>+    UnlinkedCodeBlock* unlinkedCodeBlock = recursivelyGenerateUnlinkedCodeBlockForProgram(vm, source, strictMode, scriptMode, { }, parserError, evalContextType);
>     if (parserError.isValid())
>         error = parserError;
>     if (!unlinkedCodeBlock)
>@@ -111,13 +110,12 @@ RefPtr<CachedBytecode> generateModuleByt
>     JSLockHolder lock(vm);
>     RELEASE_ASSERT(vm.atomStringTable() == Thread::current().atomStringTable());
> 
>-    VariableEnvironment variablesUnderTDZ;
>     JSParserStrictMode strictMode = JSParserStrictMode::Strict;
>     JSParserScriptMode scriptMode = JSParserScriptMode::Module;
>     EvalContextType evalContextType = EvalContextType::None;
> 
>     ParserError parserError;
>-    UnlinkedCodeBlock* unlinkedCodeBlock = recursivelyGenerateUnlinkedCodeBlockForModuleProgram(vm, source, strictMode, scriptMode, { }, parserError, evalContextType, &variablesUnderTDZ);
>+    UnlinkedCodeBlock* unlinkedCodeBlock = recursivelyGenerateUnlinkedCodeBlockForModuleProgram(vm, source, strictMode, scriptMode, { }, parserError, evalContextType);
>     if (parserError.isValid())
>         error = parserError;
>     if (!unlinkedCodeBlock)
>Index: Source/JavaScriptCore/runtime/DirectEvalExecutable.cpp
>===================================================================
>--- Source/JavaScriptCore/runtime/DirectEvalExecutable.cpp	(revision 268822)
>+++ Source/JavaScriptCore/runtime/DirectEvalExecutable.cpp	(working copy)
>@@ -34,7 +34,7 @@
> 
> namespace JSC {
> 
>-DirectEvalExecutable* DirectEvalExecutable::create(JSGlobalObject* globalObject, const SourceCode& source, DerivedContextType derivedContextType, NeedsClassFieldInitializer needsClassFieldInitializer, bool isArrowFunctionContext, bool isInsideOrdinaryFunction, EvalContextType evalContextType, const VariableEnvironment* variablesUnderTDZ, ECMAMode ecmaMode)
>+DirectEvalExecutable* DirectEvalExecutable::create(JSGlobalObject* globalObject, const SourceCode& source, DerivedContextType derivedContextType, NeedsClassFieldInitializer needsClassFieldInitializer, bool isArrowFunctionContext, bool isInsideOrdinaryFunction, EvalContextType evalContextType, const TDZEnvironment* variablesUnderTDZ, const VariableEnvironment* privateNames, ECMAMode ecmaMode)
> {
>     VM& vm = globalObject->vm();
>     auto scope = DECLARE_THROW_SCOPE(vm);
>@@ -52,7 +52,7 @@ DirectEvalExecutable* DirectEvalExecutab
>     OptionSet<CodeGenerationMode> codeGenerationMode = globalObject->defaultCodeGenerationMode();
> 
>     // We don't bother with CodeCache here because direct eval uses a specialized DirectEvalCodeCache.
>-    UnlinkedEvalCodeBlock* unlinkedEvalCode = generateUnlinkedCodeBlockForDirectEval(vm, executable, executable->source(), strictMode, JSParserScriptMode::Classic, codeGenerationMode, error, evalContextType, variablesUnderTDZ);
>+    UnlinkedEvalCodeBlock* unlinkedEvalCode = generateUnlinkedCodeBlockForDirectEval(vm, executable, executable->source(), strictMode, JSParserScriptMode::Classic, codeGenerationMode, error, evalContextType, variablesUnderTDZ, privateNames);
> 
>     if (globalObject->hasDebugger())
>         globalObject->debugger()->sourceParsed(globalObject, executable->source().provider(), error.line(), error.message());
>Index: Source/JavaScriptCore/runtime/DirectEvalExecutable.h
>===================================================================
>--- Source/JavaScriptCore/runtime/DirectEvalExecutable.h	(revision 268822)
>+++ Source/JavaScriptCore/runtime/DirectEvalExecutable.h	(working copy)
>@@ -31,7 +31,7 @@ namespace JSC {
> 
> class DirectEvalExecutable final : public EvalExecutable {
> public:
>-    static DirectEvalExecutable* create(JSGlobalObject*, const SourceCode&, DerivedContextType, NeedsClassFieldInitializer, bool isArrowFunctionContext, bool isInsideOrdinaryFunction, EvalContextType, const VariableEnvironment*, ECMAMode);
>+    static DirectEvalExecutable* create(JSGlobalObject*, const SourceCode&, DerivedContextType, NeedsClassFieldInitializer, bool isArrowFunctionContext, bool isInsideOrdinaryFunction, EvalContextType, const TDZEnvironment* parentScopeTDZVariables, const VariableEnvironment* privateNames, ECMAMode);
> private:
>     DirectEvalExecutable(JSGlobalObject*, const SourceCode&, bool inStrictContext, DerivedContextType, NeedsClassFieldInitializer, bool isArrowFunctionContext, bool isInsideOrdinaryFunction, EvalContextType);
> };
>Index: Source/JavaScriptCore/runtime/JSScope.cpp
>===================================================================
>--- Source/JavaScriptCore/runtime/JSScope.cpp	(revision 268822)
>+++ Source/JavaScriptCore/runtime/JSScope.cpp	(working copy)
>@@ -321,7 +321,7 @@ ResolveOp JSScope::abstractResolve(JSGlo
>     return op;
> }
> 
>-void JSScope::collectClosureVariablesUnderTDZ(JSScope* scope, VariableEnvironment& result)
>+void JSScope::collectClosureVariablesUnderTDZ(JSScope* scope, TDZEnvironment& result, VariableEnvironment& privateNames)
> {
>     for (; scope; scope = scope->next()) {
>         if (!scope->isLexicalScope() && !scope->isCatchScope())
>@@ -338,9 +338,10 @@ void JSScope::collectClosureVariablesUnd
>         ConcurrentJSLocker locker(symbolTable->m_lock);
>         for (auto end = symbolTable->end(locker), iter = symbolTable->begin(locker); iter != end; ++iter)
>             result.add(iter->key);
>+
>         if (symbolTable->hasPrivateNames()) {
>             for (auto name : symbolTable->privateNames())
>-                result.usePrivateName(name);    
>+                privateNames.usePrivateName(name);    
>         }
>     }
> }
>Index: Source/JavaScriptCore/runtime/JSScope.h
>===================================================================
>--- Source/JavaScriptCore/runtime/JSScope.h	(revision 268822)
>+++ Source/JavaScriptCore/runtime/JSScope.h	(working copy)
>@@ -35,6 +35,8 @@ class SymbolTable;
> class VariableEnvironment;
> class WatchpointSet;
> 
>+using TDZEnvironment = HashSet<RefPtr<UniquedStringImpl>, IdentifierRepHash>;
>+
> class JSScope : public JSNonFinalObject {
> public:
>     using Base = JSNonFinalObject;
>@@ -60,7 +62,7 @@ public:
>     static bool hasConstantScope(ResolveType);
>     static JSScope* constantScopeForCodeBlock(ResolveType, CodeBlock*);
> 
>-    static void collectClosureVariablesUnderTDZ(JSScope*, VariableEnvironment& result);
>+    static void collectClosureVariablesUnderTDZ(JSScope*, TDZEnvironment& result, VariableEnvironment& privateNames);
> 
>     static void visitChildren(JSCell*, SlotVisitor&);
> 
>Index: Source/JavaScriptCore/runtime/VM.cpp
>===================================================================
>--- Source/JavaScriptCore/runtime/VM.cpp	(revision 268822)
>+++ Source/JavaScriptCore/runtime/VM.cpp	(working copy)
>@@ -390,7 +390,7 @@ VM::VM(VMType vmType, HeapType heapType,
>     , interpreter(nullptr)
>     , entryScope(nullptr)
>     , m_regExpCache(new RegExpCache(this))
>-    , m_compactVariableMap(adoptRef(*(new CompactVariableMap)))
>+    , m_compactVariableMap(adoptRef(*(new CompactTDZEnvironmentMap)))
> #if ENABLE(REGEXP_TRACING)
>     , m_rtTraceList(new RTTraceList())
> #endif
>Index: Source/JavaScriptCore/runtime/VM.h
>===================================================================
>--- Source/JavaScriptCore/runtime/VM.h	(revision 268822)
>+++ Source/JavaScriptCore/runtime/VM.h	(working copy)
>@@ -108,7 +108,7 @@ struct CheckpointOSRExitSideState;
> class CodeBlock;
> class CodeCache;
> class CommonIdentifiers;
>-class CompactVariableMap;
>+class CompactTDZEnvironmentMap;
> class ConservativeRoots;
> class ControlFlowProfiler;
> class CustomGetterSetter;
>@@ -1004,7 +1004,7 @@ public:
>     static constexpr size_t patternContextBufferSize = 0; // Space allocated to save nested parenthesis context
> #endif
> 
>-    Ref<CompactVariableMap> m_compactVariableMap;
>+    Ref<CompactTDZEnvironmentMap> m_compactVariableMap;
> 
>     std::unique_ptr<HasOwnPropertyCache> m_hasOwnPropertyCache;
>     ALWAYS_INLINE HasOwnPropertyCache* hasOwnPropertyCache() { return m_hasOwnPropertyCache.get(); }
>Index: Source/WTF/ChangeLog
>===================================================================
>--- Source/WTF/ChangeLog	(revision 268822)
>+++ Source/WTF/ChangeLog	(working copy)
>@@ -1,3 +1,16 @@
>+2020-10-23  Saam Barati  <sbarati@apple.com>
>+
>+        Better cache our serialization of the outer TDZ environment when creating FunctionExecutables during bytecode generation
>+        https://bugs.webkit.org/show_bug.cgi?id=199866
>+        <rdar://problem/53333108>
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * wtf/RefPtr.h:
>+        (WTF::swap): Deleted.
>+        This function is no longer necessary, and causes ADL (https://en.cppreference.com/w/cpp/language/adl)
>+        compile errors when not using DumbPtrTraits and calling sort on a vector of that type.
>+
> 2020-10-20  Sihui Liu  <sihui_liu@apple.com>
> 
>         Add stubs for SpeechRecognition
>Index: Source/WTF/wtf/RefPtr.h
>===================================================================
>--- Source/WTF/wtf/RefPtr.h	(revision 268822)
>+++ Source/WTF/wtf/RefPtr.h	(working copy)
>@@ -193,12 +193,6 @@ inline void RefPtr<T, U, V>::swap(RefPtr
>     U::swap(m_ptr, o.m_ptr);
> }
> 
>-template<typename T, typename U, typename V, typename X, typename Y, typename Z, typename = std::enable_if_t<!std::is_same<U, DumbPtrTraits<T>>::value || !std::is_same<Y, DumbPtrTraits<X>>::value>>
>-inline void swap(RefPtr<T, U, V>& a, RefPtr<X, Y, Z>& b)
>-{
>-    a.swap(b);
>-}
>-
> template<typename T, typename U, typename V, typename X, typename Y, typename Z>
> inline bool operator==(const RefPtr<T, U, V>& a, const RefPtr<X, Y, Z>& b)
> {

Actions: View | Formatted Diff | Diff

Attachments on bug 199866: 411960 | 412007 | 412040 | 412054 | 412068 | 412146 | 412206 | 412225 | 412226 | 412328 | 412329 | 412330 | 412333 | 412487 | 412488 | 412490